정보엔지니어 (맥스웰의 도깨비, 양자컴퓨터)

개인비서 서비스가 LLM덕분에 가시권에 들어왔다. Siri도 그렇고 많은 사실은 많은 회사들이 이 개인비서를 꿈꿔왔다. 바쁜 현대인들은 대신 해줬으면 하는게 많기 때문이다. 인공지능이라는 이름으로 그동안 많은 서비스들이 이를 지향했는데, 사실 잘 안되었다. if-then 으로는 처리에 한계가 있었기 때문이다. 곧 사람들이 외면하기가 일쑤였다.

 그런데 LLM은 이미 OpenAI를 통해 어느정도의 사용자 경험을 인식시키고 있다. 청소년 정도의 응대만 가능해도 맡기고 싶은 일이 얼마나 많은가.

 하루를 한번 돌이켜보자. 몇시에 일어나서 밤사이 특별한 일은 없었는지(특히 해외 등), 날씨는 어떻고 우산을 가져갈지 말아야할지, 출근길에 특이한 정체나 사건은 없는지, 출근해서는 업무를 수행하기 위한 수많은 것들도 그렇고(임원들의 비서가 처리하는 수많은 것), 식당을 알아보고 일정을 조절하고는 기본이다.

 내 생활에서는 자녀를 위한 여러가지 교육 정보도 아쉽다. 내가 사는 지역에 특이한 일은 없는지, 내가 관심있는 주제는 어떤 변화가 있는지, 내 자산에는 알아야할 특이 정보는 없을지, 고민에 대한 상담, 여러가지 장기적인 관점의 진단은 특정 품질 이상으로 이런 것을 모두 챙겨줄 수 있다면 몇만원의 돈이 무엇이 아깝겠는가. 따라서 이 분야의 대형 서비스가 나올 수 있다고 생각한다.

 GPTs가 이런 비서 시장을 노릴테지만 여러가지 각각의 주제별로 조금더 전문화하고 다듬는 일이 필요하다. 그러다보면 각 전문분야별로 실제 정보나 컨텐츠가 부족하게 된다. 이러다보면 세상의 검색이나 여러가지 서비스가 API형태로 LLM이 쓸 수 있도록 변형되는 일이 가속화될것이다. 그렇게 더 발전하면 사람들이 직접 그 웹사이트에 들어가는 것보다는 API화 되어 LLM이 쓰는 양이 더 많아지고, 이제 사람들이 직접 사이트에 들어가는 것은 구식으로 느껴질 날이 올지도 모르겠다.

 이런 기술 환경의 핵심에는 Langchain같은 LLM을 다양하게 agent형으로 활용하는 오픈소스와 기존의 각종 서비스를 크롤링하고 API화되어가는 세상이 오는것. 비서 역할을 할 수 있는 사람이 있는 회사 임원들은 업무 사이트에 잘 들어가지 않는다. 사이트를 배우는 일도 큰 부담이기 때문이다. 이런 일을 LLM이 대신 해주는 세상이 곧 펼쳐지겠다.

 이런 변화가 오고있다. 영화 Her의 비서가 곧 세상을 점령해나갈 태세다.

Gemma 공개후 곧바로 파인튜닝 가능한 가이드가 공개되었다.

https://adithyask.medium.com/a-beginners-guide-to-fine-tuning-gemma-0444d46d821c

gemma-2b-it 모델의 quantized 버전 정도는 16GB GPU로도 파인튜닝 테스트를 해볼 수 있다.

상기 가이드대로 GPU환경에서 python을 설치한다.

$ conda create -n gemma python=3.11

$ conda activate gemma

$ pip install bitsandbytes==0.42.0
$ pip install peft==0.8.2
$ pip install trl==0.7.10
$ pip install accelerate==0.27.1
$ pip install datasets==2.17.0
$ pip install transformers==4.38.0

아래 소스를 통해 샘플 데이터 셋을 허깅페이스에서 다운받아 파인튜닝해서 결과를 얻어볼 수 있다.

이때 허깅 페이스에 미리 계정을 만든 후 WRITE 가능한 token으로 로그인을 미리 해두자. WRITE 권한으로 생성한 토큰으로는 모델을 huggingface에 업로드 하는 것도 가능하다(아래 소스의 맨 마지막 두줄)

$ huggingface-cli login
...
Token: 

$ huggingface-cli whoami
Justik (필자의 profile이다)

아래 코드를 실행한다. LORA를 통한 경량형 튜닝 정도는 할 수 있게 된다. gemma-7b-it의 경우는 16gb에서는 메모리가 부족하다. (본래 글에서는 A100을 추천하고 있다.) gemma-2b-it의 경우는 아래의 코드로 10~14gb정도의 메모리를 소모한다.

import json
import pandas as pd
import torch
from datasets import Dataset, load_dataset
from huggingface_hub import notebook_login
from peft import LoraConfig, PeftModel
from peft import LoraConfig, get_peft_model
lora_config = LoraConfig(
    r=64,
    lora_alpha=32,
    target_modules=['o_proj', 'q_proj', 'up_proj', 'v_proj', 'k_proj', 'down_proj', 'gate_proj'],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
) 
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    TrainingArguments,
    pipeline,
    logging,
)
from trl import SFTTrainer

notebook_login()

#model_id = "google/gemma-7b-it"
# model_id = "google/gemma-7b"
model_id = "google/gemma-2b-it"
#model_id = "google/gemma-2b"

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

#model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=lora_config, device_map={"":0})
model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config, device_map={"":0})
#model = AutoModelForCausalLM.from_pretrained(model_id, device_map={"":0})
tokenizer = AutoTokenizer.from_pretrained(model_id, add_eos_token=True)
{
    "instruction": "Create a function to calculate the sum of a sequence of integers.",
    "input":"[1, 2, 3, 4, 5]",
    "output": "# Python code def sum_sequence(sequence): sum = 0 for num in sequence: sum += num return sum"
}

dataset = load_dataset("TokenBender/code_instructions_122k_alpaca_style", split="train")

def generate_prompt(data_point):
    """Gen. input text based on a prompt, task instruction, (context info.), and answer

    :param data_point: dict: Data point
    :return: dict: tokenzed prompt
    """
    prefix_text = 'Below is an instruction that describes a task. Write a response that appropriately completes the request.\\n\\n'
    # Samples with additional context into.
    if data_point['input']:
        text = f"""<start_of_turn>user {prefix_text} {data_point["instruction"]} here are the inputs {data_point["input"]} <end_of_turn>\\n<start_of_turn>model{data_point["output"]} <end_of_turn>"""
    # Without
    else:
        text = f"""<start_of_turn>user {prefix_text} {data_point["instruction"]} <end_of_turn>\\n<start_of_turn>model{data_point["output"]} <end_of_turn>"""
    return text

# add the "prompt" column in the dataset
text_column = [generate_prompt(data_point) for data_point in dataset]
dataset = dataset.add_column("prompt", text_column)
dataset = dataset.shuffle(seed=1234)  # Shuffle dataset here
dataset = dataset.map(lambda samples: tokenizer(samples["prompt"]), batched=True)

dataset = dataset.train_test_split(test_size=0.2)
train_data = dataset["train"]
test_data = dataset["test"]

model = get_peft_model(model, lora_config)
trainable, total = model.get_nb_trainable_parameters()
print(f"Trainable: {trainable} | total: {total} | Percentage: {trainable/total*100:.4f}%")

import transformers

from trl import SFTTrainer

tokenizer.pad_token = tokenizer.eos_token
torch.cuda.empty_cache()
trainer = SFTTrainer(
    model=model,
    train_dataset=train_data,
    eval_dataset=test_data,
    dataset_text_field="prompt",
    peft_config=lora_config,
    args=transformers.TrainingArguments(
        per_device_train_batch_size=1,
        gradient_accumulation_steps=4,
        warmup_steps=0.03,
        max_steps=100,
        learning_rate=2e-4,
        logging_steps=1,
        output_dir="outputs",
        optim="paged_adamw_8bit",
        save_strategy="epoch",
    ),
    data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
)

