단일 LLM을 사용할 때의 결과가 우려스러웠다. 같은 데이터를 여러 번 분석해도 일관성이 부족하고, 때로는 명백히 잘못된 화학 지식을 근거로 제시하는 할루시네이션 현상이 빈번할 것으로 보였다.

이런 상황에서 LLM 토론 시스템에 대한 최신 연구들을 접하게 되었다. 여러 LLM이 서로 토론하며 분석 품질을 향상시킨다는 아이디어는 매력적이었지만, 실제로 효과가 있는지, 그리고 우리 프로젝트에 어떻게 적용할 수 있는지 명확하지 않았다.

두 가지 핵심 연구를 살펴보았고, 이를 통해 LLM 토론 시스템 도입의 과학적 근거와 구체적 방법론을 찾을 수 있었다.

DEEVO 연구: 토론을 통한 프롬프트 자동 진화

📄 Tournament of Prompts: Evolving LLM Instructions Through Structured Debates and Elo Ratings, 2025

우리 SAR 분석 시스템에서 가장 큰 고민은 "어떤 프롬프트가 가장 좋은 분석을 만들어내는가"였다. 화학 분야는 정답이 명확하지 않은 영역이다. Activity Cliff 분석에서 "이 구조 변화가 활성 감소의 원인인가"라는 질문에 대해 절대적 정답은 존재하지 않는다. 여러 가설이 경쟁하는 상황에서 어떤 프롬프트가 더 나은 가설을 생성하는지 평가하기가 어렵다.

DEEVO 연구진들도 정확히 같은 문제를 지적했다. 기존 프롬프트 최적화 방법들의 한계는 다음과 같았다.

• 수치형 적합도 함수 의존성: 명확한 정답이 있는 문제에만 적용 가능
• 템플릿 기반 접근: 복잡하고 주관적인 작업의 요구사항을 포착하지 못함
• 정적 최적화: 작업 특성 변화에 적응하지 못함

그들이 제시한 해결책은 진화 알고리즘과 다중 에이전트 토론을 결합하는 것이었다.

💡 핵심 아이디어는 이렇다.

두 프롬프트가 같은 문제를 해결하게 한 다음, LLM 심판들이 토론을 통해 어떤 답변이 더 나은지 결정하게 하는 것이다. 미리 정의된 평가 기준 없이 LLM 자체의 추론 능력만으로 품질을 판단한다는 점이 혁신적이었다.

이 방법이 효과적인 이유는 여러 라운드의 토론을 거치면서 각 답변의 강점과 약점이 명확히 드러나기 때문이다. 한 LLM이 놓친 부분을 다른 LLM이 지적하고, 이런 과정을 통해 더 객관적인 평가가 가능해진다.

실험 결과도 놀라웠다. 폐쇄형 작업에서는 기존 최고 방법 대비 상당한 정확도 향상을 보였고, 개방형 작업에서도 MT-Bench의 쓰기, 역할극, 인문학 부문에서 평균 1점 이상의 개선이 있었다.

특히 Elo 점수와 실제 성능 간의 상관관계가 0.87로 매우 높았는데, 이는 토론 기반 평가가 실제 품질을 정확히 반영한다는 의미다.

우리 프로젝트에 이를 적용하면,

여러 버전의 SAR 분석 프롬프트가 서로 경쟁하면서 점점 더 나은 프롬프트로 진화할 수 있다. 화학자가 수동으로 프롬프트를 개선하는 대신, 시스템이 자동으로 최적의 프롬프트를 찾아낼 수 있는 것이다.

DReaMAD 연구: 토론 시스템의 치명적 결함 발견

📄 Understanding Bias Reinforcement in LLM Agents Debate, 2025

DEEVO 연구를 분석하면서

토론 시스템이 과연 항상 좋은 결과만 가져올까? 여러 LLM이 토론한다고 해서 반드시 더 나은 결과가 나온다는 보장이 있을까? 혹시 우리가 예상치 못한 함정이 숨어있는 것은 아닐까?

하는 근본적인 의문이 들었다.

이런 의문은 우리 프로젝트에 토론 시스템을 도입하기 전에 반드시 확인해야 할 중요한 사항이었다. 만약 토론 시스템에 치명적 결함이 있다면, 단일 LLM보다도 못한 결과를 얻을 수도 있기 때문이다.

이 논문은 정확히 그런 의문에 답을 제공했다. 연구진들은 기존 다중 에이전트 토론 시스템에서 놀라운 현상을 발견했다. 토론이 오히려 편향을 강화하는 경우가 있다는 것이다.

이런 현상이 발생하는 이유를 분석해보니 논리적으로 명확했다.

대부분의 토론 시스템은 동일한 기본 모델을 복제해서 사용한다. 겉으로는 여러 에이전트가 토론하는 것처럼 보이지만, 실제로는 같은 추론 패턴을 가진 모델들이 서로의 편향을 확인하고 강화하는 상황이 벌어진다. 마치 비슷한 생각을 가진 사람들끼리 모여서 토론할 때 극단적 견해가 더욱 강화되는 인간의 "확증 편향"과 유사한 현상이다.

연구진들은 이 문제를 정량적으로 측정하기 위해 MetaNIM Arena라는 독창적인 벤치마크를 개발했다. 이 벤치마크가 우리에게 특별히 중요한 이유는 화학 분야와 유사한 특성을 가지고 있기 때문이다. 수학적으로 완벽한 답이 정해져 있으면서도 복잡한 전략적 추론이 필요한 조합 게임들을 사용했다.

Activity Cliff 분석도 마찬가지다. 이론적으로는 정확한 메커니즘이 존재하지만, 그것을 찾아내려면 화학적 지식과 논리적 추론을 결합한 복잡한 사고 과정이 필요하다. 따라서 MetaNIM Arena에서의 결과는 우리 화학 분야 적용에도 직접적인 시사점을 제공한다.

• 최적의 정보가 주어져도 편향된 패턴에 수렴
• 토론 라운드가 증가할수록 정확도 오히려 감소
• 추론의 다양성 30% 감소

이는 우리가 토론 시스템을 잘못 설계하면 단일 LLM보다도 못한 결과를 얻을 수 있다는 의미였다.

하지만 연구진들은 문제를 발견하는 데 그치지 않고 해결책도 제시했다. DReaMAD 라는 새로운 프레임워크의 핵심은 두 가지 전략이었다.

1. 전략적 사전 지식 추출

• 문제를 바로 풀기 시작하는 대신, 각 에이전트가 먼저 고수준 전략을 수립
• "이 문제의 핵심은 무엇인가", "어떤 전략이 유효할 것인가"를 스스로 정리
• 표면적인 분석을 넘어선 깊이 있는 추론 유도

2. 관점 다양화

• 동일한 모델이라도 서로 다른 관점을 강제로 부여
• 진정한 다양성 확보 (예: "공격적 전략" vs "수비적 전략")
• 편향 방지와 창의적 사고 촉진

DReaMAD의 성과는 명확했다. MetaNIM Arena에서 기존 표준 프롬프트 대비 12.0% 정확도 향상, 기존 토론 시스템 대비 20.8% 승률 향상을 달성했다. 더 중요한 것은 편향이 25% 감소했다는 점이다. 또한 일반적인 수학 문제나 상식 추론 문제에서도 높은 성능을 보여 다양한 영역에 적용 가능함을 증명했다.

인사이트 및 회고

두 연구를 분석한 결과, SAR 분석 시스템에 LLM 토론을 도입해야 하는 근거와 방향을 잡을 수 있었다.

💡 DEEVO 연구는 꾸준히 고민하고 있는 "정답이 없는 문제의 품질 평가" 방안을 제시했다.

Activity Cliff 분석에서 어떤 가설이 더 타당한지 판단하기 어려웠는데, 토론을 통한 상대 평가로 이 문제를 해결할 수 있다는 것을 확인했다. 또한 프롬프트가 자동으로 진화하는 시스템을 구축하면 화학자가 수동으로 개선하지 않아도 점점 더 나은 분석이 가능해진다.

💡 DReaMAD 연구는 더욱 중요한 경고와 해결책을 동시에 제공했다.

토론 시스템을 잘못 설계하면 오히려 역효과가 날 수 있다는 경고와 함께, 관점 다양화와 사전 전략 수립이라는 구체적 해결책도 제시했다. 우리 시스템에서는 구조화학 전문가, 생체분자 상호작용 전문가, SAR 통합 전문가로 역할을 분화하고, 각각 다른 관점으로 분석하게 만들어야 한다는 설계 방향을 생각해 볼 수 있었다.

이 두 연구를 통해 가장 중요한 확신을 얻은 것은 실험적 검증의 엄밀성이었다.

• DEEVO는 여러 벤치마크에서 일관된 성능 향상을 보였고, 특히 Elo 점수와 실제 성능의 강한 상관관계(0.87)를 통해 평가 방법의 신뢰성을 입증했다.
• DReaMAD는 수학적으로 정답이 정해진 MetaNIM Arena에서 편향 감소와 정확도 향상을 동시에 달성했다.

이를 통해 과학적으로 검증된 방법론이라는 신뢰를 기반으로 우리 프로젝트에 적용할 방안을 고민할 수 있었다.

특히 화학 분야처럼 복잡하고 때로는 주관적 판단이 필요한 영역에서는 이런 방법론의 가치가 더욱 크다고 본다. 단일 LLM의 편향과 할루시네이션을 극복하고, 전문가 수준의 신뢰할 수 있는 가설을 생성할 수 있는 실현 가능한 방향을 잡아가는 중이다. 우리 프로젝트에 LLM 토론 시스템을 도입하는 것이 선택이 아닌 필수일 수 있겠다는 생각도 든다. 두 연구를 통해 그 구체적인 설계 방향을 명확하게 정리해 보겠다.

특히 “이 구조가 왜 활성이 달라졌는지”를 논리적으로 설명하고, 근거 기반의 가설을 생성하려면 단순한 질문–답변 방식으로는 화학·재료 과학 분야의 복잡한 인과 관계를 온전히 포착하기 어려울 것으로 보였다.

이에 따라 화학 분야 프롬프트 엔지니어링의 최신 연구 성과를 참고할 필요를 느꼈고, 도메인 특화 프롬프트 엔지니어링 연구 중에서도 LLM에 전문 지식을 내장하여 정확도·재현성·할루시네이션 감소를 동시에 이룬 Liu et al. (2024)의 “Integrating Chemistry Knowledge in LLMs via Prompt Engineering”을 첫 번째 참조 논문으로 선정하였다.

📄 Integrating Chemistry Knowledge in Large Language Models via Prompt Engineering (Liu et al., 2024)

🖇  논문 선택 이유

우리가 다루려는 특허 기반 SAR(Structure–Activity Relationship) 테이블 분석은 전문 지식이 필요하고 실험 데이터가 복잡하게 얽힌 도메인으로 분류된다. 일반적인 LLM 프롬프트 방식은 이러한 분야에서 종종 부정확하거나 할루시네이션을 일으키기 쉽다.

Liu et al. 논문은 도메인 지식 내장형 프롬프트라는 새로운 방법론을 제안한다.

1. 도메인 특화 평가 세트 구축

   Liu et al.은 기존의 일반 평가셋 대신, 약물·효소·결정 재료 관련 1,280개의 문제를 자체 제작해 체계적으로 LLM 성능을 측정했다. 이는 일반 평가셋에 비해 화학 분야 난이도를 현실에 가깝게 반영한다는 점에서 의미가 크다.

2. 포괄적 성능 지표

   Capability(문제 해결 능력), Accuracy(정확도), F1 score(정밀도·재현율 통합), Hallucination drop(할루시네이션 감소) 등 네 가지 지표로 다양한 질문 유형(객관식·서술형·숫자형)을 평가했다.

3. 실물 사례 연구

   MacMillan 촉매, 파클리탁셀, 리튬 코발트 산화물 등 복잡한 화합물에 적용하여 실제 연구 현장과 유사한 조건에서 유의미한 성능 향상을 입증했다.

4. 할루시네이션 최소화

   풍부한 문맥 정보(in‑context information)를 제공할 때 할루시네이션이 크게 줄어든다는 사실을 데이터로 보여주었다.

위와 같은 이유로, 화학 분야 LLM 활용 관점이 우리 SAR 분석 프로젝트에도 적용 가능한 가이드라인이 될 수 있을 것이라 판단된다.

🖇  연구 핵심 내용 요약

Liu et al. 논문은 크게 네 단계로 연구를 전개한다.

첫째, 화학·재료 과학 도메인 특화 평가를 위해 작은 분자·효소·결정 재료 관련 1280문제를 자체 생성했다.

둘째, 일반 프롬프트(Zero-shot, Few-shot, Chain‑of‑Thought(CoT))와 도메인 지식 내장형 프롬프트를 비교 실험했다.

셋째, GPT-3.5-turbo-1106 모델을 대상으로 Capability, Accuracy, F1, Hallucination drop 등을 측정하여, 제안 방식이 객관식·주관식·서술형 등 여러 유형에서 유의미한 성능 향상을 보임을 확인했다.

넷째, 복잡한 물질(고분자, 복합 결정 등)이나 연구량이 적은 효소 분야에서 성능 저하가 관찰되었지만, 이는 LLM이 외부 지식에 의존하는 특성 때문이라는 분석을 제시했다.

정리하자면,

일반적인 프롬프트 방식과 도메인 지식 내장형 프롬프트를 직접 비교하며 그 차이를 네 가지 주요 관점에서 심층적으로 살펴본다.

1. 도메인 지식 내장형 프롬프트(Method)

" 일반 프롬프트에 전문가 사고 과정과 핵심 배경 지식을 명시적으로 추가 "

• 비교 실험: Zero‑Shot, Few‑Shot, Zero‑Shot CoT(“Let’s think step by step”), Few‑Shot CoT, Domain‑Knowledge Embedded Prompting
• 결과: 모든 지표에서 도메인 지식 내장 프롬프트가 최고 성능
  • Capability: 평균 +12%
  • Accuracy: 평균 +15%
  • F1 score: 평균 +18%
  • Hallucination drop: –25%

무엇을 바꿨나?

• 기존 방식은 질문만 던지거나(Zero‑Shot), 몇 가지 예시를 주는 수준(Few‑Shot), “단계별로 생각해보자”라고만 지시(CoT)하는 데 그쳤다.
• 도메인 지식 내장형 방식은 여기에 더해 “전문가가 실제로 갖고 있는 배경 지식”과 “구체적인 사고 흐름”을 프롬프트에 명시적으로 추가한다.

왜 중요한가?

• 일반 CoT 프롬프트는 LLM이 스스로 논리를 만들어내려 하지만, 실제 전문가가 쓰는 세부 배경 지식 없이 단순히 “생각해보라”고만 하면 근거 없는 추측이나 엉뚱한 답변이 나올 수 있다.
• 반면 도메인 지식 내장형은 “화합물 구조의 어떤 부분이 중요한지”, “어떤 물리화학 특성이 활성에 영향을 주는지” 같은 핵심 정보를 미리 제시한 뒤, 그 정보를 바탕으로 논리를 전개하도록 유도한다.

어떤 효과가 나타났나?

• 논문에서는 이 방식이 모든 평가 지표(Capability, Accuracy, F1, Hallucination drop)에서 10~20% 이상 일관된 성능 향상을 보였다고 보고한다.
• 특히 할루시네이션(근거 없는 허구 생성) 수치는 평균 25% 이상 감소했다. 이는 LLM이 “제공된 정보만 갖고 추론하도록” 제약을 주었기 때문이다.

2. 전문가 역할 부여(Expert Prompting)와 단계별 사고 흐름(CoT)

Expert Prompting이란?

• “You are a senior medicinal chemist…” 처럼 LLM에게 특정 전문가 페르소나를 부여하는 것이 효과적이라는 것이다.
• 사람도 “의사처럼 설명해달라”, “변호사처럼 분석해달라”고 하면 말투나 접근 방식이 달라지듯, LLM도 내부 가중치가 그 분야 문서들과 더 잘 매칭되도록 유도된다.

Integrating Chemistry Knowledge in Large Language Models via Prompt Engineering (Liu et al., 2024)

• Fig. 7(a-c)에서 보듯이 도메인 지식 내장형 CoT가 특히 논리적 추론 과제에서 +20% 이상 '상당한(significant)' 성능 향상을 보였다.
• 도메인 지식 내장형 프롬프트 엔지니어링 방법이 일반 프롬프트 전략보다 모든 질문 유형에서 일관되게 우수하며, 특히 능력(Capability) 및 정확도(Accuracy) 지표에서 100%를 초과하는 가장 주목할 만한 향상을 보였다고 전체적인 성능 향상을 언급한다.
• LLM이 실험 데이터 기반 답변보다 논리적 추론 기반 답변에 더 잘 수행한다는 점을 강조하며, 이러한 경향이 '도메인 특화 프롬프트 엔지니어링 방법'에서 더욱 증폭된다는 것을 볼 수 있었다.
  

단계별 CoT 구성 방법

1. 구조 차이 식별

   • 두 화합물을 나란히 놓고 “어떤 치환기나 고리 구조가 달라졌는지” 정확히 찾아내게 한다.

2. 물리화학 특성 영향 추론

   • 식별된 구조 차이가 LogP(지용성), TPSA(극성 표면적), 수소 결합 능력 등 어떤 특성에 어떤 변화를 주었을지 설명하도록 한다.

3. 생체 상호작용 가설 수립

   • 그 변화가 표적 단백질 결합 친화도, 대사 안정성, 세포 투과성 등에 어떤 영향을 미칠지 단계별로 가설을 세우게 한다.

4. 활성 변화 연결

   • 관찰된 활성 값(Activity Cliff)과 앞서 세운 가설을 논리적으로 연결해 “왜” 그 값이 나왔는지 설명하도록 한다.

5. 추가 실험 제안

   • 도킹 시뮬레이션, ADMET 예측, 합성 계획 등 가설 검증을 위한 구체적인 후속 실험을 제시하도록 한다.

이처럼 CoT를 구성하면 LLM이 단순히 답을 맞히는 것 이상으로, 실제 전문가가 논문에 쓸 법한 체계적인 분석 보고서를 생성하는 근거가 될 것으로 판단된다.

3. In‑Context Information으로 할루시네이션 억제

“In-Context Information Could Effectively Reduce Hallucination Level.”

할루시네이션이란?

• 모델이 실제 근거 없는 정보를 생성하는 현상이다. 예를 들어 “해당 화합물은 세포 내에서 X 기전을 사용한다”라는 완전히 허구의 내용을 만들어낼 수 있다.

어떻게 줄였나?

• 논문 실험에서 물리화학적 특성, 타겟 단백질 정보, assay 조건 등 가능한 모든 관련 데이터를 프롬프트에 포함했다.
• 그 결과, LLM은 “주어진 정보만 사용해 답하라”는 일종의 제약을 받게 되고, 불필요한 외부 지식 추측을 최소화했다.

정량적 개선

• In‑Context 정보가 가장 풍부한 설정에서 할루시네이션 비율이 평균 30% 이상 감소했다.
• 이는 특히 서술형 질문, 복합 메커니즘 설명 과제에서 두드러졌다.

4. 서술형(Verbal) 메커니즘 설명의 강점

숫자 선택 vs. 서술형

• 논문에서는 객관식 숫자 선택 문제(예: “A, B, C 중 정답은?”)보다 서술형 메커니즘 설명 과제에서 도메인 지식 내장형 프롬프트의 성능 향상이 더 크다고 밝혔다.
• 이는 LLM이 대규모 텍스트 학습을 통해 축적한 언어적·논리적 연결 능력을 활용할 때 진가를 발휘한다는 의미로 볼 수 있다.

프로젝트에 주는 시사점

• “가장 설득력 있는 가설을 기술하라”, “어떤 분자 상호작용 메커니즘이 활성 변화를 초래했는지 상세히 설명하라” 등 서술형 지시어를 적극적으로 활용해야 한다.
• 단순히 “활성 값이 증가한 이유는?”이 아니라, “활성 변화의 분자 수준 메커니즘을 단계별로 기술하라”처럼 문장 구조를 구체화하면 더 좋은 결과를 얻을 수 있다.

5. Few‑Shot Example로 Thought‑Chain 학습

Few‑Shot CoT

• 단순 예시 제공(Few‑Shot)과는 다르다. 여기서는 예시 하나하나에 전문가의 실제 사고 흐름(Thought‑Chain)이 포함된다.
• LLM은 이 과정을 보고 “이런 방식으로 답을 쓰면 되겠구나”를 학습한다.

Few‑Shot CoT Prompting 실험 결과

• 구성 요소
  • 문제 제시: A vs. B 구조·활성 데이터
  • 전문가 CoT: 단계별 분석
  • 최종 해석 및 검증 제안
• 실제 전문가 예시 2~3개를 제공했을 때, 모델이 초기에 제시된 Thought‑Chain을 흉내 내어 일관성 높은 가설을 생성했다.
• 예시가 복잡해질수록, 즉 실제 전문가 레퍼런스에 가까울수록 효과가 커졌다.

위 다섯 가지 관점을 통해 논문이 제시한 모든 요소가 서로 유기적으로 결합될 때 도메인 특화 프롬프트가 완성된다. 이 인사이트를 바탕으로 우리 시스템에 실제 적용할 템플릿과 실험 설계 방향을 생각해 본다.

🖇  프로젝트 적용 방안

우리 시스템은 SAR 테이블에서 Activity Cliff를 감지한 뒤, “왜 활성이 달라졌는가”에 대한 가설 생성 모듈을 LLM으로 구현한다.

이때 위 논문에서 얻은 인사이트를 다음과 같이 구체화해 볼 수 있다.

1. 전문가 페르소나(Role‑Playing)

   • 프롬프트 첫 부분에 “당신은 선임 약화학자입니다” 또는 “당신은 SAR, Activity Cliff 분석 전문가입니다”라고 명시한다.
   • 이를 통해 LLM이 단순 정보 검색 대신, 특정 관점에서 심층 분석하도록 유도한다.

2. 단계별 Chain‑of‑Thought(CoT) 구성

   • 실제 약화학자가 사용하는 분석 절차를 4~5단계로 스크립트화한다.
     1. 구조 비교: “두 구조 A와 B의 차이점을 정확히 식별하세요.”
     2. 물리화학적 영향: “식별된 변경이 소수성, 수소 결합, 전자 분포에 미치는 영향을 추론하세요.”
     3. 생체 상호작용 가설: “이 변경이 표적 단백질 결합이나 대사 안정성에 어떻게 작용할지 가설을 제시하세요.”
     4. 활성 변화 연결: “이 가설이 관찰된 Activity Cliff를 어떻게 설명하는지 연결하세요.”
     5. 추가 실험 제안: “검증을 위한 분자 도킹, ADMET 예측 등 후속 실험을 제안하세요.”

3. 풍부한 In‑Context 정보 제공

   • SAR 테이블의 구조-활성 데이터는 물론, LogP, 분자량, TPSA, 수소 결합 수용/공여자 수 등의 물리화학적 특성
   • 타겟 단백질의 명칭·기능·결합 메커니즘
   • 활성 측정 assay 종류·조건 및 관련 선행 연구 결과
   • 이렇게 구체적인 문맥을 함께 주면 LLM이 확실한 앵커를 갖고 답변을 생성한다.

4. 서술형 메커니즘 설명 유도

   • 질문 의도를 “메커니즘을 상세히 설명하라”, “가장 설득력 있는 약화학적 가설을 제시하라”처럼 서술형 동사로 명확히 규정한다.
   • 단순 나열이나 숫자 선택 대신, 인과관계를 풀어내는 글쓰기를 유도한다.

5. Few‑Shot 예시로 Thought‑Chain 시연

   • 프롬프트 앞부분에 2~3개의 실제 SAR 사례를 제시한다.
   • 각 예시는 문제(구조 쌍·활성값), 전문가의 단계별 CoT, 최종 해석 및 검증 제안으로 구성한다.
   • 이를 통해 LLM이 우리가 원하는 답변 흐름과 깊이를 모방하도록 돕는다.

프롬프트 템플릿 예시

위 논문을 통해 얻은 핵심 인사이트를 반영한 간단한 예시 템플릿을 생성해 보았다.

이 모든 요소를 결합한 프롬프트 템플릿을 고도화한다면 이론적으로 강력해 보이지만, 제시된 연구 결과를 그대로 받아들이기보다는 실험을 통해 그 유효성을 직접 검증할 것이다.

당신은 SAR 분석에 능숙한 선임 약화학자입니다.
다음 예시를 참고해 A와 B 구조의 활성 차이를 단계별로 분석하고, 그 원인을 근거 중심으로 설명한 뒤 추가 실험을 제안하세요.

[Example 1]
구조 A: SMILES_1, 활성 10 μM
구조 B: SMILES_2, 활성 0.5 μM
1. 구조 비교
2. 물리화학적 특성 영향
3. 생체 상호작용 가설
4. 활성 변화 연결
5. 추가 실험 제안

— 여기에 실제 예시 CoT와 해석을 삽입 —

[Your Task]
구조 C: SMILES_3, 활성 5 μM
구조 D: SMILES_4, 활성 50 μM

1. 구조 비교
2. 물리화학적 특성 영향
3. 생체 상호작용 가설
4. 활성 변화 연결
5. 추가 실험 제안

이처럼 전문가 역할, 단계적 CoT, 풍부한 정보, 서술형 유도, 예시 학습을 결합하면 LLM이 근거 중심의 고품질 가설을 생성할 수 있을 것으로 기대한다.

🖇  인사이트및 회고

지금까지 Liu et al. (2024)의 도메인 지식 내장형 CoT 프롬프트 엔지니어링 연구를 분석하고, 우리 SAR 프로젝트에 곧바로 적용할 수 있는 구체적인 전략을 고민해 보았다.

• 전문가 역할(Role‑Playing)로 LLM을 특정 관점에 고정시키고
• 단계별 CoT로 구조‑활성 관계를 체계적으로 추론하게 하며
• In‑Context 정보로 할루시네이션을 억제하고
• 서술형 설명으로 심층 메커니즘 분석을 유도하며
• Few‑Shot 예시로 Thought‑Chain 패턴을 학습시킬 수 있다.
  

이 글에서 제시한 CoT 기반 설계와 실험 프레임워크와 함께, 프롬프트 설계의 폭과 깊이를 더 확장하기 위해 총 네 건의 연구를 참고할 계획이다.

마찬가지로 연구 결과를 맹신하는 것이 아니라, 오히려 이 지침을 바탕으로 직접 프롬프트 엔지니어링 실험을 설계하고, 생성된 가설을 단계별로 기록/비교하면서 최적화해 나갈 것이다. 이 과정을 통해 “이 프롬프트가 정말로 더 나은 가설을 만들어내는가?” 라는 질문에 스스로 답을 내리고, 필요 시에는 템플릿과 파라미터를 재조정해야 한다.

최종적으로 신뢰도·확장성·효율성을 모두 만족하는 SAR 가설 생성 파이프라인을 완성하는 것을 목표로 한다.

🖇  딥러닝이 가져온 이점 🖇  딥러닝 기반 추천 시스템: 실제 사례 🖇  추천 시스템 적용 시 고려사항

추천 시스템의 중요성과 딥러닝을 접목함으로써 생기는 이점을 시작으로, 딥러닝 기반 추천 시스템의 실제 사례와 평가 지표를 통해 좋은 추천 시스템이란 무엇일지 이해하고 정리해 보았다.

실제로 서비스에 추천 시스템을 적용하기 위해 무엇을 고려해야 할지 생각해 보자.

🖇  추천 시스템과 딥러닝

추천 시스템의 중요성

사용자에게 적절한 콘텐츠나 상품을 추천하는 시스템은 기업의 성과와 사용자의 경험을 결정할 수 있는 핵심 요소로 자리잡았다. 최근에는 이러한 추천 시스템에 딥러닝 기술이 접목되며 더 높은 정밀도와 개인화를 가능하게 하고 있다.

추천 시스템은 상품이나 콘텐츠를 제공하고 끝나는 게 아니다.

클릭률 상승, 콘텐츠 소비 증가, 사용자 이탈률 감소 등 이어지는 효과를 유도하고 기업의 수익 구조에 실질적인 영향을 끼친다. 사용자 입장에서도 추천의 질이 향상되면 원하는 정보를 더 빠르게 얻을 수 있고, 결과적으로 만족도와 경험 전반이 좋아진다.

이처럼 중요한 추천 시스템은 우리가 매일 접하는 플랫폼 유튜브, 넷플릭스, 쇼핑몰 등에 이미 깊숙하게 자리잡고 있다. 그런데 이제는 단순한 알고리즘만으로는 한계에 부딪히는 시대가 왔다. 복잡한 사용자 행동과 데이터가 쏟아지는 환경에서 기존 방식만으로는 부족해졌고, 그 지점에서 딥러닝이 등장한다.

