Sims의 문제해결 저장소

KL Divergence 정리

Sims. — Sun, 19 Oct 2025 18:14:19 +0900

https://www.youtube.com/watch?v=Dc0PQlNQhGY&t=1681s

해당 영상을 참고하였습니다.

H의 정의

한가지 사건 일때

(가정) A→B에게 정보를 보내려고 한다 : 통신

ex)

해가 ‘동쪽’에서 떴다! 라는 소리는 당연한 소리 = 확률이 높은 상황 = 정보량이 없음( 당연함 )

해가 ‘서쪽’에서 떴다! 라는 정보 공유 = 확률이 낮은 상황 = 정보량이 엄청나게 큼 ( 희귀한 상황 ) (놀람의 정도 = 정보량)

h의 첫번째 조건

두가지 사건 일때

ex) 해가 동쪽에서 떴고, 서울에 비가 왔다.

정보1 → 해가 ‘동쪽’에서 떴다.

정보2 → 서울에 ‘비’가 왔다.

h의 두번째 조건

[DDP] DDP 학습 속도가 너무 느릴때

Sims. — Sat, 17 May 2025 21:01:41 +0900

DDP에 대해 아무것도 모르는 상태에서 DDP 학습 속도가 단일 GPU로 돌리는 것보다 느린 경우를 봤다.

왜 그런 상황이 발생했는지 경험을 공유한다.

문제는 일반 싱글 GPU에서 모델 예측하듯이 했던것이 문제다.

predicts = model(images)

DDP로 wrapper 된 model의 경우, 이렇게 사용할 시 예측은 가능하지만, 모든 GPU를 물고서 예측을 하는 것이기 때문에

사실상 순차적으로 예측을 진행하는 것.

즉, DDP의 핵심인 병렬적으로 처리를 하는게 아니다. 그럼 어떻게 해야할까?

predicts = model.module(images) ## model(images)를 하게되면 DDP 모델이기 때문에 속도 느림

.module로 하면 DDP 통신의 hook이 빠져서 개별적으로 GPU를 사용한다고 한다.

파이썬 엑셀 HYPERLINK 그대로 가져오기

Sims. — Fri, 25 Apr 2025 17:14:28 +0900

엑셀에서 위와같이 E행에 하이퍼링크가 되어있을때, 판다스로 읽어와야 할 경우가 생긴다.

이때 읽을 수 있는법은 아래와 같다.

from openpyxl import load_workbook
file = "파일위치"
wb = load_workbook(file, data_only= False) # openpyxl로 엑셀 읽기

sheet = "Sheet1" #현재 시트 이름 (자기에 맞게 변경해야함 )
ws = wb[sheet] # 해당 시트 읽기 

cell = ws.cell(row=셀의 row 위치(int), column= 셀의 column 위치 ( int) )  
colA = cell.value

위처럼 그대로 잘 가지고 오는 모습을 볼 수 있다.

여기서 가장 중요한건. load_workbook을 할때 data_only=False로 반드시 해줘야 한다.

data_only=True 면 어떤 짓을 하더라도 "네이버"만 나오게 될 것이다.

Docker VScode에 연결하기

Sims. — Wed, 26 Mar 2025 20:06:08 +0900

더이상 미룰 수 없는 Docker....

평소 Local에서 Anaconda로 가상환경 따서 진행을 하다보니 Docker를 미루게 되어 더이상 안되겠다는 마음가짐으로

평소에 사용할 때 Anaconda 대신 Docker를 생성해서 진행하고자 한다.

그러기 위해서는 Docker를 vscode에서 접속이 가능하도록 만들어야 한다.

여기서는 Docker 설치가 되어있다는 가정하에서 진행하도록 하겠다.

만약 Docker 설치가 안되있다면, 설치 후 해보길 권장한다.

1. Make Docker Container

필자는 Docker를 사용하는 방법에 익숙해지기 위한 것이므로, Docker hub에 있는 가장 최신의 python 이미지를 다운로드 받을 것이다.

docker pull python 을 통해 가장 최신 python이 설치된 이미지를 다운 받았다.

그 이후 해당 이미지를 이용해 컨테이너를 하나 만들어 보자.

그전에, 코딩하는 파일을 관리해야하니, 바인딩마운트를 이용해 임의의 폴더와 연동시켜보자.

