🤷 Motivation

• 통일된 계층과 같은 할루시네이션을 분류할 프레임워크 부족

• Hallucination에 대한 용어와 범위의 모호함

  • “사실과 다른 말하기”(Factuality issue)
  • “모르는데 아는 척하기”(Hallucination)

• Factuality와 real-world의 불일치

  • ex) 22년산 한동건(수염이 존재하는 카더가든처럼 생긴)을 train한 LLM 모델
    • 한동건의 얼굴에 대해서 묘사해달라고 하면 수염달린 카더가든 한동건이라고 함
    • 내부 지식에 한에서는 llm이 충실했지만 2025년 real-world 한동건은 수염이 없는 나폴리맛피아 닮은 한동건임

• 기존 hallucination eval dataset들은 Data saturation or Leakage문제 발생

  • data saturation:

    모델들이 성능들이 모두 좋아져서 성능 향상이 미미해지는 현상

🤷 Definition

• Hallucination

  • 훈련한대로 말하지 않거나 prompt(input context)대로 답변하지 않는것

• Claim

  • longform answer에서 검증가능한 작은 정보단위 or 사실적 진술
  • 유형
    • True: 생성된 claim의 개수
    • Flase: 생성되지 않는 claim의 개수
    • Positive: supported
    • Negative: unsupported, refuted, unverifiable

🧮 실험 Setting

• 엄선된 Wiki활용
  1. goodWiki: wikipedia Editors가 따봉한 Wiki로 필터링 - (2023/9/4)까지의 위키를 가져옴
  2. WikiRank 2024: Harmonic centrality score 기준으로 10개의 구간을 나눠서 각 문서의 난이도 분류
     • h-score란?
       • 그래프 이론에서 노드의 중요성과 영향력을 측정하는 지표임.
       • 높을수록 더 접근성이 좋고, 언급이 많이 되고 많이 알려져있다는 것
       • 문서 중요도와 대중성의 프록시로 활용
     • 각 extrinsic hallucination에는 위키 문서 기준으로 난이도 분류함
  • 어려움의 기준
    • h-score
    • longtail knowledge
• NonEntity를 만드는법
  • Mixed Entities - 각도메인당 2000개씩 총 8000개 sample
    • 동물, 식물, 박테리아 분류, 의약품과 같은 이름들을 무작위로 섞어서 새로운 용어를 만듦
    • 실제 의학, 분류학 데이터베이스(ITIS)에서 있는지 Validation → 검색 검증 x
  • Generated Entities - 1950개의 Sample
    • LLM이 다양한 도메인(비즈니스, 이벤트, 제품브랜드)에서 허구적인 Entity 이름 생성
    • Round-Robin
      • 단일 llm이 자신이 만든 가상의 엔티티에 정보를 제공하려는 bias 존재가능
      • 두가지 모델로 허구의 Enitity를 생성, 세번째모델이 이름들을 조합하여 query를 만듦.
        • Llama-3.1-405B-Instruct, GPT-4o, Mistral-Nemo-Instruct-2407
    • Brave Search API로 검색엔진으로 존재여부 검증

🤗 Taxonomy

👾 Extrinsic Hallucination

• 정의: 생성된 내용이 training data와 일치 x
• 평가 방식:
  • 한번 evaluation run할때마다 데이터가 생성되고, 평가까지 완료함.
    • wiki 문서를 보고 dynamic하게 query-gt pair를 생성함
    • LLM-as-Judge를 활용해서 각 Metric에 따라 Performance 측정

1. PreciseWikiQA

• 단답형 query-gt 500개

[Metric]

• False refusal rate

• Hallucination rate

• Correct answer rate

• [Eval 결과]

  

  • 라마 3.1 405b-instruct 는 난이도 수준에 걸쳐 일관된 Hallucination 비율을 보여줌
  • Gpt-4o와 claud-3.5-sonnet는 어려울수록 hallucination비율이 높아짐

2. LongWiki

• Longform
• 서술형 query-gt - (250개 sampled + 50개 레벨 고려 샘플링)
• [Metric]
  • False refusal rate
  • Precision
    • 생성된 답변에서 나온 전체 claim 중 supported claim의 평균 비율
    • $\text{Precision} = \frac{\text{supported claims}}{\text{all extracted claims}}$
  • Recall@K
    • $\text{Recall@}K = \frac{\min(\text{supported claims},,K)}{K}$
    • Detail
      • Precision에서 짧게 말한것에 대해서 점수를 많이 받을수도 있기에 조정
      • FN은 어떻게 아나?
        • 몰라서 K를 32개로 적당히 두고 32개가 모든
  • F1@K
    • $\text{F1@}K = \frac{2 \cdot \text{Precision} \cdot \text{Recall@}K}{\text{Precision} + \text{Recall@}K}$

[Eval 결과]

3. NonExistentRefusal

• training하지 않은 상상의 Entitiy를 섞어서 질문하면 거부하는가?
  • 관련성 없지만 넣었을때 그럴듯해보이는 entity를 프롬프트에 넣음
• 존재하지 않는 엔티티 1950개 생성후 query를 날림.
• 생성법
  • Entity 생성후 Benchmark → 모델은 모릅니다유를 시전해야함
    • Mixed Entity생성
      • 동물, 의약품, 식물, 박테리아 분류 이름 섞기
      • 검증 - db검색
    • GeneratedEntities
      • Round Robin 방식 활용
        • 2개의 모델이 개체를 생성하고, 하나의 모델이 조합함
      • 검증 - 웹검색

[Metric]

• False Acceptance Rate

[Eval 결과]

🪐 Intrinsic Hallucination

• 정의: 생성된 내용이 input context와 일치하지 않는 생성

기존 벤치마크 활용 (Static)

• 조건:
  • 기존의 잘알려지지 않으면서(Data leakage 문제 방지)
  • data saturation의 문제가 없는 데이터셋 사용
