내 주변의 문제를 해결하려는 목적에서 출발한다면, 망치를 어디에 사용할 것인지부터 생각하게 된다. 문을 부수거나 벽에 못을 박는 등 구체적인 용도와 쓰임새가 있기 때문에, 그 목적에 맞는 망치를 만드는 것은 비교적 쉽다.

하지만 기술을 먼저 생각하면 접근 방식이 달라진다. 망치의 재료와 역학, 구조와 형태에 대한 공학적 이해에서 출발해 망치 머리를 어떻게 개선하고 더 효율적으로 만들 것인지를 고민하게 된다. 이 과정에서는 거시적인 관점에서 망치의 필요성과 사용자의 실제 쓰임새를 바라보기가 어렵다. 대신 누구보다 망치의 쇠를 잘 깎고, 나무 손잡이를 정교하게 다듬는 전문가가 될 수는 있다. 그리고 이러한 기술은 망치를 다양한 용도로 활용하려는 생산자들에게 판매하기에도 좋다.

그러나 문제가 있다.

생산자의 쓰임새에 맞게 망치를 더 잘 만들려면 상상만으로는 부족하다. 직접 생산자가 되어봐야 한다. 그리고 좋은 생산자가 되려면 결국 내 주변의 문제를 해결하는 것부터 시작해야 한다. 즉, 내가 기술적인 전문가가 되고 싶고, 기술적 해자를 갖춘 인프라를 만들고 싶다는 욕망 역시 직접 생산자가 되어보지 않는 이상 그저 재미있고 멋있어 보이는 기술에 대한 동경으로 그칠 수 있다.

물론 망치 머리를 깎는 과정에서도 기술적인 문제는 발견할 수 있다. 망치의 전체적인 쓰임새를 고려하지 않더라도, 쇠를 깎다가 발견한 특정 문제를 최적화하는 솔루션은 충분히 만들 수 있다. 하지만 나는 그동안 기술을 먼저 깊이 파고들고, 이를 인프라로 만들고 싶다는 막연한 목표와 욕망을 가지고 있었다.

딥테크 인프라는 어디에서 시작되는가 수많은 사례를 조사하면서 발견한 것은, 많은 딥테크 인프라형 창업가 역시 처음부터 기반 기술 자체를 만들려고 했던 것이 아니라는 점이다. 먼저 망치를 만들어 소비자에게 판매하거나, 직접 생산자가 되어보는 과정에서 문제를 발견했다. 그리고 그 과정에서 마주한 기술적 병목과 문제의식을 바탕으로 딥테크에 접근했다. 심지어 Etched처럼 Transformer를 위한 전용 GPU가 필요한 시대가 올 것이라는 미래적 인사이트조차, 결국 망치 머리의 쇠를 깎는 과정에서 발견한 기술적 문제의식과 미래에 대한 비전으로 이해할 수 있다. 즉, 거대한 기술적 비전도 반드시 추상적인 기술 자체에서 출발하는 것은 아니다. 실제로 무언가를 만들고 사용하면서 발견한 문제에서 시작될 수 있다.

학교에서 배우는 기술과 실제 가치를 만드는 기술 학교는 망치의 용도를 먼저 고민하기보다는, 망치를 구성하는 기술적 요소를 깊고 체계적으로 학습하는 곳이다. 망치의 재료공학을 배우고, 망치 머리를 어떻게 정교하게 깎을 수 있는지, 손잡이를 어떻게 잘 만들 수 있는지를 학문적으로 깊이 탐구한다. 왜냐하면 망치의 용도를 정의하거나 망치를 생산하는 파이프라인을 구축하는 기업가와 자본가들은 망치의 모든 기술적 요소를 직접 이해할 필요가 없기 때문이다. 각 부품과 기술에 대한 깊은 전문지식을 가진 사람들을 고용하면 된다. 이러한 구조에서 학교는 특정 기술을 깊이 이해하고 개선할 수 있는 전문가를 양성하는 데 집중한다. 그렇기에 학교에서 배우는 것만으로 새롭고 실질적인 가치를 만들어내기는 어렵다. 기술이 실제로 어디에 필요하고 어떻게 사용되는지, 어떤 문제를 해결할 수 있는지는 결국 본인이 직접 고민하고 경험해야 한다.