바탕화면에는 'docker' 라는 폴더가 있고, 그 안에는 coding이라는 파일이 하나 있는 상태다.

이 폴더를 도커 안 기본이 되는 /mnt 폴더와 마운트 할 것이다.

'docker run -dit -v 바탕화면 폴더위치:/mnt 이미지명' 을 이용해 컨테이너를 하나 생성했다.

여기까지 우리가 사용하고자 할 컨테이너를 하나 생성했으니, 이제 vscode에 연결시키는 작업을 해보자.

2. Vscode로 Docker 연결

Vscode에 좌측 extention에 들어가 Dev Containers와 Docker를 설치해준다.

그 후, 다시 왼쪽 탭에 보면 Docker 아이콘이 생길 것이다. 그곳을 클릭하면 아래와 같이 어떤 컨테이너가 있는지 볼 수 있다.

CLI로 생성한 컨테이너가 존재하는 것을 볼 수 있다. 그런데 우리는 해당 컨테이너 내부 파일들에 접근하여 코딩을 해야한다. 즉, Local에서 개발하듯, VScode에서 Docker 안에 파일 목록을 볼 수 있도록 해야한다.

원하는 컨테이너에다 마우스 우클릭을하여 'Attach Visual Studio Code'를 누르면 Local 환경의 폴더를 여는 것처럼 VScode에서 사용 할 수 있다.

그럼 컨테이너 내부로 들어와 Open할 Folder를 찾아야하는데, 우리는 Local PC의 임의의 폴더를 컨테이너 /mnt 폴더에다 마운트를 해놓은 상태다.

그러므로 /mnt 폴더를 열어주자.

그럼 이렇게 로컬 PC에서 만들어 놨던 파일이 잘 마운트되어있는 것을 볼 수 있다.

여기까지 VScode에서 Docker

[VectorDB] ChromaDB 정리

Sims. — Thu, 13 Feb 2025 15:06:38 +0900

RAG를 적용하기 위해서 필요한 것이 이미 문서를 DB화 한 상태가 필요함.

문서 DB에서 질문에 가장 유사한 내용을 추출하여 LLM prompt에 넣어줌으로써 LLM에게 환각을 방지하고, 보다 정확한 답변을 생성해 내기 위해 사용.

그럼, 질문(Q)과 비슷한 내용은 어떻게 비교할 것인가? NLP에서 문자는 Vector로 표현하게 되고, Vector로 표현하게 해주는 것을 임베딩(Embedding)이라 한다.

문서 내 내용을 모두 임베딩하여 저장을 한 후, 들어온 질문(Q)와 가장 유사하다고 판단되는 문장들을 뽑아내 사용하는 방식이다.

즉, DB는 Vector를 저장해야 사용할 수 있는데, 대표적인 VectorDB는 ChromaDB, Faiss가 대표적인 것 같다.

ChromaDB 사용법 정리

1. ChromaDB 생성

import chromadb

# 크로마DB instance 생성  
cdb = chromadb.Client()

# 실질적 DB 생성 및 초기화
collection = cdb.create_collection(name="my_collection")

2. 데이터 넣기 ( add )

# 데이터 추가 
collection.add(
    documents=[
        "This is a document about pineapple",
        "This is a document about oranges"
    ],
    ids=['1','2'],
)

add 함수를 이용하여 chromaDB에 데이터를 넣어줄 수 있습니다.

단, 주의할 사항이 있습니다. " ids값은 반드시 들어가야 하며 문자형이여야 한다. "

documents만큼 ids가 반드시 필요합니다.

3. 데이터 확인 ( get )

collection.add(
    documents=[
        "This is a document about pineapple",
        "This is a document about oranges"
    ],
    ids=[str(uuid4()),str(uuid4())],
)

collection.get()

get 함수를 이용하면 DB안에 들어있는 데이터 전체를 볼 수 있다.

*Note

크로마DB는 VectorDB라는 이야기를 많이들 한다. Vector DB라고 들으면 텍스트의 Vector를 저장을 해야하는데 .get()을 통해 보면 'embeddings' : None 이라는 부분이 보인다. 그외의 데이터는 잘 보여지는 것을 알 수 있다.

그럼 embeddings 값이 저장이 안되는건가? 라는 의심을 하게 만들어서 찾아보았다.

결론은 단순히 '안보여주는 것' 일 뿐이다. 즉, 상식처럼 Vector Embedding값이 저장되는 DB이다.