• 선정된 벤치마크
  • HHEM(Hughes Hallucination Evaluation Model) → 매년 업데이트
    • text summarization → 7B미만 모델은 유용
    • 실험 디테일
      • testset
        • CNN/Daily Mail corpus 활용
      • factual consistency 데이터셋으로 Train한 hallucination detection 모델을 사용
        • 각 LLM이 생성한 요약이 원문 내용과 사실적으로 일치하는지 평가
        • 모델별 factual consistency 비율 = 환각이 없는 비율
        • 환각률 = 100 - factual consistency 비율
        • 응답 거부율은 별도로 ‘Answer Rate’로 기록.
    • 실험 세팅
      • temperature = 0
      • 프롬프트세팅
        • 깃허브 나와있는대로 ㄱㄱ
      • 사용모델: HHEM-2.1-Open
        • context length 제한은 없다고 Hugging에 나오긴했는데 한번 써보고 이상하면 github 설명대로 1000개 짧은 Corpus로 샘플링
  • ANAH 2.0 - with reference set-up
    • ANAH dataset
    • ANAH v2 model
  • FaithEval
    • FaithEval Benchmark dataset
      • https://huggingface.co/collections/Salesforce/faitheval-benchmark-66ff102cda291ca0875212d4
• 이유
  • benchmark set을 extrinsic처럼 Dynamic하게 하면 좋지만 llm as judge 자체에서도 할루시네이션이 생길 수 있음.

1. HHEM

• 매년 업데이트 되는 Text summarization 벤치마크
• 7B 미만의 모델을 평가하는데에는 유용하다고 판단해서 넣음

2. ANAH2.0

• input context로 사실적으로 정확한 정보를 주었을때 생성된 콘텐츠와 입력 context 간의 일관성 평가
• llm as judge

3. FaithEval

• 입력 Context에 노이즈를 넣거나 모순된 지식을 섞어도 잘 대답하는지 평가

문제 요약:

• main.py에서 AutoComplete.autocomplete()을 실행하면 PostgreSQL 연결은 성공 메시지가 뜨지만 실제 데이터 조회 (User.get_random_meme())에서 동작하지 않거나, GUI가 에러 (pyimage1 doesn't exist)를 발생시킴.
• 같은 코드를 단독으로 실행하면 정상 동작함.
• Messagebox에 글자가 잘 안뜨거나 Messagebox자체가 안나오는 문제

🔎 원인 분석

1. pyimage1 doesn't exist 에러는 Tkinter 이미지 객체가 생성되었는데, mainloop 중간에 소멸되어 Tkinter가 그걸 참조할 수 없게 되는 대표적인 에러입니다.

   • 이는 PhotoImage나 Label 등에 설정된 이미지가 local variable로 만들어지고, 참조 없이 사라질 때 발생합니다.
   • GUI에서 이미지 보여줄 때 self.image = tk.PhotoImage(...)처럼 인스턴스 변수로 유지해야 합니다.

2. PostgreSQL이 동작하지 않는 것처럼 보이는 이유

   • 실제로 연결은 되었고 로그도 출력되지만, GUI 창이 뜨기 전에 mainloop()가 잘못 종료되어 DB 동작까지 마무리되지 않을 수 있습니다.
   • 특히 GUI 내부에서 발생한 예외나 잘못된 흐름으로 인해 mainloop()가 조기 종료되면 이후 코드가 실행되지 않을 수 있습니다.

🛠 해결 방법

✅ 2. tk.Tk()를 MainThreadExecutor의 root가 아닌 AutoComplete에서 다시 생성해서 충돌 가능성

MainThreadExecutor는 self.root.mainloop()로 메인 이벤트 루프를 이미 돌리고 있습니다. 그런데 AutoComplete.display_meme_gui()에서 다시 tk.Tk()를 호출하는 건 중복 Tk root 생성으로 비정상 동작의 원인이 됩니다.

해결책: AutoComplete에서는 새 Tk()를 만들지 말고 Toplevel()으로 만들어야 합니다.

self.root = tk.Toplevel()

✅ 정리된 체크리스트

• tk.Tk() → tk.Toplevel()으로 바꾸기 (중복 루트 방지)

🔚 결론

코드 구조상 동작은 맞지만, Tkinter의 이미지 관리, 중복 Tk() 루트 생성, 그리고 DB 연결의 암시적 종료 시점이 문제를 일으키고 있습니다.

위 3가지를 고치면 main.py에서도 정상적으로 autocomplete()과 DB 조회가 작동할 것입니다. 원하시면 MemeSelectionGUI 쪽 예시 코드까지 보여드릴게요.

깨달음

역시 알기 위해서는 수단과 방법을 가리지 말아야한다. perplexity가 못한걸 chatgpt가 해냈다. 그리고 알기 위해서는 pyimage2 error로 검색했으면 알았을것이다.

In computing, a daemon is a program that runs as a background process, rather than being under the direct control of an interactive user.

📌 POMDP 구성요소 (수식 기반)

POMDP는 다음 7개의 요소로 정의됩니다:

$$ \text{POMDP} = \langle S, A, T, R, O, Z, \gamma \rangle $$

📌 1. belief state (신념 상태)

에이전트는 현재 상태를 직접 알 수 없으므로, 다음과 같이 상태에 대한 확률 분포를 유지합니다:

$$ b(s) = P(\text{현재 상태가 } s) $$

이를 belief state라고 부릅니다. 즉, 상태 공간 $S$에 대해 다음과 같은 확률 분포를 가집니다:

$$ b: S \rightarrow [0, 1], \quad \sum_{s \in S} b(s) = 1 $$

📌 2. Belief 업데이트 수식 (Bayes 필터)

행동 $a$ 후 관측 $o$를 받았을 때 belief를 업데이트하는 수식은:

$$ b'(s') = \eta \cdot Z(o \mid s', a) \cdot \sum_{s \in S} T(s' \mid s, a) \cdot b(s) $$

여기서:

