파랑새

[프로그래머스 LV.0] 등수 매기기 — Python 정답 & 해설

작지만 꾸준한 성장으로 — Mon, 22 Jun 2026 02:27:12 +0900

1. 문제 URL

https://school.programmers.co.kr/learn/courses/30/lessons/120882

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

2. 문제 요구사항 정리

영어 점수와 수학 점수가 담긴 2차원 배열 score가 주어졌을 때, 각 학생의 평균 점수를 기준으로 등수를 매긴 결과를 반환하는 문제입니다.

입력: 각 학생의 영어 점수와 수학 점수가 [영어, 수학] 형태로 주어집니다.
처리: 학생별 평균 점수를 구한 뒤, 높은 평균 점수부터 등수를 매깁니다.
반환값: 원래 학생 순서에 맞춰 각 학생의 등수를 담은 배열을 반환합니다.

3. 핵심 개념

✔ 1) 학생별 평균 점수 구하기

score의 각 원소에는 영어 점수와 수학 점수가 들어 있으므로, 두 점수를 더한 뒤 2로 나누어 평균 점수를 구합니다. 이렇게 구한 평균은 이후 등수를 매기는 기준이 됩니다.

✔ 2) 평균 점수를 내림차순으로 정렬하기

등수는 높은 점수부터 1등이 되므로, 평균 점수 리스트를 내림차순으로 정렬한 별도 리스트를 만듭니다. 원본 평균 리스트는 학생의 기존 순서를 유지해야 하므로 따로 보관합니다.

✔ 3) index()로 등수 찾기

정렬된 평균 리스트에서 현재 평균 점수가 처음 등장하는 위치를 찾고, 인덱스에 1을 더하면 등수가 됩니다. 같은 평균 점수가 여러 명에게 있으면 index()가 첫 번째 위치를 반환하므로 공동 등수 처리도 자연스럽게 됩니다.

✅ 4. 정답 Python 코드

def solution(score):
    avg_list = []
    
    # 각 학생의 평균 점수를 구해서 리스트에 저장
    for s in score:
        eng = s[0]
        math = s[1]
        avg = (eng + math) / 2
        avg_list.append(avg)
        
    # 등수를 매기기 위해 내림차순 정렬된 새 리스트 생성
    sorted_avg = sorted(avg_list, reverse=True)
    
    answer = []
    # 원본 평균 리스트를 돌며 등수 매기기
    for avg in avg_list:
        rank = sorted_avg.index(avg) + 1
        answer.append(rank)
        
    return answer

5. 풀이하면서 느낀 점

처음에는 학생별 평균을 구한 뒤 직접 등수를 비교해야 하나 생각했는데, 풀이를 정리하다 보니 평균 리스트를 내림차순으로 정렬해 두면 각 평균의 위치만으로 등수를 구할 수 있다는 점이 핵심이었습니다.

그래서 원본 순서를 유지하는 avg_list와 등수 기준이 되는 sorted_avg를 따로 만들고, sorted_avg.index(avg) + 1로 각 학생의 등수를 계산하는 방식으로 풀었습니다. 같은 평균 점수가 있는 경우에도 index()가 첫 번째 위치를 반환하기 때문에 공동 등수를 자연스럽게 처리할 수 있었습니다.

또한, 같은 흐름을 더 간결하게 표현하고 싶다면 평균 리스트를 리스트 컴프리헨션으로 만들고, 반환값도 리스트 컴프리헨션으로 구성할 수 있습니다. 예를 들어 변수명을 맞춰 avg = [(eng + math) / 2 for eng, math in score]처럼 평균을 만든 뒤, 정렬된 리스트에서 각 평균의 위치를 찾는 방식으로 줄여볼 수 있다는 점도 함께 생각해볼 수 있었습니다.

[프로그래머스 LV.1] 완주하지 못한 선수 — Python 정답 & 해설

작지만 꾸준한 성장으로 — Mon, 22 Jun 2026 00:17:56 +0900

1. 문제 URL

https://school.programmers.co.kr/learn/courses/30/lessons/42576

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

2. 문제 요구사항 정리

마라톤에 참여한 선수들의 이름이 담긴 participant와 완주한 선수들의 이름이 담긴 completion이 주어졌을 때, 완주하지 못한 선수 한 명의 이름을 찾아 반환하는 문제입니다.

입력: participant에는 전체 참가자 이름이, completion에는 완주한 선수 이름이 담겨 있습니다.
조건: completion의 길이는 participant보다 1 작고, 참가자 중에는 동명이인이 있을 수 있습니다.
반환값: 완주하지 못한 선수의 이름을 반환합니다.

3. 핵심 개념

✔ 1) 이름별 등장 횟수 세기

이 문제에서는 같은 이름을 가진 참가자가 있을 수 있기 때문에 단순히 이름이 존재하는지만 확인하면 안 됩니다. 각 이름이 participant에 몇 번 등장했는지를 딕셔너리에 저장해야 합니다.

✔ 2) 완주자 명단을 기준으로 카운트 줄이기

participant를 순회하며 이름별 인원 수를 세어 둔 뒤, completion을 순회하면서 완주한 선수의 카운트를 하나씩 줄입니다. 이렇게 하면 완주한 사람은 0이 되고, 완주하지 못한 사람만 양수로 남게 됩니다.

✔ 3) 남은 값이 있는 이름 반환하기

마지막으로 딕셔너리를 순회하면서 값이 0보다 큰 이름을 찾으면 됩니다. 문제에서 완주하지 못한 선수는 정확히 한 명이라고 했으므로, 해당 이름을 발견하는 즉시 반환할 수 있습니다.

✅ 4. 정답 Python 코드

def solution(participant, completion):
    person = {}
    
    for name in participant:
        person[name] = person.get(name, 0) + 1
        
    for name in completion:
        person[name] -= 1
        
    for name in person:
        if person[name] > 0:
            return name

5. 풀이하면서 느낀 점

처음에는 참가자 명단과 완주자 명단의 차이를 단순히 비교하면 된다고 생각할 수 있는데, 풀이를 정리하다 보니 같은 이름이 여러 번 등장할 수 있다는 조건이 핵심이라는 점을 떠올릴 수 있었습니다.

그래서 participant를 먼저 순회하며 이름별 인원 수를 딕셔너리에 저장하고, completion을 순회하면서 완주한 사람 수를 하나씩 줄이는 방식으로 풀었습니다. 마지막에 값이 0보다 큰 이름이 완주하지 못한 선수이므로 바로 반환할 수 있었습니다.

또한, collections.Counter를 사용하면 같은 아이디어를 더 짧게 표현할 수도 있다는 점을 이후에 생각해볼 수 있었습니다.

[프로그래머스 LV.0] 문자열 밀기 — Python 정답 & 해설

작지만 꾸준한 성장으로 — Fri, 19 Jun 2026 22:22:43 +0900

1. 문제 URL

https://school.programmers.co.kr/learn/courses/30/lessons/120921

2. 문제 요구사항 정리

문자열 A와 B가 주어졌을 때, A를 오른쪽으로 몇 번 밀어야 B가 되는지 구하는 문제입니다. 만들 수 있다면 필요한 최소 횟수를 반환하고, 어떤 방식으로 밀어도 B가 될 수 없다면 -1을 반환해야 합니다.

입력: 길이가 같은 두 문자열 A, B가 주어집니다.
처리: A를 오른쪽으로 회전시켜 B와 같아질 수 있는지 확인합니다.
반환값: 가능하면 최소 회전 횟수, 불가능하면 -1을 반환합니다.

3. 핵심 개념

✔ 1) 회전 문자열의 특징 이해하기

