[Python][AI] 로또 번호 예측 테스트 진행 및 결과 분석

출처 : https://dhlottery.co.kr/gameInfo.do?method=buyLotto

 

2025.02.18 - [개발 Code/인공지능 A.I.] - [Python][AI] 한국 로또 분석: 당첨 확률과 예측의 불가능성

2025.02.19 - [개발 Code/인공지능 A.I.] - [Python][AI] 한국 로또 분석: 당첨 번호 분석과 패턴 찾기(EDA)

2025.02.24 - [개발 Code/인공지능 A.I.] - [Python][AI] 한국 로또 분석 : 추가 EDA 및 ML 번호 예측

 

로또 번호 예측을 위한 추가 테스트를 진행하였다. 이번 테스트에서는 머신러닝 기반 모델을 활용하여 로또 당첨 번호를 예측하고, 그 성능을 평가하는 과정을 진행하였다.

---

1. 예측 모델 개요

---

예측을 위해 CatBoost, XGBoost, LightGBM, RandomForest 총 4가지 머신러닝 모델을 사용하였다.
각 모델은 로또 과거 데이터를 학습하고, 특정 회차에서 당첨될 가능성이 높은 숫자를 예측하는 방식으로 동작한다.

주요 특징

• 과거 10회차 데이터를 활용한 피처 생성
  • 가장 자주 등장한 번호
  • 홀수/짝수 비율
  • 낮은 숫자(1~22)의 비율
  • 최근 10회 동안 각 번호가 등장한 횟수 (1~45까지 45차원 벡터)
• 훈련 및 테스트 데이터 구성
  • 회차 11~800: 훈련 데이터 (train data)
  • 회차 801~1000: 검증 데이터 (validation data)
  • 회차 1001~1159: 테스트 데이터(test data)
• 4개 모델을 각각 학습하여 예측 확률을 평균화
  • 각 숫자(1~45)에 대해 예측 확률을 계산
  • 확률이 높은 6개 번호를 선택하여 최종 예측값으로 사용

---

2. 모델 학습 과정

---

각 번호(1~45)에 대해 개별적인 이진 분류 모델을 학습하였다.
즉, 숫자 1~45 각각에 대해 당첨될 확률을 예측하는 모델을 따로 학습하여 최종적으로 조합하는 방식이다.

훈련된 모델은 predict_numbers(X_test) 함수를 통해 테스트 데이터에서 당첨 확률이 높은 번호를 예측하게 된다.

 

전체 코드는 다음과 같다.

import pandas as pd
import numpy as np
from catboost import CatBoostClassifier
import xgboost as xgb
import lightgbm as lgb
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import roc_auc_score, average_precision_score

# CSV 파일에서 데이터 읽기 (컬럼: '회차', '번호1', '번호2', ..., '번호6')
data = pd.read_csv('./lotto/lotto.csv')

# 회차 순으로 정렬
data = data.sort_values('회차').reset_index(drop=True)

# 각 회차 당첨번호를 집합 형태로 변환
def row_to_set(row):
    return set([row['번호1'], row['번호2'], row['번호3'], row['번호4'], row['번호5'], row['번호6']])
data['winning_set'] = data.apply(row_to_set, axis=1)

# 피처 및 타깃 데이터 생성 (직전 10회 데이터를 활용하기 위해 11회차부터 사용)
features = []
targets = []
indices = []  # 회차 번호 저장

for i in range(10, len(data)):  # i=10는 11회차에 해당
    # 현재 회차 이전의 전체 데이터를 사용하여 가장 자주 당첨된 번호 계산
    past_draws = data.iloc[:i]
    freq = np.zeros(46)  # 인덱스 0은 사용하지 않음
    for ws in past_draws['winning_set']:
        for num in ws:
            freq[num] += 1
    most_freq = np.argmax(freq[1:]) + 1  # 인덱스 보정

    # 최근 10회 데이터 활용
    window = data.iloc[i-10:i]
    window_numbers = []
    for ws in window['winning_set']:
        window_numbers.extend(list(ws))
    window_numbers = np.array(window_numbers)
    
    # 홀수/짝수 비율
    odd_count = np.sum(window_numbers % 2 == 1)
    odd_ratio = odd_count / len(window_numbers)
    
    # 1~22번 (낮은 번호) 비율
    low_count = np.sum(window_numbers <= 22)
    low_ratio = low_count / len(window_numbers)
    
    # 최근 10회 당첨번호의 등장 횟수를 1~45까지 계산 (45차원 벡터)
    window_count = [np.sum(window_numbers == num) for num in range(1, 46)]
    
    # 최종 피처: [가장 자주 당첨된 번호, 홀수 비율, 낮은 번호 비율] + [최근 10회 각 번호 등장 횟수]
    feat = [most_freq, odd_ratio, low_ratio] + window_count
    features.append(feat)
    
    # 타깃: 현재 회차 당첨번호를 45차원 이진 벡터로 표현
    target = [1 if num in data.iloc[i]['winning_set'] else 0 for num in range(1, 46)]
    targets.append(target)
    indices.append(data.iloc[i]['회차'])

