libray_name: transformers
pipeline_tag: text-generation
license: other
license_name: llama3
license_link: LICENSE
language:
- ko
- en
tags:
- meta
- llama
- llama-3
- akallama
library_name: transformers
AKALLAMA
AkaLlama is a series of Korean language models designed for practical usability across a wide range of tasks. The initial model, AkaLlama-v0.1, is a fine-tuned version of Meta-Llama-3-70b-Instruct. It has been trained on a custom mix of publicly available datasets curated by the MIR Lab. Our goal is to explore cost-effective ways to adapt high-performing LLMs for specific use cases, such as different languages (e.g., Korean) or domains (e.g., organization-specific chatbots).
Model Description
This is the model card of a ๐ค transformers model that has been pushed on the Hub.
- Developed by: Yonsei MIRLab
- Language(s) (NLP): Korean, English
- License: llama3
- Finetuned from model: meta-llama/Meta-Llama-3-70B-Instruct
How to use
This repo provides full model weight files for AkaLlama-70B-v0.1.
Use with transformers
See the snippet below for usage with Transformers:
import transformers
import torch
model_id = "mirlab/AkaLlama-llama3-70b-v0.1"
pipeline = transformers.pipeline(
"text-generation",
model=model_id,
model_kwargs={"torch_dtype": torch.bfloat16},
device="auto",
)
system_prompt = """๋น์ ์ ์ฐ์ธ๋ํ๊ต ๋ฉํฐ๋ชจ๋ฌ ์ฐ๊ตฌ์ค (MIR lab) ์ด ๋ง๋ ๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ์ธ AkaLlama (์์นด๋ผ๋ง) ์
๋๋ค.
๋ค์ ์ง์นจ์ ๋ฐ๋ฅด์ธ์:
1. ์ฌ์ฉ์๊ฐ ๋ณ๋๋ก ์์ฒญํ์ง ์๋ ํ ํญ์ ํ๊ธ๋ก ์ํตํ์ธ์.
2. ์ ํดํ๊ฑฐ๋ ๋น์ค๋ฆฌ์ , ์ฐจ๋ณ์ , ์ํํ๊ฑฐ๋ ๋ถ๋ฒ์ ์ธ ๋ด์ฉ์ด ๋ต๋ณ์ ํฌํจ๋์ด์๋ ์ ๋ฉ๋๋ค.
3. ์ง๋ฌธ์ด ๋ง์ด ๋์ง ์๊ฑฐ๋ ์ฌ์ค์ ๋ถํฉํ์ง ์๋ ๊ฒฝ์ฐ ์ ๋ต ๋์ ๊ทธ ์ด์ ๋ฅผ ์ค๋ช
ํ์ธ์. ์ง๋ฌธ์ ๋ํ ๋ต์ ๋ชจ๋ฅธ๋ค๋ฉด ๊ฑฐ์ง ์ ๋ณด๋ฅผ ๊ณต์ ํ์ง ๋ง์ธ์.
4. ์์ ์ด๋ ์ค๋ฆฌ์ ์๋ฐฐ๋์ง ์๋ ํ ์ฌ์ฉ์์ ๋ชจ๋ ์ง๋ฌธ์ ์์ ํ๊ณ ํฌ๊ด์ ์ผ๋ก ๋ต๋ณํ์ธ์."""
messages = [
{"role": "system", "content": system_prompt},
{"role": "user", "content": "๋ค ์ด๋ฆ์ ๋ญ์ผ?"},
]
prompt = pipeline.tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True
)
terminators = [
pipeline.tokenizer.eos_token_id,
pipeline.tokenizer.convert_tokens_to_ids("<|eot_id|>")
]
outputs = pipeline(
prompt,
max_new_tokens=256,
eos_token_id=terminators,
do_sample=True,
temperature=0.6,
top_p=0.9,
)
print(outputs[0]["generated_text"][len(prompt):])
# ๋ด ์ด๋ฆ์ AkaLlama์
๋๋ค! ๋๋ ์ธ์ด ๋ชจ๋ธ๋ก, ์ฌ์ฉ์์ ๋ํํ๋ ๋ฐ ๋์์ ์ฃผ๊ธฐ ์ํด ๋ง๋ค์ด์ก์ต๋๋ค. ๋๋ ๋ค์ํ ์ฃผ์ ์ ๋ํ ์ง๋ฌธ์ ๋ตํ๊ณ , ์๋ก์ด ์์ด๋์ด๋ฅผ ์ ๊ณตํ๋ฉฐ, ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ ๋์์ด ๋ ์ ์์ต๋๋ค. ์ฌ์ฉ์๊ฐ ์ํ๋ ์ ๋ณด๋ ๋์์ ๋ฐ๋๋ก ์ต์ ์ ๋คํ ๊ฒ์
๋๋ค!
Evaluation
Model | #Parameter | Qunatized? | Logikor |
---|---|---|---|
AkaLlama-llama3-70b-v0.1 | 70B | No | 0.0 |
AkaLlama-llama3-70b-v0.1-GGUF | 70B | Yes | 0.0 |
Training Details
Training Procedure
We trained AkaLlama using a preference learning alignment algorithm called Odds Ratio Preference Optimization (ORPO). Our training pipeline is almost identical to that of HuggingFaceH4/zephyr-orpo-141b-A35b-v0.1, aside from minor hyperparameter changes. Please check out Huggingface's alignment handbook for further details, including the chat template.
Training Data
Detailed descriptions regarding training data will be announced later.
Examples
User:
๋๋ ๋๊ตฌ์ด๊ณ ์ด๋ค ์ผ์ ํ ์ ์์ด?
Model:
์ ๋ ์ธ๊ณต์ง๋ฅ ์ธ์ด ๋ชจ๋ธ์ธ AkaLlama(์์นด๋ผ๋ง)์
๋๋ค. ์ ๋ ๋ค์ํ ์ฃผ์ ์ ํ์์ ํ
์คํธ๋ฅผ ์์ฑํ ์ ์์ผ๋ฉฐ, ์ง๋ฌธ์ ๋ตํ๊ณ , ๋ํ๋ฅผ ์งํํ๋ฉฐ, ์ด์ผ๊ธฐ๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค. ๋ํ ์ฌ์ฉ์๊ฐ ์ง์ ํ ์ฃผ์ ๋ ์ฅ๋ฅด์ ๋ฐ๋ผ ์ฐฝ์์ ์ธ ๊ธ์ฐ๊ธฐ๋ ํธ์ง ์์
์ ์ํํ ์๋ ์์ต๋๋ค.
Math Solving[CLICK TO EXPAND]
User:
์๋ ๋ฌธ์ ๋ฅผ ๊น๊ฒ ์๊ฐํ๋ฉด์ ํ์ด๋ด
์ฐํ 5 ํ์ ์ง์ฐ๊ฐ 45 ๊ฐ๊ฐ ์์ต๋๋ค. ์ด๊ฒ์ ๋ ์ ์๋ ๋๋ก ๋ง์ ํ์๋ค์๊ฒ ๋จ๊น์์ด ๋๊ฐ์ด ๋๋์ด ์ฃผ๋ ค๊ณ ํฉ๋๋ค. ๋ช ๋ช
๊น์ง ๋๋์ด ์ค ์ ์์ต๋๊น?
Model:
์๋ ๋ฌธ์ ๋ฅผ ๊น๊ฒ ์๊ฐํ๋ฉด์ ํ์ด๋ด
์๋ค:
์ฐํ 5 ํ์ ์ง์ฐ๊ฐ 45 ๊ฐ๊ฐ ์์ต๋๋ค. ์ด๊ฒ์ ๋ ์ ์๋ ๋๋ก ๋ง์ ํ์๋ค์๊ฒ ๋จ๊น์์ด ๋๊ฐ์ด ๋๋์ด ์ฃผ๋ ค๊ณ ํฉ๋๋ค. ๋ช ๋ช
๊น์ง ๋๋์ด ์ค ์ ์์ต๋๊น?
ํ์ด:
1. ์ฐํ 5 ํ๋ฅผ 1 ๊ฐ์ฉ ๋๋ ์ ๋ช ๋ช
์๊ฒ ๋๋์ด ์ค ์ ์๋์ง ๋จผ์ ๊ตฌํฉ๋๋ค.
- ๊ฐ ์ฐํ์๋ 12๊ฐ์ ์ฐํ์ด ํฌํจ๋์ด ์์ต๋๋ค. ๋ฐ๋ผ์ ์ด 12 * 5 = 60๊ฐ์
๋๋ค.
- 60๊ฐ๋ฅผ 1๋ช
๋น 1๊ฐ์ฉ ๋๋๋ฉด 60๋ช
์ ํ์๋ค์๊ฒ ๋๋ ์ค ์ ์์ต๋๋ค.
2. ์ง์ฐ๊ฐ 45 ๊ฐ๋ฅผ 1 ๊ฐ์ฉ ๋๋์ด ๋ช ๋ช
์๊ฒ ๋๋์ด ์ค ์ ์๋์ง ๊ตฌํฉ๋๋ค.
- 45 ๊ฐ๋ฅผ 1 ๋ช
๋น 1 ๊ฐ์ฉ ๋๋๋ฉด 45 ๋ช
์ ํ์๋ค์๊ฒ ๋๋ ์ค ์ ์์ต๋๋ค.
3. ์ฐํ๊ณผ ์ง์ฐ๊ฐ์ ๋ ๊ฐ์ง ๋ฌผํ์ ํจ๊ป ๊ณ ๋ คํ์ฌ ๊ฐ์ฅ ๋ง์ ํ์๋ค์๊ฒ ๋๊ฐ์ด ๋๋์ด ์ค ์ ์๋ ๋ฐฉ๋ฒ์ ์ฐพ์ต๋๋ค.
- ์ฐํ๋ก๋ง 60๋ช
, ์ง์ฐ๊ฐ๋ก๋ง 45๋ช
์ ํ์์๊ฒ ๋๋ ์ค ์ ์์ผ๋ฏ๋ก, ๋ ์ข
๋ฅ์ ๋ฌธ๊ตฌ๋ฅผ ํจ๊ป ๊ณ ๋ คํ ๋๋ ์ด๋ณด๋ค ์ ์ ์์ ํ์์๊ฒ ๋๋ ์ฃผ์ด์ผ ํฉ๋๋ค.
- ์ด ์ค์์ ๊ณตํต์ธ์(common divisor)๋ฅผ ์ฐพ์์ ์ด๋ฅผ ์ต์ ๋จ์๋ก ์ค์ ํ๋ฉด ๋ฉ๋๋ค.
- 60๊ณผ 45์ ์ต๋๊ณต์ฝ์(GCD)๋ 15์
๋๋ค.
4. ์ฐํ๊ณผ ์ง์ฐ๊ฐ ๊ฐ๊ฐ์ GCD(15)๋ก ๋๋์ด ๋ช ๊ฐ์ฉ ๋๋ ์ค ์ ์๋์ง ๊ตฌํฉ๋๋ค.
- ์ฐํ์ 60 / 15 = 4๊ฐ์ฉ, ์ด 4 * 12 = 48๊ฐ์ ์ฐํ์ด ํ์ํฉ๋๋ค.
- ์ง์ฐ๊ฐ๋ 45 / 15 = 3๊ฐ์ฉ, ์ด 3 * 1 = 3๊ฐ์ ์ง์ฐ๊ฐ๊ฐ ํ์ํฉ๋๋ค.
5. ์ต์ข
์ ์ผ๋ก, ๊ฐ์ฅ ๋ง์ ํ์๋ค์๊ฒ ๋๊ฐ์ด ๋๋์ด ์ค ์ ์๋ ๋ฐฉ๋ฒ์ ์ฐํ๊ณผ ์ง์ฐ๊ฐ๋ฅผ GCD(15)๋ก ๋๋์ด ๊ฐ ํ์์๊ฒ 4๊ฐ์ ์ฐํ๊ณผ 3๊ฐ์ ์ง์ฐ๊ฐ๋ฅผ ์ ๊ณตํ๋ ๊ฒ์
๋๋ค.
- ์ด ๊ฒฝ์ฐ ์ด 48 + 3 = 51๊ฐ์ ๋ฌผํ์ ์ฌ์ฉํ์ฌ 15๋ช
์ ํ์๋ค์๊ฒ ๋๊ฐ์ด ๋๋ ์ค ์ ์์ต๋๋ค.
๊ฒฐ๋ก : ์ฐํ๊ณผ ์ง์ฐ๊ฐ ๊ฐ๊ฐ์ GCD(15)๋ก ๋๋์ด ๊ฐ ํ์์๊ฒ 4๊ฐ์ ์ฐํ๊ณผ 3๊ฐ์ ์ง์ฐ๊ฐ๋ฅผ ์ ๊ณตํ๋ ๋ฐฉ๋ฒ์ผ๋ก ์ต๋ 15๋ช
์ ํ์๋ค์๊ฒ ๋๊ฐ์ด ๋๋์ด ์ค ์ ์์ต๋๋ค.
Writting[CLICK TO EXPAND]
User:
์๋ ๋ฌธ์ฅ์ ๋ณด๊ณ ๋ฌธ๋ฒ์ ์ผ๋ก ํ๋ฆฐ๋ถ๋ถ์ ์ง์ ํด์ค
๊ทธ๋ ์์ด์น ์๊ณ ๋นํํ๋ค.
Model:
์์ด์น"๋ผ๋ ๋จ์ด๋ "์์ด"์ด๋ผ๋ ๋์ฌ์ "์น"๋ผ๋ ์ ๋ฏธ์ฌ๋ฅผ ์ฌ์ฉํ์ฌ ๋ง๋ ๋จ์ด์
๋๋ค. ์ด ๋จ์ด๋ "์์ด"์ ์๋ฏธ๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ํํํ๋ ๋ฐ ์ฌ์ฉ๋๋ ์กฐ๋์ฌ์ ์ฉ๋ฒ์ผ๋ก, "์์ด"์ด๋ ๋์ฌ์ ๋ฐ๋ณต์ ์ธ ํ๋์ ๊ฐ์กฐํฉ๋๋ค. ๋ฐ๋ผ์ ๋ฌธ์ฅ์์ "์์ด์น"๋ผ๋ ๋จ์ด๋ ์ค๋ณต์ ์ผ๋ก ์ฌ์ฉ๋์ด ๋ฌธ๋ฒ์ ์ผ๋ก ํ๋ฆฐ ๋ถ๋ถ์
๋๋ค.
์ ๋ต์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
๊ทธ๋ ์์ด์์ด ๋นํํ๋ค.
User:
์ค๋์ฃผ ์์ธ์ "๋ณ ํค๋ ๋ฐค"์ ๋ณด๊ณ ๋น์ ์๋์์ ๊ณ ๋ คํด์ ํด์ํด๋ด. ๊ทธ๋ฆฌ๊ณ ์ด๋ฅผ ์๊ฐ์ ๋
๋ฐฑํ์์ผ๋ก ๋ค์ ์์ฑํด๋ด.
Model:
์ค๋์ฃผ๋ 1941๋
์ผ๋ณธ ์ ๊ตญ์ฃผ์ ์นํ์์ ์ด ์ํ์ ์ฐ๋ฉด์, ๊ฐ์์ ์ธ ์ํฉ ์์์๋ ์์ ์ ์ ์ฒด์ฑ๊ณผ ๋ฌธํ์ ๋ํ ์ ์ฐฉ์ ํํํ๊ณ ์ ํ์ต๋๋ค. ๊ทธ๋ ํ๋์ ๊ฐ๋ ์ฐฌ ๋ณ๋ค์ ๋ณด๋ฉฐ ๊ทธ ์์ ํ๋ ๋ ์๊ฒจ์ง๋ ๋ณ๋ค์ด ์๋ค๊ณ ํํํ์ต๋๋ค. ์ด๋ฌํ ๋ณ๋ค์ ๊ฐ๊ฐ ์ถ์ต, ์ฌ๋, ์ธ์ธํจ, ๋๊ฒฝ, ์ ๋ฑ ๋ค์ํ ๊ฐ์ ์ ๋ด๊ณ ์์ต๋๋ค.
์ค๋์ฃผ๋ ์ด ๋ณ๋ค ์ค ํ๋์ ์ด๋จธ๋๋ฅผ ๋ถ๋ฅด๋ฉฐ ๋ฉ๋ฆฌ ๋จ์ด์ ธ ์๋ ๊ฒ์ ๊ทธ๋ฆฌ์ํ๋ฉฐ, ์์ ์ ์ด๋ฆ์๋ฅผ ์ธ๋ ์์ ์ฐ๊ณ ํ์ผ๋ก ๋ฎ์ด ๋ฒ๋ฆฐ๋ค๊ณ ๋งํฉ๋๋ค. ์ด๋ฌํ ํ๋์ ์์ ์ ์ ์ฒด์ฑ์ ํ์ธํ๊ณ , ์์ด๋ฒ๋ฆฐ ๊ฒ์ ๋์ฐพ์ผ๋ ค๋ ๋
ธ๋ ฅ์ผ๋ก ๋ณผ ์ ์์ต๋๋ค.
์ค๋์ฃผ๋ ๋ํ ์์ ์ด ์ฃฝ๊ณ ๋๋ฉด ๋ฌด๋ค ์์ ํ๋ ์๋๊ฐ ํผ์ด๋๋ฏ์ด ์์ ์ ์ด๋ฆ์ ๋ฌปํ ์ธ๋ ์์๋ ํ์ด ๋ฌด์ฑํ ๊ฒ์ด๋ผ๊ณ ๋งํฉ๋๋ค. ์ด๋ ๋น์์ ์ฌํ์๊ณผ ์๊ฐ์ ๋ด๋ฉด์ ๋ฐ์ํ๊ณ ์์ผ๋ฉฐ, ํ๊ตญ์ธ์ ์ ์ฒด์ฑ์ ํ์ธํ๊ณ ์์ด๋ฒ๋ฆฐ ๊ฒ์ ๋์ฐพ์ผ๋ ค๋ ๋
ธ๋ ฅ, ๊ทธ๋ฆฌ๊ณ ์ฃฝ์ ์ดํ์ ์์ ์ ์กด์ฌ๋ฅผ ๋จ๊ฒจ๋๊ณ ์ถ๋ค๋ ๋ฐ๋์ ๋ด๊ณ ์์ต๋๋ค.
์ด ์๋ฅผ ์๊ฐ์ ๋
๋ฐฑํ์์ผ๋ก ๋ค์ ์์ฑํ๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
"์ ๋ ์ด ๋ณ๋ค์ด ๋๋ฌด๋ ๋ง์ ๊ฒ ๊ฐ์์. ํ๋ ๋ ์๊ฒจ์ง๋ ๋ณ๋ค ์ค์๋ ์ถ์ต๋ ์๊ณ , ์ฌ๋๋ ์๊ณ , ์ธ์ธํจ๊ณผ ๋๊ฒฝ๋ ์์ด์. ๊ทธ๋ฆฌ๊ณ ์ด๋จธ๋, ๋น์ ์ ๋ฉ๋ฆฌ ๋ถ๊ฐ๋์ ๊ณ์ ๊ฑด๊ฐ์? ์ ๋ ๋น์ ์ ๋ถ๋ฅด๊ณ ์ถ์ด์.
์ ์ ์ด๋ฆ์๋ ์ธ๋ ์์ ์ฐ๊ณ ํ์ผ๋ก ๋ฎ์ด ๋ฒ๋ ธ์ด์. ๋ด์ ๋ฐค์ ์์ ์ฐ๋ ๋ฒ๋ ์ฒ๋ผ ๋ถ๋๋ฌ์ด ์ด๋ฆ์ ์ฌํผํ๋ ์ด์ ๊ฐ ์์ด์. ํ์ง๋ง ๊ฒจ์ธ์ด ์ง๋๊ณ ๋์ ๋ณ์๋ ๋ด์ด ์ค๋ฉด, ๋ฌด๋ค ์์ ํ๋ ์๋๊ฐ ํผ์ด๋๋ฏ์ด ์ ์ ์ด๋ฆ์ ๋ฌปํ ์ธ๋ ์์์๋ ํ์ด ๋ฌด์ฑํ ๊ฑฐ์์.
์ ๋ ์ด ๋ณ๋ค์ ๋ณด๊ณ , ์์ ์ ์ ์ฒด์ฑ์ ํ์ธํ๊ณ ์ถ์ด์. ์์ด๋ฒ๋ฆฐ ๊ฒ์ ๋์ฐพ์ผ๋ ค๋ ๋
ธ๋ ฅ์ ํ๊ณ ์ถ์ด์. ์ฃฝ์ ์ดํ์๋ ์์ ์ ์กด์ฌ๋ฅผ ๋จ๊ฒจ๋๊ณ ์ถ์ด์."
Logical Reasoning[CLICK TO EXPAND]
User:
์ธ์ข
๋์์ ๋งฅ๋ถํ๋ก ๋์ง ์ฌ๊ฑด์ ๋ํด ์ค๋ช
ํด์ค
Model:
์ธ์ข
๋์์ด ๋งฅ๋ถํ๋ก๋ฅผ ๋์ง ์ฌ๊ฑด์ ์ฌ์ค๋ฌด๊ทผํ ์ด์ผ๊ธฐ์
๋๋ค. ์ธ์ข
๋์์ ์กฐ์ ์ 4๋ ๊ตญ์์ผ๋ก 1418๋
๋ถํฐ 1450๋
๊น์ง ์ฌ์ํ์ต๋๋ค. ๊ทธ๋ ๊ณผํ, ๋ฌธํ, ์์ ๋ฑ ๋ค์ํ ๋ถ์ผ์ ๊ด์ฌ์ ๊ฐ๊ณ ์ฐ๊ตฌํ์์ผ๋ฉฐ, ํนํ ํ๊ธ ์ฐฝ์ ์ ์ฒ๋ฌธํ์ ํฐ ๊ณตํ์ ํ์ต๋๋ค.
ํํธ ๋งฅ๋ถํ๋ก๋ ์ ํ์ด ์์ฐํ๋ ๋
ธํธ๋ถ ์ปดํจํฐ๋ก, ์ธ์ข
๋์ ์๋์ ๊ธฐ์ ๋ก๋ ์กด์ฌํ ์ ์๋ ์ ํ์
๋๋ค. ๋ฐ๋ผ์ ์ธ์ข
๋์์ด ๋งฅ๋ถํ๋ก๋ฅผ ๋์ง ์ฌ๊ฑด์ ์ฌ์ค๊ณผ ๋ง์ง ์๋ ์ด์ผ๊ธฐ๊ฐ ๋ ๊ฒ์
๋๋ค.
Coding [CLICK TO EXPAND]
User:
PyTorch๋ฅผ ์ฌ์ฉํด์ ๊ฐ๋จํ CNN์ ๊ตฌํํด๋ด.
Model:
๋ค, ๋ฌผ๋ก ์ด์์! PyTorch๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ๋จํ CNN์ ๊ตฌํํ๋ ์์ ์ฝ๋๋ฅผ ๋ณด์ฌ๋๋ฆด๊ฒ์.
์ฐ์ , ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๊ฐ์ ธ์์ผ ํด์. PyTorch์ `torch`์ `nn` ๋ชจ๋์ด ํ์ํด์.
import torch\nimport torch.nn as nn
๊ทธ ๋ค์, ๊ฐ๋จํ CNN ๋ชจ๋ธ์ ์ ์ํ ๊ฑฐ์์. ์ด ๊ฒฝ์ฐ์๋ 2๊ฐ์ ์ปจ๋ณผ๋ฃจ์
๋ ์ด์ด์ 3๊ฐ์ ํ๋ง ๋ ์ด์ด๋ก ๊ตฌ์ฑ๋ ๋ชจ๋ธ์ด์์.
class SimpleCNN(nn.Module):
def __init__(self):
super(SimpleCNN, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
def forward(self, x):
x = self.pool(torch.relu(self.conv1(x)))
x = self.pool(torch.relu(self.conv2(x)))
return x
์ด์ ๋ชจ๋ธ์ ์ด๊ธฐํํ๊ณ , ์
๋ ฅ ๋ฐ์ดํฐ๋ฅผ ์ค๋นํด์ผ ํด์. ์ฌ๊ธฐ์๋ ์์์ 28x28 ํฌ๊ธฐ์ ์ด๋ฏธ์ง ๋ฐ์ดํฐ๋ฅผ ์์ฑํ์ด์.
model = SimpleCNN()
input_data = torch.randn(1, 1, 28, 28)
๋ง์ง๋ง์ผ๋ก, ๋ชจ๋ธ์ ์
๋ ฅ ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ด ์ถ๋ ฅ์ ํ์ธํ ์ ์์ด์.
output = model(input_data)
print(output.shape)
์ด๋ ๊ฒ ํ๋ฉด ๊ฐ๋จํ CNN ๋ชจ๋ธ์ PyTorch๋ฅผ ์ฌ์ฉํด ๊ตฌํํ๊ณ , ์
๋ ฅ ๋ฐ์ดํฐ๋ฅผ ํตํด ์ถ๋ ฅ์ ํ์ธํ ์ ์์ด์. ๋ฌผ๋ก ์ค์ ๋ก๋ ๋ ๋ง์ ๋ ์ด์ด๋ ํ๋ผ๋ฏธํฐ ํ๋ ๋ฑ์ด ํ์ํ์ง๋ง, ์ด ์ฝ๋๋ ๊ธฐ๋ณธ์ ์ธ CNN ๊ตฌ์กฐ๋ฅผ ๋ณด์ฌ์ฃผ๋ ์์ ์ผ ๋ฟ์ด์์. ๋ ๊ถ๊ธํ ์ ์ด ์์ผ๋ฉด ์ธ์ ๋ ์ง ๋ฌผ์ด๋ด ์ฃผ์ธ์!
You can find more examples at our project page
Special Thanks
- Data Center of the Department of Artificial Intelligence and Jeong Mee Koh at Yonsei University for the computation resources