🖇  딥러닝이 가져온 이점

1. 복잡한 데이터의 효율적 처리

딥러닝은 구조적으로 다차원적이고 비정형적인 데이터를 효과적으로 처리할 수 있다.

예를 들어, 사용자의 구매 패턴, 클릭 로그, 선호 장르 등 서로 다른 유형의 정보를 동시에 고려하고, 이를 기반으로 정확한 추천을 제공할 수 있다. 이로 인해 추천 결과의 품질이 한층 높아진다.

2. 고차원 특징 학습

추천에 사용되는 데이터는 일반적으로 고차원적이다.

수백 명의 사용자와 수만 개의 아이템이 상호작용한 데이터는 수학적으로 수천만 개의 차원을 갖게 된다. 딥러닝은 이런 고차원 공간에서 의미 있는 패턴을 찾아내고, 각 feature 간의 상관관계를 스스로 학습한다.

3. 희소 데이터 보완

대다수의 사용자는 전체 아이템 중 일부만을 경험하게 된다.

10,000개의 상품 중 10개 정도만 클릭하는 것처럼 말이다. 이렇게 상호작용이 적은 데이터는 '희소하다(sparse)'고 표현되는데, 전통적인 방식에서는 이를 처리하는 데 어려움이 많았다. 딥러닝은 이런 희소 데이터 속에서도 유의미한 연관 관계를 학습할 수 있다는 강점을 지닌다.

4. 확장성과 유연성

사용자 수나 아이템 수가 늘어날수록 추천 시스템의 복잡도는 기하급수적으로 증가한다. 하지만 딥러닝 모델은 대규모 데이터를 학습하는 데 최적화되어 있으며, GPU나 분산처리 시스템과 함께 사용하면 시스템을 안정적으로 확장할 수 있다.

🖇  딥러닝 기반 추천 시스템: 실제 사례

YouTube: 대규모 사용자 추천

YouTube는 딥러닝 기반 추천 시스템을 가장 체계적으로 도입한 사례 중 하나다. 추천 과정은 크게 두 단계로 나뉜다.

1. Candidate Generation (후보 생성)

   수많은 동영상 중에서 특정 사용자에게 맞을 법한 수천 개의 후보를 먼저 추려낸다. 이 단계에서는 사용자의 최근 시청 기록, 구독 정보, 검색 쿼리 등 다양한 feature가 활용된다.

2. Ranking (랭킹 선정)

   추려낸 후보들에 대해 점수를 매기고 최종적으로 보여줄 순서를 정한다. 이때는 콘텐츠의 품질, 시청 시간 예측, 클릭 확률 등이 고려된다.

YouTube는 이처럼 멀티태스크 딥러닝 구조를 통해 정교한 사용자 맞춤 추천을 구현하고 있으며, 관련 내용을 자세히 다룬 논문과 아티클은 다음에서 확인할 수 있다.

• Deep Neural Networks for YouTube Recommendations (Google Research)

• Recommending What Video to Watch Next: A Multitask Ranking System
• On YouTube’s Recommendation System (YouTube 공식 블로그)

Netflix: 다양한 모델 혼용

Netflix는 초기에 딥러닝 도입을 망설였던 기업 중 하나다. 이유는 전통적인 협업 필터링 방식이 이미 충분히 높은 성능을 보였기 때문이다. 하지만 이후 다양한 feature(사용자, 콘텐츠, 상황 정보 등)를 통합하면서 딥러닝의 장점이 극명하게 드러나기 시작했다.

특히 넷플릭스는 추천 대상이 되는 영역인 인기 콘텐츠 섹션, 장르별 리스트 등에 따라 서로 다른 딥러닝 모델을 적용한다. 하나의 만능 모델이 아니라 각 상황에 최적화된 다양한 모델을 병렬적으로 운영하며 사용자 경험을 극대화하는 방식이다. 관련된 넷플릭스 기술 블로그와 연구 자료는 아래에서 확인할 수 있다.

• Deep Learning for Recommender Systems: A Netflix Case Study

• Netflix Tech Blog – 추천 시스템 관련 글 모음
• Netflix Research Areas: Recommendations

국내 사례: 쿠팡, 네이버, 당근마켓 등

국내에서도 딥러닝 기반 추천 시스템은 다양한 산업에서 활발히 활용되고 있다. 아래는 대표적인 발표 아티클이다.

• 쿠팡의 추천 시스템 2년간의 진화 : 실시간 개인화 전환 과정, 모델 서빙 전략, 인덱싱 처리 방식 등을 설명하고 있다.

  발표 영상 / 발표 자료 PDF

• 네이버 AiRS, 라인, 당근마켓, 씽크빅 등 다양한 국내 사례 : 추천 편향, 인과관계, 사용자 탐색 경험, 개인화 썸네일 등에 대한 고민이 담겨 있다.

  • 딥러닝 후기시대에서 추천 시스템의 진화 / 발표 자료 PDF
  • 네이버 뉴스 추천 알고리즘 소개 블로그
  • LINE 추천 모델 개편기

🖇  추천 시스템 적용 시 고려사항

추천 시스템은 알고리즘만으로 완성되는 것이 아니다.

딥러닝 모델의 구조나 성능도 물론 중요하지만, 실제 서비스를 위해서는 다양한 관점을 동시에 고려해야 한다.

1. 정량적 평가 지표

추천 성능을 평가하는 데는 여러 지표가 존재하며, 이들은 추천의 질뿐 아니라 사용자와의 인터랙션을 정량화하는 데도 도움이 된다.

• Precision@K / Recall@K / Hit Rate@K

  상위 K개의 추천 항목 중에서 얼마나 정확하고 적절한 결과를 제시했는지를 확인하는 지표다.

• MAP / NDCG

  추천된 항목의 순서를 고려한 정밀도 측정이다. 사용자가 가장 선호할 법한 아이템이 상위에 위치하는지를 평가한다.

• AUC / Log Loss

  전반적인 예측 정확도 및 손실을 수치로 나타낸다. 일반적인 분류 문제와 유사하게 모델의 전체적인 품질을 확인할 수 있다.

이러한 지표들은 넷플릭스의 추천 평가 사례나, Deview 발표 자료에서 다양한 예시와 함께 설명되고 있으니 참고해도 좋겠다.

2. 시스템 구조 및 UI/UX

딥러닝 모델을 효율적으로 서빙하고, 사용자에게 의미 있게 전달하는 아키텍처 역시 중요하다. 추천의 정확도만 높다고 좋은 시스템은 아니다. 추천된 결과가 직관적으로 전달되고, 탐색 경험이 좋아야 실제 전환율로 이어진다.

3. 운영 및 모니터링

실서비스 환경에서는 추천 시스템이 꾸준히 학습하고, 편향을 교정하여 성능을 유지하는 것이 중요하다. Netflix, 쿠팡, 네이버 등의 기업들은 추천 시스템을 지속적으로 모니터링하고 개선하는 체계를 갖추고 있다.

🖇  인사이트 및 회고

추천 시스템은 기술적으로도, 비즈니스적으로도 이미 필수적인 요소가 되었다고 볼 수 있다. 특히 딥러닝의 도입은 정교한 개인화, 대규모 데이터 처리, 희소 데이터 대응 등 기존 방식의 한계를 극복하는 데 큰 기여를 하고 있다.

이에 따라 좋은 추천 시스템이란 무엇인지 고민하는 게 필요하다고 생각한다. 높은 정확도를 자랑하는 모델을 만드는 게 아니라, 사용자 경험이나 서비스 전략, UI 구성, 시스템 성능, 모니터링까지 종합적으로 설계되어야 진정한 의미에서 효과적인 시스템일 것이다.

앞으로 추천 시스템은 더 많은 데이터를 다루게 될 것이고, 사용자의 맥락을 더욱 정밀하게 반영하는 방향으로 진화할 것이다. 그 과정에서 무엇을 어떻게 추천할 것인가, 왜 이 추천이 필요한가에 대한 질문을 지속적으로 던질 필요가 있겠다.

🔗  이전 글

💊 영양제 Check! 개발기

이번 프로젝트는 "영양제 추천 서비스 만들기" 가 아니라, LLM이 어떻게 더 신뢰성 있게 정보를 전달할 수 있을까에 대한 고민과 실험이었다고 할 수 있다.

'누가 먹어도 괜찮은 영양제' 같은 모호한 추천이 아니라, “이 사용자에게, 이 질환에 맞는, 이 성분이 왜 필요한가” 를 설명할 수 있는 시스템이 목표였다.

개인적으로는 도메인 이해, 구조 설계, 팀 협업, 프롬프트 튜닝, 실패 사례 복기까지 다방면에서 얻은 게 많은 프로젝트였다.

이 글에서는 그 과정에서 배우고 느낀 점들을 정리해 보려고 한다.

🖇  도메인 지식의 중요성과 전문성 확보의 필요성

기술만 잘 써서 좋은 결과가 나오는 건 아니라는 건 당연하다.

건강기능식품처럼 민감한 도메인에서는 단어 하나가 의학적으로 다른 의미로 해석되기 때문에, GPT가 아무 말이나 하는 경우에 이를 그대로 신뢰하면 안 된다.

예를 들어 “눈에 좋은 영양제 뭐 있어?” 라고 했을 때 나같은 경우에는 루테인 정도를 떠올릴 수 있었다. 하지만 도메인 조사와 시나리오별 신뢰할 수 있는 관련 학술 문헌들을 찾아보면서 실제로는 루테인, 지아잔틴, 비타민A, 아스타잔틴 등 다양한 성분이 있고, 각각의 작용 기전이 다르다는 것을 알 수 있었다.

게다가 당뇨 환자가 섭취하면 안 되는 성분도 있을 수 있고, 특정 약물과 상호작용이 발생하는 경우도 있어서 성분-질환-약물 간 관계를 모르면 그냥 위험한 추천이 될 수도 있다. 이런 부분은 결국 논문을 직접 보고, 근거를 확인하고, 정리하는 과정이 필요했다.

물론 RAG의 지식베이스가 되는 학술 문헌들을 찾는 과정이 쉽지 않았다. 해당 논문이 어떤 전제를 하고, 어떤 근거로, 어떤 결과를 냈는지 확인하고 실제 조사한 내용들과 비교하여 선정하는 과정에서 신중해야 했고 시간도 오래 걸렸다. 이 작업을 통해 성분 정보의 신뢰도가 완전히 달라질 수 있기 때문에 소홀히 할 수 없었다.

그냥 “GPT가 추천해줬대” 가 아니라, “이 논문에서 실제로 A 성분이 B 질환에 효과 있다고 보고했어” 라고 근거를 제시하는 시스템을 목표로 했기 때문이다.

이 프로젝트를 정말 고도화하고 싶다면 아예 당뇨, 치매, 고혈압 등 특정 질환에 중점을 두면 지금보다 더 신뢰할 수 있는 정보를 제공할 수 있을 것 같다는 생각이 들었다. 확실히 어떤 서비스든 관련 도메인을 깊게 알아야 경쟁력이 생긴다는 점을 다시 한 번 이해할 수 있었다.

🖇  학술 논문 기반 RAG에서의 프롬프트 엔지니어링 어려움

잎서 언급한 것처럼 RAG의 지식베이스로 사용할 학술 논문을 선정하는 것에도 어려움이 있었지만, 진짜 힘들었던 건 여기부터였다.

논문 PDF를 벡터화하는 건 어렵지 않은데, 문제는 LLM이 거기서 제대로 된 답을 끌어오게 만드는 과정이었다.

단순히 질문하면 원하는 성분이 바로 딱 나오는 게 아니었던 터라 아래와 같은 고민이 계속 반복됐다.

• 문서 chunk를 어떻게 나누면 정보 손실 없이 분할될까?
• 각 chunk에 어떤 메타 정보를 넣어야 필터링과 응답이 정확해질까?
• 프롬프트 안에 어떤 조건을 넣어야 환각 없이 응답하게 만들 수 있을까?

특히 JSON 형태의 응답을 유도하는 게 쉽지 않았다.

"허용된 성분 외에는 말하지 마라", "형식은 JSON만 허용", "마크다운 금지" 같은 조건을 쭉 나열해도 종종 형식이 틀어졌다.

이런 경우는 파싱이 깨져버리기 때문에 응답을 어떻게 안정적으로 받을지에 대한 예외처리도 필요했다.

수동으로 확인해서 수정하기도 하고, 많은 시행착오가 있었지만 그 과정에서 놓치고 있던 부분을 다잡을 수 있었다.

프롬프트 엔지니어링은 내가 원하는 걸 요구하는 과정이 아니라, 문서 구조와 LLM 동작 방식을 함께 고려한 설계라는 것 !

🖇  TAVILY AI 적용 과정에서의 시행착오

초반에는 TAVILY AI를 사용해서 RAG를 구성해 보려고 했다.

실시간 검색도 되고, 웹 결과를 요약해서 보여주니까 뭔가 요긴할 것 같았는데 결론부터 말하면 이 프로젝트에는 맞지 않았다.

가장 큰 문제는 “출처가 신뢰할 만한가?” 였다.

논문이 아니라 블로그, 뉴스 기사 위주로 결과가 제공될 수 있는데 이런 정보는 챗봇이 답변할 근거로 삼기엔 너무 불안정하다. TavilyClient 는 원하는 도메인(PubMed, 식약처 등)을 지정하더라도 정확히 그 문서만 가져오진 못하고, 결국 AI가 요약한 결과를 출력하는 구조라 LLM 자체의 창작이 섞이게 된다.

우리 팀이 만들고자 한 건 논문 기반의 응답이었고, "왜 이 성분이 추천되는지" 를 출처까지 정리해서 설명할 수 있는 구조여야 했다. 결국 TAVILY는 실험용으로 써보는 데 그쳤고, 본 구현에서는 완전히 제외하게 되었다.

그래도 덕분에 프로젝트에서 설정한 방향과 목표에 적절한 구조는 어떤 것인지를 계속해서 상기하고 고민해 나갈 수 있었다.

🖇  시스템 설계와 사용자 경험 관점

이번 프로젝트를 기술 과시형 챗봇이 아니라 "진짜 쓸모 있는 서비스" 처럼 느껴지도록 하고 싶었다. 그러기 위해서는 사용자 경험(UX)을 고려한 설계가 필요했다.

성분을 뽑아주는 데서 끝나는 게 아니라,

• 어떤 성분을 추천하는지
• 왜 추천하는지
• 어떤 성분은 피해야 하는지
• 출처는 무엇인지
• 그 성분이 실제로 들어간 제품은 무엇인지까지

하나의 흐름으로 연결되어 있다는 점이 중요했다.

게다가 모든 결과는 출처가 있는 문서 기반이고, 최종 추천도 단순 응답이 아니라 실제 공공데이터에 있는 제품 목록에서 골라주기 때문에 "이걸 먹어볼까?" 라는 사용자 행동까지 자연스럽게 이어지는 것을 기대할 수 있었다.

Streamlit 기반으로 UI를 구성했는데, 프론트엔드가 과하지 않아서 오히려 더 깔끔했다. 전체 구조를 사용자 입장에서 체계적으로 연결할 수 있었던 점이 인상 깊었다.

다만, 시간의 한계로 구현하지 못했던 성분에 대한 출처 명시 부분에서는 고민이 좀 더 필요하다. 피드백 주신 것처럼 사용자에게 "추천 성분" 또는 "피해야 할 성분"을 제시할 때, 사용자 경험을 해치지 않도록 해당 내용을 뒷받침하는 연구 결과나 임상 근거를 함께 제시하는 것이 중요할 것 같다.

🖇  좋은 팀원과의 협업, 명확한 목표 설정

원활한 상호 소통으로 유능한! 팀원들과 함께하는 과정에서 많은 것들을 배울 수 있었다. 덕분에 여러 시행착오가 있었음에도 매끄럽게 진행될 수 있었다고 생각한다.

데이터톤에서는 놓쳤던, 프로젝트를 시작할 때부터 “무엇을 만들 것인가” 가 아니라 “왜 만들 것인가” 에 대한 합의가 있었다. 이 논의를 하는 동안, 어떤 프로젝트든 솔직하게 되돌아보고 회고하는 과정이 반드시 필요하다는 소소한 생각이 들었었다.

LLM 프로젝트는 "뭔가 똑똑해 보이는 챗봇을 만들자" 같은 흐름으로 갈 수 있는데, "건강 정보는 신뢰가 생명이다" 라는 명확한 문제의식을 바탕으로 출발했기 때문에 프롬프트 구조를 짤 때도, 데이터를 고를 때도, 기술 선택에 있어서도 모두 사용자 중심의 일관된 기준이 있었다.

아이디어 기획, 기술 조사, 논문 기반 문서 정제, 프롬프트 엔지니어링, 공공데이터 수집, RAG 구조 설계, UI 구성 등 서로가 맡은 파트를 책임감 있게 가져갔고, 필요한 순간엔 빠르게 공유하고 피드백을 주고받았다.

프로젝트 중 기능을 구현하다 보면 가끔 "내가 지금 이걸 왜 하고 있지?" 라는 의문이 들 때도 종종 있었는데, 이번에는 처음부터 끝까지 목적과 방향이 분명했기 때문에 동기부여가 계속 유지될 수 있었던 것 같다.

앞으로도 어떠한 프로젝트에서 뿐만 아니라 무엇을 하는지 보다, 왜 하는지를 끊임없이 생각하는 자세를 지니자.

🖇  배운 점과 앞으로의 각오

이제는 궁금한 게 생기면 일단 GPT나 Gemini 같은 LLM에게 먼저 묻는 게 자연스러울 정도로, 누구나 쉽게 정보에 접근할 수 있는 시대가 되었다.

이번 프로젝트를 하면서 이 지점에 대해 깊이 고민할 수 있었다.

    "LLM이 답변해준 정보가 정확한가?"      "그 근거는 무엇인가?"      "사용자가 스스로 검토할 수 있는 구조인가?"

이런 질문에 대해 기술적으로만 접근하는 게 아니라, 전체 구조와 설계의 문제로 확장할 수 있었다.

물론 RAG 구조를 처음부터 직접 설계하고, 프롬프트를 반복해서 튜닝하고, 논문 중심의 도메인을 설계하고, Streamlit으로 UI를 구성하고, 식약처 공공 API까지 연동하는 과정에서 기술적으로도 좋은 경험이 되었다.

구현하고 테스트하는 과정에서 계속 나를 따라다녔던 의문이 있었다.

    “이 시스템을 과연 사용자가 믿고 쓸 수 있을까?”

겉보기엔 그럴듯하게 작동하는 챗봇이지만

정작 그 안에서 사용자가 출처를 확인할 수 없다거나, 논문 기반이 아닌 내용을 생성해버린다거나, 같은 질문에 따라 답이 바뀐다면 그건 신뢰할 수 있는 시스템이 아닐 것이다.

그래서 이번 프로젝트에서는 그런 허점을 막기 위해 하나하나 설계를 조이고, 근거를 명시하고, 정보가 ‘떠도는 말’이 아니라 ‘출처 있는 지식’이 되도록 만드는 데 초점을 맞추게 되었다. 프로젝트를 되돌아보면 기술보다 설계가 중요했고, 설계보다 문제 정의가 더 중요했다고 정리할 수 있겠다.

앞으로 다가올 해커톤이나 프로젝트에서도 그럴듯한 AI가 아니라 진짜 도움을 주는, 그리고 검증 가능한 구조로 신뢰를 줄 수 있는 AI 서비스를 만들고 싶다.

약 3일 간의 짧은 프로젝트였지만 유익한 경험이 되었다.

🔗 GitHub repository

프로젝트 기간:  2025.06.30 - 2025.07.03  (4인 프로젝트)

0. 목차

1. 프로젝트 도입: 왜 '영양제 추천'인가?
2. 프로젝트 목표
3. 어떤 기술을 왜 선택했는가?
4. 문헌 수집 및 전처리 방식
5. 기술적 설계 포인트
6. 사용자 입력 처리 및 Case 분류 로직
7. 공공데이터 기반 제품 추천 파이프라인
8. Streamlit 기반 UI 구성 및 사용자 경험 설계
9. 실행 결과
10. 개선 방향
11. 프로젝트 회고

1. 프로젝트 도입: 왜 '영양제 추천'인가?

최근 몇 년 사이 건강기능식품 시장은 트렌드를 넘어 일상 소비로 정착되었다. 그러나 수백 개의 브랜드와 성분, 제품군이 동시에 쏟아지는 상황에서 소비자는 여전히 어떤 영양제를 어떻게 선택해야 할지 명확한 기준을 갖기 어렵다.

게다가 최근에는 검색보다 ChatGPT, Gemini와 같은 대형 언어모델(Large Language Model, LLM) 기반 챗봇에게 직접 질문하여 정보를 얻는 게 자연스러운 시대가 되었다.

“무슨 영양제를 먹는 게 좋을까?”, “루테인은 눈에 진짜 효과 있어?”, “이 제품은 당뇨 환자도 먹을 수 있어?” 같은 질문도 전문가가 아니라 챗봇에게 먼저 묻고는 한다.

그런데 "그 정보, 그대로 믿어도 될까?" 하는 의문도 가지고 있을 것이다.

실제로 건강 정보나 성분 추천에 대해 이들 챗봇이 제공하는 응답은 과거에 비해 상당히 정확하고 자연스럽게 보이지만, 여전히 다음과 같은 구조적인 문제가 존재한다.

• 모델마다 답변이 다르며 사용자는 어떤 응답이 진짜인지 판단할 기준이 없다.

• 출처가 명시되지 않거나, 논리의 근거가 불분명하여 검증이 어렵다.

• 특히 건강 도메인에서는 존재하지 않는 성분을 제시하거나,

  의학적으로 권장되지 않는 정보를 사실처럼 응답하는 '환각(Hallucination)' 현상이 여전히 발생한다.

이러한 배경에서 본 프로젝트는 '영양제 추천 시스템'을 만드는 것이 아니라, LLM의 불확실한 응답 구조 자체를 신뢰 가능한 구조를 제공하기 위한 기술적 실험으로 시작되었다.

" GPT보다 믿을 수 있는, 실제로 도움이 되는  영양제 추천 시스템 ”

2. 프로젝트 목표

우리 팀은 하나의 방향 속에서 세 가지의 목표를 정확하게 잡았다.

2.1  신뢰 가능한 정보 제공

• GPT-4 기반 LLM이 답변을 생성할 때 임의의 성분을 '창작'하지 않도록 하기 위해

  오직 문서 기반의 RAG 구조를 채택하였다.

• 사용된 문서는 학술 논문, 정부 가이드라인, 식약처 자료 등 46편의 PDF 문서이며,

  LLM은 반드시 이 문서 내 정보에 기반하여 답변을 생성해야 한다.

2.2  사용자 맞춤형 추천

• 사용자로부터 나이, 성별, 질환, 복용 중 약물, 선호 성분 등의 정보를 입력받고,

  키워드 기반으로 사전 정의된 Case A~D 시나리오 로 분류하여 각기 다른 처방을 반환하도록 설계하였다.

• 동일한 사용자 질문이라도 복용 중 약물 또는 질환에 따라 금기 성분이 달라질 수 있으며,

  이 분류를 통해 상호배타적인 조건 처리 및 다중 처방 적용이 가능하도록 구성하였다.

2.3  실제 제품 추천 및 실행 가능성 확보

• 성분 정보를 알려주는 데 그치지 않고,

  식품의약품안전처 공공데이터(API)를 통해 추천 성분이 포함된, 피해야 할 성분은 제외된 실제 제품을 추천한다.

• 유사도 기반 벡터 검색을 통해 추천 제품을 찾아주며,

  금기 성분이 포함된 제품은 실시간으로 필터링하여 제외한다.

• 실제 제품을 사용자에게 연결하여 정보 소비에 그치지 않고 실행 가능한 사용자 행동으로 이어지는 것을 기대하였다.

프로젝트의 방향 설정 후, 아래와 같이 역할을 분배하였다.

3. 어떤 기술을 왜 선택했는가?

3.1  LLM 환각 방지를 위한 RAG 구조 도입

GPT-4는 강력한 문장 생성 능력을 갖추었지만, 정해진 지식 범위 내에서만 작동하지 않는다. 특히 건강 도메인에서는 존재하지 않는 성분이나 제품명을 제시하는 '환각(Hallucination)' 문제가 치명적이다.

이 문제를 해결하기 위해, 본 프로젝트에서 RAG (Retrieval-Augmented Generation) 구조를 채택하는 것이 적절하다고 판단하였다.

RAG는 외부 문서에서 정보를 검색하고 이를 기반으로 LLM이 응답을 생성하는 방식으로,"문서 기반 지식의 통제" 와 "LLM 응답의 정확성" 을 동시에 확보할 수 있는 구조이다.

• Hallucination을 원천적으로 차단 가능 (문서 외 정보 사용 제한)

• 응답 신뢰도 향상 및 출처 명시 가능
• LangChain 기반으로 RAG 체인을 구성하기 용이함

3.2  문서 임베딩 및 검색을 위한 FAISS 사용

문서 검색 과정에서 핵심이 되는 것은 사용자의 질문과 가장 유사한 문단을 빠르게 찾아내는 것이다. 이를 위해

OpenAI Embedding + FAISS 인덱싱 구조를 선택하였다.

FAISS(Facebook AI Similarity Search)는 고차원 벡터 간 유사도 계산에 특화된 라이브러리로, 수천~수만 개의 벡터에서 유사한 결과를 빠르게 찾아내는 데 적합하다.

Document 객체에 메타 정보를 함께 저장하므로 검색 후 원문 출처, 문서명, 출판연도 등도 함께 추출 가능하다는 점에서 프로젝트의 방향성에 부합한다.

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

embedding = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(documents, embedding)
vectorstore.save_local("faiss_db/")

• 1만 건 이상의 문서를 벡터화하여도 검색 속도가 빠름

• Local 환경에서 저장, 로드, 추가 삽입(add_documents) 가능
• LangChain과 통합 가능 (FAISS.from_documents(), load_local() 등)

3.3  실제 제품 추천을 위한 공공데이터 API 활용

문서 기반 성분 추천만으로는 실제 사용자 액션으로 이어지기 어렵다.

이를 해결하기 위해 식품의약품안전처 건강기능식품정보 Open API 를 사용하였다.

이 API는 약 10,000건의 영양제 제품 정보를 제공하며 기능성, 성분, 주의사항, 섭취방법 등의 정보를 포함하고 있다.

• 공공기관이 제공하는 신뢰 가능한 제품 정보
• 일일 10,000건 호출 가능
• 제품명, 기능성, 주의사항, 섭취량 등의 필드가 존재하여 추천 후 연계 가능

4. 문헌 수집 및 전처리 방식

사용된 문헌은 총 46편의 학술 논문, 건강기능식품 가이드라인, 식약처 자료로 구성되어 있다. 이 문헌들은 PDF 형식으로 수집되었고, 문단 단위로 분할하고 벡터화하기 위한 사전 정제 작업이 필요하였다.

아래의 과정으로 전처리를 수행하였다.

1. 텍스트 추출:  PyMuPDF 기반으로 PDF에서 본문 텍스트 추출
2. 의미 단위 분리:  불필요한 공백/머리말 제거 후, 문단 또는 항목 기반으로 의미 단위 분리
3. LangChain 문서화:  Document 객체로 변환 (메타 정보 포함: 출처, 제목, 문서 유형 등)

문서 분할은 단순 길이 기준이 아닌 문맥 보존을 위한 chunk overlap 기법을 적용하였으며 이후 Embedding 과정으로 연결된다.

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

loader = PyPDFLoader("간건강_가이드라인.pdf")
pages = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=700, chunk_overlap=100)
documents = splitter.split_documents(pages)

5. 기술적 설계 포인트

RAG(Retrieval-Augmented Generation)를 두 번 활용해 신뢰성과 정밀도를 동시에 확보합니다.

1. 첫 번째 RAG는 사용자의 건강 상태와 선호에 따라 논문 기반 성분 정보를 추출하고,
2. 두 번째 RAG는 해당 성분을 기준으로 공공데이터에서 실제 제품을 추천한다.

이렇게 2단계로 분리된 구조는 "왜 이 성분을 추천하는가" 와 "그 성분이 포함된 제품은 무엇인가" 를 연결할 수 있다.

5.0  RAG 구조

5.1  카테고리별 문서 벡터 DB 분리 및 앙상블 리트리버 구성

사용자 입력은 단일 증상이 아닌 여러 건강 영역을 포함할 수 있다.       ex. 눈 건강 + 피로 + 커피 과다 섭취