그럼 어떻게 embedding 값을 볼 수 있을까?

get을 사용할때, include 파라미터에 embeddings를 넣어주면 뽑히는 것을 알 수 있다. 하지만, 여기서 조심해야할 것은 기존에 나왔던 documents, metadatas가 나오지 않는 것을 볼 수 있는데, 그 이유는 파라미터에 넣지 않아서 그런다.

include 파라미터의 dafault는 documents, metatdatas기 때문에 .get()만 했을때 embeddings가 나오지 않았던 것이다.

4. 검색( query )

collection.query(
    query_texts=["오늘 날씨 어때"], # Chroma will embed this for you
    n_results=2, # how many results to return,
)

chromaDB에서 검색은 .query()를 이용하여 진행할 수 있다. 쿼리로 입력된 텍스트를 Embedding을 거쳐 DB에 저장된 Embedding 값들과 유사도를 비교하여 최종적으로 거리가 멀지않은 ( 의미가 가장 가까운 ) 문장을 추출해준다.

이렇게 4가지 함수를 이용해 ChromaDB를 다뤄보았다. 추가적으로 조건 검색, 제거 같은 것들은 해당 내용에 포함되지 않으니 공식 문서에서 찾아 적용해보길 바란다.

https://docs.trychroma.com/docs/overview/introduction

Introduction - Chroma Docs

docs.trychroma.com

[LLM] Fine-Tuning

Sims. — Thu, 6 Feb 2025 20:00:38 +0900

LLM을 하다보면 '모델명-it/chat'과 같은 형식으로 허깅페이스에서 제공하는 모델들을 볼 수 있다.

이러한 모델은 chatting 형식으로 fine-tuning하여 실제 모델과 이야기를 주고받는 형식으로 답변을 생성해준다.

이번에는 튜닝의 방식과 대표적인 데이터셋, 튜닝 방법에 대해 정리를 해보고자 한다.

SFT - Supervised Fine-Tuning ( 정답이 존재하는 상태에서 진행 - next token prediction )

SFT는 두가지로 나뉜다.

1) Full Fine-Tuning

모델 전체의 파라미터를 수정하여 학습시킨다. LLM은 대체로 파라미터가 상당히 많으므로 상당한 GPU 자원이 필요한 단점이 있다.

2) Parameter-Efficient Fine-Tuning(PEFT)

모델의 '특정부분'만 파라미터를 업데이트 하는 방식. FFT보다 상대적으로 적은 GPU 자원이 필요함.

특히 PEFT 방식중에서는 LoRA 방식을 많이 사용함.

LoRA

독립된 연산을 통해 LLM의 일부 파라미터와 결합한 형태로 vector값을 수정함.

LLM은 Freeze한 상태라, 업데이트 되지 않으며, 독립적으로 연산되는 레이어만 업데이트를 진행하여 최소한의 파라미터로 LLM 모델을 튜닝할 수 있음.

한마디로 '어댑터'를 하나 만들어 적은 파라미터를 학습하는 것.

두가지 방식으로 어댑터를 모델에 추가할 수 있다.

1) model.add_adapter(peft_config)

2) get_peft_model(model, peft_config)

두가지 방법이 있어서 어떤 차이점이 있나 확인해보니, 둘다 큰 차이점은 없다.

Trainable parameters도 동일하며, 모델 내에서 LoRA가 적용되는 것 또한 동일하였다.

한가지 차이점이라면, get_peft_model은 기본 모델을 wrapper로 한번 더 쌓아 model 구조를 출력해보면 PeftModelForCausalLM 이라는걸로 감싸져 있는 것을 볼 수 있는 정도였다. 내부적으로는 큰 차이가 없어 동일하다고 보면 된다. ( get_peft_model로 진행하면 차제적으로 구성해놓은 추가적인 함수들을 사용할 수 있다. )

get_peft_model vs .add_adapter

3. 데이터셋

it / chat 형식으로 모델을 튜닝하려면, Q&A 데이터셋처럼 만들어서 최종적으론 chat template 형식으로 만들어 학습을 진행한다.

손쉽게 사용해 볼 수 있는 데이터셋 예제를 한번 보자.

이처럼 Q & A 형태의 데이터셋을 이용하여 학습을 진행하기 위해서는 하나의 문장으로 만들어 주는 과정이 필요하다.