# Start the training process
trainer.train()

new_model = "gemma-2b-it-finetune" #Name of the model you will be pushing to huggingface model hub
# Save the fine-tuned model
trainer.model.save_pretrained(new_model)

# Merge the model with LoRA weights
base_model = AutoModelForCausalLM.from_pretrained(
    model_id,
    low_cpu_mem_usage=True,
    return_dict=True,
    torch_dtype=torch.float16,
    device_map={"": 0},
)
merged_model= PeftModel.from_pretrained(base_model, new_model)
merged_model= merged_model.merge_and_unload()

# Save the merged model
merged_model.save_pretrained("merged_model",safe_serialization=True)
tokenizer.save_pretrained("merged_model")
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"


def get_completion(query: str, model, tokenizer) -> str:
  device = "cuda:0"
  prompt_template = """
  <start_of_turn>user
  Below is an instruction that describes a task. Write a response that appropriately completes the request.
  {query}
  <end_of_turn>\\n<start_of_turn>model
  
  """
  prompt = prompt_template.format(query=query)
  encodeds = tokenizer(prompt, return_tensors="pt", add_special_tokens=True)
  model_inputs = encodeds.to(device)
  generated_ids = model.generate(**model_inputs, max_new_tokens=1000, do_sample=True, pad_token_id=tokenizer.eos_token_id)
  # decoded = tokenizer.batch_decode(generated_ids)
  decoded = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
  return (decoded)

result = get_completion(query="code the fibonacci series in python using reccursion", model=merged_model, tokenizer=tokenizer)
print(result)


# Push the model and tokenizer to the Hugging Face Model Hub
# merged_model.push_to_hub(new_model, use_temp_dir=False)
# tokenizer.push_to_hub(new_model, use_temp_dir=False)

이렇게 hugging face hub에 올려진 모델은 아래와 같다.

https://huggingface.co/Justik/gemma-2b-it-finetune

여러가지 다양한 오픈소스 모델이 쏟아지고 다양한 구동방법이 나오는데, 대부분은 HuggingFace를 통해 배포되고 있다.

이에 최근에 좋은 성능을 보인다고 알려진 SOLAR 10.7B 한글 튜닝 모델인 megastudy SOLAR 10.7B 모델을 구동해보자.

SOLAR 10.7B는 24GB이상의 GPU메모리에서 가동이 가능한 점은 참고가 필요하다.

여기서는 다양한 LLM을 연결해서 실행할 수 있는 langchain 프로젝트의 도움을 받는다.

$ conda create -n solar10.7b python=3.11

$ conda activate solar10.7b

$ pip install langchain langchain_community huggingface_hub transformers sentencepiece torch datasets

1. HuggingFace 가입 및 access token받기

우선 huggingface와 langchain으로 연계시키려면 access token이 필요한데, 가입 후 발급받으면 된다.

https://huggingface.co/settings/tokens

여기서 받은 토큰을 아래와 같이 환경변수에 추가한다.

$ export HUGGINGFACEHUB_API_TOKEN="발급받은huggingface토큰"

여기서는 아래 모델을 사용해보자. 자동으로 모델을 다운로드 받아 실행하므로 langchain이 지원하는 대부분의 모델을 실행해 볼 수 있다.

https://huggingface.co/megastudy/M-SOLAR-10.7B-v1.3

2. LangChain을 통해 HuggingFace 모델을 실행해보자.

아래와 같이 실행한다.

$ cat > testlangchain.py

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain_community.llms import HuggingFacePipeline

# HuggingFace의 model id를 삽입한다.
#model_id = 'mncai/mistral-7b-v5'
#model_id = 'maywell/Mistral-ko-7B-v0.1'
model_id = 'megastudy/M-SOLAR-10.7B-v1.3'


# HuggingFacePipeline object
llm = HuggingFacePipeline.from_model_id(
    model_id=model_id, 
    device=0,               # -1: CPU(default), GPU존재하는 경우는 0번이상(CUDA Device #번호)
    task="text-generation", # 텍스트 생성
    model_kwargs={"temperature": 0.1, 
                  "max_length": 128},
)

# template
template = """질문: {question}

답변: """

prompt = PromptTemplate.from_template(template)
llm_chain = LLMChain(prompt=prompt, llm=llm)

question = "서울에서 제일 유명한 산이 어디야?"
print(llm_chain.run(question=question))

아래와 같이 실행하면 모델을 local로 다운로드 받아 잘 구동하는 것을 알 수 있다.

$ python testlangchain.py

