diff --git a/.github/workflows/cd-production.yaml b/.github/workflows/cd-production.yaml index fff9229..25749fc 100644 --- a/.github/workflows/cd-production.yaml +++ b/.github/workflows/cd-production.yaml @@ -24,7 +24,7 @@ jobs: run: kubectl apply -k k8s/model-api/overlays/production/ - name: 파드 재시작 # (이미지 태그가 계속 latest여도 새 이미지로 배포되도록) - run: kubectl rollout restart deployment/model-api + run: kubectl rollout restart deployment/model-api -n model-api # 네임스페이스 지정 - name: 배포 확인 - run: kubectl rollout status deployment/model-api + run: kubectl rollout status deployment/model-api -n model-api # 네임스페이스 지정 diff --git a/k8s/cert-manager/cluster-issuer.yaml b/k8s/cert-manager/cluster-issuer.yaml new file mode 100644 index 0000000..ec8d848 --- /dev/null +++ b/k8s/cert-manager/cluster-issuer.yaml @@ -0,0 +1,14 @@ +apiVersion: cert-manager.io/v1 +kind: ClusterIssuer # 인증서 발급, 클러스터 전체에서 사용 가능 +metadata: + name: swmlops-issuer +spec: + acme: # acme 프로토콜이 Let’s Encrypt와 통신하기 위한 표준 프로토콜 + server: https://acme-v02.api.letsencrypt.org/directory + email: simgpt02@gmail.com + privateKeySecretRef: + name: swmlops-issuer + solvers: + - http01: + ingress: + ingressClassName: traefik # k3s 에서 기본 제공해주는 ingress controller diff --git a/k8s/mlflow-db/deployment.yaml b/k8s/mlflow-db/deployment.yaml index c9fa14e..0def4c2 100644 --- a/k8s/mlflow-db/deployment.yaml +++ b/k8s/mlflow-db/deployment.yaml @@ -2,6 +2,7 @@ apiVersion: apps/v1 kind: Deployment metadata: name: mlflow-db + namespace: mlflow spec: replicas: 1 selector: diff --git a/k8s/mlflow-db/pvc.yaml b/k8s/mlflow-db/pvc.yaml index 7e94201..82c7fdb 100644 --- a/k8s/mlflow-db/pvc.yaml +++ b/k8s/mlflow-db/pvc.yaml @@ -2,6 +2,7 @@ apiVersion: v1 kind: PersistentVolumeClaim metadata: name: mlflow-db-pvc + namespace: mlflow spec: accessModes: - ReadWriteOnce diff --git a/k8s/mlflow-db/service.yaml b/k8s/mlflow-db/service.yaml index 14a21be..2e9b85c 100644 --- a/k8s/mlflow-db/service.yaml +++ b/k8s/mlflow-db/service.yaml @@ -2,6 +2,7 @@ apiVersion: v1 kind: Service metadata: name: mlflow-db + namespace: mlflow spec: type: ClusterIP selector: diff --git a/k8s/mlflow/deployment.yaml b/k8s/mlflow/deployment.yaml index a76773d..9aa78c1 100644 --- a/k8s/mlflow/deployment.yaml +++ b/k8s/mlflow/deployment.yaml @@ -2,6 +2,7 @@ apiVersion: apps/v1 kind: Deployment metadata: name: mlflow + namespace: mlflow spec: replicas: 1 selector: @@ -14,6 +15,7 @@ spec: spec: containers: - name: mlflow + image: burakince/mlflow:3.7.0 # postgreSQL 연결이 되는 버전 이미지 image: burakince/mlflow:3.7.0 # postgreSQL 연결이 되는 버전 이미지 ports: - containerPort: 5000 @@ -39,5 +41,5 @@ spec: - --port=5000 - --default-artifact-root=s3://kube-ml-bucket/mlflow-artifacts # 모델 저장 - --backend-store-uri=postgresql://mlflow:1234@mlflow-db:5432/mlflow - - --allowed-hosts=mlflow,mlflow:5000,mlflow.default.svc.cluster.local,localhost,localhost:5000 # 실제 운영 환경에서는 실제 도메인을 입력하면 될 듯 + - --allowed-hosts=mlflow.mlflow.svc.cluster.local,localhost,localhost:5000,mlflow.swmlops.site # 풀 DNS, localhost, 도메인 허용 diff --git a/k8s/mlflow/ingress.yaml b/k8s/mlflow/ingress.yaml new file mode 100644 index 0000000..4d2b93e --- /dev/null +++ b/k8s/mlflow/ingress.yaml @@ -0,0 +1,24 @@ +apiVersion: networking.k8s.io/v1 +kind: Ingress +metadata: + name: mlflow + namespace: mlflow + annotations: + cert-manager.io/cluster-issuer: swmlops-issuer # cert-manager에서 인증서를 발급받을 때 사용할 ClusterIssuer 지정 +spec: + ingressClassName: traefik # k3s 에서 기본 제공해주는 ingress controller + tls: + - hosts: + - mlflow.swmlops.site # 이 도메인으로 접속할 때 TLS 인증서 사용 + secretName: mlflow-tls + rules: + - host: mlflow.swmlops.site # 이 도메인으로 접속할 때 아래의 http 경로로 라우팅 + http: + paths: + - path: / + pathType: Prefix + backend: + service: + name: mlflow # mlflow 서비스로 이동 + 5000 포트로 이동 + port: + number: 5000 diff --git a/k8s/mlflow/service.yaml b/k8s/mlflow/service.yaml index 4d0618c..b498a78 100644 --- a/k8s/mlflow/service.yaml +++ b/k8s/mlflow/service.yaml @@ -2,11 +2,11 @@ apiVersion: v1 kind: Service metadata: name: mlflow + namespace: mlflow spec: - type: NodePort + type: ClusterIP selector: app: mlflow ports: - port: 5000 targetPort: 5000 - nodePort: 30050 diff --git a/k8s/model-api/base/deployment.yaml b/k8s/model-api/base/deployment.yaml index 21ec735..ba274c5 100644 --- a/k8s/model-api/base/deployment.yaml +++ b/k8s/model-api/base/deployment.yaml @@ -19,7 +19,7 @@ spec: - containerPort: 8000 env: - name: MLFLOW_TRACKING_URI - value: http://mlflow:5000 + value: http://mlflow.mlflow.svc.cluster.local:5000 - name: AWS_ACCESS_KEY_ID valueFrom: secretKeyRef: @@ -32,6 +32,8 @@ spec: key: secret-access-key - name: AWS_DEFAULT_REGION value: ap-northeast-2 + - name: CHURN_MODEL_VERSION # 모델 버전 추가 + value: "v5" resources: requests: cpu: "250m" diff --git a/k8s/model-api/overlays/local/kustomization.yaml b/k8s/model-api/overlays/local/kustomization.yaml index fd7d7d0..4288430 100644 --- a/k8s/model-api/overlays/local/kustomization.yaml +++ b/k8s/model-api/overlays/local/kustomization.yaml @@ -1,6 +1,8 @@ apiVersion: kustomize.config.k8s.io/v1beta1 kind: Kustomization +namespace: model-api + resources: - ../../base # base 가져다 쓴다 - service.yaml diff --git a/k8s/model-api/overlays/production/ingress.yaml b/k8s/model-api/overlays/production/ingress.yaml index f4feba1..e2a8225 100644 --- a/k8s/model-api/overlays/production/ingress.yaml +++ b/k8s/model-api/overlays/production/ingress.yaml @@ -2,9 +2,18 @@ apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: model-api + namespace: model-api + annotations: + cert-manager.io/cluster-issuer: swmlops-issuer # cert-manager에서 인증서를 발급받을 때 사용할 ClusterIssuer 지정 spec: + ingressClassName: traefik # k3s 에서 기본 제공해주는 ingress controller + tls: + - hosts: + - model.swmlops.site # 이 도메인으로 접속할 때 TLS 인증서 사용 + secretName: model-api-tls rules: - - http: + - host: model.swmlops.site # 이 도메인으로 접속할 때 아래의 http 경로로 라우팅 + http: paths: - path: / pathType: Prefix diff --git a/k8s/model-api/overlays/production/kustomization.yaml b/k8s/model-api/overlays/production/kustomization.yaml index 6b08fd8..7f51c21 100644 --- a/k8s/model-api/overlays/production/kustomization.yaml +++ b/k8s/model-api/overlays/production/kustomization.yaml @@ -1,6 +1,8 @@ apiVersion: kustomize.config.k8s.io/v1beta1 kind: Kustomization +namespace: model-api # 네임스페이스 추가(일부러 deployment.yaml에서 네임스페이스 안쓰고 여기서만 씀) + resources: - ../../base - service.yaml diff --git a/k8s/monitoring/values.yaml b/k8s/monitoring/values.yaml index 45592f6..e6d476f 100644 --- a/k8s/monitoring/values.yaml +++ b/k8s/monitoring/values.yaml @@ -4,4 +4,17 @@ prometheus: - job_name: model-api static_configs: - targets: - - model-api.default.svc.cluster.local:8000 + - model-api.model-api.svc.cluster.local:8000 # 다른 네임스페이스에 있는 model-api의 클러스터 내부 주소와 포트 + +grafana: + ingress: + enabled: true + ingressClassName: traefik + annotations: + cert-manager.io/cluster-issuer: swmlops-issuer + hosts: + - monitoring.swmlops.site + tls: + - secretName: grafana-tls + hosts: + - monitoring.swmlops.site diff --git a/k8s/namespaces.yaml b/k8s/namespaces.yaml new file mode 100644 index 0000000..7f86098 --- /dev/null +++ b/k8s/namespaces.yaml @@ -0,0 +1,14 @@ +apiVersion: v1 +kind: Namespace +metadata: + name: mlflow +--- +apiVersion: v1 +kind: Namespace +metadata: + name: model-api +--- +apiVersion: v1 +kind: Namespace +metadata: + name: monitoring diff --git a/services/model-api/app/main.py b/services/model-api/app/main.py index e6b30c9..efaa355 100644 --- a/services/model-api/app/main.py +++ b/services/model-api/app/main.py @@ -17,10 +17,10 @@ def health(): # MNIST 데이터 모델 예측 API @app.post("/mnist_predict", response_model=ResponseSchema) -def predict(request: RequestSchema): +def mnist_predict(request: RequestSchema): try: - service = get_service(request.type) # 모델에 맞는 service 지정 - output = service.predict(request.data) # 예측 결과 + service = get_service(request.type) + output = service.predict(request.data) return ResponseSchema( success=True, @@ -37,3 +37,27 @@ def predict(request: RequestSchema): metadata=None, error=str(e), ) + + +# 고객 이탈 예측 API +@app.post("/churn_predict", response_model=ResponseSchema) +def churn_predict(request: RequestSchema): + try: + service = get_service("churn") + output = service.predict(request.data) + + return ResponseSchema( + success=True, + model="churn", + result=output["result"], + metadata=output["metadata"], + error=None, + ) + except Exception as e: + return ResponseSchema( + success=False, + model="churn", + result=None, + metadata=None, + error=str(e), + ) diff --git a/services/model-api/app/models/loader.py b/services/model-api/app/models/loader.py index 2c4e0a9..e0f5549 100644 --- a/services/model-api/app/models/loader.py +++ b/services/model-api/app/models/loader.py @@ -1,16 +1,17 @@ import os import mlflow.pytorch +import mlflow.sklearn _model_cache: dict = {} - +# mlflow에서 mnist 모델 로드하는 함수 def load_model(model_name: str, version: str): cache_key = f"{model_name}_{version}" if cache_key in _model_cache: return _model_cache[cache_key] - mlflow_uri = os.getenv("MLFLOW_TRACKING_URI", "http://mlflow:5000") + mlflow_uri = os.getenv("MLFLOW_TRACKING_URI", "http://mlflow:5000") # 환경변수에서 mlflow tracking uri 가져오기, 없으면 기본값으로 http://mlflow:5000 사용 mlflow.set_tracking_uri(mlflow_uri) model_uri = f"models:/{model_name}-{version}/latest" @@ -19,3 +20,18 @@ def load_model(model_name: str, version: str): _model_cache[cache_key] = model return model + +# mlflow에서 고객 이탈 예측 모델 로드하는 함수 +def load_churn_model(model_name: str, version: str): + cache_key = f"{model_name}_{version}_sklearn" + if cache_key in _model_cache: + return _model_cache[cache_key] + + mlflow_uri = os.getenv("MLFLOW_TRACKING_URI", "http://mlflow:5000") + mlflow.set_tracking_uri(mlflow_uri) + + model_uri = f"models:/{model_name}-{version}/latest" + model = mlflow.sklearn.load_model(model_uri) + + _model_cache[cache_key] = model + return model diff --git a/services/model-api/app/services/churn_service.py b/services/model-api/app/services/churn_service.py new file mode 100644 index 0000000..e874c77 --- /dev/null +++ b/services/model-api/app/services/churn_service.py @@ -0,0 +1,65 @@ +import os +import time +from datetime import datetime, timezone + +from app.models.loader import load_churn_model +from prometheus_client import Counter, Histogram + +MODEL_NAME = "churn" +MODEL_VERSION = os.getenv("CHURN_MODEL_VERSION", "v5") + +FEATURES = [ + 'account_age_months', + 'avg_order_value', + 'total_orders', + 'days_since_last_purchase', + 'discount_usage_rate', + 'return_rate', + 'browsing_frequency_per_week', + 'cart_abandonment_rate', +] + +prediction_counter = Counter( + "churn_predictions_total", + "이탈 예측 횟수", + ["predicted"], +) +confidence_histogram = Histogram( + "churn_confidence_score", + "이탈 예측 신뢰도 분포", + buckets=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0], +) + + +def predict(data: dict) -> dict: + missing = [f for f in FEATURES if f not in data] + if missing: + raise ValueError(f"누락된 피처: {missing}") + + model = load_churn_model(MODEL_NAME, MODEL_VERSION) + + x = [[data[f] for f in FEATURES]] + + start = time.time() + predicted = int(model.predict(x)[0]) + proba = model.predict_proba(x)[0] + confidence = float(proba[predicted]) + time_ms = round((time.time() - start) * 1000, 3) + + prediction_counter.labels(predicted=str(predicted)).inc() + confidence_histogram.observe(confidence) + + return { + "result": { + "predicted_class": predicted, + "churned": bool(predicted), + "confidence": confidence, + "probabilities": {"retained": float(proba[0]), "churned": float(proba[1])}, + }, + "metadata": { + "model": MODEL_NAME, + "version": MODEL_VERSION, + "inference_time_ms": time_ms, + "timestamp": datetime.now(timezone.utc).isoformat(), + }, + } diff --git a/services/model-api/app/services/service_factory.py b/services/model-api/app/services/service_factory.py index 893a6b2..93ba777 100644 --- a/services/model-api/app/services/service_factory.py +++ b/services/model-api/app/services/service_factory.py @@ -1,8 +1,9 @@ -from app.services import mnist_service +from app.services import mnist_service, churn_service _services = { "mnist": mnist_service, + "churn": churn_service, } # 모델의 종류에 맞게 service 파일 불러오는 라우터 diff --git a/services/model-api/notebooks/churn.ipynb b/services/model-api/notebooks/churn.ipynb new file mode 100644 index 0000000..e7987c9 --- /dev/null +++ b/services/model-api/notebooks/churn.ipynb @@ -0,0 +1,559 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 6, + "id": "0f157517", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: seaborn in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (0.13.2)\n", + "Requirement already satisfied: numpy!=1.24.0,>=1.20 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from seaborn) (1.26.4)\n", + "Requirement already satisfied: pandas>=1.2 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from seaborn) (2.3.3)\n", + "Requirement already satisfied: matplotlib!=3.6.1,>=3.4 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from seaborn) (3.10.9)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (4.62.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (1.5.0)\n", + "Requirement already satisfied: packaging>=20.0 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (26.2)\n", + "Requirement already satisfied: pillow>=8 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (12.2.0)\n", + "Requirement already satisfied: pyparsing>=3 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (3.3.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from pandas>=1.2->seaborn) (2023.4)\n", + "Requirement already satisfied: tzdata>=2022.7 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from pandas>=1.2->seaborn) (2026.2)\n", + "Requirement already satisfied: six>=1.5 in /Users/simseohyeon/miniconda3/envs/mlops/lib/python3.11/site-packages (from python-dateutil>=2.7->matplotlib!=3.6.1,>=3.4->seaborn) (1.17.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install seaborn" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "08cf555d", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.metrics import accuracy_score, f1_score, roc_auc_score, classification_report, confusion_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "df3cebb5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Customer_IDaccount_age_monthsavg_order_valuetotal_ordersdays_since_last_purchasediscount_usage_ratereturn_ratecustomer_support_ticketsloyalty_memberbrowsing_frequency_per_weekcart_abandonment_rateproduct_review_score_avgengagement_scoresatisfaction_scoreprice_sensitivity_indexchurned
00520df14-712d-4c69-a0c5-95a2e7dfc1ff46164.9612170.2430.17200No6.10.4305.006.589.433.70
1a4013b3f-0688-4096-a194-6074be8ffec8339.09450.5910.08081No4.10.1834.446.258.506.90
2eb870f2c-ed3d-4a21-a8ac-273fae69ea4f2937.428470.2120.14240No1.20.4263.873.328.404.30
3a7433451-8ea9-428a-9d80-679c6963b39f3562.64930.6990.01280No3.80.7304.756.429.717.50
443f81935-49e3-44d3-94d1-5c471573898839113.03170.3820.02320No5.40.6135.006.489.925.00
\n", + "
" + ], + "text/plain": [ + " Customer_ID account_age_months avg_order_value \\\n", + "0 0520df14-712d-4c69-a0c5-95a2e7dfc1ff 46 164.96 \n", + "1 a4013b3f-0688-4096-a194-6074be8ffec8 3 39.09 \n", + "2 eb870f2c-ed3d-4a21-a8ac-273fae69ea4f 29 37.42 \n", + "3 a7433451-8ea9-428a-9d80-679c6963b39f 35 62.64 \n", + "4 43f81935-49e3-44d3-94d1-5c4715738988 39 113.03 \n", + "\n", + " total_orders days_since_last_purchase discount_usage_rate return_rate \\\n", + "0 12 17 0.243 0.1720 \n", + "1 4 5 0.591 0.0808 \n", + "2 8 47 0.212 0.1424 \n", + "3 9 3 0.699 0.0128 \n", + "4 1 7 0.382 0.0232 \n", + "\n", + " customer_support_tickets loyalty_member browsing_frequency_per_week \\\n", + "0 0 No 6.1 \n", + "1 1 No 4.1 \n", + "2 0 No 1.2 \n", + "3 0 No 3.8 \n", + "4 0 No 5.4 \n", + "\n", + " cart_abandonment_rate product_review_score_avg engagement_score \\\n", + "0 0.430 5.00 6.58 \n", + "1 0.183 4.44 6.25 \n", + "2 0.426 3.87 3.32 \n", + "3 0.730 4.75 6.42 \n", + "4 0.613 5.00 6.48 \n", + "\n", + " satisfaction_score price_sensitivity_index churned \n", + "0 9.43 3.7 0 \n", + "1 8.50 6.9 0 \n", + "2 8.40 4.3 0 \n", + "3 9.71 7.5 0 \n", + "4 9.92 5.0 0 " + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "DATA_DIR = '../../data/churn'\n", + "\n", + "features = pd.read_csv(f'{DATA_DIR}/ecommerce_customer_features.csv')\n", + "targets = pd.read_csv(f'{DATA_DIR}/ecommerce_customer_targets.csv')\n", + "\n", + "df = features.merge(targets, on='Customer_ID')\n", + "df['churned'] = df['churned'].map({'Yes': 1, 'No': 0})\n", + "\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "84f4bd4c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(6000, 8)\n", + "churned\n", + "0 0.845167\n", + "1 0.154833\n", + "Name: proportion, dtype: float64\n" + ] + } + ], + "source": [ + "FEATURES = [\n", + " 'account_age_months',\n", + " 'avg_order_value',\n", + " 'total_orders',\n", + " 'days_since_last_purchase',\n", + " 'discount_usage_rate',\n", + " 'return_rate',\n", + " 'browsing_frequency_per_week',\n", + " 'cart_abandonment_rate',\n", + "]\n", + "TARGET = 'churned'\n", + "\n", + "x = df[FEATURES]\n", + "y = df[TARGET]\n", + "\n", + "print(x.shape)\n", + "print(y.value_counts(normalize=True))" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "302a0cd9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 클래스 불균형 확인\n", + "y.value_counts().plot(kind='bar', title='Churn Distribution')\n", + "plt.xticks([0, 1], ['Retained', 'Churned'], rotation=0)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "adbe944f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 피처 상관관계 시각화\n", + "plt.figure(figsize=(10, 8))\n", + "sns.heatmap(df[FEATURES + [TARGET]].corr(), annot=True, fmt='.2f', cmap='coolwarm')\n", + "plt.title('Feature Correlation')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "bf8a6514", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train: (4199, 8), Valid: (900, 8), Test: (901, 8)\n" + ] + } + ], + "source": [ + "train_ratio, val_ratio, test_ratio = 0.7, 0.15, 0.15\n", + "\n", + "x_train, x_remaining, y_train, y_remaining = train_test_split(\n", + " x, y, test_size=1 - train_ratio, random_state=42, stratify=y\n", + ")\n", + "x_valid, x_test, y_valid, y_test = train_test_split(\n", + " x_remaining, y_remaining, test_size=test_ratio / (val_ratio + test_ratio), random_state=42, stratify=y_remaining # 클래스 분포 균등하게\n", + ")\n", + "\n", + "# 정규화\n", + "scaler = StandardScaler()\n", + "x_train_scaled = scaler.fit_transform(x_train)\n", + "x_valid_scaled = scaler.transform(x_valid)\n", + "x_test_scaled = scaler.transform(x_test)\n", + "\n", + "print(f'Train: {x_train.shape}, Valid: {x_valid.shape}, Test: {x_test.shape}')" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "e0bbe688", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 로지스틱 회귀 ---\n", + "정확도 : 0.9634\n", + "F1 점수 : 0.8800\n", + "ROC-AUC : 0.9917\n" + ] + } + ], + "source": [ + "# 로지스틱 회귀 이용\n", + "lr = LogisticRegression(random_state=42, max_iter=1000)\n", + "lr.fit(x_train_scaled, y_train)\n", + "lr_pred = lr.predict(x_test_scaled)\n", + "lr_proba = lr.predict_proba(x_test_scaled)[:, 1]\n", + "\n", + "print('--- 로지스틱 회귀 ---')\n", + "print(f'정확도 : {accuracy_score(y_test, lr_pred):.4f}')\n", + "print(f'F1 점수 : {f1_score(y_test, lr_pred):.4f}')\n", + "print(f'ROC-AUC : {roc_auc_score(y_test, lr_proba):.4f}')" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "b82f7045", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Random Forest ---\n", + "정확도 : 0.9578\n", + "F1 점수 : 0.8582\n", + "ROC-AUC : 0.9886\n" + ] + } + ], + "source": [ + "# Random Forest\n", + "rf = RandomForestClassifier(n_estimators=100, random_state=42)\n", + "rf.fit(x_train_scaled, y_train)\n", + "rf_pred = rf.predict(x_test_scaled)\n", + "rf_proba = rf.predict_proba(x_test_scaled)[:, 1]\n", + "\n", + "print('--- Random Forest ---')\n", + "print(f'정확도 : {accuracy_score(y_test, rf_pred):.4f}')\n", + "print(f'F1 점수 : {f1_score(y_test, rf_pred):.4f}')\n", + "print(f'ROC-AUC : {roc_auc_score(y_test, rf_proba):.4f}')" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "72f0c03e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "train_scores = []\n", + "valid_scores = []\n", + "max_depth_range = range(1, 21)\n", + "\n", + "for depth in max_depth_range:\n", + " model = RandomForestClassifier(n_estimators=100, max_depth=depth, random_state=42)\n", + " model.fit(x_train, y_train)\n", + " train_scores.append(f1_score(y_train, model.predict(x_train)))\n", + " valid_scores.append(f1_score(y_valid, model.predict(x_valid)))\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(max_depth_range, train_scores, label='Train')\n", + "plt.plot(max_depth_range, valid_scores, label='Validation')\n", + "plt.xlabel('max_depth')\n", + "plt.ylabel('F1 Score')\n", + "plt.title('Overfitting Check (Random Forest)')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "fe91597e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "train_scores_lr = []\n", + "valid_scores_lr = []\n", + "c_range = [0.001, 0.01, 0.1, 1, 10, 100, 1000]\n", + "\n", + "for c in c_range:\n", + " model = LogisticRegression(C=c, random_state=42, max_iter=1000)\n", + " model.fit(x_train_scaled, y_train)\n", + " train_scores_lr.append(f1_score(y_train, model.predict(x_train_scaled)))\n", + " valid_scores_lr.append(f1_score(y_valid, model.predict(x_valid_scaled)))\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(range(len(c_range)), train_scores_lr, label='Train')\n", + "plt.plot(range(len(c_range)), valid_scores_lr, label='Validation')\n", + "plt.xticks(range(len(c_range)), [str(c) for c in c_range])\n", + "plt.xlabel('C')\n", + "plt.ylabel('F1 Score')\n", + "plt.title('Overfitting Check (Logistic Regression)')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "9f00481a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 피처 중요도 (Random Forest)\n", + "importances = pd.Series(rf.feature_importances_, index=FEATURES).sort_values(ascending=False)\n", + "importances.plot(kind='bar', title='Feature Importances')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mlops", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/services/model-api/training/churn/dataset.py b/services/model-api/training/churn/dataset.py new file mode 100644 index 0000000..ad69925 --- /dev/null +++ b/services/model-api/training/churn/dataset.py @@ -0,0 +1,37 @@ +import os +import pandas as pd +from sklearn.model_selection import train_test_split + +FEATURES = [ + 'account_age_months', + 'avg_order_value', + 'total_orders', + 'days_since_last_purchase', + 'discount_usage_rate', + 'return_rate', + 'browsing_frequency_per_week', + 'cart_abandonment_rate', +] +TARGET = 'churned' + +# 데이터 불러오는 함수 +def load_data(data_dir): + features = pd.read_csv(os.path.join(data_dir, 'ecommerce_customer_features.csv')) + targets = pd.read_csv(os.path.join(data_dir, 'ecommerce_customer_targets.csv')) + df = features.merge(targets, on='Customer_ID') + df[TARGET] = df[TARGET].map({'Yes': 1, 'No': 0}) + return df + +# 데이터 전처리 함수 +def preprocess(df, train_ratio=0.7, val_ratio=0.15, test_ratio=0.15): + x = df[FEATURES] + y = df[TARGET] + + x_train, x_remaining, y_train, y_remaining = train_test_split( + x, y, test_size=1 - train_ratio, random_state=42, stratify=y + ) + x_val, x_test, y_val, y_test = train_test_split( + x_remaining, y_remaining, test_size=test_ratio / (val_ratio + test_ratio), random_state=42, stratify=y_remaining + ) + + return (x_train, y_train), (x_val, y_val), (x_test, y_test) diff --git a/services/model-api/training/churn/evaluate.py b/services/model-api/training/churn/evaluate.py new file mode 100644 index 0000000..c310284 --- /dev/null +++ b/services/model-api/training/churn/evaluate.py @@ -0,0 +1,12 @@ +from sklearn.metrics import accuracy_score, f1_score, roc_auc_score + +# 평가 +def evaluate(model, x, y): + pred = model.predict(x) + proba = model.predict_proba(x)[:, 1] + + return { + 'accuracy': accuracy_score(y, pred), + 'f1': f1_score(y, pred), + 'roc_auc': roc_auc_score(y, proba), + } diff --git a/services/model-api/training/churn/train.py b/services/model-api/training/churn/train.py new file mode 100644 index 0000000..fa1190b --- /dev/null +++ b/services/model-api/training/churn/train.py @@ -0,0 +1,70 @@ +""" +고객 이탈 예측 모델 학습 + +# 학습 실행 +python3 training/churn/train.py --version v1 +""" +import argparse +import os +import sys + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..')) + +import mlflow +import mlflow.sklearn +from sklearn.linear_model import LogisticRegression +from sklearn.pipeline import Pipeline +from sklearn.preprocessing import StandardScaler + +from training.churn.dataset import load_data, preprocess, FEATURES +from training.churn.evaluate import evaluate + + +def main(args): + df = load_data(args.data_dir) + (x_train, y_train), (x_valid, y_valid), (x_test, y_test) = preprocess(df) + + mlflow.set_tracking_uri(args.mlflow_uri) + mlflow.set_experiment("churn") + + # mlflow 에서 모델을 불러올때도 기존의 실제 데이터를 정규화 후에 적용 해야해서 파이프라인 추가 + with mlflow.start_run(run_name=args.version): + model = Pipeline([ + ('scaler', StandardScaler()), + ('clf', LogisticRegression(C=args.C, random_state=42, max_iter=1000)), + ]) + model.fit(x_train, y_train) + + val_metrics = evaluate(model, x_valid, y_valid) + test_metrics = evaluate(model, x_test, y_test) + + mlflow.log_param("version", args.version) + mlflow.log_param("C", args.C) + mlflow.log_param("features", FEATURES) + mlflow.log_metric("valid_f1", val_metrics['f1']) + mlflow.log_metric("test_accuracy", test_metrics['accuracy']) + mlflow.log_metric("test_f1", test_metrics['f1']) + mlflow.log_metric("test_roc_auc", test_metrics['roc_auc']) + + mlflow.sklearn.log_model( + model, + artifact_path="model", + registered_model_name=f"churn-{args.version}", + ) + + print(f"valid_f1 : {val_metrics['f1']:.4f}") + print(f"test_accuracy: {test_metrics['accuracy']:.4f}") + print(f"test_f1 : {test_metrics['f1']:.4f}") + print(f"test_roc_auc: {test_metrics['roc_auc']:.4f}") + print(f'MLflow에 모델 등록 완료: churn-{args.version}') + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--version', type=str, default='v1') + parser.add_argument('--C', type=float, default=1.0) + parser.add_argument('--data_dir', type=str, default='../data/churn') + parser.add_argument('--mlflow_uri', type=str, default='https://mlflow.swmlops.site') # 로컬에서 실행해도 등록되도록 기본값 변경 + args = parser.parse_args() + + main(args) diff --git a/services/model-api/training/dataset.py b/services/model-api/training/mnist/dataset.py similarity index 100% rename from services/model-api/training/dataset.py rename to services/model-api/training/mnist/dataset.py diff --git a/services/model-api/training/evaluate.py b/services/model-api/training/mnist/evaluate.py similarity index 100% rename from services/model-api/training/evaluate.py rename to services/model-api/training/mnist/evaluate.py diff --git a/services/model-api/training/train.py b/services/model-api/training/mnist/train.py similarity index 88% rename from services/model-api/training/train.py rename to services/model-api/training/mnist/train.py index e91b4f4..dd536e8 100644 --- a/services/model-api/training/train.py +++ b/services/model-api/training/mnist/train.py @@ -8,10 +8,10 @@ conda activate mlops # v1 초기 학습 -python3 training/train.py --version v1 +python3 training/mnist/train.py --version v1 # v2 재학습 (train + retrain 데이터 합쳐서 학습) -python3 training/train.py --version v2 +python3 training/mnist/train.py --version v2 """ import argparse import os @@ -23,12 +23,12 @@ import mlflow import mlflow.pytorch -sys.path.append(os.path.join(os.path.dirname(__file__), '..')) +sys.path.append(os.path.join(os.path.dirname(__file__), '../../..')) from app.models.mnist_model import get_model -from training.dataset import load_data, split_data -from training.trainer import train -from training.evaluate import evaluate +from training.mnist.dataset import load_data, split_data +from training.mnist.trainer import train +from training.mnist.evaluate import evaluate def main(args): @@ -86,7 +86,7 @@ def main(args): parser = argparse.ArgumentParser() parser.add_argument('--version', type=str, default='v1', choices=['v1', 'v2']) parser.add_argument('--data_dir', type=str, default='../data') - parser.add_argument('--mlflow_uri', type=str, default='http://localhost:30050') + parser.add_argument('--mlflow_uri', type=str, default='http://localhost:5000') args = parser.parse_args() main(args) diff --git a/services/model-api/training/trainer.py b/services/model-api/training/mnist/trainer.py similarity index 100% rename from services/model-api/training/trainer.py rename to services/model-api/training/mnist/trainer.py