기존 Dataset은 위와같은 feature를 가지고 있고 이중 instruction을 user, output을 model이 답변하는 형태로 진행을 해보려고 한다.

이미 it 형식으로 파인튜닝 된 모델을 사용할 예정이므로 기존의 chat template를 이용해서 만들어보도록 하겠다.

이처럼 채팅 형식을 만들어 기존에 있는 dataset에 'text'에다가 새롭게 추가하였다.

모델에 학습을 위해서는, 모델이 읽을 수 있도록 숫자로 변환하는 Tokenize 과정이 한번 더 필요하다.

이러한 과정을 거치면, input_ids, attention_mask가 생기게 된다.

여기서 모델에 필요한 정보는 input_ids가 필요하다. !!반드시!!

attention_mask의 경우는, Batch 처리를 하려면 Batch로 들어온 텍스트의 길이를 맞춰주기 위해 padding을 넣게되는데, 이렇게되면 의미없는 텍스트가 추가되는 것이라, 어디까지가 실제로 사용되야 할 텍스트인지 알아야 하는데, 이게 attention_mask를 통해 알 수 있다. ( 실제로, Padding을 넣지않고 학습에서 batch 진행해도 상관없음 - SFTTrainer)

결론

학습을 위해서는 input_ids ( token화된 결과물)이 필요하다!

import torch
import transformers
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from peft import prepare_model_for_kbit_training, LoraConfig, get_peft_model
from datasets import load_dataset

from datasets import load_dataset
data = load_dataset("beomi/KoAlpaca-v1.1a")
data["train"][0]

model_id = "google/gemma-2-2b-it"
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb_config, device_map="auto")

def preprocessing(x):
     
    return tokenizer.apply_chat_template([
        {"role" : "user" , "content": x['instruction']},
        {"role" : "model" , "content": x["output"]}
    ], tokenize = False)
    
data = data.map(
    lambda x: {'text': preprocessing(x) }
)
data = data.map(lambda samples: tokenizer(samples["text"]), batched=True)
# make model
config = LoraConfig(
    r=8,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, config)
print(model.print_trainable_parameters())

from transformers import TrainingArguments , Trainer
from trl import SFTTrainer
# needed for gpt-neo-x tokenizer
tokenizer.pad_token = tokenizer.eos_token

training_args = TrainingArguments(
    output_dir="./keywords_gemma_results",
    # num_train_epochs=1, # 1epoch에 250step정도 진행함 
    # num_train_epochs가 기존에 알고있던 epoch 수
    num_train_epochs = 1,
    # max_steps를 지정하면, 배치사이즈에 상관없이 step으로 하기때문에 시간이 늘어남.
    # max_steps=800,
    per_device_train_batch_size=1,
    per_device_eval_batch_size=1,
    warmup_steps=0,
    weight_decay=0.01,
    learning_rate=2e-4,
    logging_dir="./logs",
    logging_steps=100,
    )


trainer = SFTTrainer(
    model=model,
    train_dataset=data["train"],

    args=training_args,
    peft_config=config,
    # formatting_func=lambda x: x['input_ids']
)

trainer.train()

[LLM] Tokenizer 기본

Sims. — Sat, 1 Feb 2025 14:43:47 +0900

Tokenizer 기본 선언 방식

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(CFG["model"])

기존 본인이 사용하고자 하는 모델명, Tokenizer 위치를 파라미터에 넣어 불러오면 끝.

하지만, 위 방식으로 진행하면, 모델따로 토크나이저 따로 불러와 사용해야함.

이걸 한번에 할 수 있는게 바로 pipeline 함수.

# pipline을 이용하여 추론
import transformers
from transformers import AutoModelForCausalLM ,BitsAndBytesConfig
# 4bit quantization
quantization_config = BitsAndBytesConfig(load_in_4bit=True,
                                         bnb_4bit_quant_type = "nf4")


#  pipeline으로 진행하면, 자동으로 tokenizer도 불러옴 
pipline = transformers.pipeline(
    "text-generation",
    model = CFG["model"],
    model_kwargs = {'quantization_config' : quantization_config},
    device_map="auto"
)

위처럼 transformers.pipeline을 사용시 모델과 해당 모델에 사용되는 토크나이저를 한번에 받을 수 있음.

pipline.tokenizer
pipline.model

