Ver3.0 ๐ค Transformers Pipeline์ผ๋ก ํ ์คํธ ์์ฝ ์์ ์ ๋ณต

๐ค Transformers Pipeline์ผ๋ก ํ ์คํธ ์์ฝ ์์ ์ ๋ณต
AI๊ฐ ๊ธด ๊ธ์ ์์๊ฐ์ ์์ฝํด์ฃผ๋ ๋ง๋ฒ ๊ฐ์ ๊ธฐ์ ! ๐ฏ
๐ ํ ์คํธ ์์ฝ, ์ ์ด๋ ๊ฒ ํซํ ๊ธฐ์ ์ผ๊น?
์๋
! ์ค๋์ ์ ๋ง ์ค์ฉ์ ์ด๊ณ ์ฌ๋ฏธ์๋ ์ฃผ์ ๋ฅผ ๊ฐ์ง๊ณ ์์ด. ๋ฐ๋ก Transformers Pipeline์ ํ์ฉํ ํ
์คํธ ์์ฝ์ด์ผ. ๐
์์ฆ ์ ๋ณด์ ํ์ ์๋์ ์ด๊ณ ์์์? ๋ด์ค ๊ธฐ์ฌ, ๋
ผ๋ฌธ, ๋ณด๊ณ ์, ์ฌ์ง์ด SNS ๊ธ๊น์ง... ์ฝ์ด์ผ ํ ํ
์คํธ๊ฐ ๋๋ฌด ๋ง์์ ๋จธ๋ฆฌ๊ฐ ์ํ ์ง๊ฒฝ์ด์ง. ์ด๋ด ๋ AI๊ฐ ์๋์ผ๋ก ํต์ฌ๋ง ์์ ๋ฝ์์ ์์ฝํด์ค๋ค๋ฉด ์ผ๋ง๋ ์ข์๊น? ๐
๋ฐ๋ก ์ด๊ฒ ํ
์คํธ ์์ฝ(Text Summarization) ๊ธฐ์ ์ด์ผ. ๊ทธ๋ฆฌ๊ณ Hugging Face์ Transformers ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ด ์์
์ ์ ๋ง ์ฝ๊ฒ ๋ง๋ค์ด์ค. ๋ณต์กํ ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ๋ช ์ค์ ์ฝ๋๋ก ์ฌ์ฉํ ์ ์๋ค๋, ์ ๋ง ๋๋์ง ์์?
โข ํ์ ๋ ผ๋ฌธ ์ด๋ก ์์ฑ
โข ๊ณ ๊ฐ ๋ฆฌ๋ทฐ ํต์ฌ ๋ด์ฉ ์ถ์ถ
โข ํ์๋ก ์์ฝ ์๋ํ
โข ๋ฒ๋ฅ ๋ฌธ์ ํต์ฌ ์กฐํญ ์ ๋ฆฌ
โข SNS ๊ธด ๊ธ ์์ฝ๋ด
ํนํ ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ AI/๋จธ์ ๋ฌ๋ ๊ฐ๋ฐ ์ฌ๋ฅ์ ๊ณต์ ํ๊ฑฐ๋ ๋ฐฐ์ฐ๋ ค๋ ์ฌ๋๋ค์๊ฒ ์ด ๊ธฐ์ ์ ์ ๋ง ์ ์ฉํด. ์ค์ ํ๋ก์ ํธ์ ๋ฐ๋ก ์ ์ฉํ ์ ์๋ ์ค์ฉ์ ์ธ ์คํฌ์ด๊ฑฐ๋ ! ๐
๐ฏ Transformers Pipeline์ด๋ ๋ฌด์์ธ๊ฐ?
๋ณธ๊ฒฉ์ ์ผ๋ก ๋ค์ด๊ฐ๊ธฐ ์ ์, Transformers Pipeline์ด ๋ญ์ง๋ถํฐ ์์๋ณด์. ๐
Hugging Face Transformers๋ ์ต์ ์์ฐ์ด์ฒ๋ฆฌ(NLP) ๋ชจ๋ธ๋ค์ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์๊ฒ ํด์ฃผ๋ ์คํ์์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ผ. ๊ทธ๋ฆฌ๊ณ Pipeline์ ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ ๊ณตํ๋ ๊ฐ์ฅ ๊ฐํธํ ์ธํฐํ์ด์ค์ง.
์๊ฐํด๋ด. ์ผ๋ฐ์ ์ผ๋ก ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ค๋ฉด:
2๋จ๊ณ: ์ฌ์ ํ์ต๋ ๊ฐ์ค์น ๋ก๋ ๐ฆ
3๋จ๊ณ: ํ ํฌ๋์ด์ ์ค์ โ๏ธ
4๋จ๊ณ: ์ ๋ ฅ ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ ๐ง
5๋จ๊ณ: ๋ชจ๋ธ ์ถ๋ก ์คํ ๐
6๋จ๊ณ: ์ถ๋ ฅ ๋ฐ์ดํฐ ํ์ฒ๋ฆฌ ๐
์ด ๋ชจ๋ ๊ณผ์ ์ด ํ์ํด. ๋ณต์กํ์ง? ๐ต
ํ์ง๋ง Pipeline์ ์ฌ์ฉํ๋ฉด:
from transformers import pipeline
summarizer = pipeline("summarization")
result = summarizer("๊ธด ํ
์คํธ...")
print(result)
๋! ์ด๊ฒ ์ ๋ถ์ผ. ๐ฒ
Pipeline์ด ์์ ๋ชจ๋ ๋ณต์กํ ๊ณผ์ ์ ๋ด๋ถ์ ์ผ๋ก ์๋์ผ๋ก ์ฒ๋ฆฌํด์ค. ๋ง์น ์๋์ฐจ๋ฅผ ์ด์ ํ ๋ ์์ง์ ๋ณต์กํ ์๋ ์๋ฆฌ๋ฅผ ๋ชฐ๋ผ๋ ๋๋ ๊ฒ์ฒ๋ผ ๋ง์ด์ผ. ๐
2. ์ผ๊ด์ฑ: ๋ชจ๋ ์์ ์ ๋์ผํ ์ธํฐํ์ด์ค ์ ๊ณต
3. ์ต์ ํ: ์๋์ผ๋ก ์ต์ ์ ์ค์ ์ ์ฉ
4. ์ ์ฐ์ฑ: ํ์์ ์ธ๋ถ ์ค์ ์ปค์คํฐ๋ง์ด์ง ๊ฐ๋ฅ
5. ๋ค์์ฑ: 20๊ฐ ์ด์์ NLP ์์ ์ง์
๐ ํ ์คํธ ์์ฝ์ ๋ ๊ฐ์ง ๋ฐฉ์
ํ ์คํธ ์์ฝ์๋ ํฌ๊ฒ ๋ ๊ฐ์ง ์ ๊ทผ ๋ฐฉ์์ด ์์ด. ๊ฐ๊ฐ์ ํน์ง์ ์ดํดํ๋ฉด ์ํฉ์ ๋ง๊ฒ ์ ํํ ์ ์์ง! ๐
๐ ์ถ์ถ์ ์์ฝ (Extractive)
์๋ฆฌ: ์๋ณธ ํ
์คํธ์์ ์ค์ํ ๋ฌธ์ฅ๋ค์ ๊ทธ๋๋ก ๋ฝ์๋ด๋ ๋ฐฉ์
ํน์ง:
โข ์๋ฌธ์ ๋ฌธ์ฅ์ ๊ทธ๋๋ก ์ฌ์ฉ
โข ๋ฌธ๋ฒ์ ์ผ๋ก ์์ ํจ
โข ์ฌ์ค ์๊ณก ์ํ ๋ฎ์
โข ์์ฐ์ค๋ฝ์ง ์์ ์ ์์
๋น์ : ํ๊ดํ์ผ๋ก ์ค์ํ ๋ถ๋ถ๋ง ํ์ํ๋ ๊ฒ ๐๏ธ
โจ ์์ฑ์ ์์ฝ (Abstractive)
์๋ฆฌ: ๋ด์ฉ์ ์ดํดํ๊ณ ์๋ก์ด ๋ฌธ์ฅ์ผ๋ก ์ฌ๊ตฌ์ฑํ๋ ๋ฐฉ์
ํน์ง:
โข ์๋ก์ด ๋ฌธ์ฅ ์์ฑ
โข ๋ ์์ฐ์ค๋ฌ์ด ์์ฝ
โข ์์ญ๊ณผ ์ฌ๊ตฌ์ฑ ๊ฐ๋ฅ
โข ๊ณ ๊ธ ๋ชจ๋ธ ํ์
๋น์ : ์ฑ
์ ์ฝ๊ณ ์๊ธฐ ๋ง๋ก ์ค๋ช
ํ๋ ๊ฒ ๐ฌ
Transformers Pipeline์ "summarization" ์์
์ ์ฃผ๋ก ์์ฑ์ ์์ฝ์ ์ํํด. BART, T5, Pegasus ๊ฐ์ ์ต์ ๋ชจ๋ธ๋ค์ด ํ
์คํธ๋ฅผ ์ดํดํ๊ณ ์๋กญ๊ฒ ์ฌ๊ตฌ์ฑํ๋ ๋ฐฉ์์ด์ง. ๐ค
์ด๊ฒ ์ ์ค์ํ๋๋ฉด, ์์ฑ์ ์์ฝ์ด ํจ์ฌ ๋ ์์ฐ์ค๋ฝ๊ณ ์ฝ๊ธฐ ์ข์ ๊ฒฐ๊ณผ๋ฅผ ๋ง๋ค์ด๋ด๊ฑฐ๋ . ๋ง์น ์ฌ๋์ด ์์ฝํ ๊ฒ์ฒ๋ผ ๋ง์ด์ผ!
์ถ์ถ์ ์์ฝ: "์ธ๊ณต์ง๋ฅ ๊ธฐ์ ์ ๋ฐ์ ์ผ๋ก ์์ฐ์ด์ฒ๋ฆฌ ๋ถ์ผ์์ ๋๋ผ์ด ์ฑ๊ณผ๊ฐ ๋ํ๋๊ณ ์๋ค."
์์ฑ์ ์์ฝ: "AI ๋ฐ์ ์ผ๋ก NLP ๋ถ์ผ๊ฐ ํฌ๊ฒ ์ฑ์ฅํ์ผ๋ฉฐ, Transformer ๊ธฐ์ ์ด ํต์ฌ ์ญํ ์ ํ๊ณ ์๋ค."
๐ ๏ธ ํ๊ฒฝ ์ค์ ๋ฐ ์ค์น
์, ์ด์ ์ค์ ์ผ๋ก ๋ค์ด๊ฐ๋ณผ๊น? ๋จผ์ ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ ์ค์นํด์ผ ํด. ๊ฑฑ์ ๋ง, ์ด๋ ต์ง ์์! ๐
Python 3.7 ์ด์์ด ํ์ํด. ํฐ๋ฏธ๋์์ ํ์ธํด๋ณด์:
python --version
# ๋๋
python3 --version
ํ๋ก์ ํธ๋ณ๋ก ๋ ๋ฆฝ์ ์ธ ํ๊ฒฝ์ ๋ง๋ค๋ฉด ํจํค์ง ์ถฉ๋์ ๋ฐฉ์งํ ์ ์์ด:
# venv ์ฌ์ฉ
python -m venv summarization_env
# ํ์ฑํ (Windows)
summarization_env\Scripts\activate
# ํ์ฑํ (Mac/Linux)
source summarization_env/bin/activate
์ด๊ฒ ํต์ฌ์ด์ผ! ๐ฏ
pip install transformers
Transformers๋ ๋ฐฑ์๋๋ก PyTorch๋ TensorFlow๊ฐ ํ์ํด. ๋๋ถ๋ถ PyTorch๋ฅผ ์ฌ์ฉํ์ง:
# PyTorch (๊ถ์ฅ)
pip install torch
# ๋๋ TensorFlow
pip install tensorflow
CPU๋ง ์ฌ์ฉํ๋ค๋ฉด ์ ๋ช ๋ น์ด๋ก ์ถฉ๋ถํด. ์๋๋ ๋๋ฆฌ์ง๋ง ํ์ต์ฉ์ผ๋ก๋ ๋ฌธ์ ์์ด. ๐ป
๋ ํธ๋ฆฌํ ์ฌ์ฉ์ ์ํด:
# sentencepiece: ์ผ๋ถ ๋ชจ๋ธ์ ํ ํฌ๋์ด์ ์ ํ์
pip install sentencepiece
# datasets: Hugging Face ๋ฐ์ดํฐ์
์ฌ์ฉ์
pip install datasets
# accelerate: ์ถ๋ก ์๋ ํฅ์
pip install accelerate
# requirements.txt ๋ด์ฉ
transformers>=4.30.0
torch>=2.0.0
sentencepiece>=0.1.99
datasets>=2.12.0
accelerate>=0.20.0
# ์ค์น
pip install -r requirements.txt
์ค์น๊ฐ ์๋ฃ๋๋ฉด ๊ฐ๋จํ ํ ์คํธ๋ฅผ ํด๋ณด์:
python -c "import transformers; print(transformers.__version__)"
๋ฒ์ ๋ฒํธ๊ฐ ์ถ๋ ฅ๋๋ฉด ์ฑ๊ณต! ๐
๐ ์ฒซ ๋ฒ์งธ ํ ์คํธ ์์ฝ ์คํํ๊ธฐ
๋๋์ด ์ค์ ์ด์ผ! ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ํ ์คํธ ์์ฝ๋ถํฐ ์์ํด๋ณด์. ์ ๋ง ๊ฐ๋จํด์ ๋๋ ๊ฑฐ์ผ! ๐
from transformers import pipeline
# ์์ฝ ํ์ดํ๋ผ์ธ ์์ฑ
summarizer = pipeline("summarization")
# ์์ฝํ ํ
์คํธ
text = """
์ธ๊ณต์ง๋ฅ ๊ธฐ์ ์ ์ต๊ทผ ๋ช ๋
๊ฐ ๊ธ๊ฒฉํ ๋ฐ์ ์ ์ด๋ฃจ์์ต๋๋ค.
ํนํ ์์ฐ์ด์ฒ๋ฆฌ ๋ถ์ผ์์๋ Transformer ์ํคํ
์ฒ์ ๋ฑ์ฅ์ผ๋ก
ํ์ ์ ์ธ ๋ณํ๊ฐ ์ผ์ด๋ฌ์ต๋๋ค. BERT, GPT, T5 ๋ฑ์ ๋ชจ๋ธ๋ค์
๋ค์ํ ์ธ์ด ์์
์์ ์ธ๊ฐ ์์ค์ ์ฑ๋ฅ์ ๋ณด์ฌ์ฃผ๊ณ ์์ต๋๋ค.
์ด๋ฌํ ๊ธฐ์ ๋ค์ ๋ฒ์ญ, ์์ฝ, ์ง์์๋ต, ๊ฐ์ฑ๋ถ์ ๋ฑ
์ค์ํ์ ๋ง์ ์์ญ์ ์ ์ฉ๋๊ณ ์์ผ๋ฉฐ, ์์ผ๋ก๋
๋์ฑ ๋ฐ์ ํ ๊ฒ์ผ๋ก ๊ธฐ๋๋ฉ๋๋ค.
"""
# ์์ฝ ์คํ
summary = summarizer(text, max_length=50, min_length=10, do_sample=False)
# ๊ฒฐ๊ณผ ์ถ๋ ฅ
print(summary[0]['summary_text'])
์ด๊ฒ ๋์ด์ผ! ๐ฒ ์ ๋ง ๊ฐ๋จํ์ง?
์ฝ๋๋ฅผ ์คํํ๋ฉด ์ฒ์์๋ ๋ชจ๋ธ์ ๋ค์ด๋ก๋ํ๋ ์๊ฐ์ด ์ข ๊ฑธ๋ ค. ํ์ง๋ง ํ ๋ฒ ๋ค์ด๋ก๋ํ๋ฉด ๋ก์ปฌ์ ์บ์๋์ด์ ๋ค์๋ถํฐ๋ ๋น ๋ฅด๊ฒ ์คํ๋ผ. ๐ฆ
min_length: ์์ฝ๋ฌธ์ ์ต์ ํ ํฐ ์ (๊ธฐ๋ณธ๊ฐ: 30)
do_sample: ์ํ๋ง ์ฌ์ฉ ์ฌ๋ถ (False๋ฉด greedy decoding)
length_penalty: ๊ธธ์ด ํ๋ํฐ (์์๋ฉด ๊ธด ๋ฌธ์ฅ ์ ํธ)
num_beams: Beam search์ ๋น ๊ฐ์ (๋์์๋ก ํ์ง ํฅ์)
from transformers import pipeline
# ํน์ ๋ชจ๋ธ ์ง์
summarizer = pipeline(
"summarization",
model="facebook/bart-large-cnn", # ์์ด ์์ฝ์ ๊ฐ๋ ฅํ ๋ชจ๋ธ
device=0 # GPU ์ฌ์ฉ (CPU๋ -1)
)
text = """
The field of artificial intelligence has witnessed remarkable
progress in recent years. Natural language processing, in particular,
has been revolutionized by the introduction of Transformer architectures.
Models like BERT, GPT, and T5 have achieved human-level performance
across various language tasks. These technologies are being applied
in real-world scenarios including translation, summarization,
question answering, and sentiment analysis.
"""
# ๊ณ ๊ธ ํ๋ผ๋ฏธํฐ ์ค์
summary = summarizer(
text,
max_length=60,
min_length=20,
do_sample=False,
num_beams=4, # Beam search ์ฌ์ฉ
length_penalty=2.0, # ๋ ๊ธด ์์ฝ ์ ํธ
early_stopping=True
)
print(summary[0]['summary_text'])
์ ์ฝ๋์์๋ facebook/bart-large-cnn ๋ชจ๋ธ์ ๋ช ์์ ์ผ๋ก ์ง์ ํ์ด. ์ด ๋ชจ๋ธ์ CNN/DailyMail ๋ฐ์ดํฐ์ ์ผ๋ก ํ์ต๋์ด ๋ด์ค ๊ธฐ์ฌ ์์ฝ์ ํนํ ๊ฐ๋ ฅํด. ๐ฐ
1. ๋ค๊ตญ์ด ๋ชจ๋ธ ์ฌ์ฉ (์: mT5, mBART)
2. ํ๊ตญ์ด๋ก ํ์ธํ๋๋ ๋ชจ๋ธ ์ฌ์ฉ
3. ์ง์ ํ๊ตญ์ด ๋ฐ์ดํฐ๋ก ํ์ธํ๋
์ด ๋ถ๋ถ์ ๋ค์์ ๋ ์์ธํ ๋ค๋ฃฐ๊ฒ! ๐ฐ๐ท
๐จ ๋ค์ํ ์์ฝ ๋ชจ๋ธ ์ดํด๋ณด๊ธฐ
Hugging Face Model Hub์๋ ์๋ง์ ์์ฝ ๋ชจ๋ธ์ด ์์ด. ๊ฐ ๋ชจ๋ธ๋ง๋ค ํน์ง์ด ๋ค๋ฅด๋๊น, ์ํฉ์ ๋ง๊ฒ ์ ํํ๋ ๊ฒ ์ค์ํด! ๐ฏ
| ๋ชจ๋ธ | ํน์ง | ์ฅ์ | ์ฉ๋ |
|---|---|---|---|
| BART | Seq2Seq ๊ตฌ์กฐ | ๋ด์ค ์์ฝ์ ๊ฐ๋ ฅ | ์ผ๋ฐ ํ ์คํธ ์์ฝ |
| T5 | Text-to-Text | ๋ค๋ชฉ์ ํ์ฉ ๊ฐ๋ฅ | ๋ฒ์ฉ ์์ฝ |
| Pegasus | ์์ฝ ํนํ ํ์ต | ์์ฝ ํ์ง ์ฐ์ | ๊ณ ํ์ง ์์ฝ |
| mT5 | ๋ค๊ตญ์ด ์ง์ | 100๊ฐ ์ด์ ์ธ์ด | ํ๊ตญ์ด ํฌํจ ๋ค๊ตญ์ด |
| LED | ๊ธด ๋ฌธ์ ์ฒ๋ฆฌ | 16K ํ ํฐ ์ฒ๋ฆฌ | ๋ ผ๋ฌธ, ๋ณด๊ณ ์ |
BART๋ Facebook AI์์ ๊ฐ๋ฐํ ๋ชจ๋ธ๋ก, ๋ ธ์ด์ฆ ์ ๊ฑฐ ์๋์ธ์ฝ๋ ๋ฐฉ์์ผ๋ก ํ์ต๋ผ. ํนํ facebook/bart-large-cnn ๋ฒ์ ์ CNN/DailyMail ๋ฐ์ดํฐ์ ์ผ๋ก ํ์ธํ๋๋์ด ๋ด์ค ์์ฝ์ ํ์ํด. ๐ฐ
from transformers import pipeline
# BART ๋ชจ๋ธ ์ฌ์ฉ
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
article = """
Scientists have discovered a new species of deep-sea fish
in the Mariana Trench. The fish, which has been named
Pseudoliparis swirei, was found at a depth of 8,000 meters,
making it one of the deepest-living fish ever recorded.
The discovery was made during a research expedition
using advanced underwater cameras and collection devices.
"""
result = summarizer(article, max_length=40, min_length=10)
print(result[0]['summary_text'])
T5๋ Google์์ ๊ฐ๋ฐํ ๋ชจ๋ธ๋ก, ๋ชจ๋ NLP ์์ ์ ํ ์คํธ-ํฌ-ํ ์คํธ ํ์์ผ๋ก ํต์ผํ์ด. ์์ฝ ์์ ๋ "summarize: [ํ ์คํธ]" ํ์์ผ๋ก ์ ๋ ฅํ๋ฉด ๋ผ. ๐
from transformers import pipeline
# T5 ๋ชจ๋ธ ์ฌ์ฉ
summarizer = pipeline("summarization", model="t5-base")
text = "summarize: " + """
Climate change is causing significant impacts on global ecosystems.
Rising temperatures are leading to melting ice caps, rising sea levels,
and more frequent extreme weather events. Scientists warn that
immediate action is needed to reduce greenhouse gas emissions
and mitigate the worst effects of climate change.
"""
result = summarizer(text, max_length=50)
print(result[0]['summary_text'])
Pegasus๋ Google Research์์ ์์ฝ ์์ ์ ์ํด ํน๋ณํ ์ค๊ณํ ๋ชจ๋ธ์ด์ผ. Gap Sentence Generation์ด๋ผ๋ ๋ ํนํ ์ฌ์ ํ์ต ๋ฐฉ์์ ์ฌ์ฉํด์ ์์ฝ ํ์ง์ด ๋งค์ฐ ์ฐ์ํด. โญ
from transformers import pipeline
# Pegasus ๋ชจ๋ธ ์ฌ์ฉ
summarizer = pipeline("summarization", model="google/pegasus-xsum")
text = """
A new study published in Nature reveals that regular exercise
can significantly improve cognitive function in older adults.
Researchers followed 500 participants over five years and found
that those who exercised at least three times per week showed
better memory, attention, and problem-solving skills compared
to sedentary individuals.
"""
result = summarizer(text, max_length=60, min_length=20)
print(result[0]['summary_text'])
์ผ๋ฐ ๋ฌธ์ ์์ฝ: t5-base ๋๋ t5-large
๊ณ ํ์ง ์์ฝ: google/pegasus-xsum
๊ธด ๋ฌธ์ ์์ฝ: allenai/led-base-16384
๋ค๊ตญ์ด ์์ฝ: google/mt5-base
ํ๊ตญ์ด ์์ฝ: eenzeenee/t5-base-korean-summarization
ํ๊ตญ์ด ํ ์คํธ๋ฅผ ์์ฝํ๋ ค๋ฉด ํ๊ตญ์ด๋ก ํ์ต๋ ๋ชจ๋ธ์ ์ฌ์ฉํด์ผ ํด. ๋คํํ Hugging Face์๋ ํ๊ตญ์ด ์์ฝ ๋ชจ๋ธ๋ค์ด ์์ด! ๐ฐ๐ท
from transformers import pipeline
# ํ๊ตญ์ด ์์ฝ ๋ชจ๋ธ
summarizer = pipeline(
"summarization",
model="eenzeenee/t5-base-korean-summarization"
)
korean_text = """
์ธ๊ณต์ง๋ฅ ๊ธฐ์ ์ ๋ฐ์ ์ผ๋ก ๋ค์ํ ์ฐ์
๋ถ์ผ์์ ํ์ ์ด ์ผ์ด๋๊ณ ์์ต๋๋ค.
ํนํ ์์ฐ์ด์ฒ๋ฆฌ ๊ธฐ์ ์ ๊ณ ๊ฐ ์๋น์ค, ์ฝํ
์ธ ์์ฑ, ๋ฐ์ดํฐ ๋ถ์ ๋ฑ
์ฌ๋ฌ ์์ญ์์ ํ์ฉ๋๊ณ ์์ต๋๋ค. ๊ธฐ์
๋ค์ AI ๊ธฐ์ ์ ๋์
ํ์ฌ
์
๋ฌด ํจ์จ์ฑ์ ๋์ด๊ณ ์๋ก์ด ๋น์ฆ๋์ค ๊ธฐํ๋ฅผ ์ฐฝ์ถํ๊ณ ์์ต๋๋ค.
์ ๋ฌธ๊ฐ๋ค์ ์์ผ๋ก AI ๊ธฐ์ ์ด ๋์ฑ ๋ฐ์ ํ์ฌ ์ฐ๋ฆฌ ์ํ ์ ๋ฐ์
ํฐ ์ํฅ์ ๋ฏธ์น ๊ฒ์ผ๋ก ์ ๋งํ๊ณ ์์ต๋๋ค.
"""
result = summarizer(korean_text, max_length=100, min_length=20)
print(result[0]['summary_text'])
ํ๊ตญ์ด ๋ชจ๋ธ์ ์์ด ๋ชจ๋ธ๋ณด๋ค ์ ํ์ง๊ฐ ์ ์ง๋ง, ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ AI ๊ฐ๋ฐ ์ฌ๋ฅ์ ๊ฐ์ง ์ ๋ฌธ๊ฐ๋ค์ด ์ปค์คํ ๋ชจ๋ธ์ ๋ง๋ค์ด์ฃผ๊ธฐ๋ ํด. ํน์ ๋๋ฉ์ธ(๋ฒ๋ฅ , ์๋ฃ, ๊ธ์ต ๋ฑ)์ ํนํ๋ ์์ฝ ๋ชจ๋ธ์ด ํ์ํ๋ค๋ฉด ์ ๋ฌธ๊ฐ์ ๋์์ ๋ฐ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ! ๐ค
โ๏ธ ๊ณ ๊ธ ํ๋ผ๋ฏธํฐ์ ์ต์ ํ ๊ธฐ๋ฒ
๊ธฐ๋ณธ ์ฌ์ฉ๋ฒ์ ์ตํ๋ค๋ฉด, ์ด์ ๋ ์ธ๋ฐํ ์ ์ด๋ฅผ ์ํ ๊ณ ๊ธ ๊ธฐ๋ฒ๋ค์ ์์๋ณด์! ์ด ๋ถ๋ถ์ ์ ํ์ฉํ๋ฉด ์์ฝ ํ์ง์ ํฌ๊ฒ ํฅ์์ํฌ ์ ์์ด. ๐ฏ
ํ ์คํธ ์์ฑ์๋ ํฌ๊ฒ ๋ ๊ฐ์ง ๋์ฝ๋ฉ ์ ๋ต์ด ์์ด:
โข ๊ฐ์ฅ ํ๋ฅ ๋์ ์ํ์ค ์ ํ
โข ์์ ์ ์ด๊ณ ์ผ๊ด๋ ๊ฒฐ๊ณผ
โข do_sample=False, num_beams > 1
๐ฒ Sampling (ํ๋ฅ ๋ก ์ )
โข ํ๋ฅ ๋ถํฌ์์ ์ํ๋ง
โข ๋ค์ํ๊ณ ์ฐฝ์์ ์ธ ๊ฒฐ๊ณผ
โข ๋งค๋ฒ ๋ค๋ฅธ ์ถ๋ ฅ ๊ฐ๋ฅ
โข do_sample=True
from transformers import pipeline
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
text = """
Your long text here...
"""
# Beam Search ์ฌ์ฉ (์์ ์ )
result_beam = summarizer(
text,
max_length=60,
min_length=20,
do_sample=False,
num_beams=4, # 4๊ฐ์ ๋น ์ฌ์ฉ
early_stopping=True
)
# Sampling ์ฌ์ฉ (๋ค์์ฑ)
result_sample = summarizer(
text,
max_length=60,
min_length=20,
do_sample=True,
top_k=50, # ์์ 50๊ฐ ํ ํฐ์์ ์ํ๋ง
top_p=0.95, # ๋์ ํ๋ฅ 95%๊น์ง์ ํ ํฐ ๊ณ ๋ ค
temperature=0.8 # ๋ฎ์์๋ก ๋ณด์์
)
print("Beam Search:", result_beam[0]['summary_text'])
print("Sampling:", result_sample[0]['summary_text'])
temperature: 0.7-1.0 ์ถ์ฒ (๋ฎ์ผ๋ฉด ๋ณด์์ , ๋์ผ๋ฉด ์ฐฝ์์ )
top_k: 40-50 ์ ๋๊ฐ ์ ๋น
top_p: 0.9-0.95 ์ฌ์ด๊ฐ ์ข์
length_penalty: 1.0์ด ๊ธฐ๋ณธ, 2.0์ด๋ฉด ๊ธด ๋ฌธ์ฅ ์ ํธ
์ฌ๋ฌ ํ ์คํธ๋ฅผ ํ ๋ฒ์ ์ฒ๋ฆฌํ๋ฉด ํจ์ฌ ํจ์จ์ ์ด์ผ! ๐
from transformers import pipeline
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
# ์ฌ๋ฌ ํ
์คํธ๋ฅผ ๋ฆฌ์คํธ๋ก ์ค๋น
texts = [
"First article text...",
"Second article text...",
"Third article text..."
]
# ๋ฐฐ์น ์ฒ๋ฆฌ
results = summarizer(
texts,
max_length=60,
min_length=20,
batch_size=8 # ํ ๋ฒ์ 8๊ฐ์ฉ ์ฒ๋ฆฌ
)
# ๊ฒฐ๊ณผ ์ถ๋ ฅ
for i, result in enumerate(results):
print(f"Summary {i+1}: {result['summary_text']}\n")
GPU๊ฐ ์๋ค๋ฉด ๋ฐ๋์ ํ์ฉํ์! ์๋๊ฐ 10๋ฐฐ ์ด์ ๋นจ๋ผ์ ธ. โก
from transformers import pipeline
import torch
# GPU ์ฌ์ฉ ๊ฐ๋ฅ ์ฌ๋ถ ํ์ธ
device = 0 if torch.cuda.is_available() else -1
print(f"Using device: {'GPU' if device == 0 else 'CPU'}")
# GPU ์ฌ์ฉ ์ค์
summarizer = pipeline(
"summarization",
model="facebook/bart-large-cnn",
device=device
)
# ์ถ๋ก ์คํ
text = "Your text here..."
result = summarizer(text, max_length=60)
print(result[0]['summary_text'])
1. ๋ฐฐ์น ํฌ๊ธฐ ์ค์ด๊ธฐ
2. ๋ ์์ ๋ชจ๋ธ ์ฌ์ฉ (base ๋์ small)
3. ํ ์คํธ ๊ธธ์ด ์ ํ
4. 8bit ์์ํ ์ฌ์ฉ (๋์ค์ ์ค๋ช !)
๋๋ถ๋ถ์ ๋ชจ๋ธ์ 512-1024 ํ ํฐ ์ ๋๋ง ์ฒ๋ฆฌํ ์ ์์ด. ๊ธด ๋ฌธ์๋ ์ด๋ป๊ฒ ํ ๊น? ๐ค
from transformers import pipeline
def summarize_long_text(text, max_chunk_length=1000):
"""๊ธด ํ
์คํธ๋ฅผ ์ฒญํฌ๋ก ๋๋ ์ ์์ฝ"""
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
# ํ
์คํธ๋ฅผ ๋ฌธ์ฅ ๋จ์๋ก ๋ถ๋ฆฌ
sentences = text.split('. ')
# ์ฒญํฌ๋ก ๋๋๊ธฐ
chunks = []
current_chunk = ""
for sentence in sentences:
if len(current_chunk) + len(sentence) < max_chunk_length:
current_chunk += sentence + ". "
else:
if current_chunk:
chunks.append(current_chunk)
current_chunk = sentence + ". "
if current_chunk:
chunks.append(current_chunk)
# ๊ฐ ์ฒญํฌ ์์ฝ
summaries = []
for chunk in chunks:
result = summarizer(chunk, max_length=100, min_length=30)
summaries.append(result[0]['summary_text'])
# ์์ฝ๋ค์ ํฉ์ณ์ ์ต์ข
์์ฝ
combined = " ".join(summaries)
if len(combined) > 500: # ์ฌ์ ํ ๊ธธ๋ฉด ํ ๋ฒ ๋ ์์ฝ
final_result = summarizer(combined, max_length=150, min_length=50)
return final_result[0]['summary_text']
return combined
# ์ฌ์ฉ ์์
long_document = """
Very long document text that exceeds the model's maximum length...
[์ฌ๋ฌ ํ์ด์ง ๋ถ๋์ ํ
์คํธ]
"""
summary = summarize_long_text(long_document)
print(summary)
๋๋ ๊ธด ๋ฌธ์ ์ ์ฉ ๋ชจ๋ธ์ ์ฌ์ฉํ ์๋ ์์ด:
from transformers import pipeline
# LED (Longformer Encoder-Decoder) - 16K ํ ํฐ ์ฒ๋ฆฌ ๊ฐ๋ฅ
summarizer = pipeline(
"summarization",
model="allenai/led-base-16384"
)
long_text = """
[๋งค์ฐ ๊ธด ๋ฌธ์...]
"""
result = summarizer(long_text, max_length=200, min_length=50)
print(result[0]['summary_text'])
์์ฝ์ด ์ ๋์๋์ง ์ด๋ป๊ฒ ์ ์ ์์๊น? ROUGE ๋ฉํธ๋ฆญ์ ์ฌ์ฉํด๋ณด์! ๐
from transformers import pipeline
from datasets import load_metric
# ROUGE ๋ฉํธ๋ฆญ ๋ก๋
rouge = load_metric("rouge")
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
# ์๋ณธ ํ
์คํธ์ ์ฐธ์กฐ ์์ฝ
text = "Your article text..."
reference_summary = "Human-written summary..."
# ๋ชจ๋ธ ์์ฝ
model_summary = summarizer(text, max_length=60)[0]['summary_text']
# ROUGE ์ ์ ๊ณ์ฐ
scores = rouge.compute(
predictions=[model_summary],
references=[reference_summary]
)
print("ROUGE-1:", scores['rouge1'].mid.fmeasure)
print("ROUGE-2:", scores['rouge2'].mid.fmeasure)
print("ROUGE-L:", scores['rougeL'].mid.fmeasure)
ROUGE-2: 2-gram ๊ฒน์นจ (0.15-0.25๋ฉด ์ํธ)
ROUGE-L: ์ต์ฅ ๊ณตํต ๋ถ๋ถ์์ด (0.25-0.4๋ฉด ์ํธ)
์ ์๊ฐ ๋์์๋ก ์ฐธ์กฐ ์์ฝ๊ณผ ์ ์ฌํด. ํ์ง๋ง ์ ์๊ฐ ๋ฎ๋ค๊ณ ๋์ ๊ฑด ์๋์ผ. ๋ค๋ฅธ ํํ์ผ๋ก ๊ฐ์ ์๋ฏธ๋ฅผ ์ ๋ฌํ ์ ์๊ฑฐ๋ ! ๐ฏ
๐ ๏ธ ์ค์ ํ๋ก์ ํธ: ๋ด์ค ์์ฝ ์์คํ ๋ง๋ค๊ธฐ
์ด์ ๋ฐฐ์ด ๋ด์ฉ์ ์ข ํฉํด์ ์ค์ ๋ก ์ฌ์ฉํ ์ ์๋ ๋ด์ค ์์ฝ ์์คํ ์ ๋ง๋ค์ด๋ณด์! ์ด๊ฑด ํฌํธํด๋ฆฌ์ค์๋ ๋ฃ์ ์ ์๋ ๋ฉ์ง ํ๋ก์ ํธ์ผ. ๐
news_summarizer/
โ
โโโ summarizer.py # ํต์ฌ ์์ฝ ๋ก์ง
โโโ web_scraper.py # ๋ด์ค ํฌ๋กค๋ง
โโโ app.py # Flask ์น ์ฑ
โโโ requirements.txt # ์์กด์ฑ ํจํค์ง
โโโ templates/
โโโ index.html # ์น ์ธํฐํ์ด์ค
from transformers import pipeline
import torch
class NewsSummarizer:
def __init__(self, model_name="facebook/bart-large-cnn"):
"""๋ด์ค ์์ฝ๊ธฐ ์ด๊ธฐํ"""
device = 0 if torch.cuda.is_available() else -1
self.summarizer = pipeline(
"summarization",
model=model_name,
device=device
)
def summarize(self, text, max_length=130, min_length=30):
"""ํ
์คํธ ์์ฝ ์คํ"""
try:
# ํ
์คํธ ๊ธธ์ด ํ์ธ
if len(text.split()) < 50:
return "ํ
์คํธ๊ฐ ๋๋ฌด ์งง์์ ์์ฝํ ์ ์์ต๋๋ค."
# ์์ฝ ์คํ
result = self.summarizer(
text,
max_length=max_length,
min_length=min_length,
do_sample=False,
num_beams=4,
length_penalty=2.0,
early_stopping=True
)
return result[0]['summary_text']
except Exception as e:
return f"์์ฝ ์ค ์ค๋ฅ ๋ฐ์: {str(e)}"
def summarize_batch(self, texts, max_length=130, min_length=30):
"""์ฌ๋ฌ ํ
์คํธ ๋ฐฐ์น ์์ฝ"""
try:
results = self.summarizer(
texts,
max_length=max_length,
min_length=min_length,
batch_size=4,
do_sample=False,
num_beams=4
)
return [r['summary_text'] for r in results]
except Exception as e:
return [f"์ค๋ฅ: {str(e)}"] * len(texts)
# ์ฌ์ฉ ์์
if __name__ == "__main__":
summarizer = NewsSummarizer()
article = """
Artificial intelligence is transforming industries worldwide.
Companies are investing billions in AI research and development.
Machine learning models are becoming more sophisticated,
enabling new applications in healthcare, finance, and transportation.
Experts predict AI will continue to reshape the global economy
in the coming decades.
"""
summary = summarizer.summarize(article)
print("์์ฝ:", summary)
import requests
from bs4 import BeautifulSoup
from newspaper import Article
class NewsScaper:
def __init__(self):
self.headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}
def fetch_article(self, url):
"""URL์์ ๊ธฐ์ฌ ๋ด์ฉ ์ถ์ถ"""
try:
article = Article(url)
article.download()
article.parse()
return {
'title': article.title,
'text': article.text,
'authors': article.authors,
'publish_date': article.publish_date,
'url': url
}
except Exception as e:
return {'error': str(e)}
def fetch_multiple_articles(self, urls):
"""์ฌ๋ฌ URL์์ ๊ธฐ์ฌ ์ถ์ถ"""
articles = []
for url in urls:
article = self.fetch_article(url)
if 'error' not in article:
articles.append(article)
return articles
# ์ฌ์ฉ ์์
if __name__ == "__main__":
scraper = NewsScaper()
url = "https://example.com/news/article"
article = scraper.fetch_article(url)
if 'error' not in article:
print("์ ๋ชฉ:", article['title'])
print("๋ด์ฉ ๊ธธ์ด:", len(article['text']))
from flask import Flask, render_template, request, jsonify
from summarizer import NewsSummarizer
from web_scraper import NewsScaper
app = Flask(__name__)
# ์ ์ญ ๊ฐ์ฒด ์ด๊ธฐํ
summarizer = NewsSummarizer()
scraper = NewsScaper()
@app.route('/')
def index():
"""๋ฉ์ธ ํ์ด์ง"""
return render_template('index.html')
@app.route('/summarize', methods=['POST'])
def summarize():
"""ํ
์คํธ ์์ฝ API"""
data = request.json
text = data.get('text', '')
max_length = data.get('max_length', 130)
min_length = data.get('min_length', 30)
if not text:
return jsonify({'error': 'ํ
์คํธ๋ฅผ ์
๋ ฅํด์ฃผ์ธ์'}), 400
summary = summarizer.summarize(text, max_length, min_length)
return jsonify({
'summary': summary,
'original_length': len(text.split()),
'summary_length': len(summary.split())
})
@app.route('/summarize_url', methods=['POST'])
def summarize_url():
"""URL์์ ๊ธฐ์ฌ ์ถ์ถ ๋ฐ ์์ฝ"""
data = request.json
url = data.get('url', '')
if not url:
return jsonify({'error': 'URL์ ์
๋ ฅํด์ฃผ์ธ์'}), 400
# ๊ธฐ์ฌ ํฌ๋กค๋ง
article = scraper.fetch_article(url)
if 'error' in article:
return jsonify({'error': article['error']}), 400
# ์์ฝ ์คํ
summary = summarizer.summarize(article['text'])
return jsonify({
'title': article['title'],
'summary': summary,
'url': url,
'original_length': len(article['text'].split()),
'summary_length': len(summary.split())
})
if __name__ == '__main__':
app.run(debug=True, host='0.0.0.0', port=5000)
transformers>=4.30.0
torch>=2.0.0
flask>=2.3.0
newspaper3k>=0.2.8
beautifulsoup4>=4.12.0
requests>=2.31.0
sentencepiece>=0.1.99
# ํจํค์ง ์ค์น
pip install -r requirements.txt
# ์๋ฒ ์คํ
python app.py
# ๋ธ๋ผ์ฐ์ ์์ ์ ์
# http://localhost:5000
2. AWS Lambda: ์๋ฒ๋ฆฌ์ค๋ก ๋น์ฉ ์ ๊ฐ
3. Docker: ์ปจํ ์ด๋ํ๋ก ์ด์์ฑ ํฅ์
4. Streamlit: ๋น ๋ฅธ ํ๋กํ ํ์ ์ ์
๋ชจ๋ธ ํฌ๊ธฐ๊ฐ ํฌ๋ฉด ๋ฐฐํฌ๊ฐ ์ด๋ ค์ธ ์ ์์ด. ์ด๋ด ๋๋ Hugging Face Inference API๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ! ๐ฏ
2. ์ฐ๊ตฌ ๋ ผ๋ฌธ ์์ฝ: arXiv ๋ ผ๋ฌธ ์๋ ์์ฝ
3. ํ์๋ก ์์ฝ: ๊ธด ํ์ ๋ด์ฉ ํต์ฌ ์ ๋ฆฌ
4. ๊ณ ๊ฐ ๋ฆฌ๋ทฐ ๋ถ์: ์์ฒ ๊ฐ ๋ฆฌ๋ทฐ ์์ฝ
5. ๋ฒ๋ฅ ๋ฌธ์ ์์ฝ: ๊ณ์ฝ์ ํต์ฌ ์กฐํญ ์ถ์ถ
6. SNS ๋ชจ๋ํฐ๋ง: ๋ธ๋๋ ์ธ๊ธ ์์ฝ
์ด๋ฐ ํ๋ก์ ํธ๋ค์ ์ค์ ๋น์ฆ๋์ค ๊ฐ์น๊ฐ ์์ด์, ํ๋ฆฌ๋์ ํ๋ซํผ์ด๋ ์ฌ๋ฅ ๊ณต์ ์ฌ์ดํธ์์ ์์ตํํ ์ ์์ด! ๐ฐ
๐ ๋ชจ๋ธ ํ์ธํ๋: ๋๋ง์ ์์ฝ ๋ชจ๋ธ ๋ง๋ค๊ธฐ
์ฌ์ ํ์ต๋ ๋ชจ๋ธ๋ ์ข์ง๋ง, ํน์ ๋๋ฉ์ธ์ด๋ ์คํ์ผ์ ๋ง์ถ ์ปค์คํ
๋ชจ๋ธ์ด ํ์ํ ๋๊ฐ ์์ด. ์ด๋ด ๋๋ ํ์ธํ๋์ ํด์ผ ํด! ๐ฏ
์๋ฅผ ๋ค์ด, ์๋ฃ ๋
ผ๋ฌธ ์์ฝ, ๋ฒ๋ฅ ๋ฌธ์ ์์ฝ, ๋๋ ํน์ ํ์ฌ์ ๋ณด๊ณ ์ ์คํ์ผ์ ๋ง์ถ ์์ฝ์ด ํ์ํ๋ค๋ฉด ํ์ธํ๋์ด ๋ต์ด์ผ.
ํ์ธํ๋์ ์ํด์๋ (์๋ณธ ํ ์คํธ, ์์ฝ๋ฌธ) ์์ผ๋ก ์ด๋ฃจ์ด์ง ๋ฐ์ดํฐ๊ฐ ํ์ํด:
import pandas as pd
from datasets import Dataset
# ๋ฐ์ดํฐ ์ค๋น (์์)
data = {
'article': [
"Long article text 1...",
"Long article text 2...",
"Long article text 3..."
],
'summary': [
"Summary 1...",
"Summary 2...",
"Summary 3..."
]
}
df = pd.DataFrame(data)
# Hugging Face Dataset์ผ๋ก ๋ณํ
dataset = Dataset.from_pandas(df)
# ํ์ต/๊ฒ์ฆ ๋ถ๋ฆฌ
dataset = dataset.train_test_split(test_size=0.1)
print(f"ํ์ต ๋ฐ์ดํฐ: {len(dataset['train'])}๊ฐ")
print(f"๊ฒ์ฆ ๋ฐ์ดํฐ: {len(dataset['test'])}๊ฐ")
โข CNN/DailyMail (๋ด์ค)
โข XSum (BBC ๋ด์ค)
โข arXiv (ํ์ ๋ ผ๋ฌธ)
โข PubMed (์๋ฃ ๋ ผ๋ฌธ)
โข MultiNews (๋ค์ค ๋ฌธ์)
์ง์ ์์ง:
โข ์น ํฌ๋กค๋ง
โข ์ฌ๋ด ๋ฌธ์
โข ํฌ๋ผ์ฐ๋์์ฑ
์ต์ 1,000๊ฐ ์ด์์ ์ํ์ด ์์ผ๋ฉด ์ข์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ด! ๐ฏ
from transformers import AutoTokenizer
# ํ ํฌ๋์ด์ ๋ก๋
model_name = "facebook/bart-base"
tokenizer = AutoTokenizer.from_pretrained(model_name)
def preprocess_function(examples):
"""๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ ํจ์"""
# ์
๋ ฅ ํ
์คํธ ํ ํฐํ
inputs = tokenizer(
examples['article'],
max_length=1024,
truncation=True,
padding='max_length'
)
# ํ๊ฒ ์์ฝ๋ฌธ ํ ํฐํ
targets = tokenizer(
examples['summary'],
max_length=128,
truncation=True,
padding='max_length'
)
inputs['labels'] = targets['input_ids']
return inputs
# ๋ฐ์ดํฐ์
์ ์ ์ฒ๋ฆฌ ์ ์ฉ
tokenized_dataset = dataset.map(
preprocess_function,
batched=True,
remove_columns=['article', 'summary']
)
print("์ ์ฒ๋ฆฌ ์๋ฃ!")
from transformers import (
AutoModelForSeq2SeqLM,
Seq2SeqTrainingArguments,
Seq2SeqTrainer,
DataCollatorForSeq2Seq
)
# ๋ชจ๋ธ ๋ก๋
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
# ํ์ต ํ๋ผ๋ฏธํฐ ์ค์
training_args = Seq2SeqTrainingArguments(
output_dir="./results",
evaluation_strategy="epoch",
learning_rate=2e-5,
per_device_train_batch_size=4,
per_device_eval_batch_size=4,
num_train_epochs=3,
weight_decay=0.01,
save_total_limit=3,
predict_with_generate=True,
fp16=True, # Mixed precision (GPU ํ์)
push_to_hub=False,
logging_dir='./logs',
logging_steps=100,
save_steps=500
)
# ๋ฐ์ดํฐ ์ฝ๋ ์ดํฐ
data_collator = DataCollatorForSeq2Seq(
tokenizer=tokenizer,
model=model
)
# Trainer ์ด๊ธฐํ
trainer = Seq2SeqTrainer(
model=model,
args=training_args,
train_dataset=tokenized_dataset['train'],
eval_dataset=tokenized_dataset['test'],
tokenizer=tokenizer,
data_collator=data_collator
)
print("ํ์ต ์ค๋น ์๋ฃ!")
# ํ์ต ์์
print("ํ์ต ์์...")
trainer.train()
# ๋ชจ๋ธ ์ ์ฅ
trainer.save_model("./my_summarizer")
tokenizer.save_pretrained("./my_summarizer")
print("ํ์ต ์๋ฃ! ๋ชจ๋ธ์ด ์ ์ฅ๋์์ต๋๋ค.")
from transformers import pipeline
# ์ปค์คํ
๋ชจ๋ธ ๋ก๋
my_summarizer = pipeline(
"summarization",
model="./my_summarizer",
tokenizer="./my_summarizer"
)
# ํ
์คํธ
text = "Your domain-specific text..."
result = my_summarizer(text, max_length=100, min_length=30)
print(result[0]['summary_text'])
2. ๊ณผ์ ํฉ: Early stopping๊ณผ ์ ๊ทํ ์ ์ฉ
3. ํ์ต ์๊ฐ: GPU ์ฌ์ฉ ๊ถ์ฅ (CPU๋ ๋งค์ฐ ๋๋ฆผ)
4. ๋ฐ์ดํฐ ํ์ง: ๋ ธ์ด์ฆ ์ ๊ฑฐ์ ์ ์ฒ๋ฆฌ๊ฐ ์ค์
5. ํ๊ฐ: ROUGE ์ ์๋ก ์ ๊ธฐ์ ์ผ๋ก ์ฑ๋ฅ ์ฒดํฌ
ํด๋ผ์ฐ๋ GPU (Colab, AWS, Azure)๋ฅผ ํ์ฉํ๋ฉด ๋น์ฉ ํจ์จ์ ์ผ๋ก ํ์ตํ ์ ์์ด! โ๏ธ
2. Gradient Accumulation: ์์ ๋ฐฐ์น๋ก ํฐ ๋ฐฐ์น ํจ๊ณผ
3. Mixed Precision: FP16์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ
4. LoRA/QLoRA: ํ๋ผ๋ฏธํฐ ํจ์จ์ ํ์ธํ๋
5. Checkpoint Averaging: ์ฌ๋ฌ ์ฒดํฌํฌ์ธํธ ํ๊ท
์ด๋ฐ ๊ณ ๊ธ ๊ธฐ๋ฒ๋ค์ ์ฑ๋ฅ์ ํฌ๊ฒ ํฅ์์ํฌ ์ ์์ด! ๐
โก ์ฑ๋ฅ ์ต์ ํ์ ๋ฐฐํฌ ์ ๋ต
๋ชจ๋ธ์ ๋ง๋ค์๋ค๋ฉด ์ด์ ์ค์ ์๋น์ค์ ๋ฐฐํฌํด์ผ ํด. ํ์ง๋ง Transformer ๋ชจ๋ธ์ ํฌ๊ณ ๋๋ ค์ ์ต์ ํ๊ฐ ํ์์ผ! ๐จ
๋ชจ๋ธ ํฌ๊ธฐ๋ฅผ ์ค์ด๊ณ ์ถ๋ก ์๋๋ฅผ ๋์ด๋ ๊ฐ์ฅ ํจ๊ณผ์ ์ธ ๋ฐฉ๋ฒ์ด์ผ:
from transformers import pipeline
import torch
# 8bit ์์ํ ์ฌ์ฉ
summarizer = pipeline(
"summarization",
model="facebook/bart-large-cnn",
device_map="auto",
load_in_8bit=True # 8bit ์์ํ
)
text = "Your text here..."
result = summarizer(text, max_length=60)
print(result[0]['summary_text'])
โข ๋ชจ๋ธ ํฌ๊ธฐ: 100%
โข ์ถ๋ก ์๋: ๊ธฐ์ค
โข ์ ํ๋: 100%
FP16 (Half Precision):
โข ๋ชจ๋ธ ํฌ๊ธฐ: 50%
โข ์ถ๋ก ์๋: 2๋ฐฐ ๋น ๋ฆ
โข ์ ํ๋: 99.9%
INT8 (8bit):
โข ๋ชจ๋ธ ํฌ๊ธฐ: 25%
โข ์ถ๋ก ์๋: 3-4๋ฐฐ ๋น ๋ฆ
โข ์ ํ๋: 98-99%
๋๋ถ๋ถ์ ๊ฒฝ์ฐ INT8๋ก๋ ์ถฉ๋ถํ ์ฑ๋ฅ์ ์ ์งํด! ๐ฏ
ONNX๋ ๋ค์ํ ํ๋ซํผ์์ ๋น ๋ฅด๊ฒ ์คํํ ์ ์๋ ํ์ค ํฌ๋งท์ด์ผ:
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
from optimum.onnxruntime import ORTModelForSeq2SeqLM
# ์๋ณธ ๋ชจ๋ธ ๋ก๋
model_name = "facebook/bart-base"
tokenizer = AutoTokenizer.from_pretrained(model_name)
# ONNX๋ก ๋ณํ ๋ฐ ์ ์ฅ
ort_model = ORTModelForSeq2SeqLM.from_pretrained(
model_name,
export=True
)
ort_model.save_pretrained("./bart_onnx")
tokenizer.save_pretrained("./bart_onnx")
# ONNX ๋ชจ๋ธ ์ฌ์ฉ
from transformers import pipeline
summarizer = pipeline(
"summarization",
model=ort_model,
tokenizer=tokenizer
)
# ์ถ๋ก (๋ ๋น ๋ฆ!)
text = "Your text..."
result = summarizer(text)
print(result[0]['summary_text'])
ํฐ ๋ชจ๋ธ์ ์ง์์ ์์ ๋ชจ๋ธ๋ก ์ ๋ฌํ๋ ๊ธฐ๋ฒ์ด์ผ:
from transformers import pipeline
# ์ฆ๋ฅ๋ ๋ชจ๋ธ ์ฌ์ฉ (ํจ์ฌ ์๊ณ ๋น ๋ฆ)
summarizer = pipeline(
"summarization",
model="sshleifer/distilbart-cnn-12-6" # BART์ ์ฆ๋ฅ ๋ฒ์
)
text = "Your text..."
result = summarizer(text, max_length=60)
print(result[0]['summary_text'])
# ์ฑ๋ฅ ๋น๊ต
# bart-large-cnn: 400M ํ๋ผ๋ฏธํฐ, ๋๋ฆผ
# distilbart: 300M ํ๋ผ๋ฏธํฐ, 40% ๋น ๋ฆ, ์ฑ๋ฅ 95% ์ ์ง
๊ฐ์ ํ ์คํธ๋ฅผ ๋ฐ๋ณต ์์ฝํ์ง ์๋๋ก ์บ์ฑ์ ๊ตฌํํ์:
import hashlib
import json
from functools import lru_cache
class CachedSummarizer:
def __init__(self, model_name="facebook/bart-large-cnn"):
from transformers import pipeline
self.summarizer = pipeline("summarization", model=model_name)
self.cache = {}
def _get_cache_key(self, text, max_length, min_length):
"""ํ
์คํธ ํด์๋ก ์บ์ ํค ์์ฑ"""
content = f"{text}_{max_length}_{min_length}"
return hashlib.md5(content.encode()).hexdigest()
def summarize(self, text, max_length=130, min_length=30):
"""์บ์๋ฅผ ํ์ฉํ ์์ฝ"""
cache_key = self._get_cache_key(text, max_length, min_length)
# ์บ์ ํ์ธ
if cache_key in self.cache:
print("์บ์์์ ๊ฐ์ ธ์ด!")
return self.cache[cache_key]
# ์๋ก ์์ฝ
print("์๋ก ์์ฝ ์ค...")
result = self.summarizer(
text,
max_length=max_length,
min_length=min_length
)
summary = result[0]['summary_text']
# ์บ์ ์ ์ฅ
self.cache[cache_key] = summary
return summary
# ์ฌ์ฉ
summarizer = CachedSummarizer()
text = "Same text..."
summary1 = summarizer.summarize(text) # ์๋ก ์์ฝ
summary2 = summarizer.summarize(text) # ์บ์์์ ๊ฐ์ ธ์ด (๋น ๋ฆ!)
์ฌ๋ฌ ์์ฒญ์ ๋์์ ์ฒ๋ฆฌํ๋ ค๋ฉด ๋น๋๊ธฐ ๋ฐฉ์์ด ํ์ํด:
import asyncio
from concurrent.futures import ThreadPoolExecutor
from transformers import pipeline
class AsyncSummarizer:
def __init__(self, model_name="facebook/bart-large-cnn"):
self.summarizer = pipeline("summarization", model=model_name)
self.executor = ThreadPoolExecutor(max_workers=4)
async def summarize_async(self, text, max_length=130, min_length=30):
"""๋น๋๊ธฐ ์์ฝ"""
loop = asyncio.get_event_loop()
result = await loop.run_in_executor(
self.executor,
lambda: self.summarizer(
text,
max_length=max_length,
min_length=min_length
)
)
return result[0]['summary_text']
async def summarize_batch_async(self, texts):
"""์ฌ๋ฌ ํ
์คํธ ๋์ ์ฒ๋ฆฌ"""
tasks = [self.summarize_async(text) for text in texts]
return await asyncio.gather(*tasks)
# ์ฌ์ฉ
async def main():
summarizer = AsyncSummarizer()
texts = [
"Text 1...",
"Text 2...",
"Text 3..."
]
# ๋์์ ์ฒ๋ฆฌ
summaries = await summarizer.summarize_batch_async(texts)
for i, summary in enumerate(summaries):
print(f"Summary {i+1}: {summary}")
# ์คํ
asyncio.run(main())
โข ์ฅ์ : ์ค์ ๋ถํ์, ์๋ ์ค์ผ์ผ๋ง
โข ๋จ์ : ๋น์ฉ, API ์ ํ
โข ์ถ์ฒ: ํ๋กํ ํ์ , ์๊ท๋ชจ ์๋น์ค
AWS SageMaker:
โข ์ฅ์ : ๊ฐ๋ ฅํ ์ธํ๋ผ, ๋ชจ๋ํฐ๋ง
โข ๋จ์ : ๋ณต์กํ ์ค์ , ๋น์ฉ
โข ์ถ์ฒ: ๋๊ท๋ชจ ์ํฐํ๋ผ์ด์ฆ
Docker + Kubernetes:
โข ์ฅ์ : ์ ์ฐ์ฑ, ํ์ฅ์ฑ
โข ๋จ์ : ๊ด๋ฆฌ ๋ณต์ก๋
โข ์ถ์ฒ: ์ค๋๊ท๋ชจ ์๋น์ค
Streamlit/Gradio:
โข ์ฅ์ : ๋น ๋ฅธ ํ๋กํ ํ์
โข ๋จ์ : ์ ํ์ ์ปค์คํฐ๋ง์ด์ง
โข ์ถ์ฒ: ๋ฐ๋ชจ, ๋ด๋ถ ๋๊ตฌ
2. ๋ฐฐ์น ์ฒ๋ฆฌ: ์ฌ๋ฌ ์์ฒญ ๋ฌถ์ด์ ์ฒ๋ฆฌ
3. ์บ์ฑ: ์ค๋ณต ์์ฒญ ๋ฐฉ์ง
4. ์คํ ์ค์ผ์ผ๋ง: ํธ๋ํฝ์ ๋ฐ๋ผ ์๋ ์กฐ์
5. Spot ์ธ์คํด์ค: AWS/GCP ์ ๋ ดํ ์ธ์คํด์ค ํ์ฉ
6. Edge ๋ฐฐํฌ: ํด๋ผ์ด์ธํธ ์ธก์์ ์คํ (๋ชจ๋ฐ์ผ ์ฑ ๋ฑ)
์์ ๋ชจ๋ธ(distilbart)๋ก ์์ํด์ ํ์์ ํฐ ๋ชจ๋ธ๋ก ์ ๊ทธ๋ ์ด๋ํ๋ ์ ๋ต์ด ์ข์! ๐
๐ ๋ฌธ์ ํด๊ฒฐ๊ณผ ๋๋ฒ๊น
์ค์ ์์๋ ํญ์ ์์์น ๋ชปํ ๋ฌธ์ ๊ฐ ๋ฐ์ํด. ์์ฃผ ๋ง๋๋ ์ด์๋ค๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์์๋ณด์! ๐ง
์์ธ: ๋ชจ๋ธ์ด๋ ๋ฐฐ์น ํฌ๊ธฐ๊ฐ GPU/RAM ์ฉ๋์ ์ด๊ณผ
# ํด๊ฒฐ ๋ฐฉ๋ฒ 1: ๋ฐฐ์น ํฌ๊ธฐ ์ค์ด๊ธฐ
summarizer = pipeline(
"summarization",
model="facebook/bart-large-cnn",
device=0
)
# ํ ๋ฒ์ ํ๋์ฉ ์ฒ๋ฆฌ
for text in texts:
result = summarizer(text, max_length=60)
print(result[0]['summary_text'])
# ํด๊ฒฐ ๋ฐฉ๋ฒ 2: ๋ ์์ ๋ชจ๋ธ ์ฌ์ฉ
summarizer = pipeline(
"summarization",
model="facebook/bart-base" # large ๋์ base
)
# ํด๊ฒฐ ๋ฐฉ๋ฒ 3: 8bit ์์ํ
summarizer = pipeline(
"summarization",
model="facebook/bart-large-cnn",
device_map="auto",
load_in_8bit=True
)
# ํด๊ฒฐ ๋ฐฉ๋ฒ 4: CPU ์ฌ์ฉ
summarizer = pipeline(
"summarization",
model="facebook/bart-large-cnn",
device=-1 # CPU ์ฌ์ฉ
)
์์ธ: ๋ถ์ ์ ํ ํ๋ผ๋ฏธํฐ, ๋ชจ๋ธ ์ ํ ์ค๋ฅ, ๋ฐ์ดํฐ ํ์ง ๋ฌธ์
# ํด๊ฒฐ ๋ฐฉ๋ฒ 1: ํ๋ผ๋ฏธํฐ ์กฐ์
result = summarizer(
text,
max_length=130, # ๋๋ฌด ์งง์ง ์๊ฒ
min_length=30, # ์ต์ ๊ธธ์ด ๋ณด์ฅ
do_sample=False, # Greedy decoding
num_beams=4, # Beam search ์ฌ์ฉ
length_penalty=2.0, # ๊ธด ๋ฌธ์ฅ ์ ํธ
no_repeat_ngram_size=3, # ๋ฐ๋ณต ๋ฐฉ์ง
early_stopping=True
)
# ํด๊ฒฐ ๋ฐฉ๋ฒ 2: ๋ค๋ฅธ ๋ชจ๋ธ ์๋
models_to_try = [
"facebook/bart-large-cnn",
"google/pegasus-xsum",
"t5-base",
"sshleifer/distilbart-cnn-12-6"
]
for model_name in models_to_try:
summarizer = pipeline("summarization", model=model_name)
result = summarizer(text, max_length=60)
print(f"{model_name}: {result[0]['summary_text']}\n")
# ํด๊ฒฐ ๋ฐฉ๋ฒ 3: ํ
์คํธ ์ ์ฒ๋ฆฌ
def preprocess_text(text):
"""ํ
์คํธ ์ ์ """
# ๋ถํ์ํ ๊ณต๋ฐฑ ์ ๊ฑฐ
text = " ".join(text.split())
# ํน์๋ฌธ์ ์ ๋ฆฌ
text = text.replace('\n', ' ')
# ๋๋ฌด ์งง์ ํ
์คํธ ํํฐ๋ง
if len(text.split()) < 50:
return None
return text
cleaned_text = preprocess_text(text)
if cleaned_text:
result = summarizer(cleaned_text)
print(result[0]['summary_text'])
์์ธ: CPU ์ฌ์ฉ, ํฐ ๋ชจ๋ธ, ์ต์ ํ ๋ถ์กฑ
# ํด๊ฒฐ ๋ฐฉ๋ฒ 1: GPU ์ฌ์ฉ
import torch
device = 0 if torch.cuda.is_available() else -1
summarizer = pipeline("summarization", device=device)
# ํด๊ฒฐ ๋ฐฉ๋ฒ 2: ๋ชจ๋ธ ์ต์ ํ
from optimum.onnxruntime import ORTModelForSeq2SeqLM
ort_model = ORTModelForSeq2SeqLM.from_pretrained(
"facebook/bart-base",
export=True
)
summarizer = pipeline("summarization", model=ort_model)
# ํด๊ฒฐ ๋ฐฉ๋ฒ 3: ๋ฐฐ์น ์ฒ๋ฆฌ
texts = ["text1", "text2", "text3"]
results = summarizer(texts, batch_size=4)
# ํด๊ฒฐ ๋ฐฉ๋ฒ 4: ๋ ์์ ๋ชจ๋ธ
summarizer = pipeline(
"summarization",
model="sshleifer/distilbart-cnn-6-6" # ๊ฐ์ฅ ์์ ๋ฒ์
)
# ํด๊ฒฐ ๋ฐฉ๋ฒ 5: ํ
์คํธ ๊ธธ์ด ์ ํ
def truncate_text(text, max_words=500):
words = text.split()
if len(words) > max_words:
return " ".join(words[:max_words])
return text
short_text = truncate_text(long_text)
result = summarizer(short_text)
์์ธ: ์์ด ์ ์ฉ ๋ชจ๋ธ ์ฌ์ฉ
# ํด๊ฒฐ ๋ฐฉ๋ฒ 1: ๋ค๊ตญ์ด ๋ชจ๋ธ ์ฌ์ฉ
from transformers import pipeline
summarizer = pipeline(
"summarization",
model="google/mt5-base" # ๋ค๊ตญ์ด ์ง์
)
korean_text = """
ํ๊ตญ์ด๋ก ์์ฑ๋ ๊ธด ํ
์คํธ...
"""
result = summarizer(korean_text, max_length=100)
print(result[0]['summary_text'])
# ํด๊ฒฐ ๋ฐฉ๋ฒ 2: ํ๊ตญ์ด ํนํ ๋ชจ๋ธ
summarizer = pipeline(
"summarization",
model="eenzeenee/t5-base-korean-summarization"
)
# ํด๊ฒฐ ๋ฐฉ๋ฒ 3: ๋ฒ์ญ ํ ์์ฝ (์ฐํ ๋ฐฉ๋ฒ)
from transformers import pipeline
translator = pipeline("translation", model="Helsinki-NLP/opus-mt-ko-en")
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
back_translator = pipeline("translation", model="Helsinki-NLP/opus-mt-en-ko")
# ํ๊ตญ์ด -> ์์ด -> ์์ฝ -> ํ๊ตญ์ด
korean_text = "ํ๊ตญ์ด ํ
์คํธ..."
english_text = translator(korean_text)[0]['translation_text']
summary_english = summarizer(english_text)[0]['summary_text']
summary_korean = back_translator(summary_english)[0]['translation_text']
print(summary_korean)
์์ธ: ๋คํธ์ํฌ ๋ฌธ์ , Hugging Face Hub ์ ๊ทผ ์ ํ
# ํด๊ฒฐ ๋ฐฉ๋ฒ 1: ์ฌ์๋ ๋ก์ง
from transformers import pipeline
import time
def load_model_with_retry(model_name, max_retries=3):
for i in range(max_retries):
try:
summarizer = pipeline("summarization", model=model_name)
return summarizer
except Exception as e:
print(f"์๋ {i+1} ์คํจ: {e}")
if i < max_retries - 1:
time.sleep(5)
else:
raise
summarizer = load_model_with_retry("facebook/bart-large-cnn")
# ํด๊ฒฐ ๋ฐฉ๋ฒ 2: ๋ก์ปฌ ์บ์ ์ฌ์ฉ
from transformers import pipeline
import os
# ์บ์ ๋๋ ํ ๋ฆฌ ์ค์
os.environ['TRANSFORMERS_CACHE'] = './model_cache'
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
# ํด๊ฒฐ ๋ฐฉ๋ฒ 3: ์๋ ๋ค์ด๋ก๋
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
model_name = "facebook/bart-large-cnn"
# ์๋์ผ๋ก ๋ค์ด๋ก๋ ๋ฐ ์ ์ฅ
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
tokenizer.save_pretrained("./local_model")
model.save_pretrained("./local_model")
# ๋ก์ปฌ์์ ๋ก๋
summarizer = pipeline("summarization", model="./local_model")
โ Transformers ๋ฒ์ ํ์ธ (์ต์ ๋ฒ์ ๊ถ์ฅ)
โ PyTorch/TensorFlow ์ค์น ํ์ธ
โ GPU ๋๋ผ์ด๋ฒ ๋ฐ CUDA ๋ฒ์ ํ์ธ
โ ์ถฉ๋ถํ ๋์คํฌ ๊ณต๊ฐ (๋ชจ๋ธ ์บ์์ฉ)
โ ๋คํธ์ํฌ ์ฐ๊ฒฐ ์ํ
โ ์ ๋ ฅ ํ ์คํธ ์ธ์ฝ๋ฉ (UTF-8)
โ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ๋ชจ๋ํฐ๋ง
๋ฌธ์ ๊ฐ ๊ณ์๋๋ฉด GitHub Issues๋ Hugging Face ํฌ๋ผ์์ ๋์์ ๋ฐ์ ์ ์์ด! ๐ค
๐ ์ค์ ํ์ฉ ์ฌ๋ก์ ํ
์ด๋ก ๊ณผ ๊ธฐ์ ์ ๋ฐฐ์ ์ผ๋, ์ด์ ์ค์ ๋ก ์ด๋ป๊ฒ ํ์ฉํ ์ ์๋์ง ๊ตฌ์ฒด์ ์ธ ์ฌ๋ก๋ฅผ ์ดํด๋ณด์! ๐ผ
from transformers import pipeline
import feedparser
from datetime import datetime
class NewsCurator:
def __init__(self):
self.summarizer = pipeline(
"summarization",
model="facebook/bart-large-cnn"
)
def fetch_rss_feeds(self, rss_urls):
"""RSS ํผ๋์์ ๋ด์ค ๊ฐ์ ธ์ค๊ธฐ"""
articles = []
for url in rss_urls:
feed = feedparser.parse(url)
for entry in feed.entries[:10]: # ์ต์ 10๊ฐ
articles.append({
'title': entry.title,
'content': entry.summary,
'link': entry.link,
'published': entry.published
})
return articles
def create_digest(self, articles):
"""๋ด์ค ๋ค์ด์ ์คํธ ์์ฑ"""
digest = []
for article in articles:
try:
summary = self.summarizer(
article['content'],
max_length=60,
min_length=20
)[0]['summary_text']
digest.append({
'title': article['title'],
'summary': summary,
'link': article['link']
})
except:
continue
return digest
def format_digest(self, digest):
"""์ฝ๊ธฐ ์ข์ ํ์์ผ๋ก ํฌ๋งท"""
output = f"๐ฐ ์ค๋์ ๋ด์ค ๋ค์ด์ ์คํธ ({datetime.now().strftime('%Y-%m-%d')})\n\n"
for i, item in enumerate(digest, 1):
output += f"{i}. {item['title']}\n"
output += f" {item['summary']}\n"
output += f" ๐ {item['link']}\n\n"
return output
# ์ฌ์ฉ
curator = NewsCurator()
rss_feeds = [
"http://rss.cnn.com/rss/cnn_topstories.rss",
"http://feeds.bbci.co.uk/news/rss.xml"
]
articles = curator.fetch_rss_feeds(rss_feeds)
digest = curator.create_digest(articles)
formatted = curator.format_digest(digest)
print(formatted)
from transformers import pipeline
import re
class MeetingMinutesSummarizer:
def __init__(self):
self.summarizer = pipeline(
"summarization",
model="facebook/bart-large-cnn"
)
def extract_sections(self, transcript):
"""ํ์๋ก์ ์น์
๋ณ๋ก ๋ถ๋ฆฌ"""
sections = {
'agenda': [],
'discussion': [],
'decisions': [],
'action_items': []
}
# ํค์๋ ๊ธฐ๋ฐ ์น์
๋ถ๋ฆฌ
current_section = 'discussion'
for line in transcript.split('\n'):
line = line.strip()
if not line:
continue
if 'agenda' in line.lower():
current_section = 'agenda'
elif 'decision' in line.lower():
current_section = 'decisions'
elif 'action' in line.lower() or 'todo' in line.lower():
current_section = 'action_items'
else:
sections[current_section].append(line)
return sections
def summarize_meeting(self, transcript):
"""ํ์ ์ ์ฒด ์์ฝ"""
sections = self.extract_sections(transcript)
summary = "๐ ํ์ ์์ฝ\n\n"
# ์ ์ฒด ๋
ผ์ ์์ฝ
if sections['discussion']:
discussion_text = " ".join(sections['discussion'])
if len(discussion_text.split()) > 50:
discussion_summary = self.summarizer(
discussion_text,
max_length=100,
min_length=30
)[0]['summary_text']
summary += f"๐ฌ ์ฃผ์ ๋
ผ์:\n{discussion_summary}\n\n"
# ๊ฒฐ์ ์ฌํญ
if sections['decisions']:
summary += "โ
๊ฒฐ์ ์ฌํญ:\n"
for decision in sections['decisions']:
summary += f" โข {decision}\n"
summary += "\n"
# ์ก์
์์ดํ
if sections['action_items']:
summary += "๐ ์ก์
์์ดํ
:\n"
for item in sections['action_items']:
summary += f" โข {item}\n"
return summary
# ์ฌ์ฉ
summarizer = MeetingMinutesSummarizer()
transcript = """
Meeting Transcript - Product Planning
Agenda: Discuss Q4 product roadmap
Discussion:
John: We need to prioritize the mobile app development.
Sarah: I agree, but we should also focus on improving the API.
Mike: The customer feedback suggests we need better analytics.
John: Let's allocate more resources to the mobile team.
Decisions:
- Increase mobile team by 2 developers
- Launch new analytics dashboard by end of Q4
Action Items:
- John: Hire 2 mobile developers by next month
- Sarah: Prepare API improvement proposal
- Mike: Design analytics dashboard mockups
"""
summary = summarizer.summarize_meeting(transcript)
print(summary)
from transformers import pipeline
import arxiv
class PaperSummarizer:
def __init__(self):
self.summarizer = pipeline(
"summarization",
model="allenai/led-base-16384" # ๊ธด ๋ฌธ์์ฉ
)
def fetch_paper(self, arxiv_id):
"""arXiv์์ ๋
ผ๋ฌธ ๊ฐ์ ธ์ค๊ธฐ"""
search = arxiv.Search(id_list=[arxiv_id])
paper = next(search.results())
return {
'title': paper.title,
'authors': [author.name for author in paper.authors],
'abstract': paper.summary,
'pdf_url': paper.pdf_url
}
def summarize_abstract(self, abstract):
"""์ด๋ก ์์ฝ"""
if len(abstract.split()) < 100:
return abstract
summary = self.summarizer(
abstract,
max_length=80,
min_length=30
)[0]['summary_text']
return summary
def create_paper_summary(self, arxiv_id):
"""๋
ผ๋ฌธ ์์ฝ ์์ฑ"""
paper = self.fetch_paper(arxiv_id)
summary = self.summarize_abstract(paper['abstract'])
output = f"๐ {paper['title']}\n\n"
output += f"๐ฅ ์ ์: {', '.join(paper['authors'][:3])}"
if len(paper['authors']) > 3:
output += f" ์ธ {len(paper['authors'])-3}๋ช
"
output += f"\n\n๐ ์์ฝ:\n{summary}\n\n"
output += f"๐ PDF: {paper['pdf_url']}"
return output
# ์ฌ์ฉ
summarizer = PaperSummarizer()
# Attention Is All You Need ๋
ผ๋ฌธ
paper_summary = summarizer.create_paper_summary("1706.03762")
print(paper_summary)
ํ์ : allenai/led-base-16384, ๊ธฐ์ ์ฉ์ด ๋ณด์กด
๋ฒ๋ฅ : ์ปค์คํ ํ์ธํ๋, ์ ํ์ฑ ์ต์ฐ์
์๋ฃ: BioBERT ๊ธฐ๋ฐ ๋ชจ๋ธ, ์ ๋ฌธ ์ฉ์ด ์ฒ๋ฆฌ
๋น์ฆ๋์ค: ์ก์ ์์ดํ ์ถ์ถ, ๊ตฌ์กฐํ๋ ์์ฝ
SNS: ๋น ๋ฅธ ์ถ๋ก , ์งง์ ์์ฝ, ๊ฐ์ฑ ๋ณด์กด
๊ฐ ๋๋ฉ์ธ๋ง๋ค ํน์ฑ์ด ๋ค๋ฅด๋ ์ ์ ํ ๋ชจ๋ธ๊ณผ ํ๋ผ๋ฏธํฐ๋ฅผ ์ ํํ๋ ๊ฒ ์ค์ํด! ๐ฏ
from transformers import pipeline
from collections import Counter
import re
class ReviewSummarizer:
def __init__(self):
self.summarizer = pipeline(
"summarization",
model="facebook/bart-large-cnn"
)
def aggregate_reviews(self, reviews):
"""์ฌ๋ฌ ๋ฆฌ๋ทฐ๋ฅผ ํ๋์ ํ
์คํธ๋ก ํฉ์น๊ธฐ"""
# ๊ธ์ /๋ถ์ ๋ถ๋ฆฌ
positive = []
negative = []
for review in reviews:
if review['rating'] >= 4:
positive.append(review['text'])
else:
negative.append(review['text'])
return {
'positive': " ".join(positive),
'negative': " ".join(negative)
}
def extract_keywords(self, text):
"""์ฃผ์ ํค์๋ ์ถ์ถ"""
words = re.findall(r'\b\w+\b', text.lower())
# ๋ถ์ฉ์ด ์ ๊ฑฐ (๊ฐ๋จํ ์์)
stopwords = {'the', 'a', 'an', 'and', 'or', 'but', 'is', 'are'}
words = [w for w in words if w not in stopwords and len(w) > 3]
return Counter(words).most_common(10)
def create_review_summary(self, reviews):
"""๋ฆฌ๋ทฐ ์ข
ํฉ ์์ฝ"""
aggregated = self.aggregate_reviews(reviews)
summary = "โญ ๊ณ ๊ฐ ๋ฆฌ๋ทฐ ์์ฝ\n\n"
# ๊ธ์ ์ ๋ฆฌ๋ทฐ ์์ฝ
if aggregated['positive']:
pos_summary = self.summarizer(
aggregated['positive'][:1000], # ๊ธธ์ด ์ ํ
max_length=80,
min_length=20
)[0]['summary_text']
summary += f"๐ ๊ธ์ ์ ์๊ฒฌ:\n{pos_summary}\n\n"
# ๋ถ์ ์ ๋ฆฌ๋ทฐ ์์ฝ
if aggregated['negative']:
neg_summary = self.summarizer(
aggregated['negative'][:1000],
max_length=80,
min_length=20
)[0]['summary_text']
summary += f"๐ ๊ฐ์ ํ์ ์ฌํญ:\n{neg_summary}\n\n"
# ์ฃผ์ ํค์๋
all_text = aggregated['positive'] + " " + aggregated['negative']
keywords = self.extract_keywords(all_text)
summary += "๐ ์ฃผ์ ํค์๋:\n"
summary += ", ".join([f"{word}({count})" for word, count in keywords[:5]])
return summary
# ์ฌ์ฉ
summarizer = ReviewSummarizer()
reviews = [
{'rating': 5, 'text': 'Great product! Fast delivery and excellent quality.'},
{'rating': 4, 'text': 'Good value for money. Works as expected.'},
{'rating': 2, 'text': 'Disappointed with the build quality. Too expensive.'},
{'rating': 5, 'text': 'Amazing! Exceeded my expectations.'},
{'rating': 3, 'text': 'Average product. Nothing special but does the job.'}
]
summary = summarizer.create_review_summary(reviews)
print(summary)
์ด๋ฐ ์ค์ ์์ ๋ค์ ํฌํธํด๋ฆฌ์ค์ ์ถ๊ฐํ๋ฉด, ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ AI ๊ฐ๋ฐ ์ฌ๋ฅ์ ํ๋งคํ ๋ ํฐ ๋์์ด ๋ ๊ฑฐ์ผ! ์ค์ ๋น์ฆ๋์ค ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฅ๋ ฅ์ ๋ณด์ฌ์ค ์ ์๊ฑฐ๋ . ๐
๐ฏ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์! ์ฌ๊ธฐ๊น์ง ์ ๋ง ๊ธด ์ฌ์ ์ด์์ด. Transformers Pipeline์ ํ์ฉํ ํ
์คํธ ์์ฝ์ ๋ํด ์ ๋ง ๋ง์ ๊ฑธ ๋ฐฐ์ ์ง? ๐
๊ฐ๋จํ Pipeline ์ฌ์ฉ๋ฒ๋ถํฐ ์์ํด์, ๋ค์ํ ๋ชจ๋ธ ๋น๊ต, ๊ณ ๊ธ ํ๋ผ๋ฏธํฐ ์ค์ , ์ค์ ํ๋ก์ ํธ ๊ตฌํ, ์ต์ ํ ๊ธฐ๋ฒ, ๊ทธ๋ฆฌ๊ณ ์ค์ ๋น์ฆ๋์ค ํ์ฉ ์ฌ๋ก๊น์ง ๋ค๋ค์ด. ์ด ์ ๋๋ฉด ์ค๋ฌด์์ ๋ฐ๋ก ํ์ฉํ ์ ์๋ ์์ค์ด์ผ! ๐ช
2. ๋ชจ๋ธ ์ ํ์ ์ค์์ฑ: ์์ ์ ๋ง๋ ์ ์ ํ ๋ชจ๋ธ ์ ํ
3. ํ๋ผ๋ฏธํฐ ํ๋: ํ์ง๊ณผ ์๋์ ๊ท ํ ์ฐพ๊ธฐ
4. ์ต์ ํ ํ์: ์ค์๋น์ค๋ฅผ ์ํ ์ฑ๋ฅ ๊ฐ์
5. ๋๋ฉ์ธ ํนํ: ๊ฐ ๋ถ์ผ์ ๋ง๋ ์ปค์คํฐ๋ง์ด์ง
6. ์ง์์ ํ์ต: ์๋ก์ด ๋ชจ๋ธ๊ณผ ๊ธฐ๋ฒ ๊ณ์ ํ๊ตฌ
โข ๋ค์ํ ๋ชจ๋ธ ์คํํด๋ณด๊ธฐ
โข ๊ฐ๋จํ ์น ์ฑ ๋ง๋ค์ด๋ณด๊ธฐ
โข ๊ณต๊ฐ ๋ฐ์ดํฐ์ ์ผ๋ก ์ฐ์ต
์ค๊ธ์:
โข ์ปค์คํ ๋ฐ์ดํฐ๋ก ํ์ธํ๋
โข ํ๋ก๋์ ๋ฐฐํฌ ๊ฒฝํ
โข ์ฑ๋ฅ ์ต์ ํ ์ฌํ
๊ณ ๊ธ์:
โข ์๋ก์ด ์ํคํ ์ฒ ์ฐ๊ตฌ
โข ๋๊ท๋ชจ ์์คํ ๊ตฌ์ถ
โข ์คํ์์ค ๊ธฐ์ฌ
์ด๋ค ๋ ๋ฒจ์ด๋ ๊ณ์ ์คํํ๊ณ ๋ฐฐ์ฐ๋ ๊ฒ ์ค์ํด! ๐ฏ
AI ๊ธฐ์ ์ ๋น ๋ฅด๊ฒ ๋ฐ์ ํ๊ณ ์์ด. ์ค๋ ๋ฐฐ์ด ๋ด์ฉ๋ ๋ช ๋ฌ ํ๋ฉด ๋ ์ข์ ๋ฐฉ๋ฒ์ด ๋์ฌ ์ ์์ง. ํ์ง๋ง ๊ธฐ๋ณธ ์๋ฆฌ์ ์ ๊ทผ ๋ฐฉ์์ ๋ณํ์ง ์์. ์ด ๊ธ์์ ๋ฐฐ์ด ๊ฐ๋
๋ค์ ๋ฐํ์ผ๋ก ๊ณ์ ์๋ก์ด ๊ธฐ์ ์ ์ตํ๋๊ฐ๋ฉด ๋ผ! ๐
ํ
์คํธ ์์ฝ์ ์ ๋ง ์ค์ฉ์ ์ธ ๊ธฐ์ ์ด์ผ. ๋ด์ค, ์ฐ๊ตฌ, ๋น์ฆ๋์ค, ๊ต์ก ๋ฑ ๊ฑฐ์ ๋ชจ๋ ๋ถ์ผ์์ ํ์ฉํ ์ ์๊ฑฐ๋ . ์ฌ๋ฌ๋ถ๋ ์ด ๊ธฐ์ ์ ํ์ฉํด์ ๋ฉ์ง ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ณด๊ธธ ๋ฐ๋ผ! ๐ก
ํน์ ๋ ๊น์ด ๋ฐฐ์ฐ๊ณ ์ถ๊ฑฐ๋, ํ๋ก์ ํธ์ ๋์์ด ํ์ํ๋ค๋ฉด AI/๋จธ์ ๋ฌ๋ ์ ๋ฌธ๊ฐ๋ค์ด ๋ง์ด ํ๋ํ๋ ์ปค๋ฎค๋ํฐ๋ ํ๋ซํผ์ ํ์ฉํด๋ด. ํจ๊ป ๋ฐฐ์ฐ๊ณ ์ฑ์ฅํ๋ ๊ฒ ๊ฐ์ฅ ๋น ๋ฅธ ๊ธธ์ด์ผ! ๐ค
์, ์ด์ ์ฌ๋ฌ๋ถ ์ฐจ๋ก์ผ! ์ค๋ ๋ฐฐ์ด ๋ด์ฉ์ ๋ฐํ์ผ๋ก ์ง์ ์ฝ๋๋ฅผ ์์ฑํด๋ณด๊ณ , ์คํํด๋ณด๊ณ , ๋๋ง์ ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ด. ์คํจ๋ฅผ ๋๋ ค์ํ์ง ๋ง๊ณ , ๊ณ์ ์๋ํ๋ค ๋ณด๋ฉด ์ด๋์ ์ ๋ฌธ๊ฐ๊ฐ ๋์ด ์์ ๊ฑฐ์ผ! ๐
ํ์ด์ ๋น์ด! ํ์ดํ
! ๐โจ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.