문자열을 오른쪽으로 밀어 만든 결과들은 원래 문자열의 순환된 형태입니다. 예를 들어 B를 두 번 이어 붙인 B + B 안에는 B에서 시작할 수 있는 모든 순환 형태가 연속된 부분 문자열로 들어 있습니다.

✔ 2) B + B에서 A의 위치 찾기

A를 오른쪽으로 밀어 B를 만들 수 있다는 것은, 반대로 보면 A가 B + B 안에 부분 문자열로 존재한다는 뜻입니다. 이때 A가 처음 등장하는 위치가 A를 오른쪽으로 밀어야 하는 최소 횟수가 됩니다.

✔ 3) find()의 반환값 활용하기

Python의 find()는 찾는 문자열이 있으면 시작 인덱스를 반환하고, 없으면 -1을 반환합니다. 문제에서 요구하는 반환값과 정확히 맞아떨어지기 때문에 별도의 조건문 없이 그대로 사용할 수 있습니다.

✅ 4. 정답 Python 코드

def solution(A, B):
    # B를 두 번 더한 문자열에서 A의 시작 위치를 찾음
    return (B + B).find(A)

5. 풀이하면서 느낀 점

처음에는 A를 한 칸씩 직접 밀면서 B와 같은지 확인하는 방식으로 풀 수 있다고 생각했습니다. 그런데 풀이를 정리하다 보니, 회전 문자열은 두 번 이어 붙인 문자열 안에서 부분 문자열로 확인할 수 있다는 점을 활용하면 훨씬 간단하게 풀 수 있었습니다.

그래서 B + B에서 A가 처음 등장하는 위치를 찾는 방식으로 구현했습니다. find()가 문자열을 찾지 못하면 -1을 반환해 주기 때문에, 문제의 예외 처리까지 자연스럽게 해결되는 점이 깔끔하다고 느꼈습니다.

또한, deque를 이용해 직접 회전시키며 비교하는 방식으로도 접근할 수 있지만, 이번 문제에서는 문자열의 순환 구조를 이용하는 방식이 더 간결하다는 점을 이후에 생각해볼 수 있었습니다.

[Deep Learning] 경사 하강법과 Adam 옵티마이저 차이: 수식과 코드로 이해하는 장단점 비교

작지만 꾸준한 성장으로 — Fri, 19 Jun 2026 22:14:09 +0900

1. 먼저, 이 질문은 무엇을 묻고 있을까?

Gradient Descent(경사하강법), Adam(아담), Optimizer(옵티마이저) 같은 단어들은 모두 "인공지능이 어떤 원리로 똑똑해지는가?"라는 본질적인 문제를 해결하기 위해 존재한다.

머신러닝에서 학습(Training)이란 모델이 입력 데이터를 보고 예측한 값과 실제 정답을 비교하여, 틀린 만큼 내부 설정을 고쳐나가며 정답률을 올리는 반복적인 과정 전체를 의미한다. 이 흐름을 이해하기 위해서는 핵심 구성 요소인 '손실 함수'와 '옵티마이저'의 역할을 명확히 정리해야 한다.

예측의 기준이 되는 '손실 함수(Loss Function)'

인공지능 모델은 스스로의 예측이 정확한지 판단하지 못한다. 모델이 낸 예측값과 실제 정답의 차이와 불일치 정도를 정량적으로 계산하여 현재 모델이 얼마나 틀렸는지를 하나의 오차 수치로 알려주는 채점 기준표가 바로 손실 함수다.

손실 함수는 해결하려는 문제의 성격에 따라 크게 두 가지로 분류된다.
- 회귀(Regression) 문제용 손실 함수 (연속된 숫자를 맞출 때)
  - MSE (Mean Squared Error, 평균제곱오차): 큰 오차를 더 강하게 반영하여 강조하고 싶을 때 적합하다.
  - MAE (Mean Absolute Error, 평균절대오차): 일반적인 오차의 크기를 평이하게 평가할 때 적합하다.
- 분류(Classification) 문제용 손실 함수 (카테고리를 맞출 때)
  - 이진 크로스 엔트로피 (Binary Cross-Entropy): 정답 확률 분포가 두 가지 중 하나(예: Pass/Fail)일 때 정답과의 불일치를 측정한다.
  - 범주형 크로스 엔트로피 (Categorical Cross-Entropy): 정답 확률 분포가 여러 개의 카테고리 중 하나일 때 정답과의 불일치를 측정한다.

옵티마이저에게 필요한 기울기를 계산하는 '역전파(Backpropagation)'

손실 함수가 오차를 계산하면 옵티마이저가 곧바로 가중치를 수정할 수 있을까? 그렇지 않다. 손실 함수는 단순히 "현재 모델이 얼마나 틀렸는지"를 하나의 수치로 알려줄 뿐이다. 하지만 어느 가중치가 이 오차에 얼마나 영향을 주었는지, 그리고 그 가중치를 어느 방향으로 조정해야 손실이 줄어드는지는 알려주지 않는다.
이때 필요한 과정이 바로 역전파(Backpropagation)다. 역전파는 손실 함수에서 계산된 손실값을 기준으로, 모델의 출력층에서 입력층 방향으로 거꾸로 미분을 수행한다. 이 과정에서 각 파라미터, 즉 가중치와 편향이 손실에 얼마나 영향을 주었는지를 나타내는 기울기(Gradient)를 계산한다. 이 기울기는 옵티마이저가 파라미터를 업데이트하기 위해 참고하는 핵심 정보(설명서)가 된다.

설명서를 받아 실행하는 '옵티마이저(Optimizer)'

손실 함수는 단순히 "현재 이만큼 틀렸다"는 결과물인 손실 값만 제공할 뿐이다. 그렇다면 모델은 이 손실 값을 어떻게 줄여나갈 수 있을까?

모델은 내부에 있는 가중치(Weight)와 편향(Bias)이라는 파라미터를 조정하면서 예측을 바꾼다. 이 가중치와 편향을 어떤 방향으로, 얼마나 크게 움직여야 가장 빠르고 안정적으로 오차의 최저점에 도달할 수 있을지 이동 법칙을 결정하고, 그 결과에 맞춰 모델 내부의 가중치와 편향을 '실제로 수정(업데이트)'하는 알고리즘이 바로 옵티마이저(Optimizer)다.

핵심 요약

손실 함수: 현재 모델이 얼마나 틀렸는지 알려주는 정량적 '기준'
옵티마이저: 그 오차를 줄이기 위해 모델의 파라미터를 어떻게 수정할지 결정하는 '방법'

2. 경사하강법(Gradient Descent): 손실을 줄이는 가장 기본적인 방법

모든 옵티마이저의 뿌리이자 가장 클래식한 알고리즘이 바로 경사하강법(Gradient Descent)이다. 앞서 1장에서 살펴본 파이프라인을 떠올려보면, 경사하강법은 3단계 역전파(Backpropagation) 단계로부터 각 파라미터의 기울기(Gradient) 정보를 고스란히 넘겨받아 4단계 최적화(Optimization)를 수행하는 주체다.

경사하강법의 작동 범위와 메커니즘

경사하강법이 정확히 어떤 데이터를 받고 무엇을 실행하는지 경계를 명확히 하면 다음과 같다.

전달받는 것 (Input): 역전파 알고리즘이 계산해낸 현재 파라미터 위치에서의 기울기(Gradient) 정보
수행하는 것 (Action): 동일한 학습률(Learning Rate) 기준 하에, 기울기가 가리키는 반대 방향(내리막길)으로 가중치와 편향 값을 직접 수정(업데이트)

수학적으로 기울기(Gradient)는 함수 값이 가장 가파르게 '증가'하는 방향을 나타낸다. 따라서 우리의 목표인 손실 함수의 최저점을 찾으려면 기울기 값에 마이너스(-)를 붙여 반대 방향으로 파라미터를 이동시켜야 한다.