로 기존처럼 모델과 토크나이저에 접근이 가능하며 사용할 수 있음.

Chat 형식

https://huggingface.co/docs/transformers/main/ko/chat_templating

채팅 모델을 위한 템플릿

(번역중) 효율적인 학습 기술들

huggingface.co

LLM 하면서 가장 많이 활용하는 것이 chat모델일 것임.

모델명-chat / 모델명-it 과 같이 허깅페이스에 저장된 모델들이 있는데, 이것들이 바로 채팅을 위해 finetuning된 모델임.

기존 대기업에서 모델을 개발하여 배포하는 것 ( ex. google/gemma-7b )은 next token generation으로 pretrain한 모델이다.

이러한 모델을 base로 사용자들은 번역, 요약과 같은 여러가지 DownStreamTask로 FineTuning을 진행한다.

chat 형식으로 답변을 출력할 수 있도록 DownStreamTask를 진행한다고 생각하면 된다.

그럼 여기서 가장 헷갈렸던 부분이 있다. "어떤 형식으로 chat Template를 구성해야 하는가? "

여러가지 모델이 있고, 각 모델별 스페셜 토큰도 다른데 구성을 어떻게 해야할까...

결론

1. Pretrain 된 모델을 이용할 경우에는 자유롭게 만들어 주면 됨 ( 상대적으로 자유로움 )

2. 이미 chat/it 형식으로 finetuning된 모델을 이용할 경우, 기존 학습에 사용한 template를 사용하면 됨

그럼, 1번의 경우는 큰 문제가 없지만, 2번의 경우는 어떤 형식인지 알아보기 위한 방법은 아래와 같음.

# pipline을 이용하여 추론
import transformers
from transformers import AutoModelForCausalLM ,BitsAndBytesConfig
import torch
import json
import huggingface_hub

with open('./settings/config.json') as f:
    CFG = json.load(f)

# Private Token value input & login
huggingface_hub.login(token = CFG["TOKEN"])

CFG["model"] = "rtzr/ko-gemma-2-9b-it"

# 4bit quantization
quantization_config = BitsAndBytesConfig(load_in_4bit=True,
                                         bnb_4bit_quant_type = "nf4")


#  pipeline으로 진행하면, 자동으로 tokenizer도 불러옴 
pipline = transformers.pipeline(
    "text-generation",
    model = CFG["model"],
    model_kwargs = {'quantization_config' : quantization_config},
    device_map="auto"
)

위처럼 gemma를 it형식으로 학습시켜 놓은 모델을 pipeline을 이용하여 모델과 토크나이저를 불러왔다.

그 후, messages를 위 형태처럼 만들어주고, apply_chat_template를 이용하여 넣어주면 해당 모델에서 사용한 채팅형식에 맞춰서 프롬프트를 생성할 수 있다.

prompt의 출력물을 보면, <bos> <start_of_turn> <end_of_turn> 형식으로 작성되는 것을 볼 수 있는데,

학습시킬때 위와같은 형식을 바탕으로 학습을 진행하여 해당 it 모델의 chat template은 위와같다.

생성을 진행해보면 아래와 같은 결과물을 얻을 수 있다.(pipeline으로 추론을 진행하면, 끝나는 지점의 스페셜토큰을 볼 수 없기에 기존 generate 함수를 이용하여 진행하였다.)

여기서 마지막 스페셜 토큰으로 <end_of_turn> <eos> 가 생성되어 더이상 생성을 멈춘 것도 볼 수 있다.

[LLM] huggingface LLM 기본 내용 ( 양자화 )

Sims. — Thu, 30 Jan 2025 02:14:13 +0900

https://huggingface.co/docs/transformers/ko/llm_tutorial

대규모 언어 모델로 생성하기

LLM 또는 대규모 언어 모델은 텍스트 생성의 핵심 구성 요소입니다. 간단히 말하면, 주어진 입력 텍스트에 대한 다음 단어(정확하게는 토큰)를 예측하기 위해 훈련된 대규모 사전 훈련 변환기 모

huggingface.co

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-v0.1", device_map="auto", load_in_4bit=True)

pretrained_model_name_or_path : huggingface에 등록된 모델 명 or 다운로드 한 모델 위치

device_map : CPU/GPU select