이를 고려하여 문서 벡터 DB를 질환/이슈별 시나리오 케이스를 분리 저장하였으며, LangChain의 EnsembleRetriever를 통해 다중 검색이 가능하도록 구성하였다.

retriever1 = FAISS.load_local("faiss_db/case_A", embedding)
retriever2 = FAISS.load_local("faiss_db/case_b", embedding)

ensemble_retriever = EnsembleRetriever(
    retrievers=[retriever1, retriever2],
    weights=[0.5, 0.5]
)

5.2  사용자 입력 처리 및 Case 분류 로직

사용자 입력 키워드 추출 후, 시나리오별 Case를 분류하여 화이트리스트 기반 프롬프트를 설계하였다.

• RAG 응답 생성 시, LLM이 사용할 수 있는 성분 리스트를 사전에 명시하여 전달
• 프롬프트 내에 "JSON only", "마크다운 금지", "허용된 성분 외 사용 금지" 명시
• 결과적으로 환각 방지 + 응답 일관성 + 파싱 안정성 확보

>>  6. 사용자 입력 처리 및 Case 분류 로직 참고

5.3  공공데이터 기반 제품 추천 파이프라인

>>  7. 공공데이터 기반 제품 추천 파이프라인 참고

6. 사용자 입력 처리 및 Case 분류 로직

의료·영양 도메인은 "창의성" 보다 안전성·근거 기반이 최우선이다.

실제 논문마다 결과가 엇갈리고, 전문가들조차 단일 정답을 내리기 어려운 영역이므로, "모든 상황에 맞는 답변" 대신 시나리오(case) 단위로 검증된 성분만 제공하도록 구현하였다. 이 과정에서 논문/연구 자료 등 신빙성 있는 자료 조사를 통해 도메인에 대한 정확한 이해가 필요했다.

본 프로젝트는 사용자에게 다음 항목의 입력을 요구한다.

• 나이, 성별
• 현재 가지고 있는 질환 혹은 증상
• 복용 중인 약품 및 영양제
• 원하는 영양제의 특징 또는 조건 (ex. 눈 건강, 근육 회복, 뇌 건강 개선 등)

이 입력은 단순히 문자열로 구성되어 있으나, 이후 전체 파이프라인에서 핵심적인 역할을 하게 되며

특히 "사용자 상태 분류 → case별 처방 분기" 의 기준이 된다.

6.1  Case A~D 분류 체계

초기 설계 단계에서 구체적인 페르소나를 지정하여 사용자 요구를 몇 가지 유형으로 분류하였다.

이는 질문의 형태를 제한하기 위함이 아니라, LLM의 프롬프트 안정성과 응답 품질을 확보하기 위한 구조적 장치이다. 앞서 언급한 것처럼 도메인 특성 상 "모든 상황에 맞는 답변" 보다는 한정된 대상이라도 검증된 성분 정보를 제공하는 것이 중요하기 때문이다.

1. Case_A, Case_B 에서는 동일한 "음주/흡연" 이라는 변수를 주어 비교 실험을 설계하였다.
2. Case_C, Case_D 에서는 특정 질환에 중점을 두고 정확한 결과를 도출해 내는 것을 목표로 하였다.

• Case_A:  눈 건강 + 간 건강 관련
• Case_B:  커피/카페인 과다 섭취
• Case_C:  심혈관 및 혈압 관리
• Case_D:  복용 중인 약품과 충돌 가능성 (예: 철분 + 항생제)

6.2  사용자 입력 분석 함수

사용자의 자유 입력을 사전 정의된 Case에 매핑하기 위한 함수를 구성하였다.

def categorize_user_query(user_input: str) -> list:
    case_list = []
    if "간" in user_input or "음주" in user_input or "회식" in user_input:
        case_list.append("A")
    if "커피" in user_input or "카페인" in user_input:
        case_list.append("B")
    if "눈" in user_input or "루테인" in user_input:
        case_list.append("C")
    if "약" in user_input or "복용" in user_input:
        case_list.append("D")
    return case_list

해당 함수는 자유 입력을 분석하여 중첩된 case를 다중 반환한다.

즉, 한 사용자가 동시에 간 건강 + 눈 건강 + 약물 복용 정보를 입력한 경우, 세 가지 처방 논리를 모두 프롬프트에 반영할 수 있도록 설계하였다.

6.3  프롬프트 템플릿과 연결

각 case에는 다음과 같은 구조의 JSON 응답 템플릿이 사전에 정의되어 있다.

{
  "recommended": [...],
  "avoid": [...],
  "caution": [...],
  "reference": [...]
}

이 템플릿은 각 case별로 다르게 정의되고, 사용자의 입력이 여러 case에 해당될 경우 해당 템플릿을 병합하여 LLM 프롬프트로 전달한다.

프로젝트 진행 과정에서

프롬프트는 "허용된 성분만 사용하라" 는 whitelist 구조를 갖추도록 설계 방향을 잡게 되었다. 이 구조 덕분에 구조화된 응답, 일관된 필드, 안정적인 파싱이 가능해졌다.

7. 공공데이터 기반 제품 추천 파이프라인

7.1  데이터 출처 및 형식

사용된 데이터는 식약처 건강기능식품정보 공공 API로, 총 10,000건의 영양제 제품 정보를 사용하였다.

본 프로젝트에서는 다음 5가지 필드만 유지하여 벡터화 대상 문서를 구성하였다.

• 제품명
• 기능성
• 섭취 방법
• 주의사항
• 주성분

[참고] 식품의약품안전처_건강기능식품정보 Open API

7.2  데이터 수집 및 저장 전략

사용한 식약처 API에 아래과 같은 제약이 존재하는 것을 확인하였다.

• numOfRows 최대값: 100
• 호출 단위: 페이지당 100개
• 일일 최대 호출 건수: 10,000회

이를 고려하여 다음 전략으로 수집을 진행하였다.

7.3  제품 추천 로직

제품 추천은 recommended 성분 리스트를 기준으로 FAISS 검색을 수행하고,

동시에 avoid 성분 리스트에 해당하는 제품은 필터링하여 제외한다.

def filter_avoid_products(results, avoid_list):
    return [
        r for r in results
        if not any(avoid in r.page_content for avoid in avoid_list)
    ]

최종적으로 5개 제품만 추려서 사용자에게 카드 형태로 제시하고, 제품 정보는 UI 상에서 확장 가능(expandable)하게 구성하였다.

8. Streamlit 기반 UI 구성 및 사용자 경험 설계

8.1  전체 UI 흐름

UI는 Streamlit 기반으로 구성하였으며, 사용자는 한 화면 내에서 다음과 같은 흐름을 경험하게 된다.

1. 정보 입력 (폼 기반)
2. RAG 기반 챗 응답 (성분 추천 및 주의사항 포함)
3. 해당 성분 기반의 제품 카드 추천
4. 모든 응답의 출처 명시 및 JSON 기반 시각화

이러한 구성은 사용자가 응답 신뢰도를 기반으로 실시간 제품 비교 행동으로 이어질 수 있도록 UX 흐름을 설계하였다.

8.2  파싱 오류 및 예외 처리

LLM의 응답은 JSON으로 제한되어 있지만,

응답이 누락되거나 포맷 오류가 발생할 가능성을 대비하여 다음과 같은 안전 장치를 마련하였다.

• json.loads() 실패 시 즉시 오류 메시지 출력
• Streamlit 상에서 응답 중단 없이 이전 결과 유지
• 잘못된 응답이 반복되는 경우 로그 저장 후 LLM 호출 재시도

9. 실행 결과

💬  영양제 Check! 실행 결과

아래는 최종적으로 완성된 "영양제 Check!" 서비스를 실행한 화면이다.

사용자가 정보를 입력하면, 추천 성분과 피해야 할 성분, 주의사항, 실제 제품까지 순차적으로 출력되고, 각 결과는 모두 논문 또는 공공데이터에 기반한 검증된 정보만을 사용한다.

사용자는 자신의 상태에 따라 다른 결과를 받게 되며, 그 차이를 명확히 체감할 수 있다.

• Case_A, Case_B

• Case_C, Case_D

실행 결과를 해석할 때 가장 중요했던 건, 제시된 성분이 실제로 해당 사용자에게 적절한가를 도메인 기준에서 검증하는 것이었다.

공부하고 이해한 도메인 지식을 바탕으로 나와야 할 성분이 빠지거나 나오면 안 되는 성분이 포함된 경우를 구분할 수 있었고, 이 과정을 통해 현재 로직에 어떤 문제가 있는지 짚어내는 것도 가능했다.

궁극적으로는 “그럴듯한 답변” 이 아니라 정확하고 신뢰 가능한 결과만을 사용자에게 제공하는 것에 가까워질 수 있었다.

10. 개선 방향

응답 정밀도 개선 전략 및 후속 개선 방향

랭체인톤 발표 후, 퍼실님의 피드백을 통해 얻은 인사이트로 개선 방향을 생각해 볼 수 있었다.

10.1  문제점: 성분 간 유사도와 우선순위 불일치

본 프로젝트는 RAG를 두 단계로 구성하여 사용자 질문에 대한 질의응답과, 이후 조건 기반 영양제 추천까지 모두 언어 모델 기반 유사도 검색을 활용하였다. 그러나 성분 간 유사성이 높은 상황에서는 벡터 유사도 기반의 정렬이 기대만큼 명확한 우선순위를 제공하지 못할 가능성도 있다.

유사한 효능을 지닌 성분들이 다수 존재할 때, 유사도 기반 검색이 실제 추천의 우선순위와 다르게 작동할 수 있으며 이 경우 정형화된 구조의 RDB(Relational Database)를 활용한 정렬 방식이 더 효과적일 수 있다. 향후에는 RAG 기반 추천과 RDB 기반 정렬의 성능을 비교하여 추천 정확도 및 사용자 만족도를 기준으로 하이브리드 구조 도입도 고려할 수 있다.

10.2  연구 근거 인용 기능 강화

사용자에게 "추천 성분" 또는 "피해야 할 성분"을 제시할 때, 해당 내용을 뒷받침하는 연구 결과나 임상 근거(논문, 가이드라인 등)를 함께 제시하면 정보의 신뢰도와 전문성이 한층 높아질 수 있다. RAG의 응답 결과에 논문 출처 또는 핵심 문장을 인용하는 기능을 추가하거나, 근거 기반 요약 기능을 보완하는 방향으로도 개선이 가능하다.

11. 프로젝트 회고

🔗  다음 글

💊 영양제 Check! 프로젝트 회고

그러기 위해서, 의사결정 근거로써 사용자 로그 데이터를 수집하고 싶었다.

복잡한 서버 연동 없이 앱 단에서 수집할 수 있는 구조를 만들고자 했고, 그 결과 Google Sheets 를 활용하여 경량-무서버 로그 수집 시스템을 구성하게 되었다.

이 글에서는 시스템의 환경 구축과 구현 과정을 중심으로 기록해 보았다.

Google Sheets를 선택한 이유

Google Sheets는 별도의 서버나 DB 구축 없이도 데이터를 실시간으로 저장하고 확인할 수 있어 초기 구성 부담이 적다. Google Apps Script를 통해 HTTP 요청을 처리할 수 있어 간단한 로깅 서버 역할도 가능하다.

React Native 환경에서도 fetch 기반으로 쉽게 연동할 수 있고, 개발·운영 비용 없이 빠르게 테스트 가능한 점이 실용적이었다 무거운 인프라 없이 가볍게 로그 수집을 시작하기에 합리적이라 판단하였다.

결과를 먼저 소개한 뒤, 이를 가능하게 만든 환경 구축 과정을 차례대로 정리해 보았다.

로그 데이터 수집 결과

사용자 로그 데이터 수집 자동화 환경을 구축하면 앱을 사용함에 따라 구글 스프레드시트에 그 로그 데이터가 적재된다.

시트별로 action에 따라 필요한 데이터를 수집할 수 있는데,

해당 이미지에서는 앱 실행(app_open) 시 수집 가능한 가장 기본적인 데이터들이 쌓인 것을 볼 수 있다.

아키텍처

로그 데이터 수집한 아키텍처는 아래처럼 설계하였다.

React Native App ──> fetch() ──> Google Sheets API
     │                                 ▲
     ├─ AsyncStorage: Access / Refresh ┘
     └─ logEvent() util

• 앱은 OAuth 2.0 토큰 을 직접 들고 Google Sheets에 append 요청을 날린다.
• 스프레드시트는 테스트(Dev)·운영(Prod) 두 개로 분리해 데이터 오염을 막는다.
• 추후 분석은 Sheet → CSV export → Python / BigQuery 로 이어진다.

구현 과정

2025.05.20 기준으로 작성되었다.

1. 구글 스프레드시트 API 활성화 및 Access Token 발급

1-0. Google Sheets API 요금 구조

장기적인 로그 수집을 위해서 일반 계정 활성화 를 통해 결제 계정 업그레이드하여 사용하고 있다.

공식 문서에 따르면, Google Sheets API 자체는 추가 요금이 없다. 과금 SKU 자체가 없어서 호출이 많아도 비용이 0 원으로 찍힌다. 다만 초당·분당 쿼터를 넘기면 429(Too Many Requests)를 받게 되기는 한다. 과금 계정은 ‘신용카드 보증’일 뿐, Sheets API에는 실제 요금이 발생하지 않는 것이다.

다만, 무료 평가판이 끝나면 프로젝트 결제가 막혀 API도 동작하지 않기 때문에 일반 계정 활성화를 통해 업그레이드하여 사용해야 한다.

예측 불가한 트래픽 대비하여 업그레이드 후에는 Budget 알림과 쿼터 모니터링으로 예기치 않은 과금을 방지하는 것이 필요하겠다.

1-1. Google Sheets API 활성화

1. Google Cloud Console에 접속하여 구글 계정으로 로그인

2. 상단에서 프로젝트 선택 > 새 프로젝트 클릭

3. Google Sheets API 활성화

• 새로 만든 프로젝트로 이동한 다음, 왼쪽 메뉴에서 API 및 서비스 > 라이브러리 로 이동
• 검색창에 Google Sheets API 검색 → 클릭 → 사용 버튼 클릭해서 활성화

1-2. OAuth 2.0 클라이언트 ID 발급

사용자가 인증된 상태로 API에 접근하도록 Access Token을 발급받기 위한 과정이다.

1. 왼쪽 메뉴에서 API 및 서비스 > 사용자 인증 정보 로 이동

2. OAuth 동의 화면 구성 -> 이때 대상: 외부(External)

   • 외부로 설정하지 않으면 테스트 사용자를 등록할 수 없게 된다.

3. 상단에서 + 사용자 인증 정보 만들기 → OAuth 클라이언트 ID 선택

4. OAuth 클라이언트 ID 만들기

• 🌟 애플리케이션 유형: 웹 애플리케이션
• 🌟 승인된 리다이렉션 URI https://developers.google.com/oauthplayground 입력

[참고] 💡 애플리케이션 유형을 웹 애플리케이션으로 지정하지 않으면, redirect URI를 입력할 수 없다. 💡 승인된 리디렉션 URI (Authorized redirect URIs) 항목에 해당 주소를 추가하지 않으면, 이후 구글 계정 인증 단계에서 엑세스 요청이 차단되는 400: redirect_uri_mismatch 에러가 발생하게 된다.

여기까지 진행하면 Client ID와 Client Secret이 발급된다.

이후, 아래의 화면에서 확인되는 클라이언트 ID와 클라이언트 보안 비밀번호를 사용하게 된다.

1-3. 테스트 사용자 계정 등록

3-2 까지 수행 후, 곧바로 3-4로 넘어갔을 때 아래와 같은 에러를 만났다.

에러의 원인은 OAuth 동의 화면을 외부 사용자에게 공개하지 않았기 때문인 것으로 확인되었다.

현재 Google Cloud Console에서 만든 OAuth 클라이언트의 동의 화면은 "테스트 중" 상태이며, Google 계정 중 등록된 테스트 사용자만 접근할 수 있도록 제한되어 있는 것이다.

[ 해결 방법 ]

1. API 및 서비스 > OAuth 동의 화면 > 대상 으로 이동
2. 테스트 사용자로 Gmail 계정을 등록하여 저장

1-4. OAuth 2.0 Playground에서 토큰 발급

OAuth 클라이언트가 만들어졌으면 이제 Access Token을 발급받아야 한다. 가장 간단한 방법은 OAuth 2.0 Playground를 이용하는 것이다.

1. OAuth 2.0 Playground 접속

2. 오른쪽 상단 톱니바퀴(⚙️) ⅰ.  "Use your own OAuth credentials" 체크 ⅱ.  발급받은 Client ID, Client Secret 입력

3. [Setp 1] API 스코프 선택 https://www.googleapis.com/auth/spreadsheets 스코프 선택 (직접 입력도 가능)

4. 활성화된 Authorize APIs 클릭 → Google 계정 로그인

5. [Step 2] Authorization Code 발급

   • Exchange authorization code for tokens 클릭 ➱  Refresh token 및 Access token 발급 완료

   • Auto-refresh the token before it expires. →  OAuth Playground는 테스트 용이기 때문에 체크할 필요는 없음

이렇게 발급받은 토큰을 사용하여 Google Sheets에 접근할 수 있게 된다.

2. Access Token을 사용하여 Google Sheets에 데이터 수집

발급된 Access Token은 1시간(3600초) 후 만료된다. 따라서 Playground에서 함께 발급받은 Refresh Token을 이용해 자동 갱신 로직으로 구현하였다.

API 활성화와 토큰 발급 과정이 핵심이지만, React Native 기반 기술적인 구현 과정도 간략하게 정리해 보았다.

2-1. 필요한 사전 정보

1. 로그 데이터 수집을 위해 구글 스프레드시트를 생성해야 한다. 스프레드시트 ID는 URL에서 확인 가능 ➱  https://docs.google.com/spreadsheets/d/[여기가 ID]/edit

2. API가 접근하려면 스프레드시트에 사용자 계정(서비스 계정이거나 OAuth 로그인한 계정)을 편집자로 초대해야 한다.

3. Sheet 이름은 대소문자가 구분된다. →  Sheet1, sheet1 은 다름

2-2. 토큰 암호화

Playground에서 받아온 토큰들을 바로 사용할 수 없다.

GitHub Push Protection, 보안의 마지막 경고에서 언급된 사례가 바로 이 상황이었다.

민감한 CLIENT_ID, CLIENT_SECRET 값은 .env 에 두고, 앱 빌드 시 Babel 플러그인이나 EAS config로 주입한다.

현재 단계에서는 Refresh Token을 기기에 보관하긴 하지만, 실서비스에서는 Cloud Functions나 프록시 서버로 옮기면 더 안전하다.

// .env

GOOGLE_ACCESS_TOKEN=ya29...
GOOGLE_REFRESH_TOKEN=1//..
GOOGLE_CLIENT_ID=...apps.googleusercontent.com
GOOGLE_CLIENT_SECRET=...

2-3. Google Sheets 로그 기록을 위한 초기 토큰 설정

앱이 처음 실행될 때, Google Sheets API를 사용하기 위한 토큰이 없다면 .env에서 불러온 토큰을 AsyncStorage에 저장한다. 이미 저장되어 있다면 초기화를 생략하여 불필요한 덮어쓰기를 방지한다.

// App.js