수식과 코드의 1:1 직관적 비교

경사하강법의 수학적 공식과 이를 컴퓨터가 실행할 수 있도록 구현한 파이썬 코드를 매칭해 보면 그 구조를 아주 명확하게 이해할 수 있다.

1. 경사하강법 옵티마이저가 파라미터를 업데이트하는 식

다음 파라미터 = 현재 파라미터 - 학습률 × 현재 위치에서의 손실 함수 기울기
θ (Theta / theta)
- 모델 내부의 가중치(Weight)나 편향(Bias)을 의미하는 파라미터.
∇L(θ) (Gradient / gradients)
- 역전파 단계에서 계산되어 넘어온 손실 함수의 기울기.
- 현재 위치에서 손실이 가장 빠르게 증가하는 방향, 즉 오르막길 방향을 알려주는 지표다.
η (Eta / learning_rate)
- 사용자가 직접 설정하는 학습률이다.
- 파라미터를 한 번에 얼마나 크게 움직일지 결정하는 보폭의 기준 역할을 한다.

2. 파이썬 코드

import time

# [4단계: 최적화] 오직 기울기(gradient)만 넘겨받아 파라미터를 수정하는 경사하강법 함수
def gradient_descent(theta, learning_rate, gradient):
    """
    θ_next = θ_current - (learning_rate * gradient)
    """
    # 동일한 학습률 기준 하에, 넘어온 기울기 크기에 비례하여 내리막길(-) 방향으로 업데이트
    next_theta = theta - learning_rate * gradient
    return next_theta

# ==========================================
# 코랩 실습 시뮬레이션 환경 세팅
# ==========================================
current_theta = 10.0   # 시작 가중치 (산 꼭대기 위치)
learning_rate = 0.1    # 보폭 기준 값
total_steps = 3        # 시뮬레이션할 가상 루프 횟수

print("=" * 50)
print(f"  경사하강법(GD) 최적화 시뮬레이션을 시작합니다.")
print(f"   - 시작 가중치(theta): {current_theta}")
print(f"   - 고정 학습률(learning_rate): {learning_rate}")
print("=" * 50)
time.sleep(0.5)

# 가상으로 역전파가 매 회차 다른 기울기를 계산해서 던져주는 루프
for step in range(1, total_steps + 1):
    
    # [3단계 역전파 가정] 최저점에 가까워질수록 기울기(경사)가 점점 완만해진다고 가정한 가상 데이터
    if step == 1:   calculated_gradient = 8.0   # 처음엔 매우 가파름
    elif step == 2: calculated_gradient = 5.0
    elif step == 3: calculated_gradient = 3.0
    
    print(f"\n  [Iteration {step}]")
    print(f"    [3단계 역전파 완료] 계산된 기울기(Gradient) = {calculated_gradient}")
    
    # [4단계 최적화] 경사하강법으로 가중치 실제 수정 및 갱신
    updated_theta = gradient_descent(current_theta, learning_rate, calculated_gradient)
    
    # 로그 출력으로 변화 확인
    print(f"  ⚙️  [4단계 최적화 완료] 연산 식: {current_theta:.2f} - ({learning_rate} * {calculated_gradient})")
    print(f"    [파라미터 갱신 결과] theta 상태 변경: {current_theta:.2f} ➡️ {updated_theta:.2f}")
    
    # 다음 회차를 위해 현재 가중치를 업데이트된 값으로 교체
    current_theta = updated_theta
    time.sleep(0.3)

print("\n" + "=" * 50)
print(f"  최종 시뮬레이션 종료! 정답 바닥에 안착한 theta: {current_theta:.2f}")
print("=" * 50)

⚠️ Gradient Descent의 한계점

원리가 단순하고 직관적이라는 강력한 장점이 있지만, 실제 복잡한 딥러닝 모델의 손실 함수 지형에서는 다음과 같은 명확한 한계에 부딪힌다.

1) 로컬 미니마(Local Minima)와 안장점(Saddle Point)의 덫

오직 현재 시점에 눈앞에 보이는 기울기 정보만 보고 발을 내딛기 때문에 지형의 함정에 쉽게 빠진다. 진짜 최저점(Global Minimum)으로 가는 길목에 있는 얕은 웅덩이(Local Minima)를 만나거나, 말의 안장처럼 사방이 평평해져 기울기가 0이 되어버리는 평지(안장점, Saddle Point)를 만나면 그곳이 정답인 줄 알고 학습을 멈춰버리는 문제가 발생한다.

3. Adam: 과거 gradient를 기억하는 개선된 방법

Adam(Adaptive Moment Estimation, 적응적 모멘트 추정)은 현대 딥러닝 연구와 실무 환경에서 가장 범용적으로 선택되는 옵티마이저다.

기본 경사하강법이 오직 현재 시점의 단일 기울기(Gradient) 정보만을 파라미터 업데이트에 반영하는 한계를 가졌다면, Adam은 과거 계산된 기울기들의 통계적 방향성과 크기 정보를 지수 이동 평균(Exponential Moving Average) 형태로 누적하여 활용하는 알고리즘이다. 이를 위해 Adam은 기울기의 방향성을 제어하는 기능과 파라미터별 보폭을 조절하는 두 가지 핵심 메커니즘을 결합했다.

Adam의 작동 범위와 메커니즘

Adam이 정확히 어떤 데이터를 받고 무엇을 실행하는지 경계를 명확히 하면 다음과 같다.

전달받는 것 (Input): 역전파 알고리즘이 계산해낸 현재 파라미터 위치에서의 기울기(Gradient) 정보
수행하는 것 (Action): 과거 기울기들을 기반으로 계산된 '방향(1차 모멘트)'과 파라미터별 '맞춤형 보폭(2차 모멘트)'을 조합하여 가중치와 편향 값을 직접 수정(업데이트)

수학적으로 단순히 현재의 경사면에만 순종하는 GD와 달리, Adam은 직전까지 내려오던 흐름을 유지하려는 관성을 연산에 개입시키고 지형의 가파른 정도에 따라 학습률을 스스로 격차를 두어 조절한다.

수식과 코드의 1:1 직관적 비교

Adam의 수학적 공식과 이를 컴퓨터가 실행할 수 있도록 구현한 파이썬 코드를 매칭해 보면 파이토치(PyTorch) 내부에서 어떤 연산이 일어나는지 명확히 이해할 수 있다.

1. Adam 옵티마이저가 파라미터를 업데이트하는 식

θ (Theta / theta): 모델 내부의 가중치(Weight)나 편향(Bias)을 의미하는 파라미터.
g_t (Gradient / gradient): 역전파 단계에서 계산되어 넘어온 현재 시점(t)의 손실 함수 기울기.
m_t / m_hat_t (1차 모멘트): 과거 기울기들의 지수 이동 평균. 업데이트의 '최종 방향(관성)'을 결정한다.
v_t / v_hat_t (2차 모멘트): 과거 기울기 제곱들의 지수 이동 평균. 파라미터별 '적응적 보폭'을 결정한다.
η (Eta / lr): 사용자가 지정하는 기본 학습률.
β1, β2 (beta1, beta2): 과거 기억을 얼마나 남겨두고 축적할지 결정하는 하이퍼파라미터.
ε (Epsilon / eps): 분모가 0이 되는 연산 에러를 막기 위한 수치 안정성 상수.

2. 파이썬 코드

import numpy as np

# 1. 환경 세팅 (PyTorch Adam 기반 파라미터)
lr = 0.1            # 기본 학습률 (보폭 기준)
beta1, beta2 = 0.9, 0.5  # beta2를 0.5로 낮춰 3번 만에 보폭 변화가 보이도록 설정
eps = 1e-08

