재학습 전략 심화

def rollback_model(model_name, target_version=None):
    current = client.get_model_version_by_alias(model_name, "Champion")
    current_version = int(current.version)

    if target_version is None:
        target_version = max(1, current_version - 1)

    # 현재 Champion에 태그 추가
    client.set_model_version_tag(
        name=model_name, version=str(current_version),
        key="rolled_back", value="true"
    )

    # 에일리어스 변경 → 즉시 롤백 완료
    client.set_registered_model_alias(
        name=model_name, alias="Champion", version=target_version
    )

# Batch 1: 초기 모델 학습 (100 trees)
model_inc = xgb.train(params, dtrain1, num_boost_round=100)

# Batch 2: 기존 모델에 추가 학습 (50 trees 추가)
# 핵심: xgb_model 파라미터로 기존 모델 전달
model_inc = xgb.train(params, dtrain2, num_boost_round=50, xgb_model=model_inc)

# Batch 3: 계속 추가 학습
model_inc = xgb.train(params, dtrain3, num_boost_round=50, xgb_model=model_inc)

class ReplayBuffer:
    def __init__(self, max_size=2000):
        self.buffer = []
        self.max_size = max_size

    def add(self, X, Y):
        data = list(zip(X.values.tolist(), Y.values.tolist()))
        self.buffer.extend(data)
        if len(self.buffer) > self.max_size:
            self.buffer = random.sample(self.buffer, self.max_size)

    def get_replay_data(self, n_samples=500):
        samples = random.sample(self.buffer, min(n_samples, len(self.buffer)))
        X = pd.DataFrame([s[0] for s in samples], columns=feature_columns)
        Y = pd.Series([s[1] for s in samples])
        return X, Y


# Continual Learning: 새 데이터 + 리플레이 데이터 결합
replay = ReplayBuffer(max_size=2000)

for batch in batches:
    X_rep, Y_rep = replay.get_replay_data(500)
    X_combined = pd.concat([X_batch, X_rep], ignore_index=True)
    Y_combined = pd.concat([Y_batch, Y_rep], ignore_index=True)

    model_cl = xgb.train(params, xgb.DMatrix(X_combined, label=Y_combined), num_boost_round=150)
    replay.add(X_batch, Y_batch)

from river import tree, metrics, preprocessing, compose

model_online = compose.Pipeline(
    preprocessing.StandardScaler(),         # 실시간 표준화
    tree.HoeffdingAdaptiveTreeClassifier(seed=42)
)
metric = metrics.F1()

for _, row in data.iterrows():
    x = {col: row[col] for col in feature_columns}
    y = int(row[label_col])

    y_pred = model_online.predict_one(x)        # 1. 현재 모델로 예측
    if y_pred is not None:
        metric.update(y, y_pred)                 # 2. 메트릭 업데이트
    model_online.learn_one(x, y)                 # 3. 이 한 건으로 모델 업데이트

class RetrainingBandit:
    def __init__(self):
        self.actions = ["no_action", "incremental", "sliding_window", "full_retrain"]
        self.alpha = {a: 1.0 for a in self.actions}  # Beta 분포 파라미터
        self.beta_ = {a: 1.0 for a in self.actions}

    def select_action(self, context):
        scores = {}
        drift = context.get("drift_level", 0)
        for action in self.actions:
            base_score = np.random.beta(self.alpha[action], self.beta_[action])
            # 컨텍스트 기반 보정
            if action == "full_retrain" and drift > 0.2:
                base_score += 0.3
            elif action == "incremental" and 0.05 < drift <= 0.2:
                base_score += 0.2
            elif action == "no_action" and drift < 0.05:
                base_score += 0.3
            scores[action] = base_score
        return max(scores, key=scores.get), scores

    def update(self, action, reward):
        if reward > 0:
            self.alpha[action] += reward
        else:
            self.beta_[action] += abs(reward)

# 모델의 예측 확률로 불확실성 측정
probas = model_full.predict(xgb.DMatrix(full_df[feature_columns]))
uncertainty = np.abs(probas - 0.5)  # 0.5에 가까울수록 불확실

# 가장 불확실한 500건을 우선 레이블링
n_query = 500
active_idx = np.argsort(uncertainty)[:n_query]

# Active Learning으로 선택한 500건으로 학습
X_sel = full_df.iloc[active_idx][feature_columns]
Y_sel = full_df.iloc[active_idx][label_col]
model_al = xgb.train(params, xgb.DMatrix(X_sel, label=Y_sel), num_boost_round=150)

IF Concept Drift 의심 (PSI > 0.5 또는 F1 급락)
  → Cold-start (처음부터)
ELIF Data Drift만 (PSI 0.1~0.5)
  → Warm-start (기존 모델 + 새 데이터)
ELIF 변화 없음 (PSI < 0.1)
  → 재학습 불필요

# Cold-start: 전체 데이터로 처음부터
model_cold = xgb.train(params, dtrain, num_boost_round=200)

# Warm-start: 기존 모델에서 새 데이터로 추가 학습 (훨씬 빠름)
model_warm = xgb.train(params, dtrain_new, num_boost_round=50, xgb_model=model_cold)

# Jobs 파이프라인에서 호출될 때 자동 실행
drift_detected = dbutils.jobs.taskValues.get(
    taskKey="model_monitoring",
    key="drift_detected",
    default=False
)
max_psi = dbutils.jobs.taskValues.get(
    taskKey="model_monitoring",
    key="max_psi",
    default=0.0
)

if drift_detected:
    # 자동 재학습 실행
    result = full_retrain_pipeline(reason=f"auto_drift_psi_{max_psi:.2f}")

    # 결과를 다음 태스크(검증)에 전달
    dbutils.jobs.taskValues.set(key="retrain_completed", value=True)
    dbutils.jobs.taskValues.set(key="new_model_version", value=result.get("version", ""))