// Google Sheets API 사용을 위한 Access Token 및 Refresh Token 초기 저장
useEffect(() => {
  const ensureSheetsTokens = async () => {
    const [[, access], [, refresh]] = await AsyncStorage.multiGet([
      'accessTokenForSheets',
      'googleRefreshToken',
    ]);

    if (!access || !refresh) {
      // 토큰 저장 (.env 파일에 별도 관리)
      await AsyncStorage.multiSet([
        ['accessTokenForSheets', process.env.GOOGLE_ACCESS_TOKEN],
        ['googleRefreshToken', process.env.GOOGLE_REFRESH_TOKEN],
      ]);
     ...
  };

  ensureSheetsTokens();
}, []);

2-4. Google Sheets를 원격 로그 저장소로 사용 자동화

React Native 앱에서 Google Sheets를 원격 로그 저장소로 쓰기 위해 필요한 전 과정을 자동화하기 위해 다음과 같이 핵심 로직을 구상하였다.

목표는 "Access Token은 자동으로 갱신되어 로그 유실이 최소화되고, 시트에는 한국 시간 기준의 깔끔한 로그 테이블을 쌓는 것" 이다.

1. KST 타임스탬프 생성

   • 클라이언트 시간(UTC)을 한국 표준시(+9 h)로 보정하여 "YYYY-MM-DD hh:mm:ss" 형식 문자열 반환
   • 이렇게 만든 값을 모든 로그의 첫 컬럼으로 넣어 시간대를 일관되게 관리

2. OAuth 2.0 토큰 관리

   • AsyncStorage에 저장해 둔 Refresh Token을 이용해 Google OAuth 서버에 POST 요청을 보내고,
     • 새로 발급받은 Access Token을 다시 AsyncStorage에 캐싱
     • 토큰이 갱신될 때마다 그 사실도 별도 시트(Sheet2)에 기록해 추후 모니터링할 수 있게 함

3. Google Sheets 한 줄 추가(append)

   • 전달받은 배열을 지정 시트의 맨 아래 행에 추가
     • 요청에 401(만료) 응답이 오면 위의 토큰을 자동 재발급한 뒤 한 번 더 시도하므로, 호출부는 토큰 만료 여부를 신경 쓰지 않아도 됨

4. 실제 로그 이벤트 함수

   • 앱 실행을 감지하여 추출 필드와 함께 actionName 기록
   • 수집 과정에서 사용자 식별을 위해 사용되는 이메일 암호화 필요
   • 토큰이 갱신될 때마다 시스템 이벤트로 기록

추우 출석 전용 이벤트, 게시글 작성 전용 이벤트 등 유의미한 인사이트를 도출해 낼 수 있는 데이터 수집을 고려하고 있다.

// api > googleSheetLogger.js

import {Platform} from 'react-native';
import AsyncStorage from '@react-native-async-storage/async-storage';
import {GOOGLE_CLIENT_ID as CLIENT_ID, GOOGLE_CLIENT_SECRET as CLIENT_SECRET} from '@env';

const SPREADSHEET_ID = '...';
const SHEET_NAME    = '...';

// 1) KST 타임스탬프
const getKSTTimestamp = () =>
  new Date(Date.now() + 9 * 60 * 60 * 1000) 
    .toISOString()                      
    .replace('T', ' ')       
    .substring(0, 19);         

// 2) RefreshToken으로 AccessToken 재발급
const refreshAccessToken = async () => {
  const refreshToken = await AsyncStorage.getItem('googleRefreshToken');
  if (!refreshToken) throw new Error('...');

  const res = await fetch('https://oauth2.googleapis.com/token', {
    method : 'POST',
    headers: {'Content-Type': 'application/x-www-form-urlencoded'},
    body   : new URLSearchParams({
      client_id    : CLIENT_ID,
      client_secret: CLIENT_SECRET,
      refresh_token: refreshToken,
      grant_type   : 'refresh_token',
    }).toString(),
  });
  if (!res.ok) throw new Error('...');

  const {access_token} = await res.json();
  await AsyncStorage.setItem('accessTokenForSheets', access_token);
  await logRefreshTokenUsage();                     
  return access_token;
};

// 3) Google Sheets append 유틸
const appendToGoogleSheet = async (values, sheetName = SHEET_NAME) => {
  const request = async token =>
    fetch(
      `https://sheets.googleapis.com/v4/spreadsheets/${SPREADSHEET_ID}/values/${sheetName}!A1:append?valueInputOption=USER_ENTERED`,
      {
        method : 'POST',
        headers: {Authorization: `Bearer ${token}`, 'Content-Type': 'application/json'},
        body   : JSON.stringify({values: [values]}),
      },
    );

  let token = await AsyncStorage.getItem('accessTokenForSheets');
  let res   = await request(token);

  // 만료(401) → 자동 재발급 후 재시도
  if (res.status === 401) {
    token = await refreshAccessToken();
    res   = await request(token);
  }
  if (!res.ok) throw new Error('...');
};

// 4) RefreshToken 사용 기록
const logRefreshTokenUsage = async () =>
  appendToGoogleSheet(
    [getKSTTimestamp(), 'system', 'refresh_used', '-', '-', '-', '-', '-', Platform.OS],
    'Sheet2',
  );

// 5) 실제 사용자 액션 로그
export const logUserAction = async ({...}, actionName) =>
  appendToGoogleSheet(
    [
      ...
    ],
  );

3. 데이터 기반 운영을 위한 구조 확장

법적·윤리적 고려 사항

데이터 수집 구조를 설계할 때 가장 우선되어야 할 요소는 법적·윤리적 기준을 준수하는 것이다.

사용자 식별을 위한 민감 정보 수집을 배제하고, UUID(Universally Unique Identifier) 기반으로 로그를 관리함으로써 최소 수집 원칙을 따르고 있다.

또한 첫 실행 시 개인정보 처리방침과 로그 수집 목적을 사용자에게 명확히 고지하고, 동의를 받는 절차를 포함하였다. 수집된 데이터는 내부 분석 용도로만 활용되며, 광고 등 다른 목적으로의 사용은 금지된다.

보관 기간 역시 1년으로 한정하고 있으며 이후 자동 파기될 수 있도록 설계하였다. 국외 서버(Google Sheets)를 사용하는 구조 특성상 개인정보 국외 이전에 대한 안내와 동의 항목도 정책 내에 포함해야 한다.

향후에도 개인정보 보호법(PIPA) 및 관련 가이드라인에 따라 체계를 지속적으로 점검하고 개선할 예정이다.

운영(Prod) 확장 계획

현재는 테스트 환경에서 Google Sheets에 로그 데이터를 수집하고 있지만, 운영 단계에서는 보다 안정적이고 분석 친화적인 구조로 확장할 계획이다. 앱에서 민감한 인증 정보를 직접 다루지 않도록 운영용 시트는 테스트 환경과 분리하여 데이터 정확성과 보안을 강화할 예정이다.

수집된 로그는 Google Sheets에서 일정 주기로 CSV 형태로 추출하거나 BigQuery로 연동하여 대용량 데이터도 유연하게 다룰 수 있는 기반을 마련할 계획이다. 이후 시계열 흐름, 기능별 사용 패턴, 앱 버전별 변화 등을 Tableau 기반 대시보드로 시각화하여 사용자 행동을 종합적으로 해석할 수 있도록 구성할 예정이다.

또한, 쌓인 데이터를 분석 가능한 구조로 정제하여 다양한 방식의 탐색적 분석과 지표 계산이 가능하도록 관리할 예정이다. 이를 통해 앱 운영의 방향성을 도출하고, 데이터 기반의 의사결정을 체계화할 수 있는 환경을 갖춰나갈 계획이다.

🖇  왜 Word Embedding이 필요한가? 🖇  1. Word2Vec 🖇  2. FastText 🖇  3. ELMo

앞선 글에서는 자연어처리에서 가장 기초가 되는 작업인 토큰화(Tokenization)에 대해 알아보았다. 이제는 이 토큰들이 기계에게 어떤 방식으로 의미를 가질 수 있도록 만드는지를 이해해야 한다.

기계는 숫자 연산을 통해 데이터를 인지한다. 그렇다면 텍스트로 이루어진 문장을 어떻게 숫자로 바꾸고, 또 의미를 담게 할 수 있을까?

단어 하나하나를 숫자로 변환하는 가장 일반적인 방법은 바로 워드 임베딩(Word Embedding)이다. 이 글에서는 워드 임베딩의 개념과 대표적인 세 가지 임베딩 방식인 Word2Vec, FastText, ELMo를 소개한다. 전체 흐름을 이해하는 데 중점을 두고 작성하였다.

🖇  왜 Word Embedding이 필요한가?

기계는 토큰 자체를 이해하지 못한다.

우리가 "고양이"라는 단어를 보면 귀엽고 털복숭복숭..인 동물을 떠올리지만, 컴퓨터는 "고양이"라는 단어가 어떤 의미를 가지는지 전혀 알지 못한다. 따라서 기계가 이해할 수 있도록 각 단어에 숫자 벡터를 부여해야 한다. 이 벡터가 단어의 의미를 표현하는 수단이 된다.

처음에는 각 단어에 랜덤한 실수값이 할당된다. 이렇게 초기화된 벡터는 의미를 담고 있지 않기 때문에 학습을 통해 단어들 사이의 의미적 유사도나 관계성이 반영된 방향으로 벡터값을 조정해줘야 한다.

이를 위해 고안된 여러 알고리즘들이 Word Embedding 방식들이다.

🖇  1. Word2Vec

Word2Vec은 "단어를 벡터로 만든다"는 이름 그대로, 단어 하나하나를 벡터 공간에 위치시키는 방법이다.

핵심 아이디어는 간단하다. 어떤 단어가 어떤 단어들과 함께 자주 등장하는지를 보면 그 단어의 의미를 유추할 수 있다는 것이다. 이를 Distributional Hypothesis (분포 가설)이라고 부른다.

예를 들어, "난 오늘 술을 한 잔 마셨어" 라는 문장이 있다고 하자. 이 문장에서 '술'과 '마셨어'는 의미적으로 밀접하게 연결되어 있다. Word2Vec은 이러한 공동 등장(co-occurrence) 패턴을 학습해 단어 간의 관계를 벡터에 반영한다.

학습 방식

Word2Vec에는 두 가지 주요 학습 방식이 존재한다.

CBOW (Continuous Bag of Words)

• 주변 단어들을 보고 중심 단어를 예측하는 방식

Skip-gram

• 중심 단어를 보고 주변 단어를 예측하는 방식

CBOW는 학습 속도가 빠르고 일반적인 경우에 잘 작동하지만, Skip-gram은 희귀 단어에 더 강하고, 실제 성능 면에서 조금 더 우세한 것으로 알려져 있다.

Word2Vec은 은닉층 없이 단순한 구조를 사용하고, Softmax나 Negative Sampling을 통해 단어 벡터를 학습하는 방식이기 때문에 일반적으로 Shallow Neural Network로 분류된다.

[참고] 위키독스 Word2Vec

💡 Word2Vec: 단어의 주변을 보면 의미가 보인다.

🖇  2. FastText

Word2Vec은 당연히 약점도 존재한다. 특히 자주 등장하지 않는 희귀 단어는 학습 기회가 적기 때문에 그 벡터는 사실상 거의 초기 상태에서 멈춰버리는 경우도 생긴다.

이를 해결하기 위해 등장한 것이 FastText다.

FastText는 단어를 하위 단위(Subword)로 나누어 처리한다.

예를 들어, 'playing'이라는 단어를 3-gram으로 분해하면 pla, lay, ayi, yin, ing 같은 문자 단위 subword들이 생성되고, FastText는 이들의 벡터 평균으로 단어 임베딩을 구성한다. 이 방식 덕분에 처음 등장하는 단어도 그 하위 정보를 기반으로 의미를 추론할 수 있게 된다.

주요 특징

• 단어를 일정 길이의 문자 단위로 나눈다 (n-gram)
• OOV(사전에 없는 단어) 문제에 매우 강함
• 형태가 유사한 단어는 벡터도 유사하게 생성됨

• 기존 Word2Vec이 희귀 단어에 약하고, 단어의 부분 정보를 활용하지 못한다는 점에서 유용하게 작용함

[참고] FastText 설명글

💡 FastText: 단어를 잘게 나누면 의미가 보인다.

🖇  3. ELMo

Word2Vec이나 FastText는 아무리 뛰어나도 고정된 단어 벡터를 사용한다는 점에서 한계를 가진다. 예를 들어, 다음 두 문장을 보자.

• 탐스럽고 먹음직스러웠던 사과가 이렇게 썩어버리다니
• 당신이 저지른 실수는 사과한다고 용서될 수 없다

두 문장의 '사과'는 전혀 다른 의미지만 Word2Vec은 이 두 단어를 동일한 벡터로 처리한다. 이를 해결하기 위해 등장한 것이 Contextualized Word Embedding, 문맥 기반 임베딩이다.

ELMo의 등장

2018년에 발표된 ELMo(Embeddings from Language Models)는 문장 속에서 단어가 사용된 문맥 전체를 고려해 단어의 임베딩을 생성한다. 즉, 문장이 달라지면 같은 단어라도 벡터가 달라진다. 이 덕분에 동음이의어 문제나 문맥에 따른 의미 변화를 효과적으로 처리할 수 있다.

ELMo의 작동

ELMo는 양방향 LSTM (Bidirectional LSTM)을 사용해 문장의 앞과 뒤 모두를 고려한다. 최종적으로 다음 세 벡터를 합쳐 단어의 의미를 결정한다.

• ELMo는각 단어에 대해 embedding 레이어와 양방향 LSTM의 여러 층에서 나온 hidden state들을 조합하여 문맥에 맞는 벡터를 생성한다. 최종 벡터는 이 hidden state들을 학습 가능한 가중치로 결합하여 구성된다.

이렇게 만들어진 벡터는 단어마다 사용된 위치와 문맥에 따라 달라지고, 보다 정교하고 정확한 자연어 처리를 가능하게 해준다.

[참고] 모두의 연구소: ELMo 리뷰

💡 ELMo: 문맥을 반영한 의미 임베딩

인사이트 및 회고

지금까지 텍스트를 숫자로 바꾸는 가장 기초적인 방식인 Word Embedding의 기본 개념들을 정리해 보았다.

• Word2Vec은 단어 주변의 단어들을 통해 의미를 학습한다.
• FastText는 단어를 잘게 쪼개어 희귀 단어까지도 유의미하게 표현한다.
• ELMo는 문맥을 반영해 동음이의어조차 정확히 구분할 수 있다.

이렇게 되면 토큰은 단순 기호가 아니라 의미를 담은 벡터로 표현된다. 이런 벡터 덕분에 기계는 단어 간의 유사성, 문장 내의 관계성, 감정의 흐름까지도 이해할 수 있게 된다.

이 글에서는 워드 임베딩이 무엇이고, 어떤 문제를 해결하며, 왜 발전하게 되었는지를 개념적으로 이해하였다. 각 방식의 내부 구조나 수학적 원리에 대한 이해는 실제로 사용해 보면서 정리해 볼 예정이다.

이 글에서는 토큰화의 개념, 목적, 다양한 기법들을 정리해 보았다. 실질적으로 어떤 방식으로 기계가 텍스트를 다루는지 이해하기 위한 흐름에 중점을 두고 작성하였다.

🖇  토큰화란?

토큰화는 텍스트를 의미 있는 단위로 나누는 작업이다.

이 단위를 '토큰(token)'이라고 한다. 일반적으로는 단어 수준으로 나누지만 때로는 형태소, 음절, 심지어 문자 수준까지 세분화하기도 한다. 기계 학습 모델이 문장을 처리할 수 있게 만드는 첫 번째 전처리 단계로서, 이후 임베딩, 분류, 번역, 생성 등의 작업을 위해 필수적으로 수행된다.

"그녀는 나와 밥을 먹는다" 는 몇 개의 단어로 이뤄졌을까?

예를 들어, "그녀는 나와 밥을 먹는다" 라는 문장이 주어졌을 때

• 공백 기준으로 보면:  ["그녀는", "나와", "밥을", "먹는다"]  → 4개의 토큰
• 형태소 기준으로 보면:  ["그녀", "는", "나", "와", "밥", "을", "먹는다"]  → 7개의 토큰

같은 문장이라도 어떤 기준으로 나누느냐에 따라 단어 수는 달라진다. 즉, 토큰의 정의는 토큰화 방식에 따라 결정된다.

이처럼 토큰화는 텍스트를 해석하고 처리하는 방식을 좌우하고, 문장 속 의미 단위의 경계를 설정하는 중요한 작업이다.

🖇  왜 토큰화가 필요한가?

자연어는 비정형적이며 복잡한 구조를 가진다. 사람이 사용하는 언어는 문법적 오류, 은유, 생략, 반복, 신조어 등 다양한 변형이 가능하고, 의미도 문맥에 따라 달라진다. 따라서 기계가 이를 이해하려면 먼저 문장을 일정한 규칙에 따라 잘게 나누어 구조화된 형태로 바꾸는 과정이 필요하다.

주요 목적

• 텍스트 전처리 및 정규화: 불필요한 공백, 특수기호 제거 등
• 문장의 의미 파악을 위한 구조 분석
• 단어, 구, 절 단위의 의미 정보 분리
• OOV(Out-Of-Vocabulary) 문제 최소화
• 모델 학습의 효율성과 성능 향상

토큰화는 단어의 경계, 문법적 구조, 의미적 관계 등을 파악하는 기반이 된다. 특히, 통계적 기법이나 딥러닝 모델에서는 토큰화된 단위가 임베딩의 기본 단위가 되기 때문에, 성능에 직접적인 영향을 미친다.

OOV 문제에 대해서는 뒤에서 간단하게 다뤄보았다.

🖇  다양한 토큰화 기법들

공백 기반 토큰화

가장 기본적인 방식으로, .split() 함수를 이용해 단어를 공백 기준으로 분리한다. 영어처럼 띄어쓰기가 명확한 언어에서는 비교적 잘 작동하지만, 영어조차도 구두점이나 복합어 처리에 한계가 있다.

corpus = "in the days that followed i learned to spell ..."
tokens = corpus.split()
print("Tokens:", tokens)

간단하게 토큰화를 수행할 수 있다는 장점이 있지만, 형태 변화(e.g., day vs days), 구두점 처리, 복합 단어 인식 실패, 의미 단위 단절 등의 문제가 존재한다.

형태소 기반 토큰화

한국어는 교착어이자 형태소 변화가 많은 언어다. 그렇기 때문에 공백 기준 토큰화로는 조사나 어미 분리가 어려워 엉뚱한 결과가 나온다.

형태소는 '의미를 가지는 최소 단위'이며 이를 단위로 쪼개는 것이 형태소 기반 토큰화이다.

e.g.,  오늘도 공부만 한다 → [오늘, 도, 공부, 만, 한다]

주요 도구: KoNLPy

• 분석기: Hannanum, Kkma, Komoran, Mecab, Okt

from konlpy.tag import Mecab
mecab = Mecab()
print(mecab.pos("자연어처리는 매우 흥미로운 분야입니다."))

분석기 선택 기준

• 속도 중시 (대용량 문서 처리): Mecab
• 오탈자, 띄어쓰기 오류 대응: KOMORAN + Okt
• 정확도 중시: Kkma

[참고] KoNLPy: 파이썬 한국어 NLP - KoNLPy 0.5.2 documentation
[참고] 한국어 형태소 분석기 성능 비교

🖇  사전에 없는 단어, OOV 문제

공백 기반 또는 형태소 기반 방식은 미리 정의된 단어 사전에 기반하여 토큰을 생성한다. 하지만 현실의 데이터는 새로운 단어, 신조어, 외래어가 끊임없이 등장하므로 사전에 없는 단어는 <unk>(unknown token)으로 치환하게 된다.

"코로나바이러스는 2019년 12월 중국 우한에서 처음 발생한 뒤..."
→ "<unk>는 2019년 12월 중국 <unk>에서..."

<unk> 토큰으로 치환되는 상황은 모델이 단어를 인식하지 못하게 되어, 의미 손실이나 예측 오류를 일으킬 수 있다. 이를 OOV(Out-Of-Vocabulary) 문제라고 한다.

OOV 문제는 모델이 학습할 때는 본 적이 없는 단어나 문장이 테스트 데이터에 등장하여 발생하는 문제로, 핵심 단어가 치환되면 문장의 의미 전달은 실패하게 된다.

이러한 OOV 문제를 완화하기 위해 단어를 더 작은 의미 단위로 분해하는 Subword 기반 접근법이 제안되었다. 대표적인 Subword 기반 접근에는 WordPiece Model과 SentencePiece가 있다.

🖇  Subword란?

Subword는 단어보다 작은 단위로 구성된 의미 단위를 뜻한다.

Subword는 주로 의미 있는 접두사, 어근, 접미사 등의 조합으로 구성되며, 희귀 단어도 하위 단위로 분해해 처리함으로써 OOV 문제를 효과적으로 완화할 수 있다.

예를 들어, unhappiness라는 단어를 un, happi, ness와 같이 더 작은 단위로 분해할 수 있다. 이처럼 전체 단어가 아니라 단어의 일부분(sub)만으로도 의미를 구성할 수 있기 때문에 Subword 단위로 텍스트를 다루면 희귀 단어를 효과적으로 처리할 수 있다.

Subword 기반 토큰화는 사전에 없던 단어도 이미 학습된 하위 단위의 조합으로 표현할 수 있게 해 주어 OOV 문제 해결에 매우 효과적이다.

🖇  Byte Pair Encoding (BPE)

BPE는 원래는 데이터 압축을 위해 만들어진 방식이다. 자주 등장하는 문자 쌍을 하나의 단위로 묶어 사전을 구성하는 방식인데 이를 자연어처리에 적용하면 단어를 더 작은 의미 단위로 나눠 처리할 수 있고, OOV 문제를 줄일 수 있다.

BPE 작동 원리

1. 모든 단어를 문자 단위로 나눈다.
2. 가장 자주 등장하는 문자 쌍을 병합한다.
3. 반복적으로 병합하면서 새로운 토큰을 만든다.

아래의 간단한 예시로 BPE 알고리즘을 이해할 수 있다.

aaabdaaabac
→ ZabdZabac (Z=aa)
→ ZYdZYac   (Y=ab)
→ XdXac     (X=ZY)

BPE를 통해 희귀 단어를 문자 단위로 분해하여 처리할 수 있고, 토큰 조합만으로 대부분의 단어 표현 가능하다는 점도 큰 이점으로 작용한다. 또한, 병합 횟수에 따라 vocabulary 크기를 조절할 수 있어 Subword 기반 모델이 사용하는 사전을 효율적으로 설계하는 데 활용된다.

(레포 링크) 아래 논문에서 제공해 주는 예제로 동작 방식을 구현해 보았다.

[참고 논문] Neural Machine Translation of Rare Words with Subword Units

🖇  WordPiece Model (WPM)

Google에서 제안한 WordPiece는 BPE의 변형으로 BERT, RoBERTa 등에서 사용된다. 단어 조합의 가능도(likelihood)를 기반으로 가장 자연스러운 형태의 토큰을 만든다는 점에서 더 향상된 접근이다.

WPM 특징

1. 단어 시작을 _ 기호로 표시하여 토큰 경계를 명시함 e.g.,  _you, _are, _teacher
2. 빈도수 기반이 아닌 가능도 기반 병합 →  더 자연스러운 분해와 문장 복원이 가능함

WordPiece는 특히 조사, 어미 변화가 심한 한국어나 일본어에서 매우 효과적이다. 형태소 분석기 없이도 높은 정확도를 보이고, 언어 독립적인 접근이라는 점에서 장점이 크다.

[참고 논문] JAPANESE AND KOREAN VOICE SEARCH

🖇  SentencePiece: 통합형 Subword 토크나이저

SentencePiece는 전처리 없이 원시 문장을 그대로 학습하여 subword 토큰을 생성하는 방식이다.

SentencePiece는 띄어쓰기를 유지하지 않고, 공백을 특수 문자 ▁로 치환해 문장 구조를 보존하며 다국어와 비정형 텍스트에 강하다. 특히 한국어, 일본어 등에서도 별도의 형태소 분석기 없이 사용할 수 있다.

SentencePiece 특징

• 공백을 특별한 문자로 처리
• 복잡한 전처리 과정 없이 바로 학습 가능
• 다양한 언어에 범용적으로 적용 가능

[참고] GitHub: google/sentencepiece

🖇  soynlp: 한국어 전용 통계 기반 토크나이저

soynlp는 비지도 학습 기반으로 단어 경계를 인식하는 한국어 특화 토크나이저다. 단어의 다음 글자가 등장할 확률을 계산해 단어 경계를 추정하고, 사전이 필요 없다.

예를 들어 보면 트, 트와, 트와이, 트와이스

각각 다음 글자의 등장 확률을 비교하여 최적 경계를 결정하게 된다.

soynlp 특징

• 비지도학습 기반으로 미등록 단어 처리 가능
• 형태소 분석의 대안으로 사용할 수 있으며, 신조어나 비표준어가 많은 데이터에 적합

[참고] GitHub: soynlp

인사이트 및 회고

지금까지 토큰화가 무엇인지와 그 필요성으로 시작하여 토큰화의 다양한 방식과 한국어에 특화된 접근까지 정리해 보았다.

토큰화는 문장을 기계가 이해할 수 있는 단위로 나누는 과정이고, 방식에 따라 분석 결과가 완전히 달라질 수 있다는 것을 알 수 있었다.

자연어처리는 사람의 언어를 기계가 이해할 수 있도록 바꾸는 작업이인데, 토큰화를 어떻게 처리하느냐에 따라 이후 모든 모델의 성능과 방향성이 달라질 수 있게 된다.

결국 완벽한 토크나이저는 없고, 목적과 언어에 맞는 선택이 중요하겠다.

아침에 스마트폰으로 보는 뉴스 기사, 친구에게 받은 메시지, 지금 이 블로그 글까지 모두 자연어(Natural Language)다. 자연어는 사람이 일상에서 자연스럽게 사용하는 언어를 뜻한다.

이처럼 자연어는 우리가 숨 쉬듯 사용하는 언어지만 정작 그 복잡성과 정체를 잘 인지하지 못한 채 살아간다. 대부분의 사람은 모국어를 '학습'했다기보다 '노출'을 통해 습득한다. 게다가 문법을 정확히 몰라도 말하고, 듣고, 쓸 수 있다.

그렇다면  "기계는 이 언어를 제대로 이해할 수 있을까?"

이 언어를 기계에게 가르치려고 할 때 인간의 언어는 생각보다 훨씬 더 복잡하다 것을 인지할 수 있다.

🖇  자연어 vs 인공어

기계에게 언어를 가르친다고 하면 프로그래밍 언어를 떠올릴 수 있다. 파이썬, 자바스크립트, C 같은 언어들은 사람이 만든 인공어(Artificial Language)다. 문법이 명확하고 애매함이 없어, 기계는 언제나 같은 방식으로 이해하고 처리할 수 있다.

이러한 인공어는 문맥자유 문법(Context-free Grammar)을 따른다. 이는 한 문장을 해석할 때 앞뒤 문맥에 의존하지 않아도 되는 구조다. 컴파일러는 이러한 규칙 덕분에 에러를 빠르게 감지하고, 코드 실행 흐름을 정확하게 이해할 수 있다.

반면 자연어는 문맥의존 문법(Context-sensitive Grammar)을 따른다. 단어의 의미나 문장의 구조가 앞뒤 맥락에 따라 달라지고, 문법 규칙도 예외가 많다. 인간에게는 당연한 이 특성은 기계에게는 큰 장벽이 된다.

🖇  자연어의 복잡성

예를 들어 보자.

Alice drove down the street in her car.

이 문장은 두 가지로 해석될 수 있다.

1. 앨리스가 자동차를 운전해서 거리를 달렸다.
2. 앨리스가 차 안에 있는 '거리'를 운전해 달렸다.

두 번째 해석은 현실적으로 말이 안 되지만, 문법적으로는 가능하다.

이럴 때 사람은 '차 안에 거리 같은 게 있을 리 없다'는 상식을 바탕으로 해석을 하나로 고정할 수 있다. 하지만 기계는 그렇지 않다. 기계에게 상식은 학습된 데이터로만 주어지며 그조차 부족하거나 왜곡되기 쉽다.

이처럼 자연어는 단어의 뜻, 문법, 문맥, 상황, 배경지식, 상식까지 모두 고려해야 정확히 이해할 수 있기 때문에 복잡한 것이다.

🖇  자연어의 어려움

자연어는 다음 네 가지 측면에서 기계 처리에 특히 어려움을 준다.

1. 중의성(Ambiguity)

• 하나의 문장이 둘 이상의 의미로 해석될 수 있음 "나는 그녀를 보고 웃었다"  →  내가 웃었는지, 그녀가 웃었는지 모호

2. 문맥의존성(Context-dependence)

• 단어의 의미나 문장의 구조가 앞뒤 문맥에 따라 달라짐 "배가 아파"  →  배(복부)? 배(선박)?

3. 탈문법성(Non-grammaticality)

• 자연어는 종종 문법 규칙을 벗어난 표현을 포함함 "그니까 그거 있잖아, 어... 그거 뭐더라?"

4. 비정형성(Unstructured)

• 정해진 틀 없이 자유롭게 쓰이는 말과 표현
• 메신저 대화, 댓글, 속어 등

이러한 특성 때문에 자연어처리는 문법 분석 수준에서 멈출 수 없고, 의미 분석, 문백 구조 파악, 도메인 지식 기반 추론까지 필요하다.

🖇  자연어 처리란 결국

여기서 자연어 처리를 왜 배우는가를 생각해 보게 되었다.

자연어를 처리하는 것은 굉장히 복잡하고 어려운 과정이라는 것을 알 수 있었다. 그렇다면 그저 문장을 처리하거나 번역하거나 챗봇을 만들기 위해서 사람들은 자연어 처리에 비용을 투자하고 있는 걸까? 하는 궁금증이 생겼다.

좀 더 넓게 보면 자연어 처리는 언어를 이해하는 시스템을 만드는 작업이고, 이는 인간의 사고방식을 기계에 담아내려는 시도라고 해석할 수 있을 것 같다.

이 관점에서 생각해 보면 결국 자연어 처리를 배우는 것은,

"기계가 어떻게 사람처럼 말하고, 듣고, 이해할 수 있을까?" 를 진지하게 고민해보는 일이지 않을까?

앞으로 공부해 나가다 보면 어딘가 결론에 도달할 수 있을 거라 기대한다.

🖇  기계는 어떻게 시작할까?

기계는 언어를 해석하려면 가장 먼저 문장을 잘게 나눠야 한다. 이때 토큰화(Tokenization)라는 개념이 등장한다.

토큰화란 문장을 의미 단위(보통 단어 또는 그 이하)로 쪼개는 작업이다. 이 단계가 정확하지 않으면 이후에 아무리 좋은 모델을 써도 원하는 결과를 얻기 어렵다.

예시로 살펴보자.

"나는 밥을 먹었다" →  ["나는", "밥을", "먹었다"] 혹은 →  ["나", "는", "밥", "을", "먹", "었", "다"]

이처럼 문장을 어디서 자르고, 어떤 단위를 의미로 볼지 정하는 기준은 자연어 처리의 성능에 큰 영향을 미친다. 이 내용은 다음 글에서 자세히 다뤄 볼 예정이다.

인사이트 및 회고

이 글을 작성하면서 사람이 무의식적으로 사용하는 자연어가 기계에게 어떤 이유로 까다롭게 작용하는지 이해할 수 있었다.

당연한 사실이지만 기계 입장에서는 구조가 불명확하고 예외가 많은 복잡한 데이터라는 점을 생각하면서 자연어 처리에 어떤 어려움이 있을 수 있을지 생각해 보는 시간이 되었다.

동일한 문장도 상식이나 배경지식이 있어야 제대로 해석되는 것처럼 규칙 기반 처리만으로는 자연어를 이해할 수 없는 어려움을 어떻게 해결해 나갈 수 있을지 앞으로의 학습을 통해 확인해 보아야겠다.

    " 같은 모델, 같은 학습 조건인데 ..

      Adam을 쓰면 중간에 멈추고,        SGD를 쓰면 끝까지 100 epoch 다 돌아버리네? "

이 글에서는 왜 이런 차이가 발생하는지, 왜 SGD에서는 EarlyStopping이 작동하지 않는 것처럼 보이는 건지 (아니면 혹시 정말 작동하지 않는 건지)

이를 확인하고 이해하는 과정을 기록해 보았다.

EarlyStopping이란?

EarlyStopping은 모델이 더 이상 성능이 좋아지지 않는 시점에서 학습을 멈추는 전략이다.

과적합을 막고, 학습 시간을 단축하는 데 유용하게 작용한다.

from tensorflow.keras.callbacks import EarlyStopping

"""
- monitor: 모니터링 대상 (보통 'val_loss' 또는 'val_accuracy')
- patience: 개선되지 않아도 기다릴 epoch 수
- restore_best_weights: 가장 성능 좋았던 시점의 가중치 복원
"""
early_stopping_cb = EarlyStopping(
    monitor='val_loss',
    patience=10,
    restore_best_weights=True
)

문제 상황 요약

같은 모델, 같은 데이터, 동일한 EarlyStopping 설정을 사용했는데도 Adam은 중간에 학습이 멈추고, SGD는 유독 끝까지 학습이 진행되는 것을 볼 수 있었다. 겉으로 보기엔 Adam에서는 EarlyStopping이 작동하고, SGD는 무시하는 것처럼 보일 수 있지만 실제로 그런 건 아닐 것 같아  확실하게 짚고 넘어가고자 했다.

결론부터 이야기하자면,

EarlyStopping은 Adam과 SGD 모두 동일한 기준으로 동작한다. 다만, 그 조건을 누가 더 빨리 만족시키느냐의 차이라는 것을 알 수 있었다.

• Adam은 파라미터별로 학습률을 자동 조절(adaptive learning rate)하며, 모멘텀까지 활용해 빠르게 수렴한다. validation loss가 빠르게 줄고 plateau를 형성하면서 EarlyStopping이 쉽게 트리거된다.
• 반면 SGD는 학습률이 고정되어 있고 초기 수렴이 느리다. validation loss는 천천히 감소하거나 출렁거리면서, EarlyStopping이 감지할 수 있을 만큼 충분히 안정적인 개선 패턴을 보이지 않는다.

EarlyStopping이 작동하지 않는 게 아니라 멈출 만한 조건이 만들어지지 않았을 뿐이다.

아래에서 실제 로그와 그래프를 분석하여 이를 확인해 보았다.

Adam vs SGD

Adam과 SGD는 자주 사용되는 대표적인 옵티마이저다. 이 둘의 학습 특성은 EarlyStopping이 작동하는 방식에 큰 영향을 준다.

• 학습률

  • Adam:  학습률을 파라미터별로 자동 조절. 초반부터 빠르게 손실 감소.
  • SGD:  학습률 고정. 일반적으로 낮게 설정됨. 한 번의 업데이트 크기가 작고 수렴 속도도 느림.

• 초기 수렴 속도

  • Adam:  몇 epoch만에 빠르게 손실 감소, plateau 상태 도달이 빠름.
  • SGD:  느리게 손실 감소. plateau에 도달하려면 더 많은 epoch 필요.

• Validation Loss 패턴

  • Adam:  손실이 급격히 줄고, 이후 plateau 상태 또는 진동 발생. EarlyStopping이 감지하기 쉬움.
  • SGD:  손실이 서서히 줄고, 진동도 적음. 개선 폭이 작아 변화가 없는 것처럼 보이기도 함.

• EarlyStopping 반응

  • Adam: plateau가 뚜렷해서 EarlyStopping 기준을 쉽게 만족함.
  • SGD: 손실이 계속 조금씩 줄거나 출렁여서, 기준을 충족하지 못할 수 있음.

왜 SGD는 EarlyStopping이 잘 안 되는 것처럼 보일까?

1. 수렴이 느림

SGD는 고정된 학습률로 매 epoch 이동하므로 수렴이 느리다. val_loss가 감소해도 그 속도가 느려서 patience 조건을 충족하지 못할 수 있다.

2. 진동이 적음

SGD는 모멘텀이 없으면 최솟값 근처에서 진동이 크지 않다. 오히려 줄어드는 듯한 패턴을 유지해서 EarlyStopping이 작동하지 않을 수 있다.

3. 작동은 하지만 티가 안 남

기술적으로는 EarlyStopping이 동작하고 있다. 단지, val_loss가 개선되지 않은 상태가 계속되지 않아서 트리거가 안 되는 것뿐이다.

실험: val_loss 시각화

이 그래프는 동일한 모델 구조와 학습 조건에서 Adam과 SGD만 바꿔 학습시킨 결과를 시각화한 것이다. validation loss의 변동을 시각화하여 EarlyStopping의 작동을 확인하고자 하였다.

import matplotlib.pyplot as plt

def plot_val_loss(history_adam, history_sgd):
    plt.figure(figsize=(10, 5))
    plt.plot(history_adam.history['val_loss'], label='Adam - val_loss', color='blue')
    plt.plot(history_sgd.history['val_loss'], label='SGD - val_loss', color='orange')
    plt.xlabel('Epochs')
    plt.ylabel('Validation Loss')
    plt.title('EarlyStopping Behavior: Adam vs SGD')
    plt.legend()
    plt.grid(True)
    plt.show()

그래프 해석

실제 학습 로그와 (길어서 따로 첨부하진 않음) 그래프를 분석하여 val_loss와 EarlyStopping 작동 관계를 해석해 보았다.

1. Adam 해석

• Epoch 1~7: val_loss가 1.81 → 1.52까지 빠르게 감소
• Epoch 8~12: 일시적으로 증가하거나 진동하는 구간
• Epoch 13~29: 다시 감소해 최저점 1.4175 도달
• Epoch 30~39: val_loss가 다시 증가 또는 정체 → patience=10 조건 만족 → EarlyStopping 작동

→ Adam은 빠르게 수렴하고 이후 일정 구간에서 개선이 없는 상태가 이어져 조기 종료됨

2. SGD 해석

• Epoch 1~20: val_loss가 1.98 → 1.50 수준까지 점진적으로 감소
• Epoch 21~40: 감소세가 유지되며 1.43대까지 도달함
• Epoch 4160: 미세한 진동과 함께 1.391.41 수준 유지
• Epoch 61~100: 최저점 1.33 수준까지 계속 개선됨 → EarlyStopping 작동 조건 미충족

→ SGD는 전체 학습 내내 val_loss가 조금씩 줄어들며 plateau 없이 미세 개선이 지속됨 → EarlyStopping은 조건이 충족되지 않아 작동하지 않았음

EarlyStopping 로그로 확인하기

EarlyStopping로 작동 여부를 확인할 수 있다.

이 글에서는 SGD를 적용했을 때 작동하지 않는 것처럼 보이는 원인을 알고 싶었던 것이기 때문에 간단하게 설명하고 넘어가겠다.

early_stopping_cb = EarlyStopping(
    monitor='val_loss',
    patience=10,
    verbose=1,  # 학습 중 중간 로그 출력
    restore_best_weights=True  # 성능이 가장 좋았던 에폭의 가중치로 자동 복원 + 로그 출력
)

학습 중 다음 메시지가 보이면 EarlyStopping이 실제로 작동한 것이다.

Epoch 30: early stopping
Restoring model weights from the end of the best epoch: 20.

이 로그가 없다면 조건이 충족되지 않았다는 뜻이다. 즉, EarlyStopping은 항상 작동 중이며 조건을 기다리고 있는 중이다.

다른 옵티마이저는 어떨까?

지금까지 대표적인 두 옵티마이저인 Adam과 SGD의 EarlyStopping 작동 차이에 초점을 맞추어 비교해 보았다.

추가적으로 RMSprop, Adagrad, Nadam 등의 옵티마이저는 Adam처럼 빠른 수렴을 유도하기 때문에 대부분 EarlyStopping이 잘 작동하는 편이다. 고전적인 SGD는 세밀한 튜닝 없이는 조건을 만족시키기 어려워 조기 종료가 잘 되지 않는 것처럼 보일 수 있는 것이다.

그 사이의 성격을 지닌 옵티마이저와 특징을 간단하게 정리해 보았다.

💡 EarlyStopping이 작동하는지는 옵티마이저 자체보다는 수렴 특성과 손실 곡선 형태에 더 큰 영향을 받는다.

💡 옵티마이저를 선택할 때는 정확도 외에도, 학습 곡선의 형태와 EarlyStopping이 정상 작동할 수 있는지까지 고려하는 것이 중요하다.

인사이트 및 회고

EarlyStopping은 Adam, SGD 구분 없이 항상 작동하는데, 옵티마이저의 차이는 작동 조건을 얼마나 빨리 만족시키느냐에 있다는 것을 알 수 있었다.

Adam은 수렴이 빠르고 손실의 진동이 커서 조건을 조기에 만족시키는 경우가 많고, SGD는 손실이 완만하게 감소하기 때문에 조건을 만족시키지 못한 채 계속 학습되는 것처럼 보일 수 있는 것이다.

EarlyStopping이 작동하지 않는다고 무조건 문제라고 단정 짓지 말고, 그 작동 메커니즘을 이해하고 해석하는 시각을 갖추는 것이 중요하다는 생각이 들었다.

결국 모델 학습의 효율성을 높이려면 EarlyStopping을 비롯한 설정을 학습 과정의 피드백으로 활용하는 능력이 필요하겠다.

🖇  1. 콜백 (Callbacks) 🖇  2. 학습 단위 (Batch) 🖇  3. 데이터 스케일링 (Data Scaling) 🖇  4. 학습률과 에폭 (Learning Rate & Epochs) 🖇  5. 은닉층과 뉴런 수 (Hidden Layers & Neurons) 🖇  6. 활성화 함수 (Activation Function) 🖇  7. 가중치 초기화 (Weight Initialization) 🖇  8. 옵티마이저 (Optimizer)

딥러닝 모델의 성능에 있어서 '학습 기술'이 중요하게 작용한다. 어떤 활성화 함수를 사용할지, 가중치는 어떻게 초기화할지, 학습률은 얼마나 줄지, 배치 단위는 어떻게 설정할지 등 세부적인 설정이 전체 결과를 결정짓게 된다.

이 글에서는 이러한 딥러닝 학습 기술들의 특징을 기반으로 반드시 알아야 할 요소를 주제별로 정리해 보았다. 그 개념과 흐름을 이해하는 데 중점을 두었다.

🖇  1. 콜백 (Callbacks)

콜백은 모델 학습 중간에 특정 조건을 만족하면 실행되는 기능이다. Keras에서는 fit() 함수의 인자로 callbacks 리스트를 통해 지정할 수 있다.

ModelCheckpoint

• 일정 주기로 모델의 가중치를 저장해두는 기능
• 학습 도중 중단되거나 성능이 나빠진 경우, 가장 좋은 성능의 가중치를 복구할 수 있음

EarlyStopping

• 검증 성능이 개선되지 않으면 학습을 자동 중단시킴
• patience 만큼의 여유 기간을 두고 개선 여부를 판단
• 과적합을 방지하고, 불필요한 에폭을 줄이는 데 유리함
• 기본적으로는 monitor='val_loss'를 기준으로 조기 종료를 판단하며, 필요에 따라 val_accuracy나 다른 지표로 변경 가능함
• restore_best_weights=True로 설정하면 별도 저장 없이도 최적 가중치를 자동 복원

LearningRateScheduler

• 학습이 진행됨에 따라 학습률을 점차 줄이거나 일정한 전략으로 조절
• 초기에는 빠르게 학습하다가 후반에 더 정밀한 수정을 가능하게 함

TensorBoard

• 학습 과정의 손실, 정확도, 학습률 등의 변화를 시각화하여 확인 가능
• 로그 파일을 저장할 디렉토리를 지정하면 웹 인터페이스로 간편하게 모니터링 가능

💡 이처럼 콜백은 학습 도중 모델이 과적합되지 않도록 막아주고, 가장 성능이 좋았던 상태를 자동으로 저장하거나 복원해서 실수 없이 안정적으로 학습을 마칠 수 있게 해준다.

🖇  2. 학습 단위 (Batch)

전체 데이터를 한 번에 학습시키는 Full Batch 방식은 이론상 정확하지만, 계산 효율이 매우 떨어진다. 대신 다음의 방식들이 자주 사용된다.

Stochastic Gradient Descent (SGD)

• 데이터 샘플을 하나씩 학습에 사용
• 진동이 심하고 수렴 경로가 불안정하지만 메모리 효율이 높음

Mini-Batch

• 전체 데이터를 일정한 크기(n)로 분할하여 학습
• SGD의 장점(속도)과 Batch의 장점(안정성)을 적절히 결합한 형태
• 학습 속도, 수렴 안정성, 메모리 사용 사이의 균형을 잡기 위함

Batch Size가 작을수록 진동이 커지고 시간이 오래 걸리지만, 일반화에 유리한 경우도 있다.

💡 실제로 대부분 Mini-Batch 방식을 사용한다. 적절한 배치 크기 선택은 하드웨어, 메모리, 데이터 특성에 따라 달라진다.

🖇  3. 데이터 스케일링 (Data Scaling)

입력 데이터의 스케일이 너무 다르면 특정 특성이 가중치 학습에 불균형한 영향을 미친다. 이로 인한 왜곡을 방지하기 위해 전처리가 필요하다.

표준화 (Standardization)

• 평균을 0, 분산을 1로 조정 (z-score normalization) →  정규분포 형태로 스케일 조정
• 선형 회귀, PCA, 신경망 등 대부분의 기법에서 안정적인 학습을 유도함
• 딥러닝에서는 표준화가 더 일반적이며, 배치 정규화(Batch Normalization)나 층 정규화(Layer Normalization)와도 관련 깊음

정규화 (Normalization)

• 모든 값을 0~1 범위로 조정 (min-max scaling)
• 이미지 픽셀과 같이 고정 범위가 있는 경우에 적합

💡 표준화는 모델이 정규분포 전제를 포함할 때 유리하고, 정규화는 범위 제한이 필요한 상황에 자주 사용된다.

🖇  4. 학습률과 에폭 (Learning Rate & Epochs)

학습률 (learning rate)

→  손실 함수의 기울기(gradient)에 곱해지는 값

• 가중치를 얼마나 크게 변화시킬지를 결정함
• 너무 크면 최솟값을 지나쳐 버릴 수 있고(overshoot) → 발산
• 너무 작으면 수렴 속도가 느려짐
• 보통 초기에는 큰 값을 주고 점차 줄이는 방식(step decay, cosine decay 등)을 사용함
  • Step Decay:  일정 에폭마다 학습률을 줄임
  • Cosine Annealing:  학습률을 코사인 함수 곡선처럼 점차 감소
  • Warm-up:  초반 몇 에폭 동안 학습률을 천천히 증가시킴

에폭 (epochs)

→  전체 데이터를 몇 번 반복 학습할지를 의미

• 학습률이 작아질수록 충분한 학습을 위해 더 많은 에폭이 필요해짐
• 적절한 에폭은 실험을 통해 찾아야 함 (EarlyStopping을 통해 자동 조절 가능)

💡 학습률과 에폭은 서로 보완 관계이고, 일정 학습률 이하로 줄어들면 더 이상 손실 감소 효과가 없기 때문에 EarlyStopping과 연동하는 것이 일반적이다.

🖇  5. 은닉층과 뉴런 수 (Hidden Layers & Neurons)

딥러닝 모델의 표현력은 은닉층(hidden layer)의 수와 각 층의 뉴런(neuron) 수에 따라 달라진다.

• 층이 너무 적으면 패턴을 학습하지 못함 → 과소적합
• 너무 많으면 학습 데이터에 과도하게 적합함 → 과대적합
• 일반적으로 1~3개의 은닉층으로도 충분한 성능을 낼 수 있으며, 층 수보다 뉴런 수 조절이 더 민감하게 작용하는 경우도 많음

💡 적절한 구조는 데이터의 복잡도에 따라 달라지고, Dropout이나 정규화를 통해 복잡도 제어가 가능하다.

💡 중요한 건 층의 수가 아니라 필요한 만큼의 표현력만 확보하는 것이다.

🖇  6. 활성화 함수 (Activation Function)

딥러닝은 선형 모델로는 표현할 수 없는 비선형 패턴을 학습해야 하므로 활성화 함수가 필요하다. →  딥러닝이 단순 선형 회귀보다 뛰어난 이유는 비선형 활성화 함수 덕분이다.

Sigmoid 계열

• Sigmoid, Tanh, Softsign 등
• 출력이 제한적(01 또는 -11)
• 출력값이 0 또는 1 근처에서 평탄해져서 기울기 소실(vanishing gradient)이 발생할 수 있음
• RNN의 출력층 등 특수한 경우에만 사용됨

ReLU 계열

• ReLU, Leaky ReLU, ELU, SELU 등
• 기울기 소실 문제가 적고 연산 속도가 빠름
• 단점: 음수 입력에서 출력이 0이 되어 뉴런이 죽는 문제(dead neuron)가 생길 수 있음 →  ReLU
• 대부분의 CNN, DNN에서 기본 활성화 함수로 채택

💡 ReLU가 기본값으로 사용되고, 음수 대응이 필요한 경우 Leaky ReLU 등을 고려한다.

🖇  7. 가중치 초기화 (Weight Initialization)

신경망 학습은 적절한 초기 가중치 없이는 불가능하다.

모든 가중치를 0으로 초기화하면 모든 뉴런이 같은 출력을 내고, 역전파가 동작하지 않는다. 무작위로 초기화하되, 분포를 조절하여 효율적인 학습이 가능하게 하게 해야 한다.

다음은 대표적인 초기화 방법이다.

Xavier 초기화

• 입력과 출력의 노드 수에 기반하여 분포 조정
• Sigmoid, Tanh 등 대칭 함수에 적합

He 초기화

• ReLU 계열 함수에 최적화
• 평균 0, 표준편차 √(2/n) 분포

💡 올바른 초기화는 학습이 안정적으로 수렴하도록 해주고, 빠른 속도로 최적점에 도달할 수 있도록 만든다.

🖇  8. 옵티마이저 (Optimizer)

옵티마이저는 손실 함수가 최소가 되도록 파라미터를 조정하는 역할을 한다.

• SGD: 기본 경사 하강법. 단순하지만 느림

• Momentum, NAG: 경사 방향에 관성을 부여하여 진동 방지

• Adagrad: 파라미터별 학습률 조절. 자주 업데이트되는 파라미터에 작은 학습률 부여

• RMSprop: 최근 그래디언트만 반영하여 학습률 조절. RNN 등에서 효과적

• Adam: 모멘텀 + RMSprop 결합. 대부분의 모델에서 기본값으로 채택

💡 옵티마이저는 모델의 수렴 속도, 안정성, 일반화 성능을 결정하는 중요한 요소다.

💡 딥러닝에서는 대부분 Adam을 시작점으로 사용하고, 성능 향상 필요시 Lookahead, LAMB, Ranger 등의 최신 기법을 탐색한다.

9. 과소적합과 과대적합

모델이 너무 단순하거나 너무 복잡하면 학습 성능에 문제가 발생한다.

과소적합 (Underfitting)

• 학습 데이터를 충분히 반영하지 못한 상태
• 모델이 지나치게 단순하거나, 에폭이 부족할 때 발생
• 해결: 더 복잡한 모델, 더 많은 에폭, 더 좋은 특징 추출

과대적합 (Overfitting)

• 학습 데이터에 과하게 맞춰져서 새로운 데이터에 일반화되지 않는 상태
• 너무 많은 파라미터, 너무 많은 학습 횟수, 너무 적은 데이터에서 발생
• 해결: L1/L2 정규화, Dropout, 데이터 증강, 학습 조기 종료, 모델 단순화

💡 결국 좋은 모델은 학습 데이터에 너무 덜 맞춰서도, 너무 과하게 맞춰서도 안 된다. 일반화 성능을 중심으로 모델을 평가하고 조정해야 한다.

인사이트 및 회고

딥러닝은 모델을 많이 쌓는 것보다 학습을 잘 되게 만드는 설계가 훨씬 중요하다는 것을 알 수 있었다. 에폭을 늘리면 일단 성능이 나아지는 줄 알았는데 학습률이나 가중치 초기화가 잘못되면 아예 시작부터 학습이 안 된다는 걸 이해하였다.

EarlyStopping 같은 콜백이 왜 필요한지, 옵티마이저마다 어떤 차이가 있는지를 이해하는 것도 학습의 안정성에 있어 중요하다는 것을 알았다.

앞으로 학습이 안 되는 상황이 오면 무작정 구조를 바꾸기보다 먼저 학습 환경을 점검해 봐야겠다는 기준이 생겼다.

🖇  0. 딥러닝 학습 흐름 🖇  1. 옵티마이저란? 🖇  2. 경사하강법 (Gradient Descent) 🖇  3. 볼록 함수 vs 비볼록 함수 🖇  4. 학습률 (Learning Rate) 🖇  5. 지표 (Metrics)

모델 학습에서 손실 함수가 예측 성능을 수치화해준다면, 옵티마이저는 그 손실 값을 최소화하기 위해 파라미터를 어떻게 업데이트할지를 결정하는 역할을 한다. 학습 도중 혹은 완료 후 모델 성능을 평가할 때는 지표(metrics)를 사용한다.

이 글에서는 딥러닝의 학습 흐름을 이해하고 옵티마이저의 개념과 경사하강법, 학습률, 지표의 종류 순서로 정리해 보았다.

🖇  0. 딥러닝 학습 흐름

사람은 실수하거나 경험을 통해 피드백을 받고 점점 더 나아지는 방식으로 학습한다. 반면 딥러닝은 손실 함수를 통해 예측과 정답 간의 오차를 계산하고, 이를 기반으로 모델의 가중치를 반복적으로 업데이트해 나가는 방식으로 학습이 이루어진다. 오차가 작아지도록 모델 내부의 수많은 가중치를 미세하게 조정해가는 과정이 딥러닝의 학습이다.

딥러닝 모델의 학습 과정은 다음과 같은 흐름으로 이루어진다.

1. 입력 X가 모델에 들어가고
2. 레이어를 거쳐 예측 Y'를 만든다.
3. 예측값 Y'와 정답 Y를 비교하여 손실 함수로 손실값을 계산한다.
4. 손실값을 기준으로 옵티마이저가 가중치를 업데이트한다.

💡 딥러닝 모델의 학습에 필요한 구성요소는 입력 X, 정답 Y, 손실 함수, 옵티마이저, 그리고 예측값 Y'로 이루어진다. 먼저 데이터셋을 입력 X와 실제 정답(레이블)인 Y로 구분하고, 입력 데이터는 연속된 레이어를 통해 예측값 Y'로 출력된다. 이때 손실 함수는 모델의 예측값 Y'과 실제 정답 Y의 차이를 손실값으로 계산하고, 이 손실값을 기준으로 옵티마이저가 가중치를 업데이트한다. 이 과정은 예측 → 오차 측정 → 가중치 업데이트의 순서로 반복되며 계산한 손실값을 점점 줄여나가는 방향으로 진행된다. 결국 계산한 손실값을 최소화하도록 옵티마이저가 동작하는 것이 딥러닝 모델 학습이다.

이처럼 딥러닝 학습은 예측-오차 계산-오차 최소화를 반복하는 과정이고, 손실 함수와 옵티마이저는 각각 오차 계산과 학습 방향 결정을 담당한다.

🖇  1. 옵티마이저란?

옵티마이저는 손실 함수 값을 기준으로 모델 파라미터(가중치 등)를 어떤 방식으로 조정할지 결정하는 알고리즘이다. 딥러닝 모델이 학습할 때 사용하는 최적화 기법이다.

• 손실 함수는 오차를 수치화하고,
• 옵티마이저는 그 값을 줄이기 위해 모델을 업데이트한다.

Keras에서는 여러 종류의 옵티마이저를 제공하는데 모델에 맞게 선택하여 사용할 수 있다.

자주 쓰이는 옵티마이저 종류

keras.optimizer.SGD()

• 가장 기본적인 옵티마이저
• 확률적 경사하강법(Stochastic Gradient Descent)

keras.optimizer.Adam()

• 학습률을 자동 조정해주는 대표적인 옵티마이저

SGD는 고정된 학습률과 단순한 기울기 업데이트 방식을 사용하지만, Adam은 모멘텀과 적응형 학습률을 활용해 더 안정적이고 빠른 수렴을 기대할 수 있다. 특히 안장점이나 평평한 지역에서 잘 빠져나오는 특징이 있어 많이 쓰인다.

옵티마이저는 model.compile() 단계에서 설정하고, 필요하면 별도 객체로 생성해서 하이퍼파라미터를 조정할 수도 있다.

🖇  2. 경사하강법 (Gradient Descent)

옵티마이저는 손실 함수를 기반으로 모델이 어떻게 업데이트되어야 하는지 결정한다. Keras에서 여러 옵티마이저를 제공하고, 사용자는 특정 종류의 확률적 경사 하강법을 지정할 수 있다.

경사하강법은 대부분의 옵티마이저가 기반으로 삼는 핵심 원리다.

손실 함수가 정의된 공간에서 그 함수의 기울기를 따라 손실 값이 줄어드는 방향으로 조금씩 이동하면서 최적의 파라미터를 찾아가는 방식이다.

수학적으로는 미분을 통해 기울기를 계산하고, 그 기울기의 반대 방향으로 파라미터를 업데이트한다.

$$$ x_{n} = x_{n-1} - \eta \cdot \nabla f(x) $$$

• $x$:  현재 파라미터
• $\eta$:  학습률 (learning rate)
• $\nabla f(x)$:  손실 함수의 기울기

$f(x+\Delta x) - f(x)$ 형태의 미분 정의를 통해 변화량이 큰 곳에서는 빠르게 이동하고, 평평한 곳에서는 천천히 움직인다.

경사하강법의 한계: 안장점 문제

경사하강법은 기울기를 따라 이동하기 때문에 기울기가 0인 지점에서는 더 이상 나아가지 못한다. 이때 해당 지점이 실제 최소값이 아니라면 문제가 된다.

• 이런 지점을 안장점(Saddle Point)이라 부른다.
• 안장점은 한 축에서는 최솟값처럼 보이지만, 다른 축에서는 최댓값처럼 보이므로 기울기가 0이 되어 멈추게 된다.
• Adam, RMSProp 등의 옵티마이저는 이 문제를 피하기 위해 이전 변화량을 누적하거나, 축마다 학습률을 조정하는 전략을 사용한다.

🖇  3. 볼록 함수 vs 비볼록 함수

최적화 과정에서 손실 함수의 형태에 따라 결과가 달라질 수 있다.

• 볼록 함수(Convex Function): 어디서 시작하든 전역 최적점(최솟값)에 도달함
• 비볼록 함수(Non-Convex Function): 시작 위치에 따라 다른 국소 최소점에 빠질 수 있음

대부분의 딥러닝 모델은 비선형 활성 함수 등을 포함하고 있어 손실 함수가 비볼록 함수가 되는 경우가 많다. 이 때문에 경사하강법 기반의 옵티마이저가 안정적으로 작동하려면 하이퍼파라미터 조정이나 초기값 설정이 중요하다.

🖇  4. 학습률 (Learning Rate)

학습률은 옵티마이저가 파라미터를 얼마만큼 변경할지를 결정하는 값이다.

• 너무 크면 최솟값을 지나쳐 발산할 수 있고,
• 너무 작으면 학습이 매우 느리거나 지역 최솟값에서 멈춰버릴 수 있다.

경사하강법을 통해 손실함수의 반대 기울기 방향으로 업데이트 할 때 업데이트 되는 크기에 관여하며 잘못 설정한 경우 손실함수의 최저점에 도달하지 못할 수 있다.

위에서 볼 수 있듯이

• 큰 학습률: 수렴하지 못하고 진동하거나 발산
• 작은 학습률: 느리게 수렴하거나 정체
• 적절한 학습률: 빠르게 최적점에 수렴

일반적으로는 작은 학습률로 시작하고 일정 횟수마다 감소시키는 스케줄링을 쓰거나, Adam과 같은 적응형 옵티마이저를 통해 자동 조절하는 방식이 활용된다.

대표적인 스케줄링 기법으로는 StepDecay, ExponentialDecay, ReduceLROnPlateau 등이 있다.

🖇  5. 지표 (Metrics)

손실 함수가 학습 과정의 최적화를 위한 기준이라면 지표는 모델이 얼마나 잘 작동하는지를 평가하기 위한 기준이다. 손실 함수는 역전파와 파라미터 업데이트에 영향을 주는 반면, 지표는 오직 평가 목적으로만 사용된다.

모델을 평가할 때는 손실 함수 외에도 다양한 지표(metrics)를 함께 설정한다.

Keras에서 자주 쓰는 지표

• mae (Mean Absolute Error):  회귀 문제에서 자주 사용
• accuracy:  분류 문제에서 정확도를 측정
• acc:  accuracy의 줄임말로도 사용 가능

학습 중에는 지표의 변화 추이를 통해 과적합 여부나 학습 상태를 확인할 수 있다. Keras에서는 metrics 리스트를 통해 여러 지표를 동시에 모니터링할 수 있다.

인사이트 및 회고

지금까지 딥러닝 학습 흐름부터 옵티마이저, 경사하강법, 학습률, 지표의 개념과 실제 적용 시 주의할 점까지 살펴보았다. 마무리하면서 각 개념에서 이해해야 할 주요 이슈들을 정리해 보았다.

손실 함수가 예측과 정답의 차이를 수치로 표현한다면 옵티마이저는 그 차이를 줄이기 위한 방법이고, 지표는 그 결과를 평가하는 기준이라는 것을 알 수 있었다.

학습률이나 함수의 형태에 따라 학습 성능이 크게 달라질 수 있으므로 이론과 함께 실험을 병행하며 설정값을 조정하는 과정이 중요하다고 생각된다.

🖇  손실 함수란? 🖇  Keras의 손실 함수 🖇  평균절대오차 (MAE) 🖇  평균제곱오차 (MSE) 🖇  MAE vs MSE 🖇  교차 엔트로피 오차 (CEE) 🖇  손실 함수 값 계산

"손실 함수(Loss Function)"는 딥러닝에서 매우 중요한 개념이다. 문맥에 따라 목적 함수(Objective Function) 등으로 혼용되는 경우도 많다. 어떤 경우에는 손실 함수가 목적 함수 그 자체로 사용되고, 어떤 경우에는 손실 함수에 정규화 항까지 포함된 전체를 목적 함수로 간주하기도 한다. 이 글에서는 이해를 위해 손실 함수로 통일하여 사용하겠다.

이 글에서는 손실 함수의 이론적 개념과 실제 코드에서 자주 사용되는 함수명과 적용 맥락의 순서로 정리해 보았다.

🖇  손실 함수란?

모델이 학습을 잘하고 있는지를 판단하려면 그 과정에 대한 지표가 필요하다. 그 역할을 해주는 것이 손실 함수(Loss Function)다.

손실 함수는 모델이 예측한 값과 실제 정답 사이의 오차를 수치로 나타내고, 이 값이 작을수록 예측이 정확하다는 뜻이다. 학습은 이 손실 함수를 최소화하는 방향으로 진행된다. 딥러닝에서 손실 함수는 최적화 이론에 따라 미분 가능한 함수여야 하며 그 결과값을 기반으로 파라미터를 업데이트한다.

손실함수의 역할

• 학습 중 모델이 얼마나 잘 예측하고 있는지 수치적으로 보여줌
• 정답과 예측값의 차이를 바탕으로 파라미터를 어떻게 조정할지 결정하게 함
• 모델이 수렴할 수 있도록 손실 값을 최소화하는 방향으로 학습을 유도
• 최적화 과정에서 경사 하강법 등 미분 기반 기법을 사용할 수 있도록 대부분의 손실 함수는 미분 가능하게 설계됨

이처럼 손실함수는 학습이 진행되면서 해당 과정이 얼마나 잘 되고 있는지 나타내는 지표로서 모델이 훈련되는 동안 최소화될 값이다. 주어진 문제에 대한 성공 지표가 되는 것이다.

🖇  Keras의 손실 함수

Keras에서 자주 사용하는 손실 함수 세 가지와 그 특징이다.

1) sparse_categorical_crossentropy