# 기억 장치 및 시작 가중치 초기화
m, v = 0.0, 0.0
theta = 10.0

# 가상의 절벽 지형: 1회차에 엄청 가파르다가, 2회차부터 순식간에 평지가 됨
gradients = [20.0, 0.1, 0.1] 

print("-" * 60)
print(f"  Adam 최적화 시작 (시작 가중치: {theta} | 학습률: {lr})")
print("-" * 60)

for step in range(1, 4):
    grad = gradients[step - 1]
    
    # [방향 누적] 과거 기울기 흐름 기록
    m = beta1 * m + (1 - beta1) * grad
    
    # [보폭 누적] 과거 기울기 제곱 흐름 기록
    v = beta2 * v + (1 - beta2) * (grad ** 2)
    
    # [초기 편향 보정]
    m_hat = m / (1 - beta1 ** step)
    v_hat = v / (1 - beta2 ** step)
    
    # [최적화 실행] 맞춤형 보폭을 반영하여 업데이트
    next_theta = theta - (lr / (np.sqrt(v_hat) + eps)) * m_hat
    
    # 변동량 계산 (현재 위치에서 얼마나 멀리 이동했는가)
    step_size = abs(next_theta - theta)
    
    print(f"[Iteration {step}] 입력 기울기: {grad}")
    print(f"  - 현재 가중치 상태 : {theta:.2f} ➡️ {next_theta:.2f}")
    print(f"  - 실제 파라미터 보폭: {step_size:.4f}")
    print("-" * 60)
    
    theta = next_theta

⚠️ Adam의 한계점

지형의 한계를 똑똑하게 극복하는 만능 옵티마이저처럼 보이지만, 실제 학습 환경에서는 다음과 같은 명확한 부작용을 마주한다.

1) 일반화(Generalization) 성능의 한계 (막판 스퍼트 부실)

학습 초·중반에는 온갖 함정을 다 피해 다니며 압도적으로 빠르게 오차를 줄여나간다. 하지만 학습 후반부에 접어들었을 때, 최종 테스트 데이터에 대한 정확도가 투접한 경사하강법(SGD) 계열에 밀리는 현상이 자주 발생한다. 파라미터별로 보폭을 독립적으로 계속 바꾸는 적응적 특성 때문에, 마지막 정밀 튜닝 구간에서 가장 깊고 정교한 최적점(Global Minimum)의 정중앙에 안착하지 못하고 주변을 미세하게 헤매는 경향이 있다.

2) 극심한 GPU 메모리(VRAM) 소모

기본 경사하강법은 현재 가중치 파라미터의 위치만 메모리에 들고 있으면 된다. 반면 Adam은 모든 파라미터마다 1차 모멘트(m, 방향) 주머니와 2차 모멘트(v, 보폭) 주머니를 하나씩 더 차고 있어야 한다. 즉, 기억해야 할 변수가 3배로 늘어나기 때문에 대규모 모델(LLM 등)을 학습할 때 GPU 메모리 압박이 매우 심하다.

4. Gradient Descent와 Adam의 알고리즘적 차이와 선택 기준

알고리즘적 핵심 차이

두 알고리즘의 본질적인 차이는 역전파로 계산된 기울기(g_t)를 받아 과거의 이동 기록을 업데이트에 반영하는가에 있다.

Gradient Descent (경사하강법)

방향: 현재 시점의 기울기 방향만을 기준으로 움직인다. 이 때문에 안장점이나 로컬 미니마 부근처럼 기울기가 매우 작아지는 구간에서는 학습이 느려지거나 멈춘 것처럼 보일 수 있다.
보폭: 모든 파라미터에 사용자가 지정한 학습률(lr)을 동일하게 적용한다. 손실 함수 지형이 길고 좁은 계곡처럼 생긴 경우, 특정 방향으로 지그재그로 움직이며 수렴이 느려질 수 있다.

Adam (Adaptive Moment Estimation)

방향: 과거 기울기들의 이동 평균인 1차 모멘트를 사용해 이전 이동 방향을 어느 정도 기억한다. 덕분에 순간적으로 기울기가 작아지는 구간에서도 더 안정적으로 이동할 수 있다.
보폭: 과거 기울기 제곱의 이동 평균인 2차 모멘트를 사용해 파라미터별 업데이트 크기를 조절한다. 변화가 큰 파라미터는 조심스럽게, 변화가 작은 파라미터는 상대적으로 크게 업데이트할 수 있다.

연산 메커니즘 대조

비교 항목 Gradient Descent (경사하강법) Adam

핵심 판단 기준	현재 기울기	과거 기울기 정보 + 현재 기울기
연산 직관	theta - lr * gradient	theta - (lr / 적응적 보폭) * 관성 방향
메모리 소모	적음	큼. 파라미터별 1차·2차 모멘트를 추가로 저장

장단점 및 실무 선택 기준

1) Gradient Descent / SGD 계열

장점: 구조가 단순하고 메모리 사용량이 적다. Momentum, learning rate scheduler 등을 잘 조합하면 학습 후반부에 안정적으로 수렴하며 좋은 일반화 성능을 보이는 경우가 많다.
단점: 학습률 설정에 민감하고, 초기 수렴 속도가 Adam보다 느릴 수 있다.
실무 선택 기준: CNN 기반 이미지 분류처럼 최종 일반화 성능을 중요하게 보는 문제에서 자주 고려된다. 충분한 학습 시간과 튜닝 여유가 있을 때 적합하다.

2) Adam

장점: 초기 수렴 속도가 빠르고, 파라미터별로 업데이트 크기를 조절하기 때문에 학습률 설정 부담이 상대적으로 적다.
단점: 파라미터마다 1차·2차 모멘트를 저장해야 하므로 메모리 사용량이 크다. 경우에 따라 SGD 계열보다 일반화 성능이 낮게 나올 수 있다.
실무 선택 기준: NLP, Transformer, LLM 파인튜닝처럼 파라미터 수가 많고 손실 지형이 복잡한 모델에서 널리 사용된다. 현재는 Adam에 weight decay를 더 적절하게 적용한 AdamW가 실무에서 자주 사용된다.

[프로그래머스 LV.2] 괄호 회전하기 — Python 정답 & 해설

작지만 꾸준한 성장으로 — Tue, 16 Jun 2026 21:51:46 +0900

1. 문제 URL

https://school.programmers.co.kr/learn/courses/30/lessons/76502

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

2. 문제 요구사항 정리

대괄호, 중괄호, 소괄호로 이루어진 문자열 s가 주어졌을 때, 문자열을 왼쪽으로 x칸 회전했을 때 올바른 괄호 문자열이 되는 경우의 수를 구하는 문제입니다.

회전 범위: x는 0부터 s의 길이 - 1까지이며, 모든 회전 경우를 확인해야 합니다.
검증 기준: 여는 괄호와 닫는 괄호의 종류와 순서가 모두 올바르게 맞아야 합니다.
반환값: 올바른 괄호 문자열이 되는 회전 횟수의 개수를 반환합니다.

3. 핵심 개념

✔ 1) 문자열 회전 만들기

각 x에 대해 문자열을 왼쪽으로 회전한 결과를 확인해야 합니다. Python에서는 s[i:] + s[:i] 형태로 i번째 위치부터 끝까지의 문자열과 앞부분 문자열을 이어 붙이면 회전된 문자열을 만들 수 있습니다.

✔ 2) 스택으로 괄호 유효성 검사하기

올바른 괄호 문자열인지 확인할 때는 스택을 사용합니다. 여는 괄호가 나오면 stack에 넣고, 닫는 괄호가 나오면 stack의 마지막 값이 짝이 맞는 여는 괄호인지 확인합니다.