2주간의 기술 탐색에서 얻은 결론 나는 지난 2주 동안 내가 하고 싶은 기술을 먼저 앵커로 설정하고, 그 기술의 쓰임새를 찾거나 기술을 위한 기술을 만드는 방향으로 탐색했다. 마음에 드는 기술을 먼저 선택한 뒤, 그 기술을 기반으로 어떤 문제를 해결할 수 있을지 고민했다. 하지만 돌이켜보면 이것은 좋은 아이디어를 발견하기 어려운 접근 방식이었다. 나는 원래 흑마법이나 차력쇼처럼 남들이 쉽게 하지 못하는 기술적 도전을 좋아하는 사람이다. 그런데 지난 2주 동안 기술을 먼저 앵커로 삼으려다 보니, 애초에 차력쇼를 하기 위한 차력쇼를 고민하고 있었다. 굳이 그런 차력쇼를 하지 않아도 되는, 더 빠르고 좋은 방법이 있었는데도 말이다. 그렇다고 지난 2주가 무의미했던 것은 아니다. 오히려 유의미했다고 생각한다. 나는 기술을 먼저 앵커로 삼아 주제를 정하고 싶었고, 동시에 왜 그런 접근이 잘되지 않는지 직접 확인하고 싶은 막연한 궁금증도 있었다. 그동안 다양한 사례를 탐색하고 깊이 고민하면서, 단순히 누군가의 조언을 받아들이는 것이 아니라 내가 직접 확인하고 납득할 수 있는 결론에 도달했다. 이것이 지난 2주간 얻은 가장 큰 수확이다.

사고방식의 전환: 어려운 기술보다 먼저 필요한 것을 만들자 이 의문이 해결되자 오히려 나의 사고 프레임워크가 바뀌기 시작했다. 나는 그동안 딥테크라는 개념에 지나치게 매몰되어 있었다.

AI의 발전으로 생산성이 크게 높아졌으니, 이제는 더 어렵고 복잡한 문제에 도전해야 한다고 생각했다. 하나의 어려운 기술을 6개월씩 깊게 파고드는 것이 당연하다는 막연한 전제도 가지고 있었다. 하지만 딥테크를 하고 싶고 어려운 기술을 만들고 싶다고 해서, 반드시 처음부터 어려운 것에 도전해야 하는 것은 아니다. 망치가 어디에 쓰일지도 모르는 상태에서 망치 머리의 구조를 연구하거나 쇠를 잘 깎는 기술부터 개발할 필요는 없다. 그보다 먼저 어떤 용도와 필요성이 존재하는지, 애초에 망치라는 도구가 필요한지부터 충분히 고민해야 한다.

그다음에는 다양한 용도의 망치를 2주 혹은 1개월 단위로 빠르게 만들어보면서, 실제 사용자들의 반응과 피드백을 듣는 것이 더 중요하다. 직접 만들어보고, 사용해보고, 다른 사람들에게 제공하면서 비로소 무엇이 필요하고 어떤 부분이 부족한지 알 수 있다. 그 과정에서 기존 기술로는 해결하기 어려운 문제가 발견된다면, 그때 망치 머리의 구조를 연구하거나 쇠를 더 잘 깎는 기술을 깊이 파고들어도 늦지 않다. 오히려 그렇게 시작한 기술은 해결해야 할 문제가 명확하고, 실제 쓰임새가 있으며, 기술적 전문성과 해자를 쌓아야 하는 이유도 분명해진다.