load_in_4bit : 4bit Quantization( 양자화 ) -> 모델 용량 Down / 추론속도 UP/ 정확도 Down ( 단, 미래는 없어질 파라미터 이므로, 'BitsAndBytesConfig'를 통해 진행하면 좋다.)

** load_in_4bit = True를 했을때 정말 4bit으로 변경될까??

load_in_4bit없이 모델을 불러오면, 위와같이 float32로 dtype이 정해지는 것을 볼 수 있음.

load_in_4bit을 한 후 모델을 불러왔을때 아래와 같음. 특이한건, dtype이 torch.uint8로 저장되며, 값도 Params4bit이라는 것에 들어가게 됨.

여기서 알 수 있는건

1. 4bit 양자화를 하더라도 저장되는 dtype은 8bit으로 저장하는 것을 알 수 있음.

2. Params4bit이라는 Class를 통해 값이 저장되는 것을 볼 수 있음

그럼, load_in_8bit이라면 어떻게 될까?

이때는 int8로 예상 가능한 type이 나온다. 또, Int8Params라는 걸 이용해 값을 저장한다.

** 결론

즉, 4bit, 8bit은 어떠한(?) 방법을 통해 'int'형으로 바꾸는 것을 볼 수 있었다.

( 어떻게 변경하는지는 추후에 알아봐야 함)

torch_dtype

그럼, 모델을 정의할때 torch_dtype이란게 있는데 이건 뭘까?

기본적으로 torch.nn.LayerNorm과 같은 다른 모듈은 torch.float16으로 변환됩니다. 원한다면 torch_dtype 매개변수로 이들 모듈의 데이터 유형을 변경할 수 있습니다

위와같은 내용이 있는 허깅페이스에서 볼 수 있다. 한마디로, 양자화를 하지 않는 부분의 layer의 type을 setting 한다는 의미다.

torch_dtype를 float32로 설정하여 진행하면, 양자화 되지 않는 layer들은 torch.float32로 설정되는 모습을 볼 수 있다.

그럼, default( torch.float16)으로 진행하면 어떻게 될까?

양자화가 적용되지 않는 layer들은 float16으로 되는 것을 알 수 있다.

float32와 float16의 모델 크기도 살펴보니, 당연히 float16의 모델 크기가 작은것을 볼 수 있었다.

BitsAndBytesConfig 파라미터 ( 4bit )

bnb_4bit_compute_dtype : input type의 형태가 다를시, 계산 타입을 변경하여 진행 ( 속도의 장점을 얻을 수 있음 )

FP32 -> fp16 , bf16 형태로 계산 진행 ( 기본은 float32)

--> 추가 설명

양자화에서 forward, backward 는 4 bit 에서 일어나지만, gradient computation 과정에서는 float16, bfloat16, float32 등의 자료형으로 변환하여 진행해야 한다. 그러므로, 이에 맞는 자료형을 골라서 넣어주면 된다.

bnb_4bit_quant_type : bnb.nn.Linear4Bit 레이어 안에서 사용할 양자화 타입을 선택하는 것 ( fp4, nf4로 할 수 있음 )

+bnb_4bit_quant_type 은 bnb.nn.Linear4bit layer의 quant_type을 설정해주는 것

**FP4, NF4란?

FP ( Floating Point ) -> 부동소수점으로 표현, 상대적으로 높은 정밀도 / 상대적으로 낮은 연산 속도

NF ( Non- Floating Point ) -> 정수로 표현 , 상대적으로 낮은 정밀도 / 상대적으로 높은 연산 속도

bnb_4bit_use_double_quant : 양자화 이후 한번 더 양자화 진행여부

https://huggingface.co/docs/transformers/ko/quantization/bitsandbytes

bitsandbytes

bitsandbytes는 모델을 8비트 및 4비트로 양자화하는 가장 쉬운 방법입니다. 8비트 양자화는 fp16의 이상치와 int8의 비이상치를 곱한 후, 비이상치 값을 fp16으로 다시 변환하고, 이들을 합산하여 fp16으

huggingface.co

[회고] 티스토리 오블완 챌린지 - 완 -

Sims. — Wed, 27 Nov 2024 20:42:03 +0900

어느덧 티스토리에서 진행한 이벤트 오블완 챌린지가 마지막 날이 됐다..

3주라는 시간이 정말 짧게 지나간 것 같다..( 회사 일때문에 그런지도.. )