✔ 3) 실패 조건을 빠르게 처리하기

닫는 괄호가 나왔는데 stack이 비어 있거나, stack의 마지막 괄호와 짝이 맞지 않으면 해당 회전 문자열은 더 볼 필요가 없습니다. 이때 is_valid를 False로 바꾸고 바로 반복을 종료하면 불필요한 검사를 줄일 수 있습니다.

✅ 4. 정답 Python 코드

def solution(s):
    # 대괄호, 중괄호, 그리고 소괄호로 이루어진 문자열 s
    # 왼쪽으로 x칸 만큼 회전시켜야 올바른 괄호 문자열이 되게 하고, x 출력
    # 0 ~ len(s) 까지 수행. 맞으면 카운트 +1 누적
    x = 0
    pair = {']': '[', '}': '{', ')': '('}
    
    
    for i in range(len(s)):
        shifted = s[i:] + s[:i]
        
        
        stack = []
        is_valid = True
        
        
        for char in shifted:
            if char in ['[', '{', '(']:
                stack.append(char)
            else:
                if not stack or stack[-1] != pair[char]:
                    is_valid = False
                    break
                else:
                    stack.pop() 
        
        
        if is_valid and not stack:
            x += 1
    
    return x

5. 풀이하면서 느낀 점

처음에는 문자열을 회전시키는 부분이 핵심이라고 생각했는데, 풀이를 정리하다 보니 실제로 중요한 부분은 각 회전 결과가 올바른 괄호 문자열인지 안정적으로 검증하는 과정이었습니다.

그래서 각 회전마다 stack을 새로 만들고, 닫는 괄호가 나올 때마다 직전 여는 괄호와 짝이 맞는지 확인하는 방식으로 풀었습니다. 조건이 맞지 않는 순간 바로 break하도록 처리해서 불필요한 검사를 줄일 수 있었습니다.

또한, 문자열을 매번 새로 만드는 대신 인덱스를 순환시키는 방식으로도 접근할 수 있다는 점을 이후에 생각해볼 수 있었습니다.

[프로그래머스 LV.0] 유한소수 판별하기 — Python 정답 & 해설

작지만 꾸준한 성장으로 — Sat, 13 Jun 2026 23:49:55 +0900

1. 문제 URL

https://school.programmers.co.kr/learn/courses/30/lessons/120878

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

2. 문제 요구사항 정리

두 정수 a와 b가 주어졌을 때, 분수 a / b가 유한소수로 표현될 수 있는지 판별하는 문제입니다. 유한소수라면 1을, 무한소수라면 2를 반환해야 합니다.

핵심 조건: 기약분수로 만들었을 때 분모의 소인수가 2와 5만 남아야 유한소수입니다.
약분 처리: a와 b의 최대공약수로 b를 나누어 기약분수의 분모를 구합니다.
반환값: 분모에서 2와 5를 모두 제거한 뒤 1이 남으면 1, 다른 값이 남으면 2를 반환합니다.

3. 핵심 개념

✔ 1) 최대공약수로 기약분수 만들기

유한소수 여부는 원래 분모가 아니라 기약분수로 바꾼 뒤의 분모를 기준으로 판단해야 합니다. 따라서 math.gcd(a, b)를 이용해 a와 b의 최대공약수를 구하고, b를 그 값으로 나누어 약분된 분모 n을 만듭니다.

✔ 2) 유한소수의 분모 조건 이해하기

어떤 분수가 유한소수가 되려면 기약분수의 분모가 2와 5만을 소인수로 가져야 합니다. 10이 2 × 5로 이루어져 있기 때문에, 분모를 10의 거듭제곱 형태로 만들 수 있는 경우에만 소수점 아래가 유한하게 끝납니다.

✔ 3) 2와 5를 반복해서 제거하기

약분된 분모 n에서 2로 나누어떨어지는 동안 계속 2를 제거하고, 5로 나누어떨어지는 동안 계속 5를 제거합니다. 이 과정을 마친 뒤 n이 1이면 2와 5 외의 소인수가 없다는 뜻이므로 유한소수입니다.

✅ 4. 정답 Python 코드

import math 

def solution(a, b):
    ## 유한소수면 1, 아니면 2
    gcd_num = math.gcd(a, b)
    n = b // gcd_num
    
    while n % 2 == 0:
        n //= 2
        
    while n % 5 == 0:
        n //= 5
    
    return 1 if n ==1 else 2

5. 풀이하면서 느낀 점

처음에는 분모에 2와 5만 있는지 확인하면 된다고 단순하게 생각할 수 있는데, 풀이를 정리하다 보니 먼저 기약분수로 약분하는 과정이 핵심이라는 점을 떠올릴 수 있었습니다. 분모가 처음에는 복잡해 보여도 약분하고 나면 유한소수 조건을 만족할 수 있기 때문입니다.

그래서 최대공약수로 분모를 줄인 뒤, 남은 분모에서 2와 5를 하나씩 걷어내는 방식으로 풀었습니다. 수학 개념을 코드로 옮기는 문제라서 어렵지는 않았지만, 조건을 확인하는 순서를 놓치면 틀리기 쉬운 문제라고 느꼈습니다.

또한, math.gcd() 함수를 이용하는게 아닌, 유클리드 호제법으로도 풀이가 가능하다는 점을

[프로그래머스 LV.0] 배열 만들기 2 — Python 정답 & 해설

작지만 꾸준한 성장으로 — Thu, 11 Jun 2026 16:54:26 +0900

1. 문제 URL

https://school.programmers.co.kr/learn/courses/30/lessons/181921

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

2. 문제 요구사항 정리

정수 l과 r이 주어졌을 때, l 이상 r 이하의 정수 중에서 숫자 0과 5로만 이루어진 수를 모두 찾아 배열로 반환하는 문제입니다.

탐색 범위: l부터 r까지의 모든 정수를 확인합니다.
조건: 각 정수를 문자열로 바꿨을 때 모든 문자가 0 또는 5여야 합니다.
예외 처리: 조건을 만족하는 수가 하나도 없다면 [-1]을 반환합니다.

3. 핵심 개념

✔ 1) 숫자를 문자열로 변환해 자리수 확인하기

각 숫자의 모든 자리수가 0 또는 5인지 확인해야 하므로, 숫자를 문자열로 변환하면 한 글자씩 쉽게 검사할 수 있습니다. 예를 들어 505는 문자열 "505"로 바꾼 뒤 각 문자가 "0" 또는 "5"에 포함되는지 확인하면 됩니다.

✔ 2) all() 함수로 모든 조건 만족 여부 확인하기

Python의 all() 함수는 반복 가능한 값들이 모두 True일 때만 True를 반환합니다. 따라서 all(char in "05" for char in str(cur))처럼 작성하면 현재 숫자의 모든 자리수가 0 또는 5인지 간단하게 확인할 수 있습니다.

✔ 3) 조건을 만족하는 값이 없는 경우 처리하기

문제에서는 조건을 만족하는 정수가 없다면 -1이 담긴 배열을 반환해야 합니다. 따라서 탐색이 끝난 뒤 answer가 비어 있는지 확인하고, 비어 있다면 -1을 추가해 예외 상황을 처리합니다.

✅ 4. 정답 Python 코드

def solution(l, r):
    # 없는 경우 -1 리턴 예외처리
    
    answer = []
    
    for cur in range(l, r + 1):
        # 0이나 5 이외의 숫자가 들었다면 
        if all(char in "05" for char in str(cur)):
            answer.append(cur)
            
    if len(answer) == 0:
        answer.append(-1)
        
    return answer

5. 풀이하면서 느낀 점