features = np.array(features)
targets = np.array(targets)

# 회차 번호를 기준으로 데이터 분할
# 훈련: 회차 11~800, 검증: 회차 801~1000, 테스트: 회차 1001 이상
train_idx = [i for i, x in enumerate(indices) if x <= 800]
val_idx = [i for i, x in enumerate(indices) if 801 <= x <= 1000]
test_idx = [i for i, x in enumerate(indices) if x >= 1001]

X_train, y_train = features[train_idx], targets[train_idx]
X_val, y_val = features[val_idx], targets[val_idx]
X_test, y_test = features[test_idx], targets[test_idx]

# 각 번호별 모델 학습을 위한 리스트 초기화
models_cat = []
models_xgb = []
models_lgb = []
models_rf  = []

for num in range(45):  # 번호 1~45 (인덱스 0부터 44)
    y_train_num = y_train[:, num]
    y_val_num = y_val[:, num]
    
    # CatBoost 모델
    model_cat = CatBoostClassifier(
        verbose=False,
        random_state=42
    )
    model_cat.fit(X_train, y_train_num, eval_set=(X_val, y_val_num), verbose=False)
    models_cat.append(model_cat)
    
    # XGBoost 모델
    model_xgb = xgb.XGBClassifier(
        eval_metric='logloss',
        random_state=42
    )
    model_xgb.fit(X_train, y_train_num, eval_set=[(X_val, y_val_num)], verbose=False)
    models_xgb.append(model_xgb)
    
    # LGBM 모델
    model_lgb = lgb.LGBMClassifier(
        random_state=42, 
        verbosity=-1
    )
    model_lgb.fit(X_train, y_train_num, eval_set=[(X_val, y_val_num)])
    models_lgb.append(model_lgb)
    
    # RandomForest 모델
    model_rf = RandomForestClassifier(
        random_state=42
    )
    model_rf.fit(X_train, y_train_num)
    models_rf.append(model_rf)

# 검증 또는 테스트 시, 네 모델의 예측 확률을 평균하여 최종 확률 산출
def predict_numbers(X):
    preds = []
    for i in range(len(X)):
        probs = []
        for j in range(45):
            prob_cat = models_cat[j].predict_proba(X[i].reshape(1, -1))[0][1]
            prob_xgb = models_xgb[j].predict_proba(X[i].reshape(1, -1))[0][1]
            prob_lgb = models_lgb[j].predict_proba(X[i].reshape(1, -1))[0][1]
            prob_rf  = models_rf[j].predict_proba(X[i].reshape(1, -1))[0][1]
            avg_prob = (prob_cat + prob_xgb + prob_lgb + prob_rf) / 4.0
            probs.append(avg_prob)
        preds.append(probs)
    return np.array(preds)

# 테스트 데이터에 대한 확률 예측
test_probs = predict_numbers(X_test)

# 상위 6개 번호 선택: 예측 확률이 가장 높은 번호 6개 선택
test_predictions = []
for probs in test_probs:
    top6 = np.argsort(probs)[-6:] + 1  # 인덱스 보정
    test_predictions.append(np.sort(top6))

# 기존 평가: Accuracy 및 F1-Score (다중 레이블 평가)
def evaluate_predictions(y_true, y_pred):
    accuracies = []
    f1s = []
    for true, pred in zip(y_true, y_pred):
        true_set = set(np.where(true==1)[0])
        pred_set = set(np.array(pred) - 1)  # 인덱스 조정
        tp = len(true_set & pred_set)
        fp = len(pred_set - true_set)
        fn = len(true_set - pred_set)
        accuracy = (tp + (45 - len(true_set) - fp)) / 45
        if tp == 0:
            f1 = 0
        else:
            precision = tp / (tp + fp)
            recall = tp / (tp + fn)
            f1 = 2 * precision * recall / (precision + recall)
        accuracies.append(accuracy)
        f1s.append(f1)
    return np.mean(accuracies), np.mean(f1s)

acc, f1 = evaluate_predictions(y_test, test_predictions)
print("테스트 Accuracy:", acc)
print("테스트 F1-Score:", f1)

# ROC-AUC 및 PR-AUC 평가 (다중 레이블의 경우 Macro Average 사용)
roc_auc = roc_auc_score(y_test, test_probs, average='macro')
pr_auc = average_precision_score(y_test, test_probs, average='macro')
print("테스트 ROC-AUC:", roc_auc)
print("테스트 PR-AUC:", pr_auc)