• 클래스 정답이 정수 레이블(예: 0, 1, 2, ...)로 표현될 때 사용 e.g.,  정답 벡터가 [2]인 경우

2) categorical_crossentropy

• 클래스 정답이 원-핫 인코딩(예: [0, 0, 1, 0]) 형태로 제공될 때 사용
• 정답 클래스가 [0, 0, 1, 0]처럼 원-핫 형태로 주어진다면 이 함수를 사용

3) binary_crossentropy

• 이진 분류 문제에서 사용 e.g.,  정답이 0 또는 1인 경우 ([1] 혹은 [0])

🖇  평균절대오차 (MAE)

MAE(Mean Absolute Error)는 예측값과 실제값의 차이의 절댓값을 평균내는 방식으로 계산된다.

$$$ E = \frac{1}{n} \sum_{i=1}^{n} |y_i - \hat{y}_i| $$$

특징

• 오차가 커지더라도 손실 함수 값이 일정하게 증가함 (선형)
• 이상치(outlier)에 비교적 강건(Robust)함
• 이상치에 해당하는 지점에서 손실 함수 값이 크긴 하지만, 그것이 전체 평균값을 왜곡할 정도로 영향력이 크지 않음
• 회귀 문제(Regression)에서 자주 사용됨

좋은 예측을 했을 때 손실은 작고, 틀린 정도에 비례해서 손실이 선형적으로 커진다. 데이터에 노이즈가 있을 가능성이 높을 때 유용하다.

시각적으로 보면 MAE는 예측값이 정답에서 멀어질수록 기울기 1의 직선 형태로 손실이 증가한다. 즉, 예측이 잘못되었을수록 일정하게 페널티를 준다.

🖇  평균제곱오차 (MSE)

MSE(Mean Squared Error)는 오차를 제곱한 뒤 평균을 구하는 방식이다.

$$$ E = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 $$$

특징

• 오차가 커질수록 손실 함수 값이 비선형적으로 급격히 증가 (제곱 함수)
• 큰 오차에 대해 더 많은 페널티를 부여함
• 이상치의 영향을 크게 받음
• 회귀 문제(Regression)에서 자주 사용되고, 특히 이상치가 적다고 판단될 때 선호됨

시각적으로 보면 MSE는 예측값이 정답에서 멀어질수록 곡선 형태로 손실이 급격히 증가한다. 이는 오차가 작을 때는 비교적 완만하지만 큰 오차에 대해서는 매우 민감하게 반응하도록 한다.