처음에는 숫자의 각 자리수를 직접 나누어 확인하는 방식도 생각할 수 있지만, Python에서는 문자열로 변환하면 훨씬 간단하게 조건을 검사할 수 있었습니다.

특히 all()과 제너레이터 표현식을 함께 사용하면 모든 자리수가 조건을 만족하는지 한 줄로 확인할 수 있어 코드가 깔끔해졌습니다. 조건을 만족하는 수가 없을 때 [-1]을 반환해야 한다는 예외 처리도 마지막에 한 번만 확인하면 되어 흐름이 단순했습니다.

[프로그래머스 LV.0] 배열 조각하기 — Python 정답 & 해설

작지만 꾸준한 성장으로 — Thu, 11 Jun 2026 16:46:06 +0900

1. 문제 URL

https://school.programmers.co.kr/learn/courses/30/lessons/181893

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

2. 문제 요구사항 정리

정수 배열 arr와 query가 주어졌을 때, query를 순서대로 확인하면서 arr의 특정 구간만 남기는 문제입니다. query의 인덱스가 짝수인지 홀수인지에 따라 잘라내는 방향이 달라집니다.

짝수 인덱스: query[i]번 인덱스까지는 남기고, 그 뒤쪽 원소들을 잘라냅니다.
홀수 인덱스: query[i]번 인덱스부터 끝까지 남기고, 그 앞쪽 원소들을 잘라냅니다.
최종 반환값: 모든 query를 처리한 뒤 남아 있는 arr의 부분 배열을 반환합니다.

3. 핵심 개념

✔ 1) query의 인덱스 기준으로 동작 나누기

이 문제에서 중요한 점은 query의 값 자체가 아니라, 현재 query가 몇 번째 인덱스에 있는지입니다. 인덱스가 짝수라면 뒤쪽을 제거하고, 홀수라면 앞쪽을 제거해야 하므로 idx % 2 값을 기준으로 분기할 수 있습니다.

✔ 2) Python 슬라이싱으로 배열 자르기

Python에서는 슬라이싱을 이용하면 배열의 일부 구간만 간단하게 가져올 수 있습니다. arr[:val + 1]은 0번 인덱스부터 val번 인덱스까지 남기고, arr[val:]은 val번 인덱스부터 마지막 원소까지 남깁니다.

✔ 3) 매 단계마다 갱신되는 arr 사용하기

query를 처리할 때마다 arr의 길이와 원소 구성이 달라집니다. 따라서 처음 주어진 arr를 기준으로 계속 계산하는 것이 아니라, 매번 잘라낸 결과를 다시 arr에 저장하면서 다음 query를 처리해야 합니다.

✅ 4. 정답 Python 코드

def solution(arr, query):
    for idx, val in enumerate(query):
        if idx % 2 == 1: # 홀수 인덱스
            arr = arr[val : ]
        else: # 짝수 인덱스
            arr = arr[ : val + 1]
    
    return arr

5. 풀이하면서 느낀 점

문제 설명만 보면 앞부분과 뒷부분을 번갈아 자르는 과정이 조금 헷갈릴 수 있지만, query의 인덱스가 짝수인지 홀수인지에 따라 동작을 나누면 훨씬 단순하게 정리할 수 있는 문제였습니다.

특히 Python 슬라이싱의 끝 인덱스는 포함되지 않는다는 점을 잘 기억해야 했습니다. 짝수 인덱스에서 query[i]번 인덱스까지 남겨야 하므로 arr[:val + 1]처럼 +1을 해주는 부분이 핵심이었습니다.

[Python/Pandas] 데이터 리모델링 완벽 이해: 와이드 포맷을 롱 포맷으로 (melt와 pivot)

작지만 꾸준한 성장으로 — Sat, 6 Jun 2026 09:44:01 +0900

1. 데이터 리모델링의 이해

1) 데이터 리모델링이란?

정의: 수집된 원천 데이터(Raw Data)의 형태를 분석 목적이나 시각화 도구의 요구 조건에 맞게 데이터프레임의 구조(행과 열)를 재구성하는 프로세스다.
필요성: 현업이나 공공데이터 포털에서 제공되는 데이터가 항상 분석과 집계에 최적화된 형태로 제공되지는 않기 때문에 리모델링 과정이 필수적이다.
주요 패키지: 파이썬 생태계에서는 Pandas가 데이터 리모델링 패키지 역할을 수행한다. (R 언어의 tidyr, reshape2와 궤를 같이함)

2) 데이터 형태의 두 가지 분류: Wide Format vs Long Format

데이터 분석 라이브러리와 시각화 도구를 효율적으로 다루기 위해서는 두 포맷의 명확한 차이와 장단점을 이해해야 한다.

① 와이드 포맷 (Wide Format)

특징: 사람이 눈으로 읽고 직관적으로 파악하기 좋은 형태다. (.xlsx, .csv 보고서용 포맷)

학생 이름 1학기 국어 1학기 수학 2학기 국어 2학기 수학

harry	90	85	95	90
alex	100	100	100	100

장점 (인간 중심): 한 개체(예: 학생)의 모든 데이터가 한 줄(Row)에 표현된다. 사람은 정보를 가로로 훑는 데 익숙하며 공간을 적게 차지하여 인쇄용 보고서에 적합하다.
단점 (컴퓨터/라이브러리 관점): 데이터의 중요한 의미(학기, 과목 등)가 '컬럼명'에 숨어 있다. 컴퓨터 입장에서 1학기 수학은 단순한 텍스트일 뿐이므로, 전체 학기의 수학 평균을 구하려면 컬럼명을 일일이 파싱해 찾아내는 복잡한 로직이 강제된다. 특히 새로운 학기 데이터가 추가될 때마다 데이터프레임의 열(Column) 구조를 아예 새로 만들어야 하므로 확장성이 최악이다.

② 롱 포맷 (Long Format)

특징: 컴퓨터와 분석/시각화 툴(Pandas, Seaborn 등)이 가장 좋아하는 깔끔한(Tidy) 형태다. 기준 열을 고정한 채 데이터를 밑으로 길게 쌓는 방식(Melt)이다.

학생 이름 학기 과목 점수

harry	1학기	국어	90
harry	1학기	수학	85
harry	2학기	국어	95
harry	2학기	수학	90
alex	1학기	국어	100
...	...	...	...

장점 (컴퓨터/라이브러리 관점): '고정된 구조와 손쉬운 필터링'이 가능하다. 새로운 과목이나 학기가 추가되더라도 열 구조는 그대로 유지한 채 행(Row)만 아래로 추가하면 된다. 컴퓨터는 기본적으로 세로(컬럼) 방향 연산에 최적화되어 있으므로 집계 함수를 적용하기에 가장 이상적이다.
단점 (인간 중심): 동일한 식별자(harry)가 여러 행에 걸쳐 중복 출력되고 아래로 지나치게 길어져, 스크롤을 내리며 한눈에 데이터를 파악하기 어렵다.

2. 데이터 리모델링 실전 파이프라인 (End-to-End 예제)

실제 공공데이터 포털에서 와이드 포맷의 CSV 파일을 다운로드하여

으로 이어지는 전체 분석 파이프라인 흐름이다.

< 참고>
- .csv → 쉼표로 구분된 값(Comma-Separated Values)을 뜻하는 파일 형식
- https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html#pandas.read_csv - 0번 .csv 파일 읽기
- 그룹별 여러 집계 연산 - 4번 데이터 집계 .agg()
- 출력 결과 - 4번 데이터 집계 .reset_index()
  - groupby의 기준이 되어 인덱스로 가버린 '지점' 컬럼을 다시 일반 열로 내려주고 인덱스를 기본 숫자(0,1,2..)로 정렬

1) 예제 코드