• $b(s)$: 기존 신념
• $T(s' \mid s, a)$: 상태 전이 확률
• $Z(o \mid s', a)$: 관측 확률
• $\eta$: 정규화 상수 (전체 합이 1이 되도록)

📌 3. 가치 함수 (Value Function)

belief에 기반한 가치 함수는 다음과 같이 정의됩니다:

$$ V(b) = \max_{a \in A} \left[ \sum_{s \in S} b(s) R(s, a) + \gamma \sum_{o \in O} P(o \mid b, a) V(b_{a,o}) \right] $$

여기서:

• $P(o \mid b, a)$: belief 상태 $b$에서 행동 $a$ 후 관측 $o$가 나올 확률
• $b_{a,o}$: 행동 $a$ 후 관측 $o$에 대한 belief 업데이트 결과
• $V(b_{a,o})$: 업데이트된 belief에 대한 가치

📌 4. 관측 확률 계산

$$ P(o \mid b, a) = \sum_{s'} Z(o \mid s', a) \sum_{s} T(s' \mid s, a) b(s) $$

🧠 핵심 요약

❗ 어려운 점

• Belief space는 연속적인 고차원 확률 분포 → 계산량이 매우 큼
• 그래서 근사 알고리즘 (예: Particle Filter, Point-based Value Iteration)이 자주 사용됨

batch

• 데이터 Sample 묶음

batch size

• batch 1 묶음에 들어가는 sample의 개수

tokenize

• sequence(text, frame으로 나뉘어진 f0음성등)을 token으로 나눠서 수치화한것, 인덱싱으로 매핑한것

embedding

• token들에 대해서 의미적인 연관성을 기반으로 배치한것
• nn.Embedding 레이어를 통과하던 이미 만들어진 word2vec과 같은 임베딩 모델을 통과하든 첫번째 개념이 상통하면 어떤방식으로든 임베딩이라는 행위를 한것

https://wikidocs.net/64779

텐서 조작 팁

https://sputnik-kr.tistory.com/229

unsqueeze는 뭐냐?

unsqueeze는 PyTorch에서 텐서에 새로운 차원(길이 1인 축)을 추가하는 함수입니다.
예를 들어,

• quantized_f0의 shape이 (1703,)라면,
• quantized_f0.unsqueeze(0)을 하면 shape이 (1, 1703)이 됩니다[2][3][4][7].

이렇게 하면 기존에 없던 batch 차원이 생겨서,

• [1703] → [1][1703]
  즉, 배치가 1개인 시퀀스처럼 사용할 수 있습니다.

왜 쓰나?

• 딥러닝 모델(특히 Conv1d, RNN 등)은 입력에 batch 차원이 있기를 기대합니다.
• 데이터의 차원을 맞추거나, 연산(broadcasting)이나 네트워크 입력을 위해 자주 사용합니다[4][5][7].

예시

import torch
x = torch.tensor([1, 2, 3, 4])       # shape: (4,)
x1 = x.unsqueeze(0)                  # shape: (1, 4)
x2 = x.unsqueeze(1)                  # shape: (4, 1)

• unsqueeze(0)은 맨 앞에 차원을 추가,
• unsqueeze(1)은 두 번째 위치에 차원을 추가합니다.

정리:
unsqueeze는 텐서에 새로운 차원을 추가해 shape을 바꿔주는 함수입니다.
딥러닝에서 배치 차원 등을 맞출 때 필수적으로 사용합니다[2][3][4][5][7].

Citations: [1] https://pplx-res.cloudinary.com/image/private/user_uploads/35150927/dcfdae12-8bbe-4f0b-89ae-d9a629d4a871/image.jpg [2] https://pplx-res.cloudinary.com/image/private/user_uploads/35150927/dcfdae12-8bbe-4f0b-89ae-d9a629d4a871/image.jpg [3] https://pytorch.org/docs/stable/generated/torch.unsqueeze.html [4] https://stackoverflow.com/questions/57237352/what-does-unsqueeze-do-in-pytorch [5] https://www.codecademy.com/resources/docs/pytorch/tensors/unsqueeze [6] https://www.codecademy.com/resources/docs/pytorch/tensor-operations/unsqueeze [7] https://www.datasciencebyexample.com/2023/05/19/squeeze-and-unsqueeze-in-pytorch/ [8] https://dnmtechs.com/understanding-the-unsqueeze-function-in-pytorch/ [9] https://www.projectpro.io/recipes/unsqueeze-torch-tensor [10] https://blog.naver.com/je_un/222297587260 [11] https://codemax.app/snippet/what-does-unsqueeze-do-in-pytorch-in-python/ [12] https://stackoverflow.com/questions/57237352/what-does-unsqueeze-do-in-pytorch/57237378 [13] https://www.tutorialspoint.com/how-to-squeeze-and-unsqueeze-a-tensor-in-pytorch [14] https://iifx.dev/en/articles/332257550 [15] https://sanghyu.tistory.com/86 [16] https://www.slingacademy.com/article/pytorch-squeezing-and-unsqueezing-tensors/ [17] https://stackoverflow.com/questions/57237352/what-does-unsqueeze-do-in-pytorch/65831759 [18] https://www.youtube.com/watch?v=VTryujXrMOs [19] https://blog.csdn.net/chengyq116/article/details/106962842 [20] https://researchdatapod.com/understanding-unsqueeze-in-pytorch-a-beginner-friendly-guide/ [21] https://myscale.com/blog/mastering-tensor-manipulation-pytorch-guide-torch-unsqueeze/ [22] https://pytorch.org/docs/stable/generated/torch.Tensor.unsqueeze.html

Answer from Perplexity: pplx.ai/share

내가 아는 embedding의 개념은 자연어 혹은 entity들을 사용자가 원하는 의미적 유사도대로 임베딩 space에 수치화 해서 배치하는것으로 알고 있다.

근데 자연어인 lyrics를 바로 nn.Embedding에 통과 시키는것이 아닌 Lyrics가 이미 vector화 되어있는 텐서 상태로 통과 시키는것일까?

lexical embedding 방법

embedding의 과정 - Embedding layer 방식의 embedding

Background

Embedding이란

tokenization이란

nn.Embedding의 작동원리

• "인덱스"에 대해서 lookup table로 만들어주는것
• 토큰들(수치화가 되었든 안되었든)에 대해서 인덱스에 대해 아무무 tensor 수치로 L

Lyrics 는 토크나이저 -> 일반적인게 아닌 g2p 포니밈용 토크나이저 f0 는 128개의 level이고

Frame -> 시간 128개의 Level은 음의 높낮이로 embedding 애초에 시간으로 하는게 아님 잘못된 접근

임베딩과정 [멜로디]

1. 프레임(시간)별로 descrete하게 나뉘어진 128 종류의 Level(음의 높낮이)를 토큰화 시킴

ex) 20ms로 나뉘어진 f0

• 결과물은 도 레 미 미 시 파 도의 representation이 만들어짐
• 각각의 Vector들로 나오는것은 수치화된 도, 레, 미, 미, 시, 파, 도와 매핑이 되어있음.

Lookup table이란

• token들의 "인덱스"별 vector representation

CONTEXT_SIZE = 2
EMBEDDING_DIM = 10
# 셰익스피어 소네트(Sonnet) 2를 사용하겠습니다.
test_sentence = """When forty winters shall besiege thy brow,
And dig deep trenches in thy beauty's field,
Thy youth's proud livery so gazed on now,
Will be a totter'd weed of small worth held:
Then being asked, where all thy beauty lies,
Where all the treasure of thy lusty days;
To say, within thine own deep sunken eyes,
Were an all-eating shame, and thriftless praise.
How much more praise deserv'd thy beauty's use,
If thou couldst answer 'This fair child of mine
Shall sum my count, and make my old excuse,'
Proving his beauty by succession thine!
This were to be new made when thou art old,
And see thy blood warm when thou feel'st it cold.""".split()
# 원래는 입력을 제대로 토큰화(tokenize) 해야하지만 이번엔 간소화하여 진행하겠습니다.
# 튜플로 이루어진 리스트를 만들겠습니다. 각 튜플은 ([ i-CONTEXT_SIZE 번째 단어, ..., i-1 번째 단어 ], 목표 단어)입니다.
ngrams = [
    (
        [test_sentence[i - j - 1] for j in range(CONTEXT_SIZE)],
        test_sentence[i]
    )
    for i in range(CONTEXT_SIZE, len(test_sentence))
]
# 첫 3개의 튜플을 출력하여 데이터가 어떻게 생겼는지 보겠습니다.
print(ngrams[:3])

vocab = set(test_sentence)
word_to_ix = {word: i for i, word in enumerate(vocab)}


class NGramLanguageModeler(nn.Module):

    def __init__(self, vocab_size, embedding_dim, context_size):
        super(NGramLanguageModeler, self).__init__()
        self.embeddings = nn.Embedding(vocab_size, embedding_dim)
        self.linear1 = nn.Linear(context_size * embedding_dim, 128)
        self.linear2 = nn.Linear(128, vocab_size)

    def forward(self, inputs):
        embeds = self.embeddings(inputs).view((1, -1))
        out = F.relu(self.linear1(embeds))
        out = self.linear2(out)
        log_probs = F.log_softmax(out, dim=1)
        return log_probs


losses = []
loss_function = nn.NLLLoss()
model = NGramLanguageModeler(len(vocab), EMBEDDING_DIM, CONTEXT_SIZE)
optimizer = optim.SGD(model.parameters(), lr=0.001)

for epoch in range(10):
    total_loss = 0
    for context, target in ngrams:

        # 첫번째. 모델에 넣어줄 입력값을 준비합니다. (i.e, 단어를 정수 인덱스로
        # 바꾸고 파이토치 텐서로 감싸줍시다.)
        context_idxs = torch.tensor([word_to_ix[w] for w in context], dtype=torch.long)

        # 두번째. 토치는 기울기가 *누적* 됩니다. 새 인스턴스를 넣어주기 전에
        # 기울기를 초기화합니다.
        model.zero_grad()

        # 세번째. 순전파를 통해 다음에 올 단어에 대한 로그 확률을 구합니다.
        log_probs = model(context_idxs)

        # 네번째. 손실함수를 계산합니다. (파이토치에서는 목표 단어를 텐서로 감싸줘야 합니다.)
        loss = loss_function(log_probs, torch.tensor([word_to_ix[target]], dtype=torch.long))

        # 다섯번째. 역전파를 통해 기울기를 업데이트 해줍니다.
        loss.backward()
        optimizer.step()

        # tensor.item()을 호출하여 단일원소 텐서에서 숫자를 반환받습니다.
        total_loss += loss.item()
    losses.append(total_loss)
print(losses)  # 반복할 때마다 손실이 줄어드는 것을 봅시다!

# "beauty"와 같이 특정 단어에 대한 임베딩을 확인하려면,
print(model.embeddings.weight[word_to_ix["beauty"]])

파이토치 한국어 갤러리 코드 참고

동기

lyrics encoder과 melodyU encoder를 Summation한 뒤의 shape는 (1, 192, 1) - (b, h, time(seq_len))이다. 요녀석들은 enhanced condition encoder에서 다시 FFT 연산을 하는데 동일하게 nn.Embedding과 transpose를 해주었더니 시원하게 오류가 나온다.

문제정의 및 해결 요약

1. 임베딩된 산출물은 nn.Embedding layer를 통과할 필요가 없음. + nn.Embedding의 정의

   • nn.Embedding은 token별 인덱스를 기반으로 lookup table을 만드는 녀석이다. 고로 lyrics representation과 melodyU representation의 summation은 이미 Embedding의 결과물끼리 더한것이므로 float에다가 인덱스도 없으므로 nn.Embedding을 할수 없다.

2. transpose는 nn.Embedding layer를 통과해서 다시 정상화 시키기 위한 녀석
   • [b,h,t]가 nn.Embedding layer를 통과하면 [b,t,h]가 되어서 다시 정상화 시키기 위해서 transpose를 시킨다.
     • transformer encoder의 ffn이 통과할때는 [b,h,t]로 되어야함.

세부설명

PyTorch의 nn.Conv1d 레이어는 입력 텐서의 shape이 [batch, channels, length] 형태이길 기대합니다.
하지만 자연어 처리 등에서 임베딩을 거친 텐서는 보통 [batch, length, embedding_dim] (즉, [배치, 시퀀스 길이, 임베딩 차원]) 형태로 나옵니다.

예를 들어,

• 임베딩 후 텐서: [batch, time, hidden]
• Conv1d 기대 입력: [batch, hidden, time]

따라서, Conv1d에 입력하기 전에 transpose 또는 permute를 사용해 두 차원의 순서를 바꿔줘야 합니다. 이렇게 해야만 Conv1d가 임베딩 차원을 채널로 인식하고, 시퀀스 길이를 커널이 따라가며 합성곱 연산을 올바르게 수행할 수 있습니다[6][8].

"In pytorch your input shape of[6] should actually be[6] where the feature length is represented by the channel dimension and sequence length is the length dimension. Then you can define your conv1d with in/out channels of 768 and 100 respectively to get an output of[6].
... you can convert it to the correct shape with Tensor.transpose."[6]

즉,

• transpose는 임베딩 결과([batch, seq_len, hidden])를 Conv1d가 기대하는 입력([batch, hidden, seq_len])으로 맞추기 위해 반드시 필요합니다.

이것이 바로 Conv1d 앞에서 transpose를 하는 이유입니다.

Citations: [1] https://cumulu-s.tistory.com/29 [2] https://pytorch.org/docs/stable/generated/torch.nn.ConvTranspose1d.html [3] https://velog.io/@gilson/View-and-Reshape-VS-permute-and-transpose [4] https://jisuhan.tistory.com/128 [5] https://westlife0615.tistory.com/257 [6] https://stackoverflow.com/questions/62372938/understanding-input-shape-to-pytorch-conv1d [7] https://dacon.io/forum/406022 [8] https://discuss.pytorch.org/t/understanding-input-shape-to-pytorch-conv1d/85429 [9] https://www.thespacemoon.com/2021/03/03/pytorch-view-reshape-transpose/ [10] https://sksdudtjs.tistory.com/50 [11] https://iamseungjun.tistory.com/15 [12] https://jimmy-ai.tistory.com/378 [13] https://stackoverflow.com/questions/69915792/pytorch-conv1d-gives-different-size-to-convtranspose1d [14] https://wikidocs.net/64779 [15] https://imlim0813.tistory.com/58 [16] https://velog.io/@workhard/lstm-9.-pytorch-%EC%82%AC%EC%9A%A9%EB%B2%95 [17] https://wikidocs.net/217064 [18] https://leeejihyun.tistory.com/37

Answer from Perplexity: pplx.ai/share

embedding하면 shape가 달라지는 근거

임베딩 레이어(Embedding Layer)를 거친 텐서의 shape이 [batch, length, embedding_dim]이 되는 이유는 임베딩 레이어의 동작 방식과 자연어 처리 데이터의 구조 때문입니다.

1. 임베딩 레이어의 입력과 출력 구조

• 임베딩 레이어는 정수 인덱스 시퀀스(예: 단어 인덱스)를 입력으로 받습니다.

• 입력 shape: (batch_size, sequence_length)

  • batch_size: 한 번에 처리하는 문장(또는 샘플)의 개수
  • sequence_length: 각 문장의 토큰(단어) 수

• 임베딩 레이어는 각 인덱스를 임베딩 테이블에서 벡터로 변환합니다.

• 출력 shape: (batch_size, sequence_length, embedding_dim)

  • embedding_dim: 각 단어를 표현하는 벡터의 차원

"Embedding()은 (number of samples, input_length)인 2D 정수 텐서를 입력받습니다. 이 때 각 sample은 정수 인코딩이 된 결과로, 정수의 시퀀스입니다. Embedding()은 워드 임베딩 작업을 수행하고 (number of samples, input_length, embedding word dimentionality)인 3D 실수 텐서를 리턴합니다."

• [위키독스, 케라스 임베딩 층 설명][5][6]

2. 자연어 처리에서 임베딩 레이어 사용 예시

예를 들어,

• 입력: [[1,[2][3], [4, 5,6]] (batch_size=2, sequence_length=3)
• 임베딩 차원(embedding_dim)=8이라면
• 출력: (2, 3, 8)
  • 각 단어 인덱스가 8차원 벡터로 변환됨

3. 왜 이런 구조가 되는가?

• 각 문장(샘플)은 여러 단어(토큰)로 구성
• 각 단어는 하나의 임베딩 벡터로 변환
• 따라서,
  • 첫 번째 차원: 배치(문장)
  • 두 번째 차원: 시퀀스 길이(토큰 수)
  • 세 번째 차원: 임베딩 벡터 차원

4. 공식 문서 및 교재 근거

• "Embedding 층은 크기가 (samples, sequence_length, embedding_dimensionality)인 3D 실수형 텐서를 반환한다."
  [위키독스][5][6]
• "임베딩 레이어는 입력 시퀀스의 각 인덱스를 임베딩 테이블에서 벡터로 변환하여 (배치, 시퀀스 길이, 임베딩 차원) 형태로 출력한다."
  [simling.tistory][3][5]

정리:
임베딩 레이어는 입력이 [batch, sequence_length]일 때, 각 인덱스를 임베딩 벡터로 변환해 [batch, sequence_length, embedding_dim] 형태의 텐서를 반환합니다. 이 구조는 자연어 처리에서 각 문장(배치), 각 단어(시퀀스), 각 임베딩 벡터(임베딩 차원)로 구성되기 때문입니다[5][6][3].

Citations: [1] https://tech.kakao.com/posts/585 [2] https://wikidocs.net/31379 [3] https://simpling.tistory.com/1 [4] https://ebbnflow.tistory.com/154 [5] https://ingu627.github.io/keras/keras_ch6_org_1/ [6] https://wikidocs.net/33793 [7] https://wikidocs.net/37001 [8] https://velog.io/@oilyhand_01/%EB%94%A5%EB%9F%AC%EB%8B%9D-%EA%B8%B0%EC%B4%88-14 [9] https://velog.io/@yenaryu/%EC%9E%90%EC%97%B0%EC%96%B4%EC%B2%98%EB%A6%AC-%EC%9E%91%EC%82%AC%EA%B0%80-%EC%9D%B8%EA%B3%B5%EC%A7%80%EB%8A%A5-%EB%A7%8C%EB%93%A4%EA%B8%B0 [10] https://heeya-stupidbutstudying.tistory.com/entry/DL-%EC%9E%90%EC%97%B0%EC%96%B4-%EC%B2%98%EB%A6%AC%EC%97%90%EC%84%9C%EC%9D%98-%EB%8B%A8%EC%96%B4-%ED%91%9C%ED%98%84-Word-Embedding [11] https://blog.naver.com/iwin1203/222010971529 [12] https://aigaeddo.tistory.com/37 [13] https://www.youtube.com/watch?v=BbBCLPl0x_U [14] https://www.ibm.com/kr-ko/think/topics/vector-embedding [15] https://sjh9708.tistory.com/231 [16] https://dusanbaek.tistory.com/99 [17] https://wikidocs.net/22660 [18] https://cumulu-s.tistory.com/4 [19] https://soyoung-new-challenge.tistory.com/32

Answer from Perplexity: pplx.ai/share

[b, h, time(seq_len)]

• Batch size

• hidden channel

• sequence length

임베딩 차원

• 데이터가 표현되는백터 공간의 차원수=

nn.Embedding

input channel

문제

Lyrics와 quantized f0된 melody를 FFT encoding을 하면 [batch size, hidden channel, time(seq_len)-> 시퀀스 Length]가 나온다. sequence length가 다를 수도 있지 않누??

해결

mean pooling을 하세유~~

hidden channel의 각 feature마다 Mean을 때려서 seq len을 1로 맞춤 -> melody도 마찬가지

ex)

  ------hidden channel---------
김  
민
재
짜
스
  mean mean mean mean mean mean ....

__getitem__은 파이썬에서 객체가 인덱싱(obj[key]) 또는 슬라이싱(obj[start:stop])될 때 호출되는 메서드입니다. 이 메서드를 클래스 안에 정의하면, 해당 클래스의 인스턴스를 리스트나 딕셔너리처럼 사용할 수 있습니다.

📌 기본 사용법

class MyList:
    def __init__(self, data):
        self.data = data

    def __getitem__(self, index):
        print(f"Called with index: {index}")
        return self.data[index]

my_list = MyList([10, 20, 30])
print(my_list[1])  # => Called with index: 1
                   # => 20

🎯 주요 특징

• obj[key]가 호출되면 obj.__getitem__(key)가 자동으로 호출됩니다.
• key는 정수뿐만 아니라 슬라이스(slice), 튜플, 문자열 등도 될 수 있습니다.

✅ 슬라이싱도 지원 가능

class MyList:
    def __init__(self, data):
        self.data = data

    def __getitem__(self, index):
        print(f"Index received: {index}")
        return self.data[index]

lst = MyList([1, 2, 3, 4, 5])
print(lst[1:4])  # 슬라이스 객체(slice(1,4,None))가 전달됨

📦 예제: 2차원 배열 흉내내기

class Matrix:
    def __init__(self, rows):
        self.rows = rows

    def __getitem__(self, index):
        return self.rows[index]

m = Matrix([[1, 2], [3, 4]])
print(m[0][1])  # 2

⚠️ 주의사항

• __getitem__은 읽기 전용입니다. 쓰기를 하려면 __setitem__을 정의해야 합니다.
• KeyError, IndexError 등을 적절히 처리해주는 것이 좋습니다.

궁금하다면 __setitem__, __delitem__ 도 함께 설명해줄 수 있어요. 추가로 알려드릴까요?

nest_map을 만드세유

def nested_map(struct, map_fn):
    if isinstance(struct, tuple):
        return tuple(nested_map(x, map_fn) for x in struct)
    if isinstance(struct, list):
        return [nested_map(x, map_fn) for x in struct]
    if isinstance(struct, dict):
        return {k: nested_map(v, map_fn) for k, v in struct.items()}
    return map_fn(struct)

직관

Sol 1. 두개의 arr

1. arr 2개

• stack
• min_stack

2. stack은 그대로 구현
3. min_stack은 stack이 반복될때마다 계속 반복적으로 최소값을 각각의 idx로 할당

top이라는 Int idx를 Cursor로 활용해서 stack을 구현

Sol 2. 하나의 arr로 수학적 트릭

홀수번째 Idx는 stack 짝수번째 idx는 min_stack

Sol 2. 하나의 arr 수학적 트릭 2 -> 아직 70%

• 오직 min stack만 꺼낼 수 있는 수학적 트릭임!!

• Push 연산

• 2x - minElem

• 새로운 input x보다 작은지 큰지를 판별 -> 나중에 pop 할때 min value를 복원해야할지에 대한 여부를 결정해줌 단, 새로 Push된 값이 min value보다 크다면 stack에 그냥 넣어줌

• Pop 연산

• 2x-prevMinEle(stack의 이전값)

• 새로운 최소값은 2minEle - y = 2x - (2*x - prevMinEle) = prevMinEle로 계산됩니다. 단, pop된 값이 min value보다 크다면 그대로 진행

// all operations in O(1) time and O(1) extra space.

#include <iostream>
#include <stack>
using namespace std;

// A user defined stack that supports getMin() in
// addition to push(), pop() and peek()
class SpecialStack {
  private:
    stack<int> s;
    int minEle;

  public:
    SpecialStack() {
        minEle = -1;
    }

    // Add an element to the top of Stack
    void push(int x) {
        if (s.empty()) {
            minEle = x;
            s.push(x);
        }

        // If new number is less than minEle
        else if (x < minEle) {
            s.push(2 * x - minEle);
            minEle = x;
        }

        else {
            s.push(x);
        }
    }

    // Remove the top element from the Stack
    void pop() {
        if (s.empty()) {
            return ;
        }

        int top = s.top();
        s.pop();

        // Minimum will change, if the minimum element
        // of the stack is being removed.
        if (top < minEle) {
            minEle = 2 * minEle - top;
        }
    }

    // Returns top element of the Stack
    int peek() {
        if (s.empty()) {
            return -1;
        }

        int top = s.top();

        // If minEle > top means minEle stores value of top.
        return (minEle > top) ? minEle : top;
    }

    // Finds minimum element of Stack
    int getMin() {
        if (s.empty())
            return -1;

        // variable minEle stores the minimum element
        // in the stack.
        return minEle;
    }
};

int main() {
    SpecialStack ss;

    // Function calls
    ss.push(2);
    ss.push(3);
    cout << ss.peek() << " ";
    ss.pop();
    cout << ss.getMin() << " ";
    ss.push(1);
    cout << ss.getMin() << " ";
}

push가 동작하는 원리

How 2*x – minEle is less than x in push()? 


x < minEle which means x – minEle < 0 


// Adding x on both sides
x – minEle + x < 0 + x 
2*x – minEle < x 
We can conclude 2*x – minEle < new minEle 

pop이 복원되는 이유

How previous minimum element, prevMinEle is, 2*minEle – y
in pop() is y the popped element?


 // We pushed y as 2x – prevMinEle. Here 
// prevMinEle is minEle before y was inserted


y = 2*x – prevMinEle  


// Value of minEle was made equal to x
minEle = x 


new minEle = 2 * minEle – y 
                   = 2*x – (2*x – prevMinEle)
                   = prevMinEle // This is what we wanted

https://www.geeksforgeeks.org/design-a-stack-that-supports-getmin-in-o1-time-and-o1-extra-space/

Sol 3. Linked list

Sol4. stack std사용사용

핵심 내용

필자의 해석이므로 틀린부분이 있다면 지적해주세요!

• 베이지안 관점의 확률: 기존의 evidence(이미 일어난 단서들, 확률로 표현)와 hypothesis()를 기반으로 미래의 '가능성', 즉 미래의 불확실성을 예측하는 개념이다. (귀납)

• 기존: 특정 사건들에 대한 관측값의 빈도 기반으로 현상을 해석(연역)

• Evidence: 새로운 정보, 단서

• Hypothesis(prior, 사전확률): 어떤 사건이 발생했다는 주장

• posterior(사후 확률): E(새로운 정보)가 들어왔을때 H가 업데이트 되는 확률(이것으로 미래를 예측한다)

-> evidence를 관측하기 전후의 내주장에 대한 신뢰도

베이즈정리의 정의

• 베이즈 정리: 새로운 정보를 토대로 어떤 사건이 발생했다는 주장에 대한 신뢰도(예측할 미래에 대한 가능성)를 갱신해 나가는 방법

공돌이의 수학노트 고트 해석

기댓값 vs 평균

• 기댓값: 미래를 예측하기 위해서 확률들을 기반으로 구한값, 미래 가능한 결과에 대한 예측값(귀납-경험/관찰/증거에 기반한 미래 예측 판단)

• 평균: 빈도주의 관점으로 기존 데이터들을 가지고 구한값, 이미 관측된 데이터를 가지고 확실한 값(연역-이미 알고있는 데이터 가지고 판단)

왜 twist smc, llm에서는 기댓값을 쓰는가? 평균이랑 기댓값은 똑같은거 아니누? llm은 사전 정보들을 기반으로 불확실한 수치를 계속해서 prior를 업데이트하는 베이지안 관점이기 때문에 기댓값을 사용한다.

이것이 가우시안 베이지안의 관점 차이?!

가우시안: 빈도와 같은 관측값으로부터 현상 분석 및 결론(정규분포) 베이지안: 경험적인 확률들 기반으로 미래 예측(확률)

기존에는 Perplexity나 ChatGPT 같은 AI 챗봇을 활용할 때, 답변의 신뢰성을 확인하려면 출처 링크를 일일이 클릭하고 내용을 직접 찾아야 했습니다. 환각현상(Hallucination)으로 인한 잘못된 정보까지 검증하려면 추가적인 시간과 에너지가 필요했죠. 그러던중 ai가 참고했다는 원문출처를 클릭하면 답변에서 참고한부분을 자동으로 찾아주는 툴이 필요하다고 생각했습니다.

이에 저희는 ClueHunter는 AI가 참고한 출처를 단번에 검증할 수 있도록 도와주는 크롬 익스텐션을 개발했습니다.

기존에는 Perplexity에서 제공하는 출처 링크를 하나씩 클릭하고, 내용을 직접 찾아야 했다면, 이제는 ClueHunter가 출처 페이지를 자동 스크롤 & 핵심 내용 강조 표시까지 해줍니다!

현재는 Perplexity 전용 크롬 익스텐션으로 제공되지만, 앞으로 ChatGPT, Claude AI 등 다양한 AI 챗봇에서도 활용할 수 있도록 확장할 예정입니다.

🛠 ClueHunter는 오픈소스 프로젝트로, 여러분의 피드백을 환영합니다!

• ClueHunter 크롬 익스텐션
• ClueHunter.js
• ClueHunter-Perpelxity

아직 처음 배운거라 오류가 있다면 알려주세용

ML, 넓은 의미로써의 학습

모델의 가중치값을 조정해나아가는 일련의 과정

LLM에서의 학습

모델의 단어들의 관계나 문장의 의미를 백터로 변환하는 "방법"을 배운 상태

DAE (Denosing AutoEncoder)

1. transformer가 문장들을 임베딩하여 백터화하고 단어들의 관계를 학습함.
2. 그리고 마스킹과 복원하는 작업을 통해 각 단어의 문맥적 의미를 배우고 문장의 의미를 백터화 하는 능력 향상
3. 학습된 모델은 문장의 임베딩 백터로 변환

-> Chatgpt피셜이라 교차검증 필요 -> 백터화하는 과정과 denosing하는 과정은 따로 있는것 같다.

베이즈 정리는 사건이 발생한 후에 원인을 추론하는 데 사용하는 확률 법칙입니다.
즉, 이미 발생한 사건을 바탕으로 다른 사건이 일어날 확률을 업데이트하는 방법을 제공합니다.

1. 베이즈 정리의 공식

베이즈 정리는 조건부 확률을 이용하여 다음과 같이 표현됩니다:

• P(A | B): B가 발생한 후 A가 발생했을 확률 (사후 확률, Posterior Probability)
• P(B | A): A가 발생한 경우 B가 발생할 확률 (우도, Likelihood)
• P(A): A가 발생할 확률 (사전 확률, Prior Probability)
• P(B): B가 발생할 확률 (모든 가능한 경우에서 B가 발생할 확률)

2. 베이즈 정리가 왜 중요한가?

베이즈 정리는 새로운 정보가 주어졌을 때 확률을 업데이트하는 과정입니다.
즉, 기존 확률(사전 확률)을 새로운 정보(우도)를 통해 수정하여 사후 확률을 계산합니다.

• 의학적 진단: 질병이 있을 확률을 검사 결과를 기반으로 업데이트
• 기계 학습: 새로운 데이터가 주어질 때 모델이 확률을 업데이트하는 과정
• 범죄 수사: 주어진 증거를 바탕으로 용의자가 범인일 확률 계산

3. 예제: 질병 진단

어떤 병(예: 독감)에 걸릴 확률이 1%라고 가정하겠습니다.
이 병을 진단하는 검사에서 양성(positive)이 나올 확률은 다음과 같습니다:

여기서:

우리는 "검사 결과가 양성일 때 실제로 병에 걸렸을 확률" P(D | T^+)을 구해야 합니다.

베이즈 정리 적용

먼저, P(T^+)를 구해야 합니다. 전체적으로 검사에서 양성이 나올 확률은 다음과 같이 계산됩니다:

대입하면:

이제, 베이즈 정리를 사용하여 P(D | T^+)을 구합니다:

즉, 검사에서 양성이 나왔다고 해서 실제로 병에 걸렸을 확률은 약 16.1%입니다.
(검사 결과만 믿으면 안 되는 이유!)

4. 확장: 여러 개의 원인 (전확률 정리 활용)

베이즈 정리는 하나의 원인(A)이 아니라 여러 원인들이 있을 때도 사용됩니다.

만약 B가 여러 개의 가능한 원인 A_1, A_2, ..., A_n 중 하나로 인해 발생했다면:

이것을 전확률 정리 (Law of Total Probability)라고 합니다.

5. 결론

• 베이즈 정리는 새로운 정보가 주어졌을 때 확률을 업데이트하는 방법입니다.

• 조건부 확률을 활용하여 원인을 추론할 수 있습니다.

• 의학, 인공지능, 금융, 범죄 수사 등에서 널리 사용됩니다.

• 기본 공식:

• 응용 예제: 검사 결과가 양성일 때 실제 질병 확률을 구하는 문제

혹시 더 궁금한 점 있으면 질문해주세요! 😊

문제 상황

LLM시대이전 내가 고등학교에서 의문을 품었지만 질문을 구체화하지 못해서 미궁으로 빠졌었다. 문제에서 교집합 확률이나 조건부확률을 주지 않았고, 문제에서 A와 B가 종속적이라는 정보만 있고 조건부 확률도 직접 주어지지 않았다면 어떻게 해야하지?

추가적인 정보 없이 종속 사건의 교집합 확률을 구할 수 있을까?

좋은 질문이에요! 문제에서 A와 B가 종속적이라는 정보만 있고, 교집합 확률이나 조건부 확률이 주어지지 않았다면 어떻게 해야 하는지 알아보죠.

1. 기본적인 문제 상황

문제에서 다음 조건만 주어졌다고 가정해 봅시다.

이때, 교집합 확률 P(A ∩ B)을 구할 수 있을까?

2. 추가적인 정보 없이 P(A ∩ B)을 구할 수 없는 이유

우리가 사용할 수 있는 공식은:

그런데 P(A | B) 또는 P(B | A)가 없으면 이 공식을 사용할 수 없습니다.
즉, 추가적인 정보 없이 P(A ∩ B)을 계산하는 것은 불가능합니다.

💡 비유하자면
이것은 "어떤 사람이 A고, 다른 사람이 B일 때, 두 사람이 친구일 확률"을 계산하는 것과 비슷합니다.
A와 B가 서로 영향을 주는(종속적인) 관계라는 건 알지만, 얼마나 영향을 주는지(조건부 확률)가 없으면 정확한 확률을 구할 수 없어요.

3. 해결 방법: 추가 정보를 찾아야 함

그럼 이런 경우 어떻게 해야 할까요?
다음과 같은 추가적인 정보를 얻어야 합니다.

(1) 문제에서 조건부 확률을 유도할 수 있는 단서 찾기

• 어떤 경우에는 문제에 숨겨진 정보가 있을 수도 있습니다.
• 예를 들어, 문제에서 "A가 발생하면 B가 발생할 확률이 두 배 높다" 같은 단서가 있다면, 이를 조건부 확률로 변환할 수 있습니다.

(2) 실험 데이터 또는 통계 자료 활용

• 현실에서는 교집합 확률을 직접 계산하기 어려운 경우가 많습니다.
• 따라서 실험을 통해 데이터를 수집한 후, 경험적인 확률을 사용하여 조건부 확률을 추정할 수 있습니다.
• 예를 들어, 두 이벤트 A와 B에 대한 과거 데이터를 분석해서 P(A | B) 또는 P(B | A)를 근사할 수 있습니다.

(3) 베이즈 정리를 활용

• 만약 B의 사전 확률 P(B)과 A가 발생했을 때 B가 발생할 확률 P(B | A)을 알고 있다면,

  공식을 이용해서 필요한 조건부 확률을 구한 후, 이를 이용해 교집합 확률을 찾을 수도 있습니다.

4. 결론: 추가 정보 없이 확률을 구할 수 없음

✔ A와 B가 종속적이라는 정보만으로는 P(A ∩ B)을 구할 수 없다.
✔ 추가적으로 P(A | B) 또는 P(B | A) 같은 조건부 확률이 필요하다.
✔ 문제에서 숨겨진 단서를 찾아야 하며, 실험 데이터나 베이즈 정리를 활용할 수도 있다.

이제 확실히 이해되셨나요? 😊
추가 질문이 있으면 언제든지 물어보세요!