딥테크를 포기하자는 것이 아니다. 딥테크에 도달하는 순서를 바꾸자는 것이다. 기술을 먼저 정하고 그 쓰임새를 억지로 찾는 것이 아니라, 실제로 필요한 것을 만들면서 기술적인 문제를 발견하고, 그 문제를 해결하는 과정에서 깊은 전문성과 인프라를 구축하는 것이다. 지금 당장 거대한 기술적 비전이나 어려운 문제를 선택할 필요는 없다. 작더라도 쓸모 있는 것을 빠르게 만들고, 그 경험을 통해 다음 문제를 발견하면 된다.

유연한 사고를 가지자. 더 빠른 방법을 찾아보자.

AI의 장문의 글을 읽다보면 내가 ai의 답변대로 생각한다.

AI가 암묵지를 끌어내올수 있지만 ai에게 시키는것은 인간의 몫이다. 인간은 계속 ai를 활용해서 암묵지를 끌어올수있도록 생각하고 결정해야한다. 무엇을 모르는지를 계속 대화하면서 알아내야한다. 내가 모르는 지점을 AI가 단번에 도달하게 하거나 ai가 창조적인 아이디어를 추천하는것은 아직 한계가 있다. 내가 써본 ai는 물어본만큼 답해준다. 잘 시키거나 물어보려면 인간이 잘 알아야한다. 사람들은 AI가 사람을 대체할거다, AI 가 세상을 지배할거다라는 말이 계속 팽배하고 있다. 나는 회의적이다. AGI오면, 모델이 발전하면 다 대체되는거 아니겠냐는 무적의 논리를 제시한다면 할말이 없지만 저거도 지금은 나에게 부족하다. 지능의 정의가 뭉뚱그려져서 사람들은 공포에 휩싸이고있다. "사고"를 한다는건 많이 안다는것이 아니다. 스스로 판단할줄 알고, 기억하고, 변해야한다. 반면 AI는, 적어도 지금의 llm은 나에게 말할수 있는 백과사전이라고 느껴진다. 많이 알고있지만 좋은 판단을 하고, task를 완수하기 위해서는 강화학습으로 돌리고있다.

인간이 배우는 과정과는 비슷하지만 인간은 수세기동안 거쳐온 진화 유전자를 기반으로 현대 문명, 그리고 4차원의 시공간과 더불어서 다른 인간, 부모와 상호작용하면서 실수를 통해서 배운다. 인간 자체도 복잡계이고, 이 환경 자체도 복잡계이다. 이것을 모두 모델링한 "환경 시뮬레이션"에서 모델을 학습시키는것은 현재의 기술력으로는 불가능하다. 어쩌면 디지털로 이루어진 지금의 온라인 세계에서는 불가능할것이다. 고무적인것은 연구들이 그런 방향으로는 가고 있다. 강력히 통제된 환경에서 강화학습을 통해 길러진 AI의 판단력은 인간을 따라잡을 수 없다. 세상의 유기체들이 복잡계의 환경에서 상호작용하고 수세기동안 실수와 죽음을 반복하면서 길러진 판단력은 그 환경을 완벽히 모델링하지 않는 이상은 어렵다.

우리는 여기서 에이전트가 왜 코딩을 잘할수있는지를 반추해볼 수 있다. 프로그래밍이라는것은 0과 1로 이루어져있는 디지털이라는 통제되고 descrete한 공간에서 논리를 이용해서 새로운 것을 만드는 행위이다. 프로그래밍은 세상에 비해서는 통제하기 매우쉽고, 유한세계이다. 계산 가능하다. 프로그래밍이라는 규칙과 논리는 유한한 space에서 하는 작업이기에 빠르게 대체가 가능하다. 다만 인간의 뇌, 인지 에너지로는 프로그래밍을 숙련하기 위해서는 인간이 이해할 수 있는 형태로 변환해야만 이해하고, 작업속도를 낼수있다. 0과 1의 기계어에서 인간이 읽을 수 있는 프로그래밍 언어로 만들어지는것이다. 프로그래밍은 때문에 패턴읽기에 강력한 AI가 습득하고 완성도있게 활용할 수 있는 좋은 영역이다.