import pandas as pd

# ==========================================
# 0. [공공데이터 시나리오] pd.read_csv() 로드 단계
# ==========================================
# ※ 실제 공공데이터 포털에서 다운로드한 '지점별_매출.csv' 파일이 아래와 같다고 가정합니다.
# ------------------------------------------
# [지점별_매출.csv 원본 형태]
# 지점,1월,2월
# "서울 ",100,150
# "부산",200,250
# "서울 ",100,150
# "광주",300,350
# ------------------------------------------
#
# [공식 문서 핵심 파라미터 적용 가이드]
# - filepath_or_buffer: '지점별_매출.csv' (읽어올 파일 경로)
# - encoding='utf-8': 한글 깨짐 방지를 위한 표준 인코딩 옵션 (윈도우 환경에선 cp949 사용)
# - header=0: 파일의 몇 번째 행을 컬럼명(헤더)으로 지정할지 설정 (기본값은 0번째 행).
#             만약 파일 첫 줄에 쓸데없는 제목이 있고 2번째 줄부터 데이터가 시작된다면 header=1로 설정하여 정제함.
#
# [코드 실행] 아래 코드를 통해 원천 CSV 파일이 '데이터프레임 단위'로 메모리에 로드됩니다.
# df_wide = pd.read_csv('지점별_매출.csv', encoding='utf-8', header=0)

# (실습 편의를 위해 read_csv 결과물과 동일한 데이터프레임을 수동 생성하여 파이프라인을 시작합니다.)

# ==========================================
# 1. 원본 데이터: 사람이 보기 편하지만 오염된 [와이드 포맷]
# ==========================================
# - '지점'명에 공백 존재 (문자열 오염 및 중복 발생)
df_wide = pd.DataFrame({
    '지점': ['서울 ', '부산', '서울 ', '광주'],  
    '1월': [100, 200, 100, 300],
    '2월': [150, 250, 150, 350]
})
print("=== [1] 원본 와이드 포맷 ===")
print(df_wide)

# ==========================================
# 2. 리모델링: 컴퓨터가 좋아하는 [롱 포맷]으로 구조 변경 (Melt)
# ==========================================
# [melt() 핵심 파라미터 3대장 한 줄 요약]
# - id_vars='지점': 세로로 녹이지 않고 기준점으로 고정해 둘 '기둥' 컬럼을 지정합니다.
# - var_name='월': 가로로 나열되어 있던 기존 컬럼명('1월', '2월')들을 모아서 새로 만들 '열 이름'입니다.
# - value_name='매출': 그 컬럼들 밑에 적혀 있던 진짜 숫자(값)들을 모아서 새로 만들 '열 이름'입니다.

df_long = df_wide.melt(
    id_vars='지점', 
    var_name='월', 
    value_name='매출'
)
print("\\n=== [2] melt 적용 후 롱 포맷 ===")
print(df_long)

# ==========================================
# 3. 데이터 변환(Transformation): 롱 포맷 상태에서 '단 한 줄로' 정제
# ==========================================
# - 롱 포맷은 구조가 고정되어 있어 컬럼이 늘어나도 전처리 코드가 변하지 않음
df_long['지점'] = df_long['지점'].str.strip()  # 문자열 처리: 공백 제거로 '서울 '을 '서울'로 통일
df_long = df_long.drop_duplicates()           # 중복 제거: 공백이 합쳐지면서 생긴 진짜 중복 행 제거
print("\\n=== [3] 데이터 변환 및 정제 완료 ===")
print(df_long)

# ==========================================
# 4. 데이터 집계(Aggregation): 6대 핵심 함수와 요약 표 완성
# ==========================================
# - 개별 기본 집계 함수 (sum, mean, count, max, min)를 .agg()로 묶어 다중 집계 수행
# - groupby()를 결합하여 지점별로 완벽하게 요약된 표(DataFrame)를 생성
df_result = df_long.groupby('지점')['매출'].agg(['sum', 'mean', 'count', 'max', 'min']).reset_index()

# 팀원들이 보기 편하게 요약 표 컬럼명 정제
df_result.columns = ['지점', '총합(sum)', '평균(mean)', '개수(count)', '최대(max)', '최소(min)']
print("\\n=== [4] 최종 데이터 집계 결과 (요약 표) ===")
print(df_result)

# ==========================================
# 5. 데이터 재구조화: 집계 완료된 데이터를 다시 보고서용 [피벗 테이블]로 변환
# ==========================================
# [공식 문서 pivot() 파라미터 설명]
# - index='지점': 새로운 표의 행(Row) 자리에 위치할 기준 컬럼을 지정합니다.
# - columns='지표': 새로운 표의 열(Column) 자리에 가로로 나열할 기존 행 데이터들을 지정합니다.
# - values='값': 표의 내부에 채워 넣을 진짜 수치형 데이터 컬럼을 지정합니다.

# 집계 표(df_result)를 사람이 가로로 한눈에 비교하기 좋게 '총합'과 '평균' 지표만 골라 피벗을 수행합니다.
df_long_summary = df_result.melt(id_vars='지점', var_name='지표', value_name='값') # 피벗을 보여주기 위해 살짝 롱 포맷화
df_final_pivot = df_long_summary.pivot(index='지점', columns='지표', values='값')

print("\\n=== [5] 최종 보고서용 피벗 테이블 (Pivot 완료) ===")
print(df_final_pivot)

2) 단계별 출력 결과

=== [1] 원본 와이드 포맷 ===
    지점   1월   2월
0  서울   100  150
1   부산  200  250
2  서울   100  150
3   광주  300  350

=== [2] melt 적용 후 롱 포맷 ===
    지점   월   매출
0  서울   1월  100
1   부산  1월  200
2  서울   1월  100
3   광주  1월  300
4  서울   2월  150
5   부산  2월  250
6  서울   2월  150
7   광주  2월  350

=== [3] 데이터 변환 및 정제 완료 ===
   지점   월   매출
0  서울  1월  100
1  부산  1월  200
3  광주  1월  300
4  서울  2월  150
5  부산  2월  250
7  광주  2월  350

=== [4] 최종 데이터 집계 결과 (요약 표) ===
   지점  총합(sum)  평균(mean)  개수(count)  최대(max)  최소(min)
0  광주      650     325.0          2      350      300
1  부산      450     225.0          2      250      200
2  서울      250     125.0          2      150      100

=== [5] 최종 보고서용 피벗 테이블 (Pivot 완료) ===
지표  개수(count)  총합(sum)  최대(max)  최소(min)  평균(mean)
지점                                                
광주        2.0    650.0    350.0    300.0     325.0
부산        2.0    450.0    250.0    200.0     225.0
서울        2.0    250.0    150.0    100.0     125.0

3. 핵심 요약 및 결론

데이터 전처리와 집계는 유기적인 파이프라인이다: 데이터 리모델링과 전처리, 집계는 각각 분리된 작업이 아니다. 외부 정형 데이터(CSV) 로드 후 [컴퓨터가 좋아하는 롱 포맷 변환 (melt)] → [일괄 데이터 정제] → [그룹 기반 다중 집계 (groupby + agg)]→ [최종 사람 중심 보고서 변환 (pivot)]으로 이어지는 선형적 파이프라인 구조를 가질 때 개발 생산성과 코드 가독성이 극대화된다.
리모델링의 본질은 유지보수성 확보다:
롱 포맷으로 데이터를 리모델링하면 월별 컬럼이 아무리 우측으로 추가되거나 데이터의 양이 늘어나도 전처리 및 집계 코드가 단 한 줄도 변하지 않는 강력한 확장성을 확보할 수 있다. 이것이 현업 분석가들이 번거로운 형태 변환을 매 프로젝트마다 선행하는 핵심 원동력이다.