🖇  MAE vs MSE

공통점

• 둘 다 회귀 모델에서 예측값과 실제값 사이의 오차를 측정하는 데 사용되는 손실 함수
• 손실 값이 작을수록 예측이 정답과 가까운 것을 의미

차이점

MAE는 오차가 매우 크더라도(outlier) 제곱항으로 영향을 미치는 것이 아니라 차이의 절대값만큼만 영향을 미치기 때문에 MSE에 비해 상대적으로 이상치에 더 강건한 것이다.

즉, 둘 다 오차를 기준으로 총합을 해 평균을 구한다는 것은 동일하지만 각각의 오차를 절대 값으로 다룰지 혹은 제곱 값으로 처리하는지가 다르다.

🖇  교차 엔트로피 오차 (CEE, Cross Entropy Error)

교차 엔트로피는 분류 문제에서 가장 널리 쓰이는 손실 함수다. 이진 분류(binary classification) 또는 다중 클래스 분류(multi-class classification)에 사용된다.

결과적으로 소프트맥스(softmax) 함수의 출력과 실제 정답(원-핫 인코딩) 사이의 차이를 측정한다.

$$$ E = - \sum_{i=1}^{n} y_i \log(\hat{y}_i) $$$

정답을 맞추면 손실이 0에 가까워지고 틀릴수록 로그값 특성에 의해 손실이 급격하게 커진다. 이 함수는 예측 확률이 정답일수록 낮은 손실을, 틀릴수록 매우 큰 손실을 부여한다.

이진 분류 문제의 교차 엔트로피 (Binary Cross Entropy, BCE)

$$$ E = - \sum_{i=1}^{2} y_i \log(\hat{y}_i) $$$

이진 분류에서는 보통 binary_crossentropy를 사용한다. 확률적으로 예측한 값이 실제 정답과 얼마나 가까운지를 평가한다.

🖇  손실 함수 값 계산

이번에는 교차 엔트로피 손실 함수가 실제로 어떻게 계산되는지, 예측이 얼마나 정답에 가까웠는지를 수치로 어떻게 표현하는지 계산해 보자.

예시 1) 다중 분류 문제에서 softmax 출력이 [0.6, 0.1, 0.3]이고 정답이 첫 번째 클래스일 때 (즉, y = [1, 0, 0])

정답 레이블은 원-핫 인코딩 방식으로 표현된다. 정답인 클래스 인덱스에만 1이 있고 나머지는 모두 0인 벡터다.

이때 교차 엔트로피 손실 함수는 아래와 같이 계산된다.

$$ \begin{aligned} E &= 1 \times -\log(0.6) + 0 \times -\log(0.1) + 0 \times -\log(0.3) \ &= -\log(0.6) \ &\approx 0.511 \end{aligned} $$

예측 확률이 0.6인 첫 번째 클래스를 정답으로 예측했을 때 손실 값은 약 0.511이다. 이 값은 모델이 정답을 비교적 잘 예측했다는 뜻이다. 예측이 더 정확해질수록 softmax 확률이 1에 가까워지고, 이 손실 값은 0에 가까워진다.

예시 2) 이진 분류 문제에서 예측값이 0.8일 때

이진 분류에서는 출력값이 1일 확률로 해석된다. 따라서 상황에 따라 손실 함수의 값이 달라진다.

실제 정답이 1일 경우

• $E = -\log(0.8) \approx 0.223$

• 예측값이 0.8이면 정답인 1에 가까운 확률을 준 셈이므로, 손실이 작게 나온다. 예측이 맞을수록 손실이 작아진다는 원리를 잘 보여주는 수치다.

실제 정답이 0일 경우

• $E = -\log(1 - 0.8) = -\log(0.2) \approx 1.609$

• 이 경우는 정답이 0인데 모델은 0.8이라는 높은 확률로 1이라고 예측했다. 틀린 예측을 매우 자신 있게 한 상황이기 때문에 손실 값이 크게 나온다. 이처럼 교차 엔트로피 손실 함수는 틀린 예측을 더 강하게 페널티 주는 구조라는 것을 알 수 있다.

요약하자면,

교차 엔트로피 손실 함수는 "정답 클래스에 얼마나 높은 확률을 줬는지"를 기준으로 손실을 계산한다. 높은 확률로 정답을 예측하면 손실이 작아지고, 틀린 예측을 자신 있게 할수록 손실이 커진다.

인사이트 및 회고

손실 함수는 딥러닝 모델이 학습하는 데 있어 중요하다는 것을 알 수 있었다. 어떤 손실 함수를 선택하느냐에 따라 모델의 학습 방향과 특성이 결정된다. 회귀 문제에서는 MAE와 MSE 중 데이터 특성에 맞는 것을 고르고, 분류 문제에서는 출력 형식(정수인지, 원-핫 인코딩인지)에 따라 적절한 교차 엔트로피 함수를 선택해야 한다.

🖇  기본 임포트 🖇  1. Sequential API 🖇  2. Functional API 🖇  3. Subclassing API 🖇  어떤 방식을 언제 선택해야 할까?

딥러닝 모델을 구성하는 방법에는 여러 가지가 있다. 그중 Keras를 사용할 때는 대부분 3가지 방법 중 하나를 선택하게 된다.

• Sequential API
• Functional API
• Subclassing API

각각의 방식은 구조, 표현력, 유연성에서 차이가 있다.

이 글에서는 세 가지 방법의 개념과 구조, 예제를 비교하면서 어떤 상황에서 어떤 방식을 선택하면 좋을지 정리해 보았다. 각각의 방식이 어떤 구조와 개념적 배경을 갖고 있는지, 왜 그렇게 쓰이는지에 대해 이해하는 과정도 함께 담아보았다.

🖇  기본 임포트

딥러닝 모델을 구현하기 위해서는 TensorFlow와 Keras의 모듈을 임포트해야 한다.

from tensorflow.keras import models, layers, utils
import tensorflow as tf

🖇  1. Sequential API

가장 단순하고 직관적인 방식으로, 순차적인 구조에 적합하다.

Sequential API는 위에서 아래로, 순차적으로 레이어를 쌓아가는 방식이다. 마치 블록을 위에서부터 아래로 쌓듯이 하나씩 레이어를 추가하는 구조다. 입력에서 출력까지 흐름이 단방향이고 직선적이며 분기나 병합이 없다.

MLP 구조나 단순한 CNN 모델에서 주로 사용된다.

• 구현이 간단하고 읽기 쉽지만, 입력이 여러 개이거나 출력이 여러 개인 모델 또는 레이어 간 연결이 복잡한 모델은 표현할 수 없다.

• Sequential API는 내부적으로 자동으로 입력 형태를 추론하고 레이어를 쌓는 방식이기 때문에 디버깅이나 복잡한 흐름 제어가 어렵다.

예제 1:   add() 메서드로 레이어 추가

model = models.Sequential()
model.add(layers.Input(shape=(28, 28)))
model.add(layers.Dense(300, activation='relu'))
model.add(layers.Dense(100, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
model.summary()
utils.plot_model(model, show_shapes=True)

예제 2:   리스트 형태로 레이어 정의

model = models.Sequential([
    layers.Input(shape=(28, 28), name='Input'),
    layers.Dense(300, activation='relu', name='Dense1'),
    layers.Dense(100, activation='relu', name='Dense2'),
    layers.Dense(10, activation='softmax', name='Output')
])
model.summary()
utils.plot_model(model, show_shapes=True)

🖇  2. Functional API

모듈처럼 조립하는 방식으로, 유연하고 복잡한 모델을 표현할 수 있다.

Functional API는 각 레이어를 함수처럼 조립하듯 연결하는 방식이다. Sequential 방식보다 훨씬 유연해서 다음과 같은 구조도 표현할 수 있다.

• 다중 입력/출력
• 병렬 네트워크
• 중간 결과 재활용
• 스킵 연결

입출력 텐서를 변수처럼 다루고, 그 사이를 함수 형태로 연결하는 개념이다. 모델 흐름이 눈에 잘 보이고, 재사용과 디버깅도 편해서 많이 사용된다. 또한 모델을 시각화하거나 구조적으로 설명할 때도 명확하다.

예제 1:   단일 입력/출력 기본 구조

inputs = layers.Input(shape=(28, 28, 1))
x = layers.Flatten()(inputs)
x = layers.Dense(300, activation='relu')(x)
x = layers.Dense(100, activation='relu')(x)
outputs = layers.Dense(10, activation='softmax')(x)

model = models.Model(inputs=inputs, outputs=outputs)
model.summary()
utils.plot_model(model, show_shapes=True)

예제 2:   입력과 은닉층 결과를 연결 (Concatenate)

inputs = layers.Input(shape=(28, 28))
hidden1 = layers.Dense(100, activation='relu')(inputs)
hidden2 = layers.Dense(30, activation='relu')(hidden1)
concat = layers.Concatenate()([inputs, hidden2])
output = layers.Dense(1)(concat)

model = models.Model(inputs=inputs, outputs=output)
model.summary()
utils.plot_model(model, show_shapes=True)

예제 3:   다중 입력 + 다중 출력

입력이 두 개, 출력이 두 방향으로 나뉘는 복잡한 구조를 구현할 수 있다. 예측 문제를 분기하거나 멀티태스크 학습 등에서 유용하게 사용된다.

input_1 = layers.Input(shape=(40,), name="Input_1")
input_2 = layers.Input(shape=(10,), name="Input_2")

x1 = layers.Dense(100, activation='relu')(input_1)
x2 = layers.Dense(100, activation='relu')(input_2)

concat = layers.Concatenate()([x1, x2])
output_1 = layers.Dense(1, name="dense_2")(concat)

x = layers.Dense(40, activation='relu', name="dense_3")(concat)
output_2 = layers.Dense(10, name="dense_4")(x)

model = models.Model(inputs=[input_1, input_2], outputs=[output_1, output_2])
model.summary()
utils.plot_model(model, show_shapes=True)

🖇  3. Subclassing API

클래스로 모델을 정의하는 방식으로, 완전한 자유도를 제공한다.

Subclassing 방식은 Model 클래스를 상속받아 모델을 직접 정의하는 방식이다. 모델 구성뿐 아니라 call() 함수에서 레이어 흐름도 직접 제어할 수 있어서 가장 자유롭다.

• 조건문, 반복문 등 파이썬 코드와 결합해 동적 구조를 구현할 수 있다.
• 강화학습, RNN, 조건부 분기 네트워크 같은 복잡한 구조에서 특히 유용하다.

Functional API조차 표현할 수 없는 커스텀 로직을 필요로 할 때 사용하는 방식이다. 다만 자유도가 높은 만큼 코드가 복잡하고 디버깅이 어려울 수 있다.

예제:   Functional에서 만든 모델을 Subclassing으로 구현

class CustomModel(models.Model):
    def __init__(self):
        super().__init__()
        self.dense1 = layers.Dense(100, activation='relu')
        self.dense2 = layers.Dense(100, activation='relu')
        self.concat = layers.Concatenate()
        self.output1 = layers.Dense(1, name="dense_2")
        self.shared = layers.Dense(40, activation='relu', name="dense_3")
        self.output2 = layers.Dense(10, name="dense_4")

    def call(self, inputs):
        input1, input2 = inputs
        x1 = self.dense1(input1)
        x2 = self.dense2(input2)
        merged = self.concat([x1, x2])
        out1 = self.output1(merged)
        x = self.shared(merged)
        out2 = self.output2(x)
        return [out1, out2]

# 입력 테스트
input1 = tf.random.normal([32, 40])
input2 = tf.random.normal([32, 10])
model = CustomModel()
output = model([input1, input2])
model.summary()

🖇  어떤 방식을 언제 선택해야 할까?

Keras의 세 가지 딥러닝 모델 구현 방식 중 어떤 방식을 어떨 때 사용하면 좋을지 정리해 보았다.

• 구조가 단순하고 빠르게 테스트하고 싶다면 → Sequential
• 모델 구조가 조금이라도 복잡하거나 시각화가 필요하다면 → Functional
• 학습 중 동적인 조건 분기나 반복이 필요하다면 → Subclassing

인사이트 및 회고

딥러닝 모델을 구성할 수 있는 방법은 다양하지만, 가장 많이 사용되는 세 가지 방식과 그 특징을 함께 살펴보았다.

Sequential API는 빠르게 실습할 때 편하고, Functional API는 대부분의 실무 모델을 다룰 수 있으며, Subclassing은 복잡한 사용자 정의 구조를 구현할 때 사용할 수 있겠다는 것을 알 수 있었다.

더 다양한 예제로 세 가지 방법의 차이와 쓰임새를 체득할 수 있도록 비교해 보아야겠다. 구조를 잘 이해하면 어떤 방식으로든 딥러닝 모델을 자유롭게 설계할 수 있을 거라 기대한다.

🖇  1. 딥러닝 모델의 구조 🖇  2. 레이어란? 🖇  3. 주요 레이어의 종류와 예시 🖇  4. 활성화 함수 종류와 특징 🖇  5. 레이어 예제: Dense Layer와 랜덤 입력

딥러닝 모델을 만들기 위해서는 모델의 구성 요소들이 어떤 역할을 하고, 어떻게 연결되는지를 정확히 이해해야 한다.

이 글에서는 Keras에서 딥러닝 모델을 구성할 때 활용하는 주요 API 구조와 레이어(Layer)의 개념, 종류, 특징, 실제 코드 사용법의 순서로 정리해 보았다.

입력 → 레이어 → 출력 → 손실 함수로 이어지는 기본 흐름을 바탕으로 딥러닝 모델이 내부적으로 어떻게 작동하는지 감을 잡는 데 도움이 될 것이라 생각한다.

🖇  1. 딥러닝 모델의 구조

딥러닝 모델은 여러 구성 요소로 나뉘고, Keras에서는 크게 세 가지 API 계층으로 볼 수 있다.

• Core Modules API: 딥러닝의 기본을 이루는 요소들이 포함된다. 모델을 학습하고 평가할 때 꼭 필요한 기능들이다.

• Model API: 모델 구조를 정의하는 방식이다. Sequential API는 레이어를 순서대로 쌓는 방식이고, Functional API는 더 복잡한 모델을 만들 수 있는 함수형 연결 방식이다. 이와 관련해서는 다음 글에서 다뤄 볼 예정이다.

• Layer API: 실제로 모델을 구성하는 레이어들을 정의한다.문제 유형과 데이터 형태에 따라 적절하게 선택해서 조합한다.

이처럼 Keras는 세 가지 API를 통해 딥러닝 모델을 구성하는 전체 구조를 레고 블록처럼 조립할 수 있게 해준다. 각각의 구성요소는 독립적이지만 조합해서 더 강력한 모델을 만드는 게 가능하다.

🖇  2. 레이어란?

딥러닝 모델은 여러 개의 레이어(Layer) 로 구성된다.

레이어는 딥러닝 모델에서 정보를 처리하는 기본 단위라고 생각할 수 있다. 구조는 일반적으로 다음과 같다.

• 입력층 (Input Layer)
• 은닉층 (Hidden Layer)
• 출력층 (Output Layer)

[Input Layer] → [Hidden Layer 1] → [Hidden Layer 2] → ... → [Output Layer]

각 레이어는 입력 데이터를 받아서 가중치와 바이어스를 적용하고, 활성화 함수를 통해 출력을 변환한다. 이렇게 변환된 출력은 다음 레이어로 전달되고, 이런 과정이 반복되면서 점점 더 복잡한 함수를 학습하게 된다. 결국 이 구조가 딥러닝 모델의 핵심인 것이다.

💡 쉽게 말하면, 레이어는 정보를 점점 더 복잡하게 바꿔주는 필터 역할을 한다고 보면 된다. 하나의 레이어는 간단한 연산만 하더라도 여러 개가 쌓이면 복잡한 패턴도 잘 잡아낸다.

🖇  3. 주요 레이어의 종류와 예시

1) Input 객체

모델의 입력 형상을 정의할 때 사용한다. shape, dtype, batch_size, name 등을 설정할 수 있다.

keras.Input(shape=(28, 28), dtype=tf.float32)
keras.Input(shape=(28, 28), dtype=tf.float32, batch_size=16, name='input')

Input은 말 그대로 모델에 데이터를 넣는 입구 역할이다. 모델 설계 시 가장 먼저 정의해 줘야 한다.

2) Dense Layer (완전연결층)

모든 입력 노드와 출력 노드를 연결하는 기본 레이어다. (Fully Connected) 유닛 수를 지정하면 해당 개수만큼의 뉴런이 만들어진다. name, activation 등도 설정 가능하다.

layers.Dense(10)
layers.Dense(10, name='layer1')
layers.Dense(10, activation='relu', name='dense_layer')

입력 뉴런:    x₁     x₂     x₃
              \    |    /
               \   |   /
                \  |  /
                 \ | /
              Dense Layer
                 / | \
                /  |  \
               y₁     y₂  ← 출력 뉴런

이렇게 입력의 모든 노드가 출력의 모든 노드에 연결돼 있어서 모든 조합에 대해 계산이 이루어지는 구조다.

대부분의 MLP에서 가장 많이 쓰이는 레이어로, 뉴런마다 입력을 모두 받아서 가중치 곱을 수행한 뒤 바이어스를 더한다.

3) Flatten Layer

다차원 입력을 1차원으로 변환해주는 레이어다. 주로 CNN 모델에서 Fully Connected Layer로 연결할 때 사용한다.

inputs = keras.Input(shape=(28, 28, 1))
layer = layers.Flatten()(inputs)
print(layer.shape)  # 출력: (None, 784)

Flatten은 CNN에서 마지막에 Dense와 연결하기 전에 꼭 필요하다. (e.g., MNIST 숫자 분류에서 28x28 이미지를 784 벡터로 펴기)

4) Activation Layer

활성화 함수만 따로 쓰고 싶을 때 사용하는 레이어다. Dense 안에 넣을 수도 있지만, 더 명시적으로 표현할 수 있다. 비선형성을 추가해서 복잡한 함수 근사가 가능해진다.

layer = layers.Activation('relu')

명시적으로 레이어를 나눔으로써 네트워크 구조가 더 읽기 쉬워지고, 중간에 수정하거나 실험할 때 유리하다.

🖇  4. 활성화 함수 종류와 특징

1) Sigmoid 함수

• 출력이 0과 1 사이로 제한됨
• 확률을 예측하는 이진 분류에서 자주 쓰임
• 포화 영역에서는 gradient가 거의 0에 가까워져서 학습이 느려질 수 있음 (vanishing gradient 문제)

2) tanh (하이퍼볼릭 탄젠트)

• 출력 범위가 -1에서 1 사이
• 중심이 0이라서 sigmoid보다 학습이 더 빠르게 수렴하는 경우가 많음
• 여전히 포화 구간 문제는 존재함

3) ReLU (Rectified Linear Unit)

• 입력이 0보다 크면 그대로 출력, 작으면 0 출력
• 계산이 빠르고 성능이 좋아서 가장 널리 사용됨
• 다만, 음수 입력에 대해서는 gradient가 0이 되면서 뉴런이 죽는 문제가 있음 (dying ReLU)

4) Leaky ReLU

• ReLU의 단점을 보완한 함수
• 음수 입력에 대해 작은 음수 값으로 출력해서 dying ReLU 문제를 완화함

5) ELU (Exponential Linear Unit)

• 음수 입력에서도 gradient가 남도록 설계됨
• 0 이하에서는 exponential 연산을 사용해서 계산량이 많아지는 단점이 있음

ReLU와 그 변형 함수들은 대부분의 모델에서 성능이 잘 나오기 때문에 기본값처럼 사용된다. 상황에 따라 적절한 선택이 필요하다.

🖇  5. 레이어 예제: Dense Layer와 랜덤 입력

inputs = tf.random.uniform(shape=(5, 2))
layer = layers.Dense(10, activation='relu')
outputs = layer(inputs)
print(layer.weights)
print(layer.bias)
print(outputs)

이 코드는 5×2 크기의 입력 데이터를 무작위로 만든 다음, Dense 레이어를 거쳐서 출력 결과와 가중치, 바이어스를 출력해 보는 예시다. 레이어 내부에서 어떤 연산이 이루어지는지 직접 확인해볼 수 있다.

출력 결과를 보면 레이어가 입력 데이터를 어떻게 처리하고 변환하는지 눈으로 확인할 수 있어서 직관적인 학습에 도움이 된다.

인사이트 및 회고

딥러닝 모델은 다양한 구성 요소와 레이어로 이루어져 있고, 각각의 레이어는 입력 데이터를 가공해서 다음 단계로 전달하는 역할을 한다.

모델 구조는 Sequential 방식으로 간단하게 쌓을 수도 있고, Functional 방식으로 유연하게 만들 수도 있다는 것을 알 수 있었다.

Input 객체로 입력을 정의하고, Dense나 Flatten, Activation 같은 레이어들을 조합해서 모델을 구성하게 된다. 또, 어떤 활성화 함수를 쓰느냐에 따라서 학습 속도와 성능이 달라질 수 있으니까 그 특성을 잘 이해하고 모델에 맞는 걸 선택하는 것이 중요하겠다.

이런 기본 개념들을 잘 익히고 직접 실습해본다면 딥러닝을 좀 더 이해할 수 있을 거라 생각한다.

🖇  1. 텐서란 무엇인가 🖇  2. 텐서의 차원별 구조 🖇  3. 텐서 생성 🖇  4. 텐서 변환 🖇  5. 텐서 연산

딥러닝을 이해하려면 텐서(Tensor)의 개념부터 정확히 짚고 넘어가야 한다.

텐서는 딥러닝 모델에서 데이터를 표현하고 전달하는 기본 단위로, 스칼라부터 고차원 배열까지 다양한 형태로 존재한다. TensorFlow에서는 텐서를 정의하고 연산하는 방식이 직관적이지만 연산 중 발생할 수 있는 타입 오류나 차원 불일치는 종종 혼란을 야기할 수 있다.

이 글에서는 텐서의 구조와 연산 방식, 자주 사용하는 함수들을 코드와 함께 정리하고, 실제 연산 결과를 통해 동작 원리를 직관적으로 이해하는 데 초점을 맞추었다. 텐서의 기본기가 제대로 잡혀있어야 이후의 모델링과 실험에서 시행착오를 줄일 수 있을 거라 생각한다.

🖇  1. 텐서란 무엇인가

텐서(Tensor)는 데이터 구조이면서 딥러닝 모델의 핵심 데이터 단위로 작동한다.

입력 데이터, 가중치, 출력, 손실값 등 모든 요소가 텐서 형태로 표현되며 이들은 GPU에서의 연산에 최적화되어 빠르고 효율적으로 처리된다.

간단히 말하면 텐서는 수치 데이터를 표현하는 다차원 배열(multidimensional array) 이다. Python의 리스트나 Numpy 배열과 유사하지만 텐서는 딥러닝 연산을 위한 특화 기능과 속성을 포함하고 있다. 일반적으로 수치형 데이터를 저장하고, 동적 크기를 가진다. 텐서 구조를 제대로 이해하는 것은 딥러닝 모델을 자유자재로 구성하고 디버깅하는 데에 꼭 필요하다.

[출처] 모두의연구소 LMS 텐서 표현과 연산

텐서의 세 가지 핵심 속성

• Rank: 축(axis)의 개수, 즉 차원 수를 의미한다. 예를 들어 0D는 스칼라, 1D는 벡터, 2D는 행렬, 3D는 시계열 데이터, 4D는 이미지 등이다.

• Shape: 각 축의 크기를 나타내는 튜플이다. 예를 들어 (3, 4)는 3행 4열의 2D 텐서를 뜻한다.

• Data Type (dtype): 저장된 값의 자료형으로 float32, int32, bool, string 등 다양한 타입이 존재한다.

텐서를 제대로 이해하기 위해서는 다양한 차원의 구조를 직접 눈으로 보고 경험하는 것이 필요하다.

🖇  2. 텐서의 차원별 구조

텐서의 차원 수는 곧 데이터의 구조를 의미한다. 데이터가 어떤 형태를 가지고 있는지 이해하려면 각 차원의 의미를 알아야 한다.

아래는 차원별 텐서의 구조와 예시를 코드와 살펴본 것이다.

# 0D 텐서 (스칼라)
scalar = tf.constant(7)
print(scalar.shape)  # 출력: ()

# 1D 텐서 (벡터)
vector = tf.constant([1.0, 2.0, 3.0])
print(vector.shape)  # 출력: (3,)

# 2D 텐서 (행렬)
matrix = tf.constant([[1, 2, 3], [4, 5, 6]])
print(matrix.shape)  # 출력: (2, 3)

# 3D 텐서 (시계열 데이터)
time_series = tf.random.normal(shape=(10, 5, 2))  # 10개 샘플, 5개의 타임스텝, 2개 특성
print(time_series.shape)  # 출력: (10, 5, 2)

# 4D 텐서 (이미지 배치)
images = tf.random.normal(shape=(32, 64, 64, 3))  # 32개의 RGB 이미지
print(images.shape)  # 출력: (32, 64, 64, 3)

# 5D 텐서 (비디오)
videos = tf.random.normal(shape=(16, 10, 64, 64, 3))  # 16개 비디오, 각 10프레임, 64x64 RGB
print(videos.shape)  # 출력: (16, 10, 64, 64, 3)

이처럼 차원이 올라갈수록 더 복잡한 데이터를 표현할 수 있고, 실제 모델에서 자주 사용되는 구조도 함께 익혀두는 것이 좋다. 아래에서 각 차원별 텐서 구조의 특징을 조금 더 자세히 살펴보자.

0D Tensor (Scalar)

• 축이 없는 텐서이며 단일 값을 담고 있다.
• 예: tf.constant(1)

t0 = tf.constant(1)
print(t0)              # 출력: 1
print(tf.rank(t0))     # 출력: 0

1D Tensor (Vector)

• 하나의 축을 가지는 텐서로, 값들의 리스트와 유사하다.
• 예: tf.constant([1, 2, 3])

t1 = tf.constant([1, 2, 3])
print(t1)
print(tf.rank(t1))     # 출력: 1

2D Tensor (Matrix)

• 두 개의 축을 가지며 행과 열의 구조로 데이터를 저장한다.
• 통계 데이터, 샘플과 특성 구조에 사용됨

t2 = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(t2)
print(tf.rank(t2))     # 출력: 2

3D Tensor

• 세 개의 축을 가지며 주로 시계열 또는 순차적 데이터 표현에 사용된다.
• 축 예시: (samples, timesteps, features)

t3 = tf.constant([[[1, 1], [2, 2]], [[3, 3], [4, 4]]])
print(t3)
print(tf.rank(t3))     # 출력: 3

4D Tensor

• 네 개의 축을 가지며 주로 컬러 이미지 데이터에서 사용된다.
• 축 예시: (samples, height, width, channels)
• 흑백 이미지는 3D 텐서로 표현 가능함

5D Tensor

• 다섯 개의 축을 가지며 비디오 데이터처럼 시간 축까지 포함된 경우에 사용된다.
• 축 예시: (samples, frames, height, width, channels)

🖇  3. 텐서 생성

tf.constant()는 텐서를 생성하는 가장 기본적인 방법으로, 초기값을 고정된 값으로 설정할 때 사용된다.

데이터 타입(dtype)을 명시하면 연산 중 타입 불일치를 방지할 수 있고, 모델의 메모리 효율성도 조절할 수 있다.

• 정수형 텐서는 카운팅 작업에 자주 사용
• 실수형 텐서는 대부분의 연산 (가중치, 손실 등)에 활용
• 문자열 텐서는 레이블 인코딩, 토큰 처리 등에 사용

# 정수형 텐서 (기본: int32)
i = tf.constant(2)
print(i)

# 실수형 텐서 (기본: float32)
f = tf.constant(2.)
print(f)

# 문자열 텐서
s = tf.constant("Suan")
print(s)

# dtype 명시 생성
f16 = tf.constant(2., dtype=tf.float16)
print(f16)

i8 = tf.constant(2, dtype=tf.int8)
print(i8)

텐서의 타입

Data Type	TF Type	설명
DT_FLOAT	tf.float32	32비트 부동 소수
DT_FLOAT64	tf.float64	64비트 부동 소수
DT_INT8	tf.int8	8비트 정수
DT_INT32	tf.int32	32비트 정수 (기본값)
DT_UINT8	tf.uint8	부호 없는 8비트 정수
DT_STRING	tf.string	문자열 (바이트 배열 형태)
DT_BOOL	tf.bool	불리언 타입
DT_COMPLEX64	tf.complex64	복소수 (실수+허수 각 32비트)
DT_QINT8	tf.qint8	정수형 양자화 연산용
DT_QUINT8	tf.quint8	부호 없는 양자화 정수