# 테스트 회차 당 5세트 예측 (실제 로또 구매 시 5회 구매 모사)
def generate_multiple_predictions(X, models_cat, models_xgb, models_lgb, models_rf, num_sets=5):
    all_sets = []
    for i in range(len(X)):
        probs = []
        for j in range(45):
            prob_cat = models_cat[j].predict_proba(X[i].reshape(1, -1))[0][1]
            prob_xgb = models_xgb[j].predict_proba(X[i].reshape(1, -1))[0][1]
            prob_lgb = models_lgb[j].predict_proba(X[i].reshape(1, -1))[0][1]
            prob_rf  = models_rf[j].predict_proba(X[i].reshape(1, -1))[0][1]
            avg_prob = (prob_cat + prob_xgb + prob_lgb + prob_rf) / 4.0
            probs.append(avg_prob)
        probs = np.array(probs)
        sets = []
        sorted_idx = np.argsort(probs)[::-1]
        # 첫 번째 세트: 상위 6개 번호
        sets.append(np.sort(sorted_idx[:6] + 1))
        # 추가 세트: 상위 번호 조합에서 일부 번호를 교체하여 변형 적용
        for s in range(1, num_sets):
            candidate = list(sorted_idx[:6])
            idx_to_swap = s % 6
            for cand in sorted_idx:
                if cand not in candidate:
                    candidate[idx_to_swap] = cand
                    break
            sets.append(np.sort(np.array(candidate) + 1))
        all_sets.append(sets)
    return all_sets

multiple_predictions = generate_multiple_predictions(X_test, models_cat, models_xgb, models_lgb, models_rf, num_sets=5)

# 예시: 첫 번째 테스트 회차의 5세트 예측 번호 출력
print("첫 번째 테스트 회차 예측 번호 5세트:")
for s in multiple_predictions[-1]:
    print(s)
print("1160회 당첨 번호")
print('[7, 13, 18, 36, 39, 45]')

---

728x90

반응형

3. 모델 평가 결과

---

성능 지표

• 테스트 Accuracy: 0.7741
• 테스트 F1-Score: 0.1530
• 테스트 ROC-AUC: 0.5049
• 테스트 PR-AUC: 0.1652

❗ Accuracy가 77.4%로 높은 것처럼 보이지만, 이는 전체 45개 번호 중에서 6개만 정답이므로 의미가 크지는 않다.
❗ F1-score와 PR-AUC가 낮게 나온 것은 예측된 번호와 실제 당첨 번호가 많이 일치하지 않는다는 의미이다.

 

---

4. 예측 결과 분석

---

첫 번째 테스트 회차 예측 번호 (1160회)

실제 로또를 구매한다고 가정하고, 각 회차별 5세트씩 번호를 예측하였다. 

첫 번째 테스트 회차 예측 번호 5세트:
[14 17 40 41 42 43]
[13 14 17 40 42 43]
[13 14 17 40 41 43]
[13 14 17 41 42 43]
[13 14 40 41 42 43]

1160회 실제 당첨 번호

[7, 13, 18, 36, 39, 45]

분석

• 예측된 번호와 실제 당첨 번호를 비교했을 때, 13 하나만 일치하였다.
• 즉, 정확한 예측 성능은 낮았다.
• 예측 확률이 높은 번호를 선택하는 방식이지만, 실제 로또는 완전한 난수에 가까운 분포를 보이기 때문에 예측이 쉽지 않다.

---

5. 결론 및 개선 방향

---

결론

• 머신러닝 모델을 활용하여 로또 번호를 예측하는 것은 매우 어렵다.
• 과거 데이터 패턴을 활용한다고 해도 실제 당첨 번호와의 일치율은 낮다.
• 단순 확률 기반 접근보다, 추첨 패턴에 대한 심층 분석이 필요하다.

개선 방향

1. 더 다양한 피처 추가
   • 현재는 최근 10회 데이터만 활용했지만, 더 긴 기간의 패턴을 반영하는 방식을 고려할 수 있다.
   • 예를 들어, 특정 번호가 나온 이후 다음 회차에서 등장할 확률 등을 분석할 수 있다.
2. 다양한 모델 조합
   • CNN(Convolutional Neural Network) 또는 Transformer 모델을 적용하여 더 정교한 패턴 학습을 시도할 수 있다.

---

6. 로또 번호 예측, 과연 가능할까?

---

• 머신러닝을 활용한 로또 번호 예측은 단순한 랜덤 선택보다 일부 확률을 고려할 수 있는 장점이 있지만, 완벽한 예측은 사실상 불가능에 가깝다.
• 다만, 특정 패턴을 분석하고 활용하는 연구는 의미가 있을 수 있으며, 장기적인 분석을 통해 일부 유의미한 경향을 찾을 수도 있다.

➡ 로또 번호 예측은 단순한 확률 게임이지만, 머신러닝을 활용한 다양한 패턴 분석을 통해 더욱 정교한 전략을 만들어볼 수 있을 것이다.