돌아와서 내가 AI에게 의미있는 조언을 끌어내기 위해서는 내가 원하는걸 명확히하고, 깊이있게 사고할 수 있고, 생각의 주체가 내가 되어야만 좋은 방향을 잡을 수있다. 내가 깨달은것은 두가지다.

1. AI는 "나에게 좋은 결정"을 못한다.
2. 질문도 제한된 공간, 혹은 제약이 있는 질문일수록 의미있는 답변을 준다.

복잡한세계(주식, 인간의 인생, 개인적인 질문)와 연관될수록 AI에게 자율성을 주는 질문을 던지거나 시키면 의미있는 결과물을 얻기 어려울것이다. 하지만 이 복잡한 세계를 단순한 세계로 줄일수있는 좋은 제약이 걸린 질문과 지시를 AI에게 내린다면 내가 원하는 결과물을 얻을 수 있다. 이 때문에 domain knowledge가 중요한것도 특정 분야가 복잡한 세계일수록 단순한 세계로 줄일 수 있는 제약을 줄 수 있는 capability이기 때문에 중요하다는것이다. 때문에 AI 가 좋아질수록 인간은 덜배울것이 아니라 더 알아야한다. 사주풀이나 인간관계 고민상담도 모두 패턴화 되어있기 좋은 문제들이기에 유용하다. 이것 또한 제한된 공간으로 만들어버릴수있는 것이다.

하루 8-9시간 gpt 6 pro와 이야기하다보면 힘만 빠지고, 의미있는 결론에 도달하지 못한 경우가 많았다. 왜일까?

AI는 나에게 조언을 준다. 그리고 나는 그것을 읽는다. 초반에는 내가 무엇을 모르는지 모르는 상태에서 시작하니 AI에게 복잡한세계에 대한 질문을 그대로 넣어버린다. 그것에 목적과 의도가 없는 상태에서 내가 요구를 하면 평균적인 답을 준다. 그 질문에 대해서 나온 평균적인 답은 실질적인 해결책과는 거리가 멀거나 이미 해결된 문제이거나 사실 문제가 아니었던것이었다.

또한 나는 무엇을 모르는지 모르기때문에 AI 의 답변이 좋은것인지 검수할 수 없다. 그렇기에 나는 AI가 말한대로 생각하게 된다. 하지만 나의 질문은 질이 낮은 질문이기에 AI는 그것에 맞춰 평균적인 답변을 준다. 나는 그 평균적인 답변들의 굴레에서 빠져나오지 못하고 계속해서 AI의 장문의 말들을 읽고 AI가 말한대로 생각하고 삽질을 한다. 하지만 전문가 인간에게 물어보는것은 질이 다르다. 지식의 차이는 있어도 노하우의 차이는 크다.

AI로 콘텐츠 자동화했다, 글을 자동화했다, 영화 만들었다는 적어도 재밌고 좋은 컨텐츠를 만들 수 있는 사람이 지시를 해야 결과물이 나오지 AI가 알아서 만드는건 slop 싸게다. 의도를 전달할 잘하는 인간이 필요하다.

1. 인간은 AI의 답변을 듣기 이전에 충분한 생각의 시간을 확보해야한다.
2. 그리고 AI에게 답변과 일처리를 잘시키기 위해서는 내가 시키고 물어볼 수 있는 지식을 계속해서 배워야한다.
3. 결정과 판단은 AI의 답변대로 하는것이 아닌 AI의 제안을 곁들여서 내가 내려야한다.

다른 사람들은 나와 같은 삽질을 하지 않으면 좋겠다는 마음에 이글을 전해본다. AI추천한 아이디어나 내용은 한계가 있다. 결정과 생각은 인간이 해야한다.

🤷 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하는 과정은 따로 있는것 같다.