일단 2024년이 끝나가는 마당에 회사일에 치이고 퇴근 후 더이상 기운이 안나 추가적인 공부를 거의 안한 것 같다.

그때 마침 티스토리에서 챌린지를 한다는 소식에 냉큼 참여했다.

다시 생각해봐도 정말 참여하기 잘 했다. 평소 공부하고 싶었던 것을 해당 챌린지 삼아 공부하여 블로그에 정리해 놓는 아주 좋은 시간이 됐다. 덕분에 deep하게 모델에 대한 이해를 한층 더 강화할 수 있었고, 수정 사항을 발견하여 추후에는 수정하여 commit도 보내볼 참이다.

모델뿐만 아니라 알고리즘 관련한 공부도 많이 진행했다. 취업하고 알고리즘에 관심이 뜸했는데, 챌린지를 참여해야 한다는 명목으로 다시금 알고리즘을 풀어보기 시작했다. 몇개 올리진 않았지만, 챌린지가 끝나고도 지속적으로 블로그에 글을 올리면서 나의 지식을 쌓아나갈 생각이다.

오늘 챌린지는 마무리 되지만, 이번 챌린지를 발판삼아 올해의 마무리를 잘 해야겠다.

고맙다! 티스토리!

[백준] 최소신장트리 (MST) - 전력난

Sims. — Tue, 26 Nov 2024 20:41:06 +0900

이번에도 MST 알고리즘 문제를 하나 풀어보고자 한다.

https://www.acmicpc.net/problem/6497

해당문제도 MST 관련된 문제여서, 여기까지 풀어본다면 MST에 대한 개념은 충분히 잡을 수 있을 것이라 생각이 든다.

해당 문제도 오리지널 MST 알고리즘을 통해서 풀 수 있는 문제다.

MST 알고리즘에 관련해서 다시한번 기억해보자.

1. node, edge , value가 각각 주어지는 상황에서, 최소한의 value을 이용하여 모든 노드를 하나의 그래프에 속하도록 만드는 테스크이다.

2. edge의 총 개수는 node - 1로 MST를 구성할 수 있다.

3. MST는 유니온 파인드 알고리즘을 이용해서 해결할 수 있다.

MST 문제를 풀때 위 내용만 기억하고 진행하면 될 것이다.

푸는 순서에서도 기억해야할 것이 한가지 있었다.

Greedy 하게 풀기위해 value를 오름차순으로 정리하여 하나씩 간선을 이어가며 진행하면 된다.

Greedy하게 접근하는것이 유니온 파인드와는 다른점이니 기억하자.

순서

1. value 값으로 오름차순으로 정렬한다.

2. 유니온파인드 알고리즘을 구성한다.

3. 두 노드가 같은 그래프(root노드가 같으면)면 넘어가고, 다르다면 연결한다.

위 3단계를 거쳐서 알고리즘을 작성하면 되므로 그렇게 어렵지 않게 MST문제를 풀 수 있을것이다.

여기서 다른분들과 속도의 차이가 조금 나서, 그 이유를 살펴본 결과 sort를 할때 value가 같은경우가 있을 것 같아 x[1]으로 추가적으로 soring을 진행했는데, 그럴필요 없었고 속도만 늦추는 상황이 발생했었다.

import sys

input = sys.stdin.readline
sys.setrecursionlimit(1000000)

while True:
  M, N = map(int,input().split())
  if M == 0 and N == 0 :
    break
  edge_list = []

  for _ in range(N):
    edge_list.append(list(map(int,input().split())))
  edge_list.sort(key = lambda x : (x[2]))

  parent = [ x for x in range(M + 1 )]

  def getParent(parent , n):
    if parent[n] == n:
      return n
    parent[n] = getParent(parent, parent[n])
    return parent[n]

  def Union(parent , n1, n2 ):
    pn1 = getParent(parent, n1 )
    pn2 =getParent(parent, n2 )

    if pn1 < pn2 :
      parent[pn2] = pn1
    else:
      parent[pn1] = pn2


  def find(parent, n1, n2 ):
    if getParent(parent , n1) == getParent(parent , n2):
      return True
    else:
      return False  

  total_sum = 0
  result = 0
  for i in edge_list:
    x,y,z = i
    total_sum += z
    
    if find(parent, x,y):
      result += z
      continue
    
    Union(parent, x, y)
    
  print(result)