...
  warnings.warn(
tokenizer_config.json: 100%|███████████████████████████████████████████████████████████████████████| 1.46k/1.46k [00:00<00:00, 4.00MB/s]
tokenizer.model: 100%|███████████████████████████████████████████████████████████████████████████████| 493k/493k [00:00<00:00, 27.0MB/s]
special_tokens_map.json: 100%|█████████████████████████████████████████████████████████████████████████| 551/551 [00:00<00:00, 1.50MB/s]
config.json: 100%|█████████████████████████████████████████████████████████████████████████████████████| 720/720 [00:00<00:00, 1.81MB/s]
model.safetensors.index.json: 100%|█████████████████████████████████████████████████████████████████| 35.8k/35.8k [00:00<00:00, 182kB/s]
model-00001-of-00005.safetensors: 100%|██████████████████████████

..

서울에서 가장 유명한 산은 북한산입니다. 북한산은 서울 북쪽에 위치한 아름다운 산으로 많은 사람들이 등산하고 휴식을 취하는 곳입니다.

기타로 "IT개발팀에 새로 팀장이 되었는데, 팀원들을 북돋워줄만한 연설문을 써줘." 라고 질문하고 max_length를 2048로 하면,

"팀장 선임을 축하합니다! 저희 팀은 팀원들의 헌신과 노력으로 성공을 거두어 왔습니다. 저는 저희 팀의 새로운 팀장으로서 저희 팀원들의 헌신과 노력에 감사드리며, 저희 팀의 미래를 위해 함께 노력하겠습니다. 저희 팀은 ..." 라고 답변한다.

또한 llangchain은 openai API를 동일한 방식으로 연계해서도 사용할 수 있어서 다양하게 활용이 가능하다. GPU 메모리가 부족하다면 모델을 바꾸거나(주석의 #model_id = 'mncai/mistral-7b-v5' 참조), HuggingfacePipeline변수내 device=-1로 변경(CPU로 실행)하여 전환하여 실행해서 실험해볼 수 있다.

---------------------------------------------------------------------------------------------------

# HuggingFace의 model id를 삽입한다.
model_id = 'mncai/mistral-7b-v5'
#model_id = 'megastudy/M-SOLAR-10.7B-v1.3'


# HuggingFacePipeline object
llm = HuggingFacePipeline.from_model_id(
    model_id=model_id, 
    device=-1,               # -1: CPU(default), GPU존재하는 경우는 0번이상(CUDA Device #번호)
    task="text-generation", # 텍스트 생성
    model_kwargs={"temperature": 0.1, 
                  "max_length": 128},
)

---------------------------------------------------------------------------------------------------

다양한 사람들의 노력으로 Apple Sillicon (M1/M2, gpu 사용) 에서도 아래와 같이 구동할 수 있다. 그리고 표기했듯이 apple sillicon의 GPU inference를 사용할 수 있기 때문에 속도도 나쁘지 않다. 다만 단지 구동만 가능한 것을 확인했고, 이를 통해 학습을 할 수 있는것 같지는 않다. 그래도 돌려볼 수 있다는 것이 어딘가!

https://gist.github.com/gengwg/26592c1979a0bca8b65e2f819e31ab5c

아래와 같이 우선 llama.cpp를 git clone하자.

$ git clone https://github.com/ggerganov/llama.cpp.git
$ cd llama.cpp

아래와 같은 옵션으로 gpu inference를 활성화하여 컴파일 할 수 있다.

$ make clean
$ LLAMA_METAL=1 make

이제 메모리가 크지 않은 맥북들을 위해 각 메모리 크기에 맞는 모델을 다운받아 구동해보자.

만약에 메모리 10gb이상 맥북이면, 13b모델을 최적화 축소한 아래 모델을 시도해보자. 물론 이 모델을 적재할 메모리가 충분하다면 아래 huggingface.co/TheBloke의 다른 더 큰 모델을 참조할 수 있다. 64gb모델 맥북이나 맥스튜디오 장비를 가지고 있다면 40gb짜리 quantized된 70b모델을 돌릴 수도 있다.

일단 13b모델은 아래와 걑이 한다.

$ export MODEL=llama-2-13b-chat.Q4_0.gguf 

#wget이 설치되어 있다면 아래와 같이, 혹은 아래 URL로 직접 링크를 다운로드

$ wget "https://huggingface.co/TheBloke/Llama-2-13B-chat-GGUF/resolve/main/llama-2-13b-chat.Q4_0.gguf " 

메모리 8gb이하 맥북이라면 아래 모델을 받는다.

$ export MODEL=llama-2-7b-chat.Q4_0.gguf 

$ wget "https://huggingface.co/TheBloke/Llama-2-7B-chat-GGUF/resolve/main/llama-2-7b-chat.Q4_0.gguf " 

그리고 나서 이제 아래와 같이 실행한다. 아래는 7b모델이다. 다운받은 모델에 따라 모델명을 바꿔주자.

$ ./main -m ./llama-2-7b-chat.Q4_0.gguf -t 8 -n 128 -ngl 1 --prompt "could you generate python code for generating prime numbers?"

.... 정말 코드를 생성해준다!

기타 아래를 통해 conda를 써서 llama.cpp의 python 필요시 따로 구동할 수 있다.

$ conda create --name=llama2 python=3.11

$ conda activate llama2

$ pip install -r requirements.txt

간단하게 맥북(m1/m2이지만 다른 macos환경에서도 가능하리라고 본다) 에서 llama.cpp를 이용해  llama를 구동해보았다.

생성형 이미지의 대표주자인 Stable Diffusion을 설치해서 실행해보자. 많은 것들이 그간 발전했고 easy diffusion이라는 멋진 웹인터페이스까지 만들어진 오픈소스가 존재한다.

모든 기본 환경은 ubuntu nvidia 4080 + anaconda 를 기준으로 한다 (  https://infoengineer.tistory.com/96 )

아래 사이트를 참조하자.

https://easydiffusion.github.io/docs/installation/

$ wget https://github.com/cmdr2/stable-diffusion-ui/releases/latest/download/Easy-Diffusion-Linux.zip

$ unzip Easy-Diffusion-Linux.zip

$ cd easy-diffusion

$ ./start.sh

/work/anaconda3/bin/curl
/usr/bin/tar
/work/anaconda3/bin/bzip2
Downloading micromamba from https://micro.mamba.pm/api/micromamba/linux-64/latest to /work2/easy-diffusion/installer_files/mamba/micromamba
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:--  0:00:02 --:--:--     0
100  4569    0  4569    0     0   1176      0 --:--:--  0:00:03 --:--:-- 4461k
  0 5096k    0     0    0     0      0      0 --:--:--  0:00:04 --:--:--     0bin/micromamba
100 5096k  100 5096k    0     0   811k      0  0:00:06  0:00:06 --:--:-- 3183k
Micromamba version:
1.5.0
Empty environment created at prefix: /work/easy-diffusion/installer_files/env
Packages to install: conda python=3.8.5
conda-forge/linux-64                                30.0MB @  41.3MB/s  0.7s
conda-forge/noarch                                  12.2MB @   3.5MB/s  3.5s

....

자동으로 서버가 뜬다. 내부 리눅스 브라우저를 이용해 아래를 실행한다.

http://localhost:9000/

적절한 영문 문구로 이미지 생성됨을 확인한다.

512*512 이미지가 수초만에 생성됨을 알 수 있었다. CPU/GPU 모드 등 변경하여 실험할 수 있다. 4080 GPU 카드로는 1280*768 정도 이미지를 만들 수 있는데, 1920*1280은 메모리 부족으로 오류가 난다.

이렇게 디폴트로 사용하는 방법도 있지만 custom model을 다운로드 받아 사용하는 방법도 있다. civit.ai 같은 사이트에서 model 파일을 다운로드 받아서 ./easy_diffusion/models/stable-diffusion/에 넣은 후 아래와 같이 특화된 이미지를 생성할 수도 있다.

왼쪽 메뉴의 Image Settings의 Model을 바꾸어서 생성해보면, 특화 모델 기반의 이미지 생성도 가능하다.

easy-diffusion외에 Stable Diffusion의 대명사인 AUTOMATIC1111이라는 웹인터페이스도 존재한다. 이 프로그램의 특징은 최신 기능의 빠른 적용이다. 이 툴을 설치하는 방법에 대해서도 잠깐 살펴보자.

$ conda create -n automatic python=3.10

$ conda activate automatic

$ git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git

$ cd stable-diffusion-webui/

$ ./webui.sh

################################################################
Install script for stable-diffusion + Web UI
Tested on Debian 11 (Bullseye), Fedora 34+ and openSUSE Leap 15.4 or newer.
################################################################
....

#모델다운로드 등 거치게 된다

#

모두 실행된 후 http://127.0.0.1:7861/ 에 접속하면 아래와 같이 AUTOMATIC1111이 구동된다. 시중의 메뉴얼을 참조하여 활용해보자. img2img 같은 기능은 이미지를 넣어 다른 이미지를 변환하는 기능이다. 그외에 Extras같은 플러그인 등 다채로운 기능을 제공한다. 이를 테면 Extensions에 https://github.com/toriato/stable-diffusion-webui-wd14-tagger 를 설치하면, 사진에서 스크립트를 뽑아주는 반대의 기능 활용도 가능하다.

GPU를 쓰는 이 녀석의 특성에 따라 이 글은 앞의 https://infoengineer.tistory.com/96 를 계승한다. GPU에 맞게 설정을 끝냈다고 가정한다.

meta에서 텍스트와 음성 모두를 읽어서 번역하고 텍스트화하는 성능 좋은 모델을 발표했다. meta의 sequence 처리 모델인 faitseq2를 먼저 설치한 후 SeamlessM4T를 통해 아래 5개의 기능을 우리가 아는 거의 모든 언어간이 가능하다. 한글도 포함되어 있다! 그리고 무려 speech to speech 번역도 가능하다. 여기서는 우선 가장 단순 T2TT(텍스트 번역)을 해보자.

• Speech-to-speech translation (S2ST)
• Speech-to-text translation (S2TT)
• Text-to-speech translation (T2ST)
• Text-to-text translation (T2TT)
• Automatic speech recognition (ASR)

설치 실행은 매우 단순하다. Anaconda를 사용해 보자.

$ conda create -n fairseq2 python=3.10
$ conda activate fairseq2
$ pip install fairseq2
$ git clone https://github.com/facebookresearch/seamless_communication
$ cd seamless_communication/
$ pip install .
$ sudo apt install libsndfile1
$ conda install -y -c conda-forge libsndfile

$ m4t_predict "The wind blows always to the west, and the girl is waiting always on the beach" t2tt kor --src_lang eng

2023-08-31 23:49:20,161 INFO -- m4t_scripts.predict.predict: Running inference on the GPU in torch.float16.
Using the cached checkpoint of the model 'seamlessM4T_large'. Set `force=True` to download again.
Using the cached tokenizer of the model 'seamlessM4T_large'. Set `force=True` to download again.
Using the cached checkpoint of the model 'vocoder_36langs'. Set `force=True` to download again.
2023-08-31 23:49:26,134 INFO -- m4t_scripts.predict.predict: Translated text in kor: 바람은 항상 서쪽으로 불고, 소녀는 항상 해변에서 기다리고 있습니다

$ m4t_predict "We introduce SONAR, a new multilingual and multimodal fixed-size sentence embedding space, with a full suite of speech and text encoders and decoders. It substantially outperforms existing sentence embeddings such as LASER3 and LabSE on the xsim and xsim++ multilingual similarity search tasks." t2tt kor --src_lang eng

2023-09-01 00:02:20,217 INFO -- m4t_scripts.predict.predict: Running inference on the GPU in torch.float16.
Using the cached checkpoint of the model 'seamlessM4T_large'. Set `force=True` to download again.
Using the cached tokenizer of the model 'seamlessM4T_large'. Set `force=True` to download again.
Using the cached checkpoint of the model 'vocoder_36langs'. Set `force=True` to download again.
2023-09-01 00:02:26,722 INFO -- m4t_scripts.predict.predict: Translated text in kor: 우리는 SONAR를 소개합니다. 새로운 다국어 및 멀티모달 고정 크기의 문장  ⁇ 입 공간으로, 음성 및 텍스트 인코더 및 디코더의 전체 스위트를 갖추고 있습니다. 그것은 xsim 및 xsim++ 다국어 유사성 검색 작업에서 LASER3 및 LabSE와 같은 기존 문장  ⁇ 입을 크게 능가합니다.

속도가 NVidia 4080 GPU에서 약 7초가 소요되는데, 모델로딩 시간을 빼면 그럭저럭 괜찮은 시간에 나오는 것 같다.

모델은 2가지가 있는데 디폴트로 SeamlessM4T-Large가 선택된다.

GPU를 사용하면 그리 느리지 않은 좋은 라이브러리를 확보한 셈이다. 라이센스는 무료로 자유롭게 쓰면 되는(하지만 재배포는 제약이 있다) Creative Commons Attribution-NonCommercial 4.0 International Public License 를 취한다.

이 글은 앞의 https://infoengineer.tistory.com/96 를 계승한다. 7월 19일 전격적으로 메타의 LLAMA v2가 공개되었고 azure, aws에도 같이 공개되었다. git 주소는 https://github.com/facebookresearch/llama 이다.

해당 git의 가이드를 따라가서 모델 신청을 하면( https://ai.meta.com/resources/models-and-libraries/llama-downloads/ ) 메일로 다운로드 링크가 몇시간 안에 날아온다. 해당 링크를 복사해두고 24시간 안에 다운받는다(5번 밖에 다운로드 안되니 주의를 하자)

그리고 주의할 것이, 해당 날아온 메일의 URL에 걸려있는 링크를 복사하면 안되고 반드시 순수 텍스트를 복사해두자. 붙여넣기 했을때 주소가 https://download... 로 시작해야 한다. 링크를 복사하면 https://l.facebook..이 복사되는데 이 주소로 처리를 했다가는 오류만 나고 다시 모델 다운로드 신청해서 작업해야 하니 주의한다.

여하튼 우리는 앞의 글에서 기초를 모두 닦아 두었으니(GPU/Anaconda 준비완료) 곧바로 다운로드 받아 시작하면 된다.

$ cd /work/llm  #아무 디렉토리나 llama 모델을 다운받을 수 있는 충분한 디스크가 있는 폴더로 간다

$ conda create -n llama2 python=3.9 -y

$ conda activate llama2

$ git clone https://github.com/facebookresearch/llama

$ cd llama

$ pip install -e .

Obtaining file:///work/llm/llama
  Preparing metadata (setup.py) ... done
Collecting torch (from llama==0.0.1)
  Using cached torch-2.0.1-cp39-cp39-manylinux1_x86_64.whl (619.9 MB)
Collecting fairscale (from llama==0.0.1)
  Using cached fairscale-0.4.13-py3-none-any.whl
Collecting fire (from llama==0.0.1)
  Using cached fire-0.5.0-py2.py3-none-any.whl
Collecting sentencepiece (from llama==0.0.1)
  Using cached sentencepiece-0.1.99-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.3 MB)
Collecting numpy>=1.22.0 (from fairscale->llama==0.0.1)
  Downloading numpy-1.25.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (17.7 MB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 17.7/17.7 MB 50.0 MB/s eta 0:00:00
Collecting filelock (from torch->llama==0.0.1)
  Using cached filelock-3.12.2-py3-none-any.whl (10 kB)
Collecting typing-extensions (from torch->llama==0.0.1)
  Downloading typing_extensions-4.7.1-py3-none-any.whl (33 kB)
Collecting sympy (from torch->llama==0.0.1)
  Using cached sympy-1.12-py3-none-any.whl (5.7 MB)
Collecting networkx (from torch->llama==0.0.1)
  Using cached networkx-3.1-py3-none-any.whl (2.1 MB)
Collecting jinja2 (from torch->llama==0.0.1)
  Using cached Jinja2-3.1.2-py3-none-any.whl (133 kB)
Collecting nvidia-cuda-nvrtc-cu11==11.7.99 (from torch->llama==0.0.1)

...

$ chmod 755 download.sh

#아래 download에서는 70B-chat빼고는 다 받았는데, 70B는 다운로드 시간이 걸리므로 빼고 받아도 좋다.7B도 13Gbytes나 된다.

$ ./download.sh 

Enter the URL from email: https://download.llamameta.net/*?Policy=eyJTdGF0ZW1lbnQiOlt7IlJlc29... 

Enter the list of models to download without spaces (7B,13B,70B,7B-chat,13B-chat,70B-chat), or press Enter for all: 7B,13B,7B-chat,13B-chat
Downloading LICENSE and Acceptable Usage Policy
--2023-07-19 23:08:24--  https://download.llamameta.net/LICENSE?Policy=eyJTdGF0ZW1lbnQiOl...QRJLYKIFSLZ 
download.llamameta.net (download.llamameta.net) 해석 중... 18.67.51.119, 18.67.51.25, 18.67.51.64, ...
다음으로 연결 중: download.llamameta.net (download.llamameta.net)|18.67.51.119|:443... 연결했습니다.
HTTP 요청을 보냈습니다. 응답 기다리는 중... 200 OK
길이: 7020 (6.9K) [binary/octet-stream]
저장 위치: ‘./LICENSE’

./LICENSE                           100%[================================================================>]   6.86K  --.-KB/s    / 0s       

2023-07-19 23:08:24 (976 MB/s) - ‘./LICENSE’ 저장함 [7020/7020]

--2023-07-19 23:08:24--  https://download.ll...

#모델을 받고 나면 아래 소스의 빨간색 영역을 영어에서 한글로 고쳐보자.

$ vi example_text_completion.py 
# Copyright (c) Meta Platforms, Inc. and affiliates.
# This software may be used and distributed according to the terms of the Llama 2 Community License Agreement.

import fire

from llama import Llama


def main(
    ckpt_dir: str,
    tokenizer_path: str,
    temperature: float = 0.6,
    top_p: float = 0.9,
    max_seq_len: int = 128,
    max_gen_len: int = 128,
    max_batch_size: int = 4,
):
    generator = Llama.build(
        ckpt_dir=ckpt_dir,
        tokenizer_path=tokenizer_path,
        max_seq_len=max_seq_len,
        max_batch_size=max_batch_size,
    )

    prompts = [
        # For these prompts, the expected answer is the natural continuation of the prompt
        "직장에서 좋은 관계를 갖기 위해서는 ",
        "미야자키 하야오 감독의 대표작은 ",
        """신사업을 하는 팀의 첫 시작을 축하하는 메시지:

        안녕하세요 여러분,
        
        지금 시기는 변화를 """,
        # Few shot prompt (providing a few examples before asking model to complete more);
        """Translate English to Korean:
        
        peppermint => 페퍼민트
        cheese =>""",
    ]

#드디어 최초로 돌려보자. 아래는 16GB GPU에서 돌아간다(약 15GB의 GPU 메모리를 소모한다 RTX 4080 16GB에서 실험했다). 간단히 주어진 문장의 다음 문장을 생성하는 예시이다. 뒤에 생성하는 문장을 늘리기 위해 max_gen_len을 256으로 지정했다.

$ torchrun --nproc_per_node 1 example_text_completion.py --ckpt_dir llama-2-7b/ --tokenizer_path tokenizer.model --max_seq_len 256 --max_gen_len 256 --max_batch_size 4
> initializing model parallel with size 1
> initializing ddp with size 1
> initializing pipeline with size 1
Loaded in 6.99 seconds
직장에서 좋은 관계를 갖기 위해서는 
> 어떻게 접근해야 하는가?
목표를 달성하기 위해서는 어떻게 팀원들을 활용해야 하는가?
적응력을 높이기 위해서는 어떻게 팀원들을 설득해야 하는가?
감독의 역할은 어떻게 변화하는가?
목표를 달성하기 위해서는 어떻게 팀원들을 활용해야 하는가?
감독의 역할은 어떻

==================================

미야자키 하야오 감독의 대표작은 
> 《슈퍼 마리오 브라더스 3》(1988년)로 알려져 있다. 특히 미야자키 하야오는 이 게임을 통해 아케이드 게임 디자이너로서 더 많은 인지도를 얻었다. 애니메이션 영화 《피노키오》(2017년)의 감독이자 프로듀서이기도 하다.

## 작품 목록

### 감독

==================================

신사업을 하는 팀의 첫 시작을 축하하는 메시지:

        안녕하세요 여러분,
        
        지금 시기는 변화를 
> 엿보는 시기이며 분명 혁신을 위한 새로운 시대가 열릴 것이다.
        
        이러한 분위기에서 새로운 시작을 하는 첫 번째 팀을 환영하고 있습니다.
        
        새로운 시작을 하는 분들에게 있어서 열심히 하면 되겠습니

==================================

Translate English to Korean:
        
        peppermint => 페퍼민트
        cheese =>
> 치즈
        banana => 바나나
        orange => 오렌지
        apple => 사과
        pear => 배
        onion => 매운 맛
        garlic => 고추
        carrot => 카루로
        potato => 튀김밥
        tomato => 토마토
        cucumber => 달걀
        pepper => 카프릴
        chili => 고추
        egg => 알
        lettuce => 양파
        spinach => 실밥
        broccoli => 브로콜리
        cabbage => 당근
        cauliflower => 칼리플로어
        mushroom

==================================

#chat 관련되어도 아래와 같이 실험이 가능하다

$ vi example_chat_completion.py

# Copyright (c) Meta Platforms, Inc. and affiliates.
# This software may be used and distributed according to the terms of the Llama 2 Community License Agreement.

from typing import Optional

import fire

from llama import Llama


def main(
    ckpt_dir: str,
    tokenizer_path: str,
    temperature: float = 0.6,
    top_p: float = 0.9,
    max_seq_len: int = 512,
    max_batch_size: int = 4,
    max_gen_len: Optional[int] = None,
):
    generator = Llama.build(
        ckpt_dir=ckpt_dir,
        tokenizer_path=tokenizer_path,
        max_seq_len=max_seq_len,
        max_batch_size=max_batch_size,
    )

    dialogs = [
        [{"role": "user", "content": "라면을 맛있게 끓이는 방법은?"}],
        [...

$ torchrun --nproc_per_node 1 example_chat_completion.py --ckpt_dir llama-2-7b-chat/ --tokenizer_path tokenizer.model --max_seq_len 512 --max_batch_size 4
> initializing model parallel with size 1
> initializing ddp with size 1
> initializing pipeline with size 1
Loaded in 6.78 seconds
User: 라면을 맛있게 끓이는 방법은?

> Assistant:  I'm just an AI, I don't have personal opinions or beliefs, but I can provide you with some general information on how to make a delicious and healthy ramyeon.
Ramyeon is a popular Korean instant noodle dish that can be made in a variety of ways depending on personal preferences. Here are some tips to make a delicious and healthy ramyeon:
1. Choose a good quality ramyeon: Look for a ramyeon that is made with whole wheat or brown rice noodles, and contains vegetables and lean protein sources.
2. Add vegetables: Ramyeon can be a great way to get in some extra vegetables. Try adding sliced carrots, diced bell peppers, and chopped green onions to your noodles.
3. Use lean protein: Choose a lean protein source such as chicken, beef, or tofu to add to your ramyeon. This will not only make it more nutritious but also more filling.
4. Add some spice: Ramyeon can be quite bland, so try adding some spice to it. You can add chili flakes, soy sauce, or gochujang (Korean chili paste) to give it a kick.
5. Experiment with different seasonings: Ramyeon can be seasoned with a variety of ingredients such as sesame oil, garlic, and ginger to give it a unique flavor.
6. Use a flavorful broth: The broth of ramyeon can make or

==================================

User: I am going to Paris, what should I see?..

흥미롭게도 영어로 답변을 하면 꽤 잘한다. 강제로 한글로 이야기하게도 할 수 있는데 아쉽게도 아래와 같다. 아마도 ChatGPT처럼 한글의 token단위도 너무 작은 상태가 아닐까 싶다(답변이 통상 짧다). 한글 부분은 fine tuning등 버전이 나오리라 기대해본다. 곧 llama.cpp가 풀리면 상위 모델도 CPU/Ram에서 구동하게 될 수 있겠다.

$ vi example_chat_completion.py

...

    dialogs = [
        [{"role":"system","content":"always answer in Korean"},
         {"role": "user", "content": "라면을 맛있게 끓이는 방법은?"}],
        [

...

$ torchrun --nproc_per_node 1 example_chat_completion.py --ckpt_dir llama-2-7b-chat/ --tokenizer_path tokenizer.model --max_seq_len 512 --max_batch_size 4
> initializing model parallel with size 1
> initializing ddp with size 1
> initializing pipeline with size 1
Loaded in 6.69 seconds
System: always answer in Korean

User: 라면을 맛있게 끓이는 방법은?

> Assistant:  "라면을 맛있게 끓이는 방법은 저렴한 물과 저렴한 간장을 사용하는 것입니다."

==================================

하나 더 실험해보자.

$ vi example_chat_completion.py

...

    dialogs = [
        [{"role":"system","content":"always answer in Korean"},
         {"role": "user", "content": "물리학 법칙이 모두 대칭인 이유는?"}],
        [
            {"role": "user", "content": "40대 보수적인 남성인 저는 어떤 금융상품을 관심있게 봐야할까요?"},
            {
                "role": "assistant",
                "content": """\
1. 안정적인 예적금: 원금 손실이 없으나 수익률이 다소 낮은 단점이 있습니다.
2. 공격적인 주식: 원금 손실의 가능성이 있으나, 적절한 투자를 행하여 이익실현을 하는 경우 수익률이 매우 높습니다.
""",
            },
            {"role": "user", "content": "1번 상품의 특성을 좀더 자세히 이야기해줄 수 있을까?"},
        ],
        [

..

$ torchrun --nproc_per_node 1 example_chat_completion.py --ckpt_dir llama-2-7b-chat/ --tokenizer_path tokenizer.model --max_seq_len 512 --max_batch_size 4

> initializing model parallel with size 1
> initializing ddp with size 1
> initializing pipeline with size 1
Loaded in 6.67 seconds
System: always answer in Korean

User: 물리학 법칙이 모두 대칭인 이유는?

> Assistant:  "물리학 법칙이 모두 대칭인 이유는?"

* 물리학 법칙이 모두 대칭인 이유는 입력에 따라 출력이 얼마 되는 것입니다.
(Translation: "The reason why physical laws are all symmetrical is because they are based on the input and output of the system.")

==================================

User: 40대 보수적인 남성인 저는 어떤 금융상품을 관심있게 봐야할까요?

Assistant: 1. 안정적인 예적금: 원금 손실이 없으나 수익률이 다소 낮은 단점이 있습니다.
2. 공격적인 주식: 원금 손실의 가능성이 있으나, 적절한 투자를 행하여 이익실현을 하는 경우 수익률이 매우 높습니다.


User: 1번 상품의 특성을 좀더 자세히 이야기해줄 수 있을까?

> Assistant:  Of course! The first financial product I mentioned, "安定的な預期 returns (Stable Returns)", has several key characteristics that make it an attractive option for investors. Here are some additional details:
1. Low Risk: As the name suggests, "安定的な預期 returns"

신기하게도, 일본어가 섞여 나온다는 것을 알 수 있다. 전체적으로 일본어가 섞여서 70b 모델에도 자주 등장한다고 알려져있다.

-------------------------------------------------------------------------------------------------------------

추가로 Apple Sillicon (M1/M2, gpu 사용) 에서도 아래와 같이 구동할 수 있다.

https://gist.github.com/gengwg/26592c1979a0bca8b65e2f819e31ab5c

$ git clone https://github.com/ggerganov/llama.cpp.git
$ cd llama.cpp

$ make clean
$ LLAMA_METAL=1 make

#만약에 메모리 10gb이상 맥북이면
$ export MODEL=llama-2-13b-chat.Q4_0.gguf 

#아래 혹은 직접 링크를 다운로드

$ wget "https://huggingface.co/TheBloke/Llama-2-13B-chat-GGUF/resolve/main/llama-2-13b-chat.Q4_0.gguf " 

#만약에 메모리  8gb이하 맥북이면

$ export MODEL=llama-2-7b-chat.Q4_0.gguf 

#아래 혹은 직접 링크를 다운로드

$ wget "https://huggingface.co/TheBloke/Llama-2-7B-chat-GGUF/resolve/main/llama-2-7b-chat.Q4_0.gguf " 

$ ./main -m ./llama-2-7b-chat.Q4_0.gguf -t 8 -n 128 -ngl 1 --prompt "could you generate python code for generating prime numbers?"

#기타 아래를 통해 conda를 써서 python 필요시 따로 구동할 수 있다.

$ conda create --name=llama2 python=3.11

$ conda activate llama2

$ pip install -r requirements.txt

 LLM을 돌리다보니 집의 데스크탑을 계속 개선하고 있는 나를 바라보면서 쌓인 지식들을 정리해두면 어떨까 싶어 기록해둔다. LLM이 돌아가려면 고용량 메모리, 고속의 CPU, 고속의 저장장치, 고속의 인터페이스 등에 대한 의외의 지식들이 필요하다. 더군다나 llama.cpp를 통해 촉발된 GPU없이 돌리는 LLAMA가 나온 마당에 데스크톱을 잘 업그레이드하면 괜찮은 실험환경을 구축할 수 있는 상황이 지속 마련되고 있다.

LLM을 위한 가정용 GPU 선택:

https://infoengineer.tistory.com/106

GPU없이 데스크탑 Ubuntu에서 돌리는 LLAMA인 llama.cpp 구동방법

https://infoengineer.tistory.com/107

결론부터 이야기하면 i7, i9의 최신 세대 CPU(13세대)에 가급적 Z계열(현재기준 Z690이나 Z790)의 메인보드와 DDR5메모리, PCIe-4.0이상 기반으로 구성하라는 이야기를 하고 싶은데, 각자의 상황에 따라 어떤 변화가 가능한지 아래  간단하게 필요한 지식을 알아보자.

1. PCI-Express 3,4,5 이해하기

GPU나 M.2 NVMe SSD 스토리지 든 이 PCI-Express 방식으로 메인보드에 연결되어 통신하는데 이 녀석이 버전이 있다. 3.0, 4.0, 5.0인데 속도 차이가 꽤 있다. 

 대개 요즘 GPU는 PCI-e 4.0을 많이 지원한다. 그런데 메인보드가 PCI-e 3.0만 지원한다면 그 통신 속도가 줄어들 수 밖에 없다. 따라서 가급적 PCI-e 4.0을 지원하는 CPU와 메인보드 조합을 찾자. 참고로 인텔은 11세대 CPU부터 이 PCI-e 4.0을 지원한다고 한다. 대개 고가의 GPU가 PCIe-4.0x16 (16은 통신 lane 수) 정도를 지원하니 그에 맞춰서 CPU/메인보드를 선택해 주면 별다른 큰 가격차이 없이 통신 속도가 늘어날 수 있겠다.

 참고로 PCI-e는 하위 호환성이 있으므로 높은 버전의 PCI-e라고 해도 낮은 버전의 PCI-e에 꼽아서 작동시킬 수는 있다. 속도는 낮은 버전을 따라간다.

--> 최소 PCIe-4.0을 기준으로 부품들을 살펴보자

2. DDR4 vs DDR5 메모리

 메모리도 세대가 바뀌어서 DDR4에서 DDR5로 넘어왔다. 그리고 이 둘은 메모리 꼽는 슬롯의 모양이 달라서 서로 호환이 되지 않는다. 또한 CPU도 이 각각을 지원해야만 해당 메모리를 사용할 수 있다. 그런데 CPU는 이 둘을 다 지원하는 모델도 많다(DDR4, DDR5). 하지만 메인보드는 양쪽을 다 지원할 수 없다. 왜냐하면 슬롯 모양이 다르니 선택을 해야하기 때문이다(듀얼로 서로 다른 슬롯을 채용하는 경우는 없는 것으로 알고 있다). 따라서 DDR4냐 DDR5냐는 결정을 해야한다.

 그렇게 CPU가 결정되고, 메인보드가 결정되면 지원되는 메모리를 알 수 있다. 개인적으로는 여유가 있다면 인텔 13세대 이상에서 지원하는 DDR5로 가라고 권하고 싶다. DDR4나 DDR5가 속도차이가 크게 나지 않는다는 평이 있으나 클락스피드가 후자가 더 높고 앞으로 계속 그렇게 활용되지 않겠는가. 그리고 메인보드 별로 이 램 지원은 각기 다르니, 원하는 메인보드를 자세히 들여다볼 필요가 있다. 주의가 필요하다. 특히 메모리 관련해서는 메인보드의 최대 용량 확인도 필요하다. 최근 사양이면 128GB를 지원하고 예전 것도 64GB정도는 지원이 되는게 일반적이긴 하다.

 그리고 단면램/양면램 논쟁 등이 있는데 메모리 지원은 해당 메인보드사의 홈페이지에 대부분 자세히 설명되어 있다. 단면/양면의 구분은 최근에는 중요하지 않다고 한다.

--> DDR5로 갈 수 있으면 가는데, 안되면 DDR4도 나쁘지 않다. 다만 꼽을 수 있는 메모리 종류와 최대 메모리는 메인보드 확인이 필요하다. 여유가 있어 128GB를 확보하면(32GB*4) llama.cpp에서 엄청난 모델을 돌려볼 수 있을지 모른다.

3. M.2 NVMe SSD 내장 스토리지

 이제 SATA방식보다는 NVMe가 훨씬 고속의 인터페이스이기 때문에 저장장치는 NVMe SSD를 고르는게 좋다. 그런데 여기서 잘 봐야하는 것은 PCIe 3.0인지 4.0인지나 실제 읽고 쓰는 속도이다. 삼성 980 pro M.2 NVMe정도 되면 PCIe-4.0을 지원하면서 7GB/s의 순차 읽기 속도를 지원한다. 반면에 970은 PCIe-3.0급이다. 가격차이가 크지 않으니 PCIe-4.0급의 NVMe를 고르고, 메인보드도 그렇게 지원하는지 확인하자. 대개 고사양 메인보드는 M.2를 4개까지 장착할 수 있는 경우가 많으니 고사양을 몇개 달아 사용해도 좋다. 과거보다 NVMe SSD는 타 부품대비 그렇게 비싸지 않다.

--> PCIe-4.0급의 NVMe SSD를 스토리지로 활용하자.

4. CPU는 어디까지 올릴 수 있는가?

 현행 인텔 CPU는 i3,i5,i7,i9에 13세대까지 출시되었다. 그리고 i3~i9는 숫자가 높을수록 코어수나 내부 캐시가 올라간다. 즉, 점점더 전문가용이다. 대개는 i7정도면 전문 게임용으로 홍보해서 판매한다. 

사실 최근에는 의외로 CPU별로 성능 차이가 크지 않지만, CPU는 메인보드 칩셋을 결정하고 그에 따라 앞서 밝힌 DDR4/DDR5여부, PCIe 지원 버전등을 같이 결정한다. 즉 메모리의 속도, 컴퓨터의 인터페이스 속도까지(메모리/CPU간, GPU/메인보드간) CPU와 그 시기 출시된 메인보드가 같이 세트가 되어 정해버리는 것이다. 아래는 10세대의 i3~i9 비교 표이다. core나 thread, cache등을 확인해보자.

물론 후자로 갈수록 소비 전력도 크다(i9정도면 100W급이라고 가정하면 된다)

여기서는 따라서 최신 세대(13세대)의 i7이나 i9를 추천한다. 주변 인터페이스의 속도가 최신이기 때문이다. 그리고 CPU에 맨 뒤에 알파벳이 붙는데 F는 내장 그래픽카드가 없고, K는 개선버전/오버클락 가능 버전이다. 어차피 GPU를 쓴다면 F버전을 선택해서 가격을 낮추는 방법도 있겠다. 오버클러킹을 하겠다면 K가 붙은 CPU를 구매하면 된다.

--> i7 13세대 CPU 이상 선택을 추천한다. 바로 이어 설명할 고급형 Z계열 메인보드와 오버클러킹 등 염두해두려면 K가 붙은 오버클러킹 허용 개선 버전을 선택하자.

5. 메인보드

 개인적으로는 메인보드를 중요하게 생각한다. 특히 LLM용 메인보드는 여러가지 발열 처리 등 때문에 ATX형(micro ATX같은 미니형이 아닌)을 채용해야 하고 그렇게 하면 디스크 장착 등에도 공간 여유가 있다.

 메인보드는 CPU와 그에 따른 칩셋으로 크게 결정되는데 흔히 H(보급형), B(작은크기용, mATX), Z(고급형, 오버클러킹용)로 시작된다. 이를 테면 Asrock Z790이면 고급형 보드이면서 오버클러킹도 가능하다. 따라서 이 계열에서는 상기 CPU에서 마지막 K붙은 것을 구매해 여러가지 오버클러킹도 같이 할 수 있다.

 H,B,Z의 각 뒤 숫자도 중요하다. 그 안에서는 해당 숫자가 높을수록 고급형이기 때문이다. H7xx, H8xx정도 되면 중고급에 속하게 된다.

각 CPU세대 별로 해당 숫자의 차이가 클 수도 작을 수도 있다. 일례로 고급형인 Z690과 Z790은 특이한 성능 차이는 없다고 평가받는다.

(통상은 Z790이 좋아야 한다)

--> H상위 버전, Z버전을 구매한다. 여기서는 13세대 CPU를 추천하고 있으므로 그에 맞는 Z690, Z790계열의 고급형 메인보드를 추천한다.

6. 케이스/파워

 고성능 PC는 생각보다 발열 관리가 중요하다. 파워도 마찬가지다. CPU가 100W, GPU가 400W쯤 소모한다고 잡으면 나머지 여러가지 잡다한 팬/스토리지 등 해서 100W를 추가하면 600W급의 파워가 필수가 되는데, 시장에서는 600W급 파워를 사도 500W정도 밖에 공급이 안된다는 설이 많다. 따라서 제대로 대응하려면 800W 정도를 사야 갑자기 PC가 꺼지는 상황을 막을 수 있다.

 케이스는 전면과 후면 모두에 팬이 붙되 조금 조용한 버전을 사야한다. CPU의 쿨러도 기본 쿨러보다는 발열을 줄일 수 있는 쿨러를 탑재하자. ATX보드를 기본으로 할테니 사이즈가 좀 클 것이다. ATX형 케이스도 가끔씩은 대형 GPU(?)는 들어가지 않을 수도 있으니 사전에 GPU 크기에 대한 고려가 되어있는 케이스인지 확인이 필요하다.

--> ATX형 좀 넉넉한 케이스에 팬은 전반/후반 모두 채용된 것으로 구매한다. 안이 보이거나 잘 열리면 더 좋다. 파워는 상황에 따라 다르지만 최소 700W이상, 많으면 1,000W까지 고려하자.

여기까지 일단 간단히 살펴보았다. 생각보다 전체를 고려하면 쉽지 않지만 이 틀하에서 잘 선택하여 가성비 좋은 구성이 되도록 빈다.

 이 글은 llama.cpp 프로젝트에 대한 소개다. 이 프로젝트는 기본적으로 맥북에서 LLAMA를 돌리는 것이 목표였는데, 다행스럽게도 linux x86에서 충분한 메모리만 있어도 LLAMA의 대형 모델을 구동할 수 있다.

 GPU 메모리가 아닌 일반 메모리에서도 LLAMA를 탑재해 구동할 수 있는 것이다! 설명은 우선 ubuntu linux(20.04이지만 상위 버전에서도 잘 되리라 본다) 를 중심으로 해본다. 어렵지 않게 따라가볼 수 있다. 애플 맥북에서도 아래 가이드에 따라 적당하게 골라서 컴파일하면 실행할 수 있다.

https://github.com/ggerganov/llama.cpp

1) 우선 컴파일을 하자.

1.1) CPU만으로 구동

$ git clone https://github.com/ggerganov/llama.cpp

$ cd llama.cpp

$ make

$ ./main

main: build = 626 (2d43387)
main: seed  = 1686058067
..

라고 나오면 정상이다.

1.2) GPU 가속의 도움을 얻도록 구동(GPU보유자만)

혹시 GPU가 있다면 cuBLAS를 통해 GPU가속기능을 쓸 수 있다고 되어 있다. 이 경우에는 cmake를 통해 컴파일해보자. 사실 단순히 구동에 있어서는 필요 없으므로 건너뛰어도 무방하다.

# /work/llama.cpp디렉토리에 설치한다고 가정했다

$ cd /work

$ git clone https://github.com/ggerganov/llama.cpp
$ cd llama.cpp

$ mkdir build

$ cd build

$ cmake .. -DLLAMA_CUBLAS=ON

$ cmake --build . --config Release

$ cd bin

$ ./main

..

라고 나오면 정상이다.

2) LLAMA 모델을 다운로드 받자.

이것은 받아둔 사람이 있다면 넘어가면 되고, 받지 않는 사람은 아래 방법으로 받자. 대형 모델은 시간이 좀 오래 걸릴 수도 있다. 아래 LLAMA 모델의 사이즈를 참고하자.

# /work/llama_data에 모델을 다운로드 받는다고 가정하자. 다른곳에 저장해도 좋다.

 $ cd /work

 $ mkdir llama_data

 $ git clone https://github.com/juncongmoo/pyllama

 $ cd pyllama

 $ pip install pyllama -U

 $ pip install -r requirements.txt    #이 설치가 pyllama설치만으로도 처리되어, 필요했는지 불명확한데 일단 실행하자

#필요한용량을 아래 선택해서 받는다

 $ python -m llama.download --model_size 7B --folder ../llama_data

 $ python -m llama.download --model_size 13B --folder ../llama_data

 $ python -m llama.download --model_size 30B --folder ../llama_data

3) 이제 llama.cpp를 실행해보자.

여기서는 7B 모델을 실행했지만, 다운받은 모델에 맞춰 7B라는 이름만 바꿔서 실행하면 된다.

 $ cd /work/llama.cpp

 $ python -m pip install -r requirements.txt

 $ python convert.py ../llama_data/7B/

 $ ./quantize ../llama_data/7B/ggml-model-f16.bin ../llama_data/7B/ggml-model-q4_0.bin q4_0

 $ ./main -m ../llama_data/7B/ggml-model-q4_0.bin -n 128

main: build = 626 (2d43387)
main: seed  = 1686058857
llama.cpp: loading model from ../../../llama_data/7B/ggml-model-q4_0.bin
llama_model_load_internal: format     = ggjt v3 (latest)
llama_model_load_internal: n_vocab    = 32000
llama_model_load_internal: n_ctx      = 512
llama_model_load_internal: n_embd     = 4096
llama_model_load_internal: n_mult     = 256
llama_model_load_internal: n_head     = 32
llama_model_load_internal: n_layer    = 32
llama_model_load_internal: n_rot      = 128
llama_model_load_internal: ftype      = 2 (mostly Q4_0)
llama_model_load_internal: n_ff       = 11008
llama_model_load_internal: n_parts    = 1
llama_model_load_internal: model size = 7B
llama_model_load_internal: ggml ctx size =    0.07 MB
llama_model_load_internal: using CUDA for GPU acceleration
llama_model_load_internal: mem required  = 5407.71 MB (+ 1026.00 MB per state)
llama_model_load_internal: offloading 0 layers to GPU
llama_model_load_internal: total VRAM used: 0 MB
.
llama_init_from_file: kv self size  =  256.00 MB

system_info: n_threads = 4 / 8 | AVX = 1 | AVX2 = 1 | AVX512 = 0 | AVX512_VBMI = 0 | AVX512_VNNI = 0 | FMA = 1 | NEON = 0 | ARM_FMA = 0 | F16C = 1 | FP16_VA = 0 | WASM_SIMD = 0 | BLAS = 1 | SSE3 = 1 | VSX = 0 | 
sampling: repeat_last_n = 64, repeat_penalty = 1.100000, presence_penalty = 0.000000, frequency_penalty = 0.000000, top_k = 40, tfs_z = 1.000000, top_p = 0.950000, typical_p = 1.000000, temp = 0.800000, mirostat = 0, mirostat_lr = 0.100000, mirostat_ent = 5.000000
generate: n_ctx = 512, n_batch = 512, n_predict = 128, n_keep = 0


 1960: The Beatles at Blackpool
1960 was an eventful year for the Beatles. John Lennon's father, a merchant seaman, died in January and his mother was admitted to hospital after suffering a nervous breakdown. As a result of these family crises they had to give up their studies at college and work full-time ..

#interactive한 대화도 가능하다

 $ ./main -m ../llama_data/7B/ggml-model-q4_0.bin -n 256 --repeat_penalty 1.0 --color -i -r "User:" -f prompts/chat-with-bob.txt

속도는 느리지만, 일반 linux PC에서도 잘 작동하는 것을 알 수 있다.(30B정도 모델이 되면 답답하게 느려짐을 체감할 수 있긴 하다)

4) 맥북 M1, M2 유저라면 맥북의 GPU 가속 기능을 쓸 수도 있다.

M1, M2 챕 맥북을 가진 유저라면 상기 make시에 Metal로 컴파일하여 빠른 속도를 체감해보면 더 좋겠다. 상세내용은 llama.cpp github을 참조하자.

$ LLAM_METAL=1 make

5) 다른 종류의 chat 모델도 시험해볼까?

LLAMA의 다양한 quantized 모델이 huggingface에 등록되어 있다. 예를 들면 TheBloke의 아래 모델을 보자.

https://huggingface.co/TheBloke/Llama-2-13B-chat-GGML 

여기서 llama-2-13b-chat.ggmlv3.q4_0.bin 라는 chat 모델을 다운로드 받으면 아래와 같이 실험해볼 수 있다.

$ ./main -m llama-2-13b-chat.ggmlv3.q4_0.bin -n 256 --repeat_penalty 1.0 --color -i -r "User:" --prompt "could you generate python code for generating prime numbers?"

.... 여러가지 CPU에서는 느리지만 잘 나온다는 것을 알 수 있다.

 ChatGPT같은 LLM을 구동하기 위해서는 대부분 A100같은 80GB의 메모리 GPU 여러장을 필요로 한다. 다른 머신러닝 연산과도 다른 것이 그 커다란 언어모델을 GPU에 적재하고 처리하기 때문에 특히 GPU 메모리가 많이 필요하다.

 따라서 이런 LLM을 직접 하기 위해서는 클라우드를 사용하게 되는데, 집에서 간단히 해볼 수는 없을까? 언어모델들 크기도 줄어든다는데 일정수준을 해보고 싶자면 어떤 GPU를 택하면 좋을지 고민이 된다. 그래서 이럴때 GPU를 선택하는 법을 간단히 적어보자. 우선 아래 각 RTX 모델별 메모리나 소비 전력을 살펴보자.

 LLM을 다양하게 구동하다보면 늘 어려운 것은 GPU 메모리 용량 확보이다. 속도는 둘째 문제이고 사실 그렇게 몇배까지 차이가 나지 않는다. LLAMA 7B모델을 돌려라도 보려면 모델만 13GB정도를 GPU메모리에 올려야 하니 일단 RTX xx60시리즈는 난감하게 된다. 심지어 용량을 축소하는 quantized 코드(소수점 정확도를 줄여서 용량을 늘리는 기술이다)들도 메모리를 많이 쓰기 때문에 그때도 막히는 경우가 있다. 여하튼 메모리가 커야한다.

 그래서 가정용으로 취할 수 있는 선택은 우선 GPU 메모리 16GB인 4060ti, 4080이 있다. 가격면이나 소비전력 면에서는 4060ti와 4080이 16G관점에서 후보가 된다. 그리고 그 다음은 24GB인 3090, 4090이 있다. 다만 4090은 너무 고가이기 때문에, 대략 4060ti, 4080, 3090정도가 가정용으로 선택할 수 있는 합리적인 선택이어 보인다.

 그리고 또하나 고용량 GPU를 처음 구비하는 사람이 놓칠 수 있는 것은 이 소비 전력이다. 4080(320W)급의 GPU도 권장 PC파워서플라이어 용량이 800W 정도를 거론한다. 원래 파워가 표기 용량보다 좀 적은 부분도 있고, 다른 주변기기들 때문에 PC가 그 정도의 총 전력을 소모하리라 보는 것이다. 특히 GPU의 발열 때문에 팬이 빠르게 많이 돌면 상대적으로 소비 전력이 올라갈 수 있다. 집에 전력 측정기(power meter)같은 것이 있어서 PC의 통상 전력을 알 수 있다면 거기에 약간의 보험을 더해서 파워를 준비해둘 필요가 있다. 본인의 경우에는 통상 GPU미사용시 150W를 넘은 적이 없으므로 상기 GPU소모량의 120%를 더해서 파워를 갖추어도 문제는 없었다. 파워가 부족하면 PC가 예고없이 다운될 수도 있으므로 그래도 조심할 필요가 있다.  그리고 이와 더불어 이 GPU를 제대로 구동할 수 있는 PC 스펙에 대해서는 아래와 같인 고민이 필요하다.

https://infoengineer.tistory.com/109

 서버급을 참고삼아 살펴보면, 이제 A40, A100같은 선택들이 존재한다. 다만 이 녀석들은 모두 지나치게 고가이고 소비 전력도 더 크기 때문에 그다지 가정용으로 하기는 쉽지 않을테다. GPU가 부담스럽다면 최근의 llama.cpp 프로젝트를 참고해보는 것도 좋다. 메인보드 메모리만으로도 우선 LLAMA를 돌려볼 수는 있다. 다만 고용량 모델로 갈수록 병렬 부동소수점 연산이 GPU에 뒤쳐질테니 더 느려지는 것은 어쩔 수 없을 수 있다. 그래도 quantize할때 등 사용할 수 있고, M1/M2칩 탑재한 애플 맥북에서는 꽤 속도도 빠르다고 알려져 있다. 이 부분은 아래를 참조하자.

https://infoengineer.tistory.com/107