[FastAPI] async/await는 왜 필요할까? 비동기 처리의 본질과 모델 추론 API 예제로 이해하기

작지만 꾸준한 성장으로 — Sat, 30 May 2026 03:12:43 +0900

1. 미리보는 3줄 요약 (TL;DR)

비동기 처리의 본질: 한 작업을 더 빨리 끝내는 기술이 아니라, 결과값을 기다리는 동안 서버가 놀지 않게 하여 전체 처리 능력을 높이는 기술입니다.
async/await 문법의 핵심: async def 선언과 내부의 await 호출이 한 세트로 움직여야 하며, await은 대기하는 동안 이벤트 루프에 제어권을 돌려준다는 의미입니다.
무조건 비동기가 정답은 아니다: CPU를 오래 쓰는 작업에서는 효과가 제한적이며, 서비스 규모와 병목 지점에 따라 동기와 비동기 방식을 올바르게 선택해야 합니다.

2. 주제에 대한 깊은 이해

주요 개념 정리

FastAPI: Python으로 API 서버를 만들 수 있는 모던 웹 프레임워크입니다.
비동기 처리와 async/await의 차이: * 비동기 처리: 서버 자원을 효율적으로 쓰게 해주는 큰 개념 및 처리 방식입니다.
- async/await: Python에서 이 비동기 처리를 직관적으로 표현하는 문법적 수단입니다.
이벤트 루프 (Event Loop): 비동기 작업 관리자입니다. 서버에 들어오는 요청들을 계속 왔다 갔다 순회하면서, 지금 바로 실행 가능한 작업이 있는지 판단하고 처리합니다.
모델 추론 API: AI 모델을 학습시키는 API가 아니라, 이미 학습된 모델에게 입력을 주고 예측 결과를 받는 API입니다.
- 전체 흐름: 요청 ➡️ 입력 검증(Pydantic) ➡️ 전처리 ➡️ 모델 추론 ➡️ 후처리 ➡️ 응답 반환

3. 비동기 처리가 필요한 이유와 시나리오

호출, DB 조회, 큐 대기, 파일 입출력(I/O)처럼 결과값 반환까지 대기 시간이 긴 요청을 처리할 때, 서버가 그 시간을 낭비하지 않고 실행 가능한 다른 요청을 함께 처리하기 위함입니다.

동기 vs 비동기 트래픽 시나리오 비교

❌ 동기적 처리 (Sync)

한 작업이 끝날 때까지 다음 흐름이 그대로 멈춰서 기다리는 방식입니다.

A 요청 시작 ➡️ 모델 응답 대기 (3초간 서버 멈춤) ➡️ A 완료
B 요청 시작 ➡️ 모델 응답 대기 (3초간 서버 멈춤) ➡️ B 완료
C 요청 시작 ➡️ 모델 응답 대기 (3초간 서버 멈춤) ➡️ C 완료

⭕ 비동기적 처리 (Async)

대기 시간이 발생하면 시간을 낭비하지 않고 다음 요청을 바로 받습니다.

A 요청 시작 ➡️ 모델 응답 대기 (기다리는 동안 제어권 반납)
B 요청 시작 ➡️ 모델 응답 대기 (기다리는 동안 제어권 반납)
C 요청 시작 ➡️ 모델 응답 대기 (기다리는 동안 제어권 반납)
➡️ A / B / C 응답이 도착하는 순서대로 즉시 반환

️ 4. 검증을 위한 FastAPI PoC

import asyncio
import time
from fastapi import FastAPI

app = FastAPI()

# 실제 프로덕션 환경이라면 대형 AI 모델(가중치)이 로드되어 있다고 가정합니다.

# ------------------------------------------------------------------
# ❌ [시나리오 1] 동기(Sync) 방식의 모델 추론 API
# ------------------------------------------------------------------
@app.post("/predict/sync")
async def predict_sync(text: str):
    start_time = time.time()
    
    #   Blocking 작업 시뮬레이션
    # 예: 동기 방식 외부 API 호출, 동기 DB 조회, 동기 파일 I/O, 잘못 작성된 모델 호출
    # time.sleep은 현재 실행 흐름을 완전히 멈추는 동기 함수입니다.
    #
    # 즉, "async를 붙였는데도 서버가 막히는" 상황을 보여주는 예시입니다.

    time.sleep(5.0) 
    
    end_time = time.time()
    process_time = end_time - start_time
    return {
        "mode": "Sync (Blocking)",
        "input": text,
        "result": f"요약 완료 (소요시간: {process_time:.2f}초)"
    }

# ------------------------------------------------------------------
# ⭕ [시나리오 2] 외부 API를 활용한 비동기(Async) 방식의 모델 추론 API
# ------------------------------------------------------------------
@app.post("/predict/async")
async def predict_async(text: str):
    start_time = time.time()
    
    # ✨ I/O-Bound 대기 시뮬레이션 (예: OpenAI나 외부 Ollama 서버에 API 요청 후 대기)
    # asyncio.sleep은 대기하는 동안 '이벤트 루프'에 제어권을 반납하여 다른 요청을 받게 합니다.
    # (외부 AI API, DB, 큐 응답을 기다리는 I/O 대기 상황을 흉내냅니다.)
    #
    #   Q. 'await time.sleep(5.0)'은 안 되나요?
    #   A. time.sleep은 동기 함수이므로 await과 함께 사용할 수 없습니다. (= 자격 미달)
    #      마지막에 '10 + "안녕"'을 하면 데이터 타입이 맞지 않아 TypeError가 나는 것처럼
    #      await 뒤에 일반 함수를 넣으면 파이썬이 아래와 같은 자격 미달 에러를 던집니다.
    #        TypeError: object NoneType can't be used in 'await' expression
    
    await asyncio.sleep(5.0) 
    
    end_time = time.time()
    process_time = end_time - start_time
    return {
        "mode": "Async (Non-Blocking)",
        "input": text,
        "result": f"요약 완료 (소요시간: {process_time:.2f}초)"
    }

# ------------------------------------------------------------------
#   [상태 점검 API] 서버가 살아있는지 확인하는 가벼운 헬스체크
# ------------------------------------------------------------------
@app.get("/health")
def health_check():
    return {"status": "healthy", "message": "서버가 정상적으로 응답하고 있습니다!"}

⚖️ 5. 그렇다면 비동기가 무조건 정답일까? (한계와 선택)

① CPU를 오래 쓰는 작업에서의 제한

AI 모델 추론 과정에서 외부 API가 아닌, 서버 내부적으로 CPU를 극도로 오래 쓰는 연산 작업이 포함되어 있다면 비동기 처리의 효과가 제한적입니다.

② 일반 CRUD 및 게시글 조회(Read) API에서의 고민

비동기가 좋은 이유: 여러 사람이 하나의 게시글을 동시에 읽을 때, DB에서 내용을 가져오는 대기 시간이 존재하므로 비동기 드라이버나 ORM을 활용하면 서버가 대기하는 동안 다른 요청을 처리할 수 있어 효율이 좋아집니다.
고려해야 할 트레이드오프: 하지만 서버가 비동기로 요청을 너무 빠르게 다 받아내면, 역으로 데이터베이스(DB) 쪽에 부하가 몰릴 수 있습니다. 이런 경우 DB 단에서 캐싱이나 인덱스 최적화 같은 설계가 추가로 필요할 수 있습니다.

최종 요약

트래픽이 크지 않다면 동기 방식도 충분히 안정적이며 구현을 단순화시켜 줍니다. 무조건 비동기가 정답이라기보다는, 서비스의 규모와 시스템의 어느 지점에 병목이 있는지에 따라 개발자가 알맞게 선택해야 합니다.