🖇  4. 텐서 변환

타입 변환

tf.cast()는 텐서의 데이터 타입을 변환할 때 사용된다.

• 예를 들어, int와 float 타입을 더하려고 할 때 오류가 발생할 수 있는데, 이때 타입을 맞춰주는 것이 중요하다.
• 정확한 연산을 위해선 tf.float32, tf.int32 등 원하는 타입으로 명시적 변환이 필요하다.

f32 = tf.cast(f16, tf.float32)
print(f32)

형상 변환

tf.reshape()은 텐서의 전체 원소 수를 유지하면서 형태만 바꿔준다.

• 주로 모델 입력에 맞게 데이터를 변환할 때 사용된다.
• CNN에서 Flatten하거나, RNN에 넣기 위해 (batch, time, feature) 형태로 바꿀 때 유용하다.

x = tf.constant([[1], [2], [3]])
print(x.shape)

y = tf.reshape(x, [1, 3])
print(y)

전치 (Transpose)

tf.transpose()는 행과 열 또는 다차원 텐서의 축을 뒤집을 때 사용된다.

• 주로 행렬 곱셈 전, 이미지 채널 순서 변경, attention 모델 내부에서 key/query 전치 등에서 자주 쓰인다.

print(tf.transpose(y))

차원 압축/추가

tf.squeeze()는 차원 중 1인 차원을 제거한다.
반대로, tf.expand_dims()는 새로운 축을 추가한다.

• 이 연산들은 모델 입력 형식을 맞출 때 필수적으로 사용된다.
• 예를 들어 (28, 28) 이미지를 CNN에 넣기 위해 (28, 28, 1)로 확장하는 것이 대표적이다.

print(tf.squeeze([[1], [2]]))
print(tf.expand_dims([1, 2], axis=0))
print(tf.expand_dims([1, 2], axis=1))

텐서 분리 및 연결

tf.split()은 하나의 텐서를 여러 조각으로 나누고,
tf.concat()은 여러 텐서를 하나로 붙일 수 있다.

• 예를 들어 배치된 데이터를 여러 GPU에 나누거나, 다양한 소스의 데이터를 하나로 합치는 데 활용된다.

print(tf.split(x, 3))               # 3개로 분리
print(tf.concat([x, x], axis=0))    # 연결 (행 방향)
print(tf.concat([x, x], axis=1))    # 연결 (열 방향)

🖇  5. 텐서 연산

딥러닝 모델은 텐서를 중심으로 구성되기 때문에 텐서 연산은 데이터를 변환하고 모델을 구성하는 데 중요하게 작용한다.

산술 연산 (0D)

0차원(스칼라) 텐서 간 연산은 Python의 기본 수치 연산과 매우 유사하게 동작한다. 연산 결과 역시 0D 스칼라로 반환되고, 텐서플로우 내부에서는 모두 tf.Tensor 객체로 처리된다.

print(tf.constant(2) + tf.constant(2))
print(tf.constant(2) - tf.constant(2))
print(tf.multiply(2, 3))
print(tf.divide(4, 2))

텐서 타입 불일치와 캐스팅

TensorFlow는 타입이 다른 텐서 간 연산을 자동으로 허용하지 않기 때문에 연산 전 tf.cast()로 명시적 형 변환이 필요히다. 모델 구현 중에서도 정수형 인덱스와 실수형 확률값을 혼용할 경우 이런 오류가 자주 발생한다.

# 오류: int + float
# tf.constant(2) + tf.constant(2.2)

# 해결: 타입 캐스팅
print(tf.cast(tf.constant(2), tf.float32) + tf.constant(2.2))

1D, 2D 텐서 연산

연산 대상이 2D 텐서인 경우, 같은 위치에 있는 원소끼리 연산이 수행된다. 단, 두 텐서의 shape이 다르더라도 연산이 가능한 경우가 있는데 이를 브로드캐스팅(broadcasting) 이라고 한다.

• 예를 들어 (2, 3) 텐서와 (1, 3) 텐서를 더하면 (2, 3) 형태로 자동 확장되어 연산된다.

# 2D 텐서
a = tf.constant([[1, 2], [3, 4]])
b = tf.constant([[5, 6], [7, 8]])

print(a + b)
print(a - b)
print(a * b)
print(a @ b)  # 행렬곱
print(a / b)

함수형 연산 방식

Python 연산자(+, -, *, /, @)를 직접 사용해도 되지만, 동일한 기능을 수행하는 TensorFlow의 함수형 API(tf.add(), tf.matmul() 등)를 사용하는 것이 가독성과 확장성 측면에서 유리할 때가 많다.

print(tf.add(a, b))
print(tf.subtract(a, b))
print(tf.multiply(a, b))
print(tf.matmul(a, b))
print(tf.divide(a, b))

유용한 함수들

x = tf.constant([[4.0, 5.0, 6.0], [10.0, 9.0, 8.0]])

print(tf.reduce_max(x))     # 최대값
print(tf.argmax(x))         # 최대값의 위치
print(tf.nn.softmax(x))     # 소프트맥스 결과

텐서 함수 정리

복잡한 모델을 구현할 때 텐서의 모양을 바꾸거나 데이터를 나누고 붙이는 작업이 빈번하게 발생한다. 이때 유용하게 사용되는 주요 함수들이다.

함수	설명
tf.shape	텐서 구조 확인
tf.size	전체 원소 수 확인
tf.rank	차원 수 확인
tf.reshape	형상 재구성
tf.squeeze	1인 차원 제거
tf.expand_dims	축 추가
tf.slice	슬라이싱
tf.split	분할
tf.concat	연결
tf.tile	반복 생성
tf.reverse	역순 배열
tf.transpose	전치
tf.gather	인덱싱 수집

텐서 연산 정리

앞서 실습한 텐서 연산들을 기호별로 정리하였다.

인사이트 및 회고

TensorFlow의 텐서 구조와 연산을 실습하면서 내부 작동 원리를 직관적으로 이해할 수 있었다. 막연하게 딥러닝에서 사용되는 라이브러리라고 이해하고 있었는데 제대로 짚고 넘어갈 수 있었다.

0D부터 2D까지 다양한 차원의 텐서를 다뤄보며 shape와 rank의 개념이 확실히 정리되었고, 타입 미스매치나 차원 불일치로 인한 오류 발생 시 해결 방향도 생각해 볼 수 있었다.

연산 방식의 차이(연산자 vs 함수형 API)를 비교하면서 코드 가독성과 안정성을 어떻게 고려할 수 있을지도 중요한 포인트라고 생각한다. 실제 모델링 전에 텐서 조작 흐름을 전체적으로 정리할 수 있는 유익한 시간이었다.

🖇  1. 인공신경망과 딥러닝 🖇  2. 전통적 신경망 vs 딥러닝 신경망 🖇  3. 기울기 소멸 문제 🖇  4. 과적합과 일반화 문제 🖇  5. 딥러닝 최신 트렌드

앞선 글에서 살펴봤듯이 딥러닝은 인공지능 분야에서 가장 빠르게 발전하고 있는 기술 중 하나로, 다양한 분야에 적용되어 탁월한 성능을 보여주고 있다. 특히 컴퓨터 비전, 자연어 처리, 음성 인식, 자율주행 등에서 혁신적인 성과를 만들어내며 주목받고 있다.

이러한 딥러닝의 중심에는 인공신경망(Artificial Neural Network)이라는 핵심 개념이 존재한다. 이 글에서는 인공신경망의 구조와 원리를 시작으로, 딥러닝 기술이 어떻게 발전해왔고 어떤 방식으로 작동하는지 정리해 보았다.

🖇  1. 인공신경망과 딥러닝

인공신경망(Artificial Neural Network)은 인간의 뇌를 수학적으로 모델링한 구조다. 입력 데이터를 받아 일정한 연산 과정을 통해 출력값을 내는 계산 네트워크로, 딥러닝은 이러한 인공신경망을 다층으로 쌓아 복잡한 문제를 해결하는 방식이다.

일반적으로 인공신경망은 1~2개의 은닉층(hidden layer)을 가진 얕은 구조였다. 반면 딥러닝은 수십 개 이상의 은닉층을 포함하며, 이로 인해 심층신경망(Deep Neural Network)이라 불린다. 많은 층을 통해 입력 데이터의 다양한 특성(feature)을 점차 추상화하며 이미지 분류나 음성 인식처럼 복잡한 문제를 해결하는 데 유용하게 작용하고 있다.

계층별 정보 처리 방식

• 입력층(input layer): 원본 데이터를 받는다
• 은닉층(hidden layers): 데이터의 패턴을 점점 고차원적으로 표현
• 출력층(output layer): 최종 예측값이나 결과를 출력

💡 예를 들어,

얼굴 인식 문제에서는 처음 은닉층이 픽셀의 밝기 등을 구분하고, 다음 층은 테두리(edge), 윤곽선, 눈·코·입과 같은 구조적 특징을 인식하여, 마지막 출력층에서는 해당 인물이라는 최종 클래스를 예측하는 방식이다.

🖇  2. 전통적 신경망 vs 딥러닝 신경망

기존의 신경망은 데이터를 입력받기 전에 사람이 직접 특징을 추출하여 사용했다. 이미지 데이터라면 색상 히스토그램이나 가장자리 위치 등을 사람이 정의한 feature vector로 변환한 뒤 신경망의 입력으로 사용했다.

이런 방식은 특징 추출 품질이 전체 성능에 큰 영향을 준다는 단점이 있었고, 좋은 성능을 내기 위해 도메인 지식이 필요했다.

반면 딥러닝 신경망은 특징 추출과 학습을 동시에 수행한다. 데이터로부터 의미 있는 표현을 자동으로 학습하고, 그 위에 모델을 쌓아 최종적인 예측을 한다. 이로 인해 성능과 범용성 측면에서 기존 방식보다 뛰어난 결과를 보여준다.

특징 추출을 포함한 딥러닝의 장점

• 자동화: 사람이 개입하지 않아도 학습 데이터에서 직접 특징을 학습함
• 범용성: 도메인에 관계없이 적용 가능하며 특징 설계 부담을 줄임
• 성능 향상: 고차원적이고 추상적인 특징을 학습할 수 있어 예측 정확도가 높아짐

이처럼 딥러닝은 높은 성능과 뛰어난 확장성으로 인해 이미지 처리, 자연어 처리, 음성 인식 등 다양한 분야에서 널리 활용되고 있다.

하지만 그만큼 많은 파라미터(parameter)를 학습해야 하기 때문에, 다음과 같은 부담이 존재한다.

딥러닝 신경망의 문제점

• 많은 데이터 요구: 자동 특징 학습에는 대량의 라벨된 데이터가 필요함
• 학습 비용: 연산량과 메모리 사용이 커서 고성능 하드웨어가 필요함
• 해석 불가능성: 결과는 뛰어나지만, 내부 결정 과정을 이해하기 어려움

이러한 단점들을 극복하기 위한 연구가 활발히 이루어지고 있으며, 설명 가능한 인공지능(XAI) 등의 분야가 이에 해당한다.

💡 딥러닝의 발전과 주요 인물

• 제프리 힌튼(Geoffrey Hinton): 역전파 알고리즘, 볼츠만 머신, 딥러닝 혁신 주도
• 조슈아 벤지오(Yoshua Bengio): 시퀀스 모델, 어텐션 메커니즘 등 자연어 처리 발전 기여
• 얀 르쿤(Yann LeCun): 컨볼루션 신경망(CNN)과 시각 인식 시스템 발전
  이들은 2018년 튜링상을 공동 수상하며 딥러닝의 대중화와 이론적 기초를 동시에 확립했다.

🖇  3. 기울기 소멸 문제

딥러닝에서는 역전파(backpropagation)를 통해 오차를 출력층에서 입력층 방향으로 전달하며 가중치를 업데이트한다. 하지만 층이 깊어질수록 기울기(gradient)가 작아져 거의 0에 가까워지는 현상이 발생할 수 있다. 이를 기울기 소멸(Vanishing Gradient) 문제라고 한다.

기울기 소멸은 주로 시그모이드(sigmoid), 쌍곡탄젠트(tanh)와 같은 비선형 함수에서 나타난다. 이로 인해 초깃값과 상관없이 가중치가 거의 업데이트되지 않는 문제가 발생한다.

이 문제는 딥러닝 초기 학습이 어려운 원인 중 하나였고, 이후 ReLU 같은 새로운 활성화 함수와 배치 정규화(batch normalization) 기법이 대안으로 제시되었다.

🖇  4. 과적합과 일반화 문제

딥러닝 모델은 복잡도가 크기 때문에 과적합(overfitting)이 자주 발생한다. 과적합이란 학습 데이터에는 잘 맞지만 보지 못한 새로운 데이터에 대해서는 성능이 떨어지는 상태를 말한다.

• 과적합(overfitting): 학습 데이터에 지나치게 특화됨
• 과소적합(underfitting): 모델이 너무 단순하거나 학습이 부족해 데이터를 제대로 설명하지 못함

과적합을 방지하는 방법

• 규제화(Regularization) : 큰 가중치 값에 큰 규제를 가하여 과적합되지 않도록 모델을 제한 : 규제의 강도를 정하는 적절한 가중치가 중요

• 드롭아웃(Dropout) : 학습 시 임의로 일부 노드의 출력을 제거해 일반화 능력을 높임

• 배치 정규화(Batch Normalization) : 모델에 입력되는 샘플들을 균일하게 만드는 방법 : 미니 배치 단위로 평균이 0, 표준편차가 1이 되도록 정규화

이러한 기법들은 딥러닝 모델의 일반화 성능을 높이는 데 중요한 역할을 한다.

🖇  5. 딥러닝 최신 트렌드

딥러닝은 최근 다양한 학습 패러다임을 받아들이며 더욱 확장되고 있다.

• 전이 학습(Transfer Learning) : 대규모 데이터로 미리 학습한 모델을 다른 문제에 응용

• 자기지도학습(Self-supervised Learning) : 라벨 없이 스스로 학습하도록 설계

• 메타 학습(Meta Learning) : 학습하는 방법을 학습함으로써 적은 데이터로도 빠르게 학습

• 설명 가능한 인공지능(XAI) : 신경망 내부 작동을 이해 가능하도록 설명 모델 개발

• NAS(Neural Architecture Search) : 최적의 신경망 구조를 자동으로 탐색

• AutoML : 강화학습 기반으로 최적 모델 구조를 생성

이러한 기법들은 복잡한 문제를 더 빠르고 효과적으로 해결하기 위한 노력의 일환이다.

주요 딥러닝 프레임워크

• TensorFlow: 구글이 주도하여 개발한 프레임워크로, 다양한 언어와 플랫폼 지원
• Keras: 사용자 친화적인 고수준 API로 빠른 프로토타이핑 가능
• PyTorch: 유연하고 직관적인 코드 구조로 연구 개발자들이 선호
  이러한 프레임워크 덕분에 모델 구축과 실험이 쉬워졌고, 산업과 학계의 접점이 넓어졌다.

인사이트 및 회고

딥러닝은 단순한 인공신경망에서 출발해 오늘날의 고도화된 지능형 시스템으로 발전했다는 점이 흥미롭게 다가왔다. 다양한 구조, 학습 알고리즘, 프레임워크의 등장으로 앞으로도 더 많은 응용 가능성이 기대된다.

지금은 데이터의 양과 질, 모델의 구조, 학습 방식의 최적화가 모두 중요하게 작용하는 시대라고 생각한다. 이러한 딥러닝 기술을 정확히 이해하고 발전 방향을 읽는 것은 앞으로의 인공지능 분야에서 중요한 기반으로 작용할 수 있을 것이다.

🖇  1. 퍼셉트론(Perceptron)이란? 🖇  2. 퍼셉트론: AND 연산 🖇  3. 퍼셉트론: XOR 문제 🖇  4. 퍼셉트론의 한계 🖇  5. 다층 퍼셉트론(MLP)의 등장 🖇  6. MPL 학습 한계 🖇  7. MPL 학습 한계 해결

퍼셉트론은 입력과 가중치의 선형 결합을 바탕으로 이진 분류를 수행하는 가장 기본적인 인공 신경망 구조이다.

AND, OR처럼 선형적으로 구분 가능한 문제는 퍼셉트론 하나로 해결할 수 있지만, XOR처럼 비선형적인 구조를 가진 문제는 해결하지 못하는 한계가 존재한다. 이러한 한계를 극복하기 위해 은닉층을 추가한 구조인 MLP(Multi-Layer Perceptron)가 등장하게 된다.

이 글에서는 퍼셉트론의 동작 원리를 짚어보고, XOR 문제를 통해 구조적 한계를 이해한 뒤 MLP로의 확장 과정을 정리해 보았다.

🖇  1. 퍼셉트론(Perceptron)이란?

퍼셉트론은 1957년 프랭크 로젠블랫(Frank Rosenblatt)이 제안한 인공 뉴런의 초기 모델이다.

인간의 신경세포(뉴런)가 일정한 자극을 받았을 때만 신호를 전달하듯, 퍼셉트론도 입력값을 받아 조건에 따라 출력을 할지 말지를 결정한다.

이때 출력을 할지 말지를 정하는 기준이 되는 것이 활성화 함수다.

퍼셉트론의 계산은 다음과 같은 흐름을 따른다.

$$ z = \sum_{i=1}^{n} w_i x_i + b \quad \Rightarrow \quad \text{output} = \begin{cases} 1 & \text{if } z > 0 \ 0 & \text{otherwise} \end{cases} $$

• $x_i$:  입력값
• $w_i$:  가중치
• $b$:  바이어스
• $z$:  입력과 가중치의 선형 조합
• $output$:  활성화 함수의 결과값 (0 또는 1)

이 구조는 신경세포의 ‘발화 여부 결정’, 즉 세포체(soma)에서 받아들인 자극이 일정 기준을 넘으면 반응하고, 넘지 않으면 반응하지 않는 생물학적 원리를 모방한 것이다.

퍼셉트론 vs 생체신경망

인공신경망은 실제 생물학적 뉴런의 작동 원리를 수학적으로 단순화한 구조이다. 퍼셉트론은 이러한 생물학적 뉴런을 수식으로 표현한 가장 기초적인 모델인데, 두 구조는 구성 요소와 정보 처리 방식에서 많은 유사점을 보인다.

아래 표는 퍼셉트론의 연산 구조와 생체신경망의 생리적 작동 방식을 비교한 것이다. 이를 통해 인공신경망이 뇌의 뉴런을 어떤 식으로 모방했는지를 이해하는 데 도움이 될 수 있다.

퍼셉트론은 입력값과 가중치를 곱해 모두 더하고, 이 결과에 바이어스를 더한 뒤, 활성화 함수를 통해 출력 신호를 만들어낸다. 이 흐름은 뇌에서의 자극 수용 → 연산 → 발화 → 전달의 구조와 흡사하다.

이처럼 퍼셉트론은 생체신경망의 작동 원리를 기반으로 한 수학적 모델로, 신호의 입력부터 출력까지 전반적인 처리 과정을 단순하지만 효과적으로 모사한다. 이 개념은 이후에 나올 될 다층 신경망, 역전파, 딥러닝의 기반이 된다.

🖇  2. 퍼셉트론: AND 연산

퍼셉트론은 간단한 논리 연산을 매우 잘 수행한다. 퍼셉트론으로 AND 연산을 수행하는 예시를 하나 살펴보자.

• 입력: $x_1$ = 1, $x_2$ = 1
• 가중치: $w_1$ = 0.6, $w_2$ = 0.6
• 바이어스: $b$ = -1

$z = (0.6 \times 1) + (0.6 \times 1) + (-1) = 0.2 \Rightarrow \text{output} = 1$

• 반면 $x_1 = 0$, $x_2 = 1$이면

$z = (0.6 \times 0) + (0.6 \times 1) + (-1) = -0.4 \Rightarrow \text{output} = 0$

이처럼 퍼셉트론은 직선 하나를 기준으로 데이터를 양분하는 데 매우 적합하다.

🖇  3. 퍼셉트론: XOR 문제

그러나 퍼셉트론은 선형 분리가 불가능한 문제에서는 제대로 작동하지 않는다. 그 대표적인 예가 바로 XOR 문제다.

XOR 진리표의 네 개의 좌표를 2차원 평면에 표시하면 다음과 같은 분포가 된다.

• (0,0)과 (1,1)은 클래스 0
• (0,1)과 (1,0)은 클래스 1

이들은 직선 하나로는 나눌 수 없다. 즉, 퍼셉트론의 구조로는 XOR 문제를 해결할 수 없는 것이다.

💡 단일 퍼셉트론은 하나의 직선(결정 경계)만 학습할 수 있기 때문에 비선형 문제나 곡선 경계를 요구하는 문제는 풀 수 없다.

🖇  4. 퍼셉트론의 한계

1969년, 마빈 민스키(Marvin Minsky)와 시모어 페퍼트(Seymour Papert)는 저서   『Perceptrons』 에서 퍼셉트론이 XOR 문제를 해결하지 못한다는 사실을 수학적으로 증명했다.

이로 인해 인공지능에 대한 과도한 기대가 꺾였고, 정부와 기업의 투자도 끊기면서 AI 연구는 1970~80년대 동안 정체 상태에 빠지게 되었고, 이를 AI 겨울(AI Winter)이라고 부른다.

그러나 이 시기의 좌절은 오히려 더 강력한 신경망 구조의 필요성을 자각하게 해준 중요한 계기로 작용했다.

🖇  5. 다층 퍼셉트론(MLP)의 등장

XOR 문제는 입력 공간을 비선형적으로 변형해야 해결할 수 있다.

이러한 변형을 가능하게 만드는 구조로 다층 퍼셉트론(MLP, Multi-Layer Perceptron)이 등장하였다.

MLP의 구조

• 입력층: 원본 데이터를 입력받음
• 은닉층: 입력을 조합하여 중간 표현을 만들어냄 (1개 이상 존재)
• 출력층: 최종 예측값을 출력

MLP는 여러 뉴런과 여러 층을 활용해 단일 퍼셉트론이 학습할 수 없는 복잡한 관계나 곡선 경계까지도 학습할 수 있게 해준다.

1. 첫 번째 은닉 뉴런이 (0,1), (1,0)을 감지한다.
2. 두 번째 은닉 뉴런이 (0,0), (1,1)을 감지한다.
3. 출력 뉴런은 위 둘을 조합하여 XOR 출력값을 만든다.

결과적으로, XOR 문제도 MLP에서는 해결 가능하다.

다층 퍼셉트론과 딥러닝의 경계

참고로 MLP은 은닉층이 12개 정도인 얕은 구조를 말할 때가 많고, 딥러닝(Deep Learning)은 은닉층이 수십수백 개 이상으로 구성된 깊은 구조(Deep Neural Network, DNN)를 의미한다.

또한 딥러닝에는 CNN, RNN, Transformer 등 다양한 구조도 포함된다.

하지만 이 모든 복잡한 모델도 결국 퍼셉트론 구조를 층층이 확장한 것이라는 점에서 MLP은 딥러닝의 뿌리라고 할 수 있다.

🖇  6. MPL 학습 한계

구조를 확장한다고 해서 모든 문제가 해결되지는 않는다. MLP은 구조적으로는 유연하지만 학습 자체는 매우 어렵다. 크게 두 가지의 이유로 설명할 수 있다.

1) 계단 함수 사용의 한계

• 퍼셉트론은 보통 계단 함수(step function)를 활성화 함수로 사용한다.
• 계단 함수는 불연속적이기 때문에 기울기(gradient)를 계산할 수 없고, 따라서 가중치를 수정하는 학습이 불가능하다.

2) 은닉층의 오차 측정 불가능

• 출력층은 정답과 비교해 오차를 알 수 있지만
• 은닉층은 "이 뉴런이 얼마나 잘못된 결과에 기여했는지"를 측정하기 어렵다. → 학습이 불가능한 구조가 되어버린다.

🖇  7. MPL 학습 한계 해결

(1) 미분 가능한 활성화 함수 도입

퍼셉트론의 계단 함수 대신 Sigmoid, Tanh, ReLU 같은 함수가 도입되었다.

이 함수들은 미분 가능하기 때문에 가중치의 기울기를 계산할 수 있게 해주며 경사하강법 적용이 가능해진다.

(2) 역전파 알고리즘(Backpropagation)

1986년, 데이비드 루멜하트(David Rumelhart)와 제프리 힌튼(Geoffrey Hinton) 등은 역전파 알고리즘을 소개했다.

이 알고리즘은 오차를 출력층 → 은닉층 → 입력층 방향으로 거슬러 올라가며 가중치를 조정하는 방식이다.

• 출력층에서 손실을 계산
• 각 뉴런이 손실에 얼마나 영향을 끼쳤는지 기울기 계산
• 이 기울기를 바탕으로 가중치를 조금씩 수정

$$ w_i \leftarrow w_i - \eta \cdot \frac{\partial L}{\partial w_i} $$

• $\eta$:  학습률 (learning rate), 가중치를 얼마나 크게 조정할지를 결정하는 하이퍼파라미터
• $\frac{\partial L}{\partial w_i}$:  손실 함수 $L$에 대한 가중치 $w_i$의 변화율 (기울기)

퍼셉트론은 인공지능 모델의 시작이었지만, XOR 같은 단순한 비선형 문제도 해결할 수 없는 구조적 한계를 가지고 있었다.

이 한계를 정확히 짚어낸 연구 덕분에 다층 퍼셉트론 구조가 등장했고, 이어서 활성화 함수 개선과 역전파 알고리즘이 도입되며 현대 딥러닝의 기반이 완성되었다.

인사이트 및 회고

퍼셉트론은 신경망의 기초를 이루는 개념이지만 선형 분류 문제만 해결 가능하다는 한계를 알 수 있었다.

XOR 문제처럼 두 집단이 직선 하나로 나뉘지 않는 경우, 퍼셉트론은 어떤 조합의 가중치와 바이어스로도 올바른 출력을 만들지 못한다는 점이 흥미로웠다. 딥러닝을 막연히 공부했을 때는 '왜 층을 더 쌓아야 하는가?'에 대한 의문을 가지지 못했는데 MPL의 원리를 이해하면서 대답까지 이끌어낼 수 있었다.

여기서도 마찬가지로, 결국 중요한 건 모델보다는 문제에 맞는 구조를 설계하는 능력이라고 생각된다. 이 글을 통해 단일 뉴런 구조에서부터 계층적 구조로 넘어가는 배경을 명확히 이해할 수 있었다.

🖇  1. 인공신경망이란? 🖇  2. 생물학적 뉴런의 구조 🖇  3. 인공 뉴런 모델 🖇  4. 인공신경망의 계층 구조 🖇  5. 활성화 함수의 역할 🖇  6. 역전파 알고리즘

딥러닝에서 가장 먼저 이해해야 하는 개념이 인공신경망(Artificial Neural Network, ANN)이다. 핵심 원리는 생각보다 간단할 수 있다. 인간의 뇌 구조에서 영감을 받아 수학적으로 구현된 모델이기 때문이다.

이 글에서는 인공신경망의 동작 원리를 생물학적 뉴런의 구조와 비교하며 설명하고, 실제로 컴퓨터가 데이터를 처리하고 학습하는 과정을 단계별로 다루고 있다.

• 생물학적 뉴런은 어떤 구조로 신호를 주고받을까?
• 인공 뉴런은 이를 어떻게 수학적으로 흉내 낼까?
• 신경망은 입력부터 출력까지 어떤 과정을 거쳐 학습할까?

이 질문을 바탕으로 입력층-은닉층-출력층으로 구성된 계층 구조와 활성화 함수, 역전파 알고리즘의 순서로 딥러닝의 기초를 정리해 보았다.

🖇  1. 인공신경망이란?

인공신경망(Artificial Neural Network)은 인간의 뇌를 수학적으로 모방한 구조로, 기계가 데이터를 학습하고 패턴을 인식할 수 있게 해주는 계산 모델이다. 뇌의 뉴런들이 자극을 받고 신호를 전달하는 생물학적 구조에서 착안해 설계되었다.

기본적으로 인공신경망은 입력층(Input layer), 은닉층(Hidden layer), 출력층(Output layer)의 계층 구조를 가지고, 각 층은 여러 개의 뉴런(노드)으로 구성된다.

신경망은 데이터가 입력되어 → 가중치 연산을 거치고 → 비선형 변환을 통해 → 예측 또는 분류 결과를 출력하는 흐름으로 동작한다.

이러한 구조는 이미지 분류, 음성 인식, 자연어 처리 등 실제 문제를 해결하기 위해 딥러닝에서 광범위하게 활용된다.

🖇  2. 생물학적 뉴런의 구조

인간의 뇌에는 약 860억 개의 뉴런이 존재하며 이들은 서로 전기·화학적 신호를 주고받는다.

• 수상돌기(Dendrite): 다른 뉴런에서 오는 신호를 받아들이는 역할
• 세포체(Cell Body): 신호를 종합하고 필요한 연산을 수행
• 축삭(Axon): 처리된 신호를 다른 뉴런으로 전달
• 축삭 말단(Axon Terminal): 신호가 다음 뉴런의 수상돌기로 전달되는 지점
• 시냅스(Synapse): 두 뉴런이 연결되어 신호를 주고받는 접합부

생물학적 뉴런의 정보 흐름은 ‘자극의 수용 → 종합 → 전달’이고, 이는 인공 뉴런의 정보 처리 방식에 그대로 반영된다.

🖇  3. 인공 뉴런 모델

인공 뉴런은 실제 뉴런의 작동 원리를 수학적으로 단순화한 구조이다.

하나의 인공 뉴런은 다음과 같은 계산 과정을 거친다.

$$ z = \sum_{i=1}^{n} w_i x_i + b \quad \Rightarrow \quad y = f(z) $$

• $x_i$:  입력값 (이미지의 각 픽셀, 사용자 행동 데이터 등)
• $w_i$:  입력에 대한 가중치. 입력의 중요도를 조절하는 파라미터
• $b$:  바이어스. 뉴런의 출력 기준을 조정
• $f(z)$:  활성화 함수. 출력값을 비선형적으로 변환하여 표현력을 높임

이 모델은 단순한 연산처럼 보이지만 뉴런을 여러 개 연결하면 매우 복잡한 함수도 근사할 수 있다. 실제로 신경망은 이런 단순한 계산 단위를 수천, 수만 개 쌓아 복잡한 문제를 해결한다.

[이미지] 최초의 인공신경망

🖇  4. 인공신경망의 계층 구조

인공신경망은 하나의 인공 뉴런이 아닌 수많은 뉴런들이 층 단위로 연결된 구조를 가진다.

입력층(Input Layer)

• 데이터를 받아들이는 역할. 원본 데이터를 은닉층으로 전달

은닉층(Hidden Layer)

• 입력을 바탕으로 특징을 추출하거나 가공
• 깊은 신경망일수록 이 층이 많아짐
• 은닉층은 일반적으로 Dense Layer, 즉 모든 뉴런이 완전히 연결된 구조(Fully Connected)로 구성됨. 이 구조는 각각의 입력 특징이 출력 결과에 모두 반영되도록 함.

출력층(Output Layer)

• 최종적으로 예측값을 출력 e.g., 분류 문제에서는 softmax 함수 등을 통해 확률값 출력

각 층의 뉴런은 이전 층의 모든 뉴런과 연결되며, 이로 인해 네트워크는 고차원의 비선형 함수도 학습할 수 있다.

예를 들어 고양이 사진과 개 사진을 분류하는 경우, 입력층은 픽셀 값, 은닉층은 귀, 털, 코 같은 중간 특징을, 출력층은 ‘고양이’, ‘개’ 같은 결과를 출력하게 된다.

🖇  5. 활성화 함수의 역할

활성화 함수는 선형 연산만으로는 표현할 수 없는 복잡한 관계를 학습하기 위한 핵심 구성 요소이다.

선형 함수만 사용하면 신경망의 모든 층을 합쳐도 결국 하나의 선형 함수로 축소되며 이로 인해 표현력이 떨어지게 된다.

대표적인 활성화 함수는 다음과 같다.

• Step Function: 초기 퍼셉트론에서 사용. 0 이상이면 1, 미만이면 0. 하지만 미분 불가능하여 학습이 불가능
• Sigmoid Function: 출력값을 0~1 사이로 압축. 하지만 gradient vanishing 문제 발생
• ReLU (Rectified Linear Unit): 0 이하에서는 0, 0 이상은 그대로 출력. 계산이 빠르고 성능이 뛰어나 현대 딥러닝에서 가장 널리 사용됨

활성화 함수는 신경망에 비선형성(non-linearity)을 부여해주므로 이 덕분에 신경망은 매우 복잡한 문제도 다룰 수 있다.

🖇  6. 역전파 알고리즘

다층 구조의 신경망은 수많은 가중치와 바이어스를 가진다. 이들을 효과적으로 학습시키기 위해서는 역전파 알고리즘이 필요하다.

역전파(Backpropagation)는 예측값과 실제값의 차이(오차)를 기준으로, 각 가중치가 얼마나 잘못된 결과에 영향을 끼쳤는지 계산하여 이를 바탕으로 가중치를 수정하는 방식이다.

다음과 같은 흐름으로 학습하게 된다.

1. 순전파 (Forward Propagation): 입력 → 은닉층 → 출력층으로 예측값 계산
2. 오차 계산 (Loss Function): 예측값과 정답의 차이 측정 (MSE, Cross Entropy 등)
3. 역전파 (Backpropagation): 오차를 뒤로 전달하면서 각 파라미터의 기울기(gradient) 계산
4. 가중치 갱신 (Gradient Descent): 기울기를 기반으로 가중치 업데이트

이 알고리즘은 1980년대 중반 루멜하트(Rumelhart), 힌튼(Hinton) 등이 실용화하면서 본격적으로 딥러닝이 부활하게 된 계기가 되었다.

인사이트 및 회고

인공신경망은 인간의 뇌를 본떠 만든 모델이지만 단순한 수학 연산을 반복적으로 구성한 구조로 만들어진다. 이 구조를 깊고 넓게 쌓아 올리면 매우 복잡한 문제도 해결할 수 있는 강력한 모델이 된다는 것이 흥미롭다.

흔히 "딥러닝은 어렵다"고 생각하는 이유 중 많은 부분이 용어나 구조에 대한 첫 진입 장벽 때문이라는 생각이 들었다.

뉴런 하나의 작동 원리와 학습 흐름을 명확히 이해하면 그 위에 다양한 모델을 쌓을 수 있을 것이다. 이 글을 통해 인공신경망의 기본 개념, 작동 방식, 학습 흐름을 체계적으로 정리할 수 있었다.

🖇  1. 데이터 수집 🖇  2. 데이터 전처리 🖇  3. 이미지 불러오기 및 정규화 🖇  4. 딥러닝 모델 구성 및 학습 🖇  5. 테스트셋 평가 및 시각화

이전 글에서는 정제된 MNIST 데이터셋으로 딥러닝 모델에 학습시켜 보는 실습을 진행하였다. 실제로는 데이터를 직접 만들고 가공해야 하는 경우가 많기 때문에 이번에는 직접 수집한 데이터를 기반으로 분류 모델을 구성해 보는 실습을 진행해 보았다.

웹캠을 이용해 가위, 바위, 보 이미지를 직접 촬영하고, 이를 바탕으로 딥러닝 모델을 학습시켜 분류기를 구현한다. MNIST 숫자 분류와 마찬가지로 데이터 수집 → 전처리 → 모델 훈련 → 평가 → 시각화 → 일반화 성능 점검까지의 전체 흐름을 살펴보았다.

다음과 같은 목표를 세우고 수행하였다.

• 직접 촬영한 RGB 컬러 이미지를 분류하는 모델 만들기
• 사용자 정의 데이터셋을 구성하고 전처리하기
• CNN 기반 딥러닝 모델을 구성하고 훈련하기
• 훈련셋과 테스트셋 간 중복 여부를 검사하여 데이터셋 검증하기
• 테스트셋으로 모델 일반화 성능을 평가하고 혼동행렬로 시각화하기

🖇  1. 데이터 수집

1.1 Teachable Machine이란?

Teachable Machine은 구글이 제공하는 웹 기반 머신러닝 훈련 도구다.

코딩 지식 없이도 웹캠, 마이크 등을 통해 데이터를 수집하고, 모델을 훈련하고, 결과를 바로 확인할 수 있다.

본 실습에서는 Teachable Machine의 Image Project > Standard image model 기능을 활용하여 가위, 바위, 보 각각의 이미지를 웹캠으로 촬영하였다.

1.2 이미지 수집 절차

1. Teachable Machine 사이트 접속 → Get Started 클릭
2. Image Project → Standard image model 선택
3. 세 개의 클래스(가위, 바위, 보)를 생성하고, 웹캠으로 각각 100장씩 이미지 수집

1.3 수집 시 유의사항

• 한 사람만 촬영한 데이터는 각도, 조명, 손 모양이 제한적이므로 일반화 성능이 낮아질 수 있다.
• 여러 사람이 협업하여 서로 다른 손 크기, 배경, 밝기 등을 반영한 데이터가 포함되면 학습에 유리하다.
• 손 모양이 명확히 드러나도록, 웹캠에 가까이 대고, 흰 배경 등으로 명도 대비를 높이면 정확도 향상에 도움이 된다.

💡 이번 실습에서는 이 사항을 간과하고 손 색과 비슷한 배경에서 촬영을 진행하였다. 학습 데이터 성능에 따라 재촬영을 고려하고 있었다.

1.4 데이터 저장

촬영을 마친 뒤, 우측 상단 메뉴에서 Export Image 기능을 사용해 각 클래스를 .zip 파일로 다운로드했다.

파일 이름은 다음과 같이 사용하였다.

• scissor.zip – 가위
• rock.zip – 바위
• paper.zip – 보

🖇  2. 데이터 전처리

이제 수집한 데이터를 바탕으로 다음의 단계로 실습을 진행한다.

1. Teachable Machine을 통해 웹캠 기반 이미지 수집
2. 이미지 전처리 (리사이징 및 정규화)
3. CNN 모델 구성 및 학습
4. 직접 만든 테스트셋을 활용한 일반화 성능 평가
5. 혼동행렬 시각화 및 성능 분석
6. 훈련셋과 테스트셋 간의 중복 이미지 검사

각 단계에서 왜 이 과정을 수행하는지, 이 코드가 무슨 역할을 하는지를 충분히 이해하면서 작성해 보았다.

2.1 라이브러리 임포트 및 버전 확인

• 딥러닝 프레임워크로 TensorFlow, 수치 계산용 NumPy를 사용한다.
• 호환성 문제가 없도록 실습 환경의 버전을 확인한다.

import tensorflow as tf
import numpy as np

print(tf.__version__)
print(np.__version__)

2.2 압축 해제 및 이미지 불러오기

Google Colab을 활용하여 Google Drive에 저장된 scissor.zip, rock.zip, paper.zip 파일을 각각 다음 폴더에 압축 해제한다.

• !는 Colab 셀에서 리눅스 명령어를 실행할 수 있도록 해주는 명령어이다.
• 각 클래스별 이미지를 디렉토리에 나눠 저장한다.

from google.colab import drive
drive.mount('/content/drive')

!unzip /content/drive/MyDrive/DS/DL/scissor.zip -d 가위
!unzip /content/drive/MyDrive/DS/DL/rock.zip -d 바위
!unzip /content/drive/MyDrive/DS/DL/paper.zip -d 보

2.3 이미지 크기 통일 (리사이징)

딥러닝 모델에 이미지를 입력하기 위해 입력 크기를 통일해야 한다.

• glob은 디렉토리 내의 모든 .jpg 파일을 리스트로 가져온다.
• PIL.Image.resize를 사용하여 28x28 픽셀로 변환한다.

# 이미지 파일을 열고 처리하기 위한 라이브러리(Pillow 패키지의 핵심 모듈)
from PIL import Image  # 이미지 로딩, 리사이징, 색 변환 등에 유용
# 특정 경로 내 파일들을 패턴에 맞게 한 번에 불러올 수 있도록 도와주는 모듈
import glob
# 디렉토리 경로 조작, 파일 존재 여부 확인 등 운영체제 관련 기능 제공
import os

def resize_images(img_path):
    images = glob.glob(img_path + '/*.jpg')  # 지정 경로에서 .jpg 이미지 파일 목록을 리스트로 가져오기

    print(len(images), ' images to be resized.')  # 총 이미지 수 출력

    # 이미지 크기 리사이징 대상 크기 정의 (CNN 입력 형식에 맞춤)
    target_size = (28, 28)

    for img in images:
        old_img = Image.open(img)  # 이미지 파일 열기 (PIL 객체)
        new_img = old_img.resize(target_size, Image.Resampling.LANCZOS)  # 리사이즈 (LANCZOS는 고급 보간법)
        new_img.save(img, 'JPEG')  # 기존 파일에 덮어쓰기 저장

    print(len(images), ' images resized.')  # 완료된 이미지 수 출력

# 각 클래스별 이미지가 저장된 폴더(가위/바위/보)를 대상으로 resize_images() 함수 호출
# : 모든 이미지를 28x28 크기로 리사이즈하고, 완료 여부 출력
# : CNN 모델의 입력 크기를 통일하기 위한 전처리 작업
image_dir_path = './가위'       # 이미지가 들어있는 폴더 경로 지정
resize_images(image_dir_path)

image_dir_path = './바위'
resize_images(image_dir_path)

image_dir_path = './보'
resize_images(image_dir_path)

🖇  3. 이미지 불러오기 및 정규화

3.1 데이터셋 불러오기

이미지를 numpy array로 변환하여 모델에 입력할 수 있도록 처리한다.

• 이미지 resize 함수 정의

def load_data(img_path, folder_names):
    # 클래스 이름에 따라 라벨을 0(가위), 1(바위), 2(보)로 지정
    label_map = {'가위': 0, '바위': 1, '보': 2, ...}
    all_imgs, all_labels = [], []

    for folder in folder_names:
        files = glob.glob(f"{img_path}/{folder}/*.jpg")

        for file in files:
            img = Image.open(file).resize((28, 28))
            all_imgs.append(np.array(img))
            all_labels.append(label_map[folder])

    return np.array(all_imgs), np.array(all_labels)

x_train, y_train = load_data('.', ['가위', '바위', '보'])

• 이미지 데이터 로드 및 전처리 함수 정의

  def load_data(img_path, folder_names):
    """
    이미지 데이터를 불러오고 라벨을 부여하는 함수
    - 가위: 0, 바위: 1, 보: 2 라벨 부여
      - 테스트용 폴더도 라벨은 동일하게 부여
    - 학습용: folder_names = ['가위', '바위', '보']
    - 테스트용: folder_names = ['가위_test', '바위_test', '보_test']
    """
  
    img_size = 28       # 이미지 가로, 세로 크기
    color = 3           # RGB 컬러 채널 (3채널)
  
    # 라벨 맵: 폴더 이름에 따라 라벨 부여
    label_map = {
        '가위': 0, '바위': 1, '보': 2,
        '가위_test': 0, '바위_test': 1, '보_test': 2,
        '가위_test2': 0, '바위_test2': 1, '보_test2': 2,
        '가위_test3': 0, '바위_test3': 1, '보_test3': 2
    }
  
    # 이미지 배열 및 라벨 배열 초기화
    all_imgs = []
    all_labels = []
  
    # 지정된 폴더 목록에 대해 이미지 로드
    for folder in folder_names:
        files = glob.glob(os.path.join(img_path, folder, '*.jpg'))
        label = label_map[folder]
  
        for file in files:
            try:
                img = Image.open(file).resize((img_size, img_size))  # 이미지 로드 및 리사이즈
                img = np.array(img, dtype=np.int32)                  # 배열 변환
                all_imgs.append(img)
                all_labels.append(label)
            except Exception as e:
                print(f"[오류] {file} 읽기 실패:", e)
  
    print('데이터의 이미지 개수:', len(all_imgs))
    return np.array(all_imgs), np.array(all_labels)  # 이미지 데이터와 라벨 반환

3.2 데이터 정규화

• RGB 이미지의 픽셀 값은 0255 범위를 가지므로 01로 정규화하여 학습 안정성을 높인다.

# 함수 실행: 현재 디렉토리 기준으로 데이터 로드
image_dir_path = '.'
(x_train, y_train) = load_data(image_dir_path, ['가위', '바위', '보'])

# 데이터를 무작위로 섞어 모델이 편향 없이 학습할 수 있도록 준비
x_train, y_train = shuffle(x_train, y_train, random_state=42)

# 이미지 정규화: 픽셀 값을 0~1 사이로 변환해 학습 안정화
x_train_norm = x_train / 255.0

# 데이터 형태 확인
print('x_train shape: {}'.format(x_train.shape))  # (샘플 수, 28, 28, 3)
print('y_train shape: {}'.format(y_train.shape))  # (샘플 수,)

3.3 학습 데이터 확인

모델 학습에 들어가기 전에 불러온 학습 데이터 이미지와 라벨이 어떻게 출력되는지 확인해 보았다.

import matplotlib.pyplot as plt

plt.imshow(x_train[224])         # RGB 이미지 그대로 출력
plt.axis('off')                  # 축 눈금 숨김
plt.show()

# 해당 이미지의 실제 정답 라벨 출력
print('라벨: ', y_train[224])    # 0=가위, 1=바위, 2=보

28x28 이미지로 출력되다 보니 픽셀이 깨지는 것을 육안으로 확인할 수 있다. 아마 이러한 이유로 인해 이후 테스트 데이터에서 모델 성능이 낮게 측정되는 것이 아닌가 하는 추측을 해 볼 수 있었다.

🖇  4. 딥러닝 모델 구성 및 학습

가위/바위/보 이미지 분류를 위한 CNN 모델을 정의한다.

• 입력: 크기 (28x28x3)의 컬러 이미지
• 출력: 3개의 클래스(가위=0, 바위=1, 보=2)에 대한 확률 분포

4.1 CNN 모델 설계

CNN 모델의 파라미터에 대한 설명은 MNIST 숫자 분류에서 자세히 다뤄보았다.

• Conv2D: 필터를 이용해 이미지 특징 추출
• MaxPooling2D: 특성 맵을 축소하여 계산량 줄이고 주요 특징 유지
• Flatten: 2D를 1D로 펼쳐서 Fully Connected Layer로 전달
• Dense: 분류를 위한 신경망 계층
• 마지막 softmax: 클래스별 확률 출력

import tensorflow as tf         # TensorFlow: 딥러닝 프레임워크
from tensorflow import keras    # Keras: 고수준 API
import numpy as np              # NumPy: 수치 연산용

# 하이퍼파라미터 설정
n_channel_1 = 16       # 첫 번째 Conv 층의 필터 수
n_channel_2 = 32       # 두 번째 Conv 층의 필터 수
n_dense = 32           # Dense 층 뉴런 수
n_train_epoch = 2      # 학습 epoch 수

# CNN 모델 정의
model = keras.models.Sequential()
model.add(keras.layers.Conv2D(n_channel_1, (3, 3), activation='relu', input_shape=(28, 28, 3)))
model.add(keras.layers.MaxPool2D(2, 2))
model.add(keras.layers.Conv2D(n_channel_2, (3, 3), activation='relu'))
model.add(keras.layers.MaxPooling2D((2, 2)))
model.add(keras.layers.Flatten())
model.add(keras.layers.Dense(n_dense, activation='relu'))
model.add(keras.layers.Dense(3, activation='softmax'))

# 모델 요약 정보 출력: 각 층의 출력 형태, 파라미터 수 확인 가능
model.summary()

Model: "sequential_1"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ conv2d_2 (Conv2D)               │ (None, 26, 26, 16)     │           448 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_2 (MaxPooling2D)  │ (None, 13, 13, 16)     │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_3 (Conv2D)               │ (None, 11, 11, 32)     │         4,640 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_3 (MaxPooling2D)  │ (None, 5, 5, 32)       │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ flatten_1 (Flatten)             │ (None, 800)            │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_2 (Dense)                 │ (None, 32)             │        25,632 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_3 (Dense)                 │ (None, 3)              │            99 │
└─────────────────────────────────┴────────────────────────┴───────────────┘
 Total params: 30,819 (120.39 KB)
 Trainable params: 30,819 (120.39 KB)
 Non-trainable params: 0 (0.00 B)

4.2 모델 컴파일 및 훈련

정의한 CNN 모델을 컴파일하고 학습시키기

• compile(): 모델 학습 방식(손실 함수, 최적화 알고리즘, 평가 지표 등)을 설정
• 주어진 입력(x_train)과 정답(y_train)을 사용해 모델을 실제로 학습

# 모델 컴파일: 학습 방법과 평가 방식 정의
model.compile(
    optimizer='adam',                        # Adam 옵티마이저: 학습률 자동 조절로 효율적인 학습 수행
    loss='sparse_categorical_crossentropy',  # 정수형 클래스 레이블(0~2)을 사용할 때 적합한 다중 클래스 손실 함수
    metrics=['accuracy']                     # 학습 중 정확도(accuracy)를 측정해 성능 확인
)

# 모델 훈련: 학습 데이터를 사용하여 weight 업데이트 진행
model.fit(
    x_train,              # 학습에 사용할 입력 이미지 데이터
    y_train,              # 각 이미지의 실제 정답 레이블
    epochs=n_train_epoch  # 전체 데이터를 n_train_epoch번 반복해서 학습 (기본값 10)
)

Epoch 1/2
10/10 ━━━━━━━━━━━━━━━━━━━━ 2s 18ms/step - accuracy: 0.3608 - loss: 10.7289
Epoch 2/2
10/10 ━━━━━━━━━━━━━━━━━━━━ 0s 19ms/step - accuracy: 0.7551 - loss: 1.0474
<keras.src.callbacks.history.History at 0x7b357b9f2dd0>

epochs를 10으로 설정했을 때 epoch 7/10부터는 accuracy가 1.0000이 나왔다. 특히 5~10 epoch 사이에 급격한 향상과 정교한 미세조정이 이루어진 것을 확인할 수 있었다.

그러나 이후에는 과적합을 방지하기 위해 epoch를 2로 설정해 보았다.

🖇  5. 테스트셋 평가 및 시각화

테스트셋은 같은 실습을 진행하는 팀원들이 각자 촬영한 이미지를 받아 진행하였다. 즉, 촬영한 사람과 배경 등의 환경이 완전히 다른 데이터셋이다.

5.1 테스트셋 로딩 및 정규화

테스트셋도 동일한 전처리(리사이징 및 정규화)를 적용해야 한다.

test_image_dir_path = './가위_test'
resize_images(test_image_dir_path)

test_image_dir_path = './바위_test'
resize_images(test_image_dir_path)

test_image_dir_path = './보_test'
resize_images(test_image_dir_path)

# 테스트 데이터 로드 (가위: 0, 바위: 1, 보: 2)
# : 이미지 데이터를 배열로 읽고 라벨링
test_image_dir_path = '.'
(x_test, y_test) = load_data(test_image_dir_path, ['가위_test', '바위_test', '보_test'])
# # 정규화: 이미지 픽셀 값을 0~1 사이로 스케일링
x_test_norm = x_test/255.0

5.2 훈련셋과 테스트셋 중복 확인

테스트 데이터셋을 불러오는 과정에서 경로 문제가 있어서 accuracy가 1.0 이 나오는 문제가 발생했었다.

동일한 이미지가 훈련셋과 테스트셋에 동시에 포함되면 성능이 왜곡될 수 있기 때문에 정확히 같은 이미지가 있는지 체크하는 과정이 필요하다고 판단하였다.

overlap_count = 0
for i in range(len(x_test)):
    for j in range(len(x_train)):
        if np.array_equal(x_test[i], x_train[j]):
            overlap_count += 1
print('중복 이미지 개수: ', overlap_count)

중복 이미지 개수: 0

5.2 모델 평가

학습한 CNN 모델을 테스트 데이터셋에 대해 평가한다. 학습되지 않은 데이터에 대한 성능을 평가하여 과적합 여부나 일반화 수준을 확인할 수 있다.

• 모델이 x_test 데이터를 기반으로 예측한 결과와 실제 라벨 y_test를 비교하여
• 손실 함수(loss)와 정확도(accuracy) 출력

# 테스트 데이터로 모델 성능 평가: 손실값, 정확도 return
test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=2)
print('test_loss: {} '.format(test_loss))
print('test_accuracy: {}'.format(test_accuracy))

10/10 - 0s - 25ms/step - accuracy: 0.3567 - loss: 4.7789
test_loss: 4.778869152069092 
test_accuracy: 0.3566666543483734

테스트 데이터에서 성능 해석 (accuracy: 0.356)

• 일반화 성능 부족
• 학습에서 본 적 없는 데이터에 대해 모델이 잘 예측하지 못하고 있다는 뜻
• loss 값이 크게 나온 것도 모델이 예측을 틀리는 경우가 많다는 의미
• 모델이 너무 복잡하거나 너무 단순해서 적절한 일반화를 하지 못한다고 판단할 수 있음

5.3 혼동행렬 시각화

예측된 결과가 어떤 클래스에서 잘못 분류되었는지를 시각적으로 확인하여 패턴을 찾아내기 위해 혼동행렬을 확인해 보았다.

• 각 행은 실제 라벨, 열은 예측 라벨

# 모델이 예측한 클래스 라벨 (확률에서 가장 높은 값 선택)
y_pred = model.predict(x_test_norm)
y_pred_labels = np.argmax(y_pred, axis=1)

# 혼동행렬 계산
cm = confusion_matrix(y_test, y_pred_labels)

class_names = [0, 1, 2]
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=class_names)
disp.plot(cmap=plt.cm.Blues)
plt.title('Confusion Matrix of Rock-Paper-Scissors Model')
plt.show()

정확하게 분류된 경우

• 가위(0) 클래스는 100개 중 100개를 정확히 가위(0)로 예측됨 (100% 정확도)
• 실제가 바위(1)인 이미지 100개 중 98개가 가위(0)로 잘못 예측됨
• 실제가 보(2)인 이미지 100개 중 92개도 가위(0)로 잘못 예측됨

이를 통해 모든 클래스가 가위로 예측되는 경향을 보인다는 것을 알 수 있다. 모델이 가위만 잘 인식하고, 나머지는 구분하지 못하고 있는 상태라고 해석할 수 있다.

총 3개의 서로 다른 테스트 데이터셋으로 똑같은 평가를 진행했지만 전부 위와 비슷한 경향이 나타났다.

5.4 원인 분석

이와 같은 현상이 발생하는 원인을 추정해 보았다.

(1) 데이터 불균형이나 라벨링 오류가 원인일 가능성?

• 훈련 데이터에서 가위 이미지가 과도하게 많았다면 모델이 "무조건 가위로 예측하면 손해가 없다"고 학습했을 수 있지만 가위, 바위, 보 각각의 이미지를 직접 촬영했기 때문에 이것이 원인이 되지는 못한다.

(2) 데이터 품질 저하

• 바위와 보 데이터가 유독 흐리거나, 작거나, 배경이 복잡했을 수 있다. 모델이 특성을 제대로 학습하지 못하고 가위 특징만 강하게 학습했을 수 있다. 이것도 같은 환경과 픽셀을 가지고 있기 때문에 이렇다할 원인이라고 볼 수는 없을 것 같다.

(4) 모델 과적합 또는 학습 부족

• Epoch 수가 너무 적거나 모델 복잡도가 낮아 모든 클래스를 구분할 표현력이 부족했을 수 있다. 단순히 ‘가위’ 특징만 빠르게 학습하고 조기 종료되었을 가능성도 있을 것 같다. 이후 딥러닝 모듈을 더 공부하면서 원인을 찾아낼 필요가 있다.

혼동행렬을 통해 모델이 특정 클래스(가위)에 과도하게 치우친 상태임을 명확히 볼 수 있었다.

모델 구조의 문제를 의심하기 전에 일단 데이터 구성과 라벨링, 학습 조건을 먼저 파악해 볼 필요가 있다. 우선 훈련 데이터와 테스트 데이터를 다시 제작해 보고, 여러 환경에서 테스트를 진행해 보는 것도 하나의 방법이겠다.

이미지의 픽셀이나 하이퍼파라미터 조정 등 초가적인 모델 개선과 함께 테스트셋에 대한 성능의 원인을 분석해 보아야겠다.

인사이트 및 회고

웹캠을 활용해 직접 데이터를 수집하고 분류 모델들어 성능을 평가하는 과정까지 수행해 볼 수 있었다. CNN 구조 설계와 이미지 전처리 전 과정 이후 테스트셋 구성과 평가의 중요성, 혼동행렬을 통한 성능 분석을 통해 해결해야 할 문제가 무엇인지 인지할 수 있었다.

복잡한 모델이 아니라도 작은 이미지에 대한 분류는 간단한 CNN으로도 충분한 성능을 낼 수 있다는 것을 확인했다는 점에서 흥미로웠지만, 테스트셋에 대한 평가 과정에서 정확도가 무너지는 것을 보고 무엇이 진짜 원인인지 파악하여 해결하는 과정이 필요하다는 것을 알 수 있었다. 지금까지는 딥러닝의 기본적은 흐름을 이해하기 위한 실습이었지만, 이후 더 공부해 나가면서 이 실습으로 다시 돌아와 원인을 분석해 볼 예정이다.