diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..69ff3b4 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,13 @@ +venv +.venv +__pycache__ +*.pyc +*.pyo +*.pyd +.git +.github +.env +.vscode +.idea +logs +*.log \ No newline at end of file diff --git a/.env.example b/.env.example index 96b02ca..db99b5e 100644 --- a/.env.example +++ b/.env.example @@ -10,17 +10,32 @@ AI_MANUAL_API_URL= COLLEAGUE_SKILL_API_URL= # Kafka -KAFKA_BOOTSTRAP_SERVERS= +BROKER_URL_1= +BROKER_URL_2= # Redis Cache REDIS_URL=redis://localhost:6379/0 REDIS_KEY_PREFIX=aims:ai-service -REDIS_CACHE_TTL_SECONDS=300 +REDIS_CACHE_TTL_SECONDS=60 -# Main MySQL DB -# Bottleneck analysis results are written to this DB. -MAIN_DATABASE_URL=mysql+pymysql://aims_user:change-me@localhost:3306/maindb?charset=utf8mb4 +# Elasticsearch / OpenSearch +ELASTICSEARCH_URL=http://localhost:9200 +ELASTICSEARCH_USERNAME= +ELASTICSEARCH_PASSWORD= +ELASTICSEARCH_VERIFY_CERTS=true +ELASTICSEARCH_BOTTLENECK_INDEX=aims-bottleneck-analysis-v1 +ELASTICSEARCH_DEFECT_TRANSFER_INDEX=aims-defect-transfer-analysis-v1 -# Sample MySQL DB -# Use this DB for sample/source data connections when needed. -SAMPLE_DATABASE_URL=mysql+pymysql://sample_user:change-me@localhost:3306/sampledb?charset=utf8mb4 +# MySQL DB +# MAIN_DATABASE_URL contains the shared driver/user/password/host/port. +# MAIN_DB_NAME and SAMPLE_DB_NAME select the actual schema/database. +MAIN_DATABASE_URL=mysql+pymysql://aims_user:change-me@localhost:3306/?charset=utf8mb4 +MAIN_DB_NAME=maindb +SAMPLE_DB_NAME=sampledb + +# Manufacturing source event JSON generation +MANUFACTURING_EVENT_SCHEDULER_ENABLED=true +# Optional limits. If omitted, all car_master rows matching the production date are used. +# MANUFACTURING_EVENT_SCHEDULER_EVENTS_PER_DAY=42800 +# MANUFACTURING_EVENT_CAR_POOL_SIZE=10700 +MANUFACTURING_EVENT_INSERT_CHUNK_SIZE=1000 diff --git a/.github/workflows/deploy-ai-service.yml b/.github/workflows/deploy-ai-service.yml new file mode 100644 index 0000000..09fa6a2 --- /dev/null +++ b/.github/workflows/deploy-ai-service.yml @@ -0,0 +1,323 @@ +name: Build AI Service and Update GitOps + +on: + push: + branches: + - dev + - main + paths: + - "app/**" + - "main.py" + - "worker_main.py" + - "requirements.txt" + - "pyproject.toml" + - "uv.lock" + - "Dockerfile" + - ".dockerignore" + - ".github/workflows/deploy-ai-service.yml" + + workflow_dispatch: + +concurrency: + group: ai-service-${{ github.ref_name }} + cancel-in-progress: false + +env: + AWS_REGION: ap-northeast-2 + EKS_CLUSTER_NAME: aims-dev-eks + ECR_REPOSITORY: aims/ai-service + NAMESPACE: aims-project + + INFRA_REPOSITORY: SK-Rookies-AIMS/infra + INFRA_BRANCH: dev + INFRA_MANIFEST_PATH: k8s/ai-service/kustomization.yaml + +jobs: + deploy: + runs-on: ubuntu-latest + + permissions: + contents: read + + steps: + - name: Checkout AI service repository + uses: actions/checkout@v4 + + - name: Configure AWS credentials + uses: aws-actions/configure-aws-credentials@v4 + with: + aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} + aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} + aws-region: ${{ env.AWS_REGION }} + + - name: Login to Amazon ECR + id: login-ecr + uses: aws-actions/amazon-ecr-login@v2 + + - name: Ensure ECR repository exists + run: | + set -euo pipefail + + if ! aws ecr describe-repositories \ + --repository-names "$ECR_REPOSITORY" \ + --region "$AWS_REGION" \ + > /dev/null 2>&1; then + + aws ecr create-repository \ + --repository-name "$ECR_REPOSITORY" \ + --region "$AWS_REGION" \ + --image-scanning-configuration scanOnPush=true \ + --image-tag-mutability MUTABLE + fi + + - name: Build and push Docker image + id: build-image + shell: bash + run: | + set -euo pipefail + + IMAGE_TAG="${GITHUB_REF_NAME}-${GITHUB_SHA::12}" + IMAGE_URI="${{ steps.login-ecr.outputs.registry }}/${ECR_REPOSITORY}:${IMAGE_TAG}" + BRANCH_IMAGE_URI="${{ steps.login-ecr.outputs.registry }}/${ECR_REPOSITORY}:${GITHUB_REF_NAME}" + + echo "Building image: $IMAGE_URI" + + docker build \ + -t "$IMAGE_URI" \ + -t "$BRANCH_IMAGE_URI" \ + . + + docker push "$IMAGE_URI" + docker push "$BRANCH_IMAGE_URI" + + echo "image_uri=$IMAGE_URI" >> "$GITHUB_OUTPUT" + echo "image_tag=$IMAGE_TAG" >> "$GITHUB_OUTPUT" + + - name: Checkout infra repository + uses: actions/checkout@v4 + with: + repository: ${{ env.INFRA_REPOSITORY }} + ref: ${{ env.INFRA_BRANCH }} + token: ${{ secrets.INFRA_REPO_TOKEN }} + path: infra + fetch-depth: 0 + + - name: Update kubeconfig and ensure namespace + if: github.ref_name == 'dev' + shell: bash + run: | + set -euo pipefail + + aws eks update-kubeconfig \ + --region "$AWS_REGION" \ + --name "$EKS_CLUSTER_NAME" + + kubectl create namespace "$NAMESPACE" \ + --dry-run=client \ + -o yaml | + kubectl apply -f - + + - name: Load AI service runtime parameters from SSM + if: github.ref_name == 'dev' + shell: bash + run: | + set -euo pipefail + + RDS_SECRET_ARN=$(aws ssm get-parameter \ + --name "/aims/dev/rds/secret-arn" \ + --region "$AWS_REGION" \ + --query "Parameter.Value" \ + --output text) + + RDS_HOST=$(aws ssm get-parameter \ + --name "/aims/dev/backend/rds-host" \ + --region "$AWS_REGION" \ + --query "Parameter.Value" \ + --output text) + + RDS_PORT=$(aws ssm get-parameter \ + --name "/aims/dev/backend/rds-port" \ + --region "$AWS_REGION" \ + --query "Parameter.Value" \ + --output text) + + MAIN_DB_NAME=$(aws ssm get-parameter \ + --name "/aims/dev/backend/main-db-name" \ + --region "$AWS_REGION" \ + --query "Parameter.Value" \ + --output text) + + SAMPLE_DB_NAME=$(aws ssm get-parameter \ + --name "/aims/dev/backend/sample-db-name" \ + --region "$AWS_REGION" \ + --query "Parameter.Value" \ + --output text) + + REDIS_HOST=$(aws ssm get-parameter \ + --name "/aims/dev/redis/host" \ + --region "$AWS_REGION" \ + --query "Parameter.Value" \ + --output text) + + REDIS_PORT=$(aws ssm get-parameter \ + --name "/aims/dev/redis/port" \ + --region "$AWS_REGION" \ + --query "Parameter.Value" \ + --output text) + + JWT_SECRET_KEY=$(aws ssm get-parameter \ + --name "/aims/dev/backend/jwt-secret-key" \ + --region "$AWS_REGION" \ + --with-decryption \ + --query "Parameter.Value" \ + --output text) + + OPENAI_API_KEY=$(aws ssm get-parameter \ + --name "/aims/dev/ai-service/openai-api-key" \ + --region "$AWS_REGION" \ + --with-decryption \ + --query "Parameter.Value" \ + --output text) + + for VALUE in \ + "$RDS_SECRET_ARN" \ + "$RDS_HOST" \ + "$RDS_PORT" \ + "$MAIN_DB_NAME" \ + "$SAMPLE_DB_NAME" \ + "$REDIS_HOST" \ + "$REDIS_PORT" \ + "$JWT_SECRET_KEY" \ + "$OPENAI_API_KEY"; do + + if [ -z "$VALUE" ] || [ "$VALUE" = "None" ]; then + echo "Required AI service SSM parameter is empty" + exit 1 + fi + done + + echo "::add-mask::$RDS_SECRET_ARN" + echo "::add-mask::$JWT_SECRET_KEY" + echo "::add-mask::$OPENAI_API_KEY" + + { + echo "RDS_SECRET_ARN=$RDS_SECRET_ARN" + echo "RDS_HOST=$RDS_HOST" + echo "RDS_PORT=$RDS_PORT" + echo "MAIN_DB_NAME=$MAIN_DB_NAME" + echo "SAMPLE_DB_NAME=$SAMPLE_DB_NAME" + echo "REDIS_HOST=$REDIS_HOST" + echo "REDIS_PORT=$REDIS_PORT" + echo "JWT_SECRET_KEY=$JWT_SECRET_KEY" + echo "OPENAI_API_KEY=$OPENAI_API_KEY" + } >> "$GITHUB_ENV" + + - name: Create or update AI service Secret + if: github.ref_name == 'dev' + shell: bash + run: | + set -euo pipefail + + SECRET_JSON=$(aws secretsmanager get-secret-value \ + --secret-id "$RDS_SECRET_ARN" \ + --region "$AWS_REGION" \ + --query "SecretString" \ + --output text) + + DB_USER=$(echo "$SECRET_JSON" | jq -r '.username') + DB_PASSWORD=$(echo "$SECRET_JSON" | jq -r '.password') + + if [ -z "$DB_USER" ] || [ "$DB_USER" = "null" ]; then + echo "DB username is missing" + exit 1 + fi + + if [ -z "$DB_PASSWORD" ] || [ "$DB_PASSWORD" = "null" ]; then + echo "DB password is missing" + exit 1 + fi + + DB_USER_ENCODED=$(printf '%s' "$DB_USER" | jq -sRr @uri) + DB_PASSWORD_ENCODED=$(printf '%s' "$DB_PASSWORD" | jq -sRr @uri) + + MAIN_DATABASE_URL="mysql+pymysql://${DB_USER_ENCODED}:${DB_PASSWORD_ENCODED}@${RDS_HOST}:${RDS_PORT}/${MAIN_DB_NAME}?charset=utf8mb4" + + REDIS_URL="redis://${REDIS_HOST}:${REDIS_PORT}/0" + + echo "::add-mask::$DB_USER" + echo "::add-mask::$DB_PASSWORD" + echo "::add-mask::$MAIN_DATABASE_URL" + echo "::add-mask::$REDIS_URL" + echo "::add-mask::$JWT_SECRET_KEY" + + kubectl create secret generic ai-service-secret \ + --namespace "$NAMESPACE" \ + --from-literal=OPENAI_API_KEY="$OPENAI_API_KEY" \ + --from-literal=JWT_SECRET_KEY="$JWT_SECRET_KEY" \ + --from-literal=MAIN_DATABASE_URL="$MAIN_DATABASE_URL" \ + --from-literal=DB_USER="$DB_USER" \ + --from-literal=DB_PASSWORD="$DB_PASSWORD" \ + --from-literal=DB_HOST="$RDS_HOST" \ + --from-literal=DB_PORT="$RDS_PORT" \ + --from-literal=MAIN_DB_NAME="$MAIN_DB_NAME" \ + --from-literal=SAMPLE_DB_NAME="$SAMPLE_DB_NAME" \ + --from-literal=REDIS_URL="$REDIS_URL" \ + --dry-run=client \ + -o yaml | + kubectl apply -f - + + - name: Update AI service image tag in GitOps repository + env: + IMAGE_URI: ${{ steps.build-image.outputs.image_uri }} + shell: bash + run: | + set -euo pipefail + + MANIFEST="infra/${INFRA_MANIFEST_PATH}" + + if [ ! -f "$MANIFEST" ]; then + echo "Manifest not found: $MANIFEST" + exit 1 + fi + + IMAGE_TAG="${IMAGE_URI##*:}" + + sed -i -E \ + "s|^([[:space:]]*)newTag:.*$|\1newTag: ${IMAGE_TAG}|" \ + "$MANIFEST" + + echo "Updated AI service image tag:" + grep -n "newTag:" "$MANIFEST" + + cd infra + + git config user.name "github-actions[bot]" + git config user.email "41898282+github-actions[bot]@users.noreply.github.com" + + git add "$INFRA_MANIFEST_PATH" + + if git diff --cached --quiet; then + echo "Image tag is already up to date" + exit 0 + fi + + git diff --cached + + git commit \ + -m "chore(ai-service): deploy ${GITHUB_REF_NAME}-${GITHUB_SHA::12}" + + for ATTEMPT in 1 2 3; do + echo "GitOps push attempt: $ATTEMPT" + + git pull --rebase origin "$INFRA_BRANCH" + + if git push origin "HEAD:$INFRA_BRANCH"; then + echo "GitOps image update pushed successfully" + exit 0 + fi + + sleep $((ATTEMPT * 5)) + done + + echo "Failed to push AI service image update" + exit 1 \ No newline at end of file diff --git a/.gitignore b/.gitignore index 67ea03d..c900596 100644 --- a/.gitignore +++ b/.gitignore @@ -37,3 +37,9 @@ htmlcov/ .DS_Store Thumbs.db +# DataSet +datasets/ + +# Docs +app/docs/PRD_*.md +app/docs/*.md \ No newline at end of file diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..c70edfa --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.11.13 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..00a51df --- /dev/null +++ b/Dockerfile @@ -0,0 +1,26 @@ +FROM python:3.11-slim + +ENV PYTHONDONTWRITEBYTECODE=1 +ENV PYTHONUNBUFFERED=1 +ENV PIP_NO_CACHE_DIR=1 + +WORKDIR /app + +RUN apt-get update \ + && apt-get install -y --no-install-recommends \ + build-essential \ + gcc \ + g++ \ + curl \ + && rm -rf /var/lib/apt/lists/* + +COPY requirements.txt . + +RUN python -m pip install --upgrade pip setuptools wheel \ + && python -m pip install -r requirements.txt + +COPY . . + +EXPOSE 8000 + +CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"] \ No newline at end of file diff --git a/README.md b/README.md index 9dc6996..955ad91 100644 --- a/README.md +++ b/README.md @@ -1,112 +1,380 @@ -# AI Service +# AIMS - AI Service -FastAPI 기반 AI 서비스 API Gateway / Orchestrator입니다. +### AIMS (Auto Intelligence Manufacturing System) - AI 기반 자동차 스마트팩토리 관제 시스템 -`ai-services` Namespace 내에서 Pod 형태로 배포되며, ChatGPT API, AI 매뉴얼 API, colleague-skill(dot-skill) 등 외부 AI/API 및 내부 지식 서비스를 통합 연계합니다. +`ai-service`는 SK 쉴더스 루키즈 개발 5기 **AI 기반 자동차 스마트팩토리 관제 시스템 AIMS**에서 발생하는 제조 이벤트를 기반으로 병목 분석, 불량 전이 예측, SHAP 기반 원인 분석, AI 메뉴얼 생성을 제공하는 FastAPI 기반 AI 서비스입니다. -## 기술 스택 +제조 이벤트를 수집하고 분석 결과를 DB와 Elasticsearch에 함께 반영한 뒤, 운영 화면이 빠르게 최신 상태를 볼 수 있도록 돕는 역할을 합니다. -- Python -- FastAPI -- Uvicorn -- Kubernetes Pod 배포 +핵심적으로는 다음을 수행합니다. -## 프로젝트 구조 +- 공정별 병목을 계산합니다. +- 어떤 차량이 다음 공정에서 불량으로 이어질 가능성이 있는지 예측합니다. +- SHAP으로 불량 전이 원인을 설명합니다. +- 운영자가 바로 읽을 수 있는 AI 메뉴얼을 생성합니다. +- Kafka로 입력과 분석을 분리하고, Elasticsearch로 조회 성능을 확보합니다. -```text -ai-service/ -├─ app/ -│ ├─ core/ -│ │ ├─ config.py -│ │ ├─ exceptions.py -│ │ └─ logging.py -│ ├─ api/ -│ │ ├─ router.py -│ │ └─ routers/ -│ │ ├─ health.py -│ │ └─ root.py -│ ├─ service/ -│ │ ├─ orchestrator/ -│ │ ├─ llm/ -│ │ └─ analysis/ -│ ├─ ml/ -│ │ ├─ datasets/ -│ │ ├─ preprocessing/ -│ │ ├─ features/ -│ │ ├─ training/ -│ │ ├─ evaluation/ -│ │ ├─ inference/ -│ │ ├─ registry/ -│ │ └─ artifacts/ -│ ├─ kafka/ -│ ├─ dto/ -│ │ ├─ request/ -│ │ └─ response/ -│ │ └─ common_response.py -│ ├─ utils/ -│ │ ├─ datetime_utils.py -│ │ ├─ json_utils.py -│ │ └─ response_utils.py -│ └─ main.py -├─ main.py -├─ requirements.txt -└─ README.md +  +## ✨ 주요 기능 + +### 1. 불량 탐지 및 전이 예측 + +image +image + +- 차량 단위로 다음 공정 불량 가능성을 예측하고 전이 경로를 함께 봅니다. +- 현재 공정, 다음 공정, 설비 신호, 사이클 타임, 대기 시간, 재공 수량, 진동/온도/도막 두께를 함께 봅니다. +- 결과는 `defect_transfer_prediction_result`에 저장됩니다. +- 조회 시에는 ES의 `predictedAt` 날짜를 기준으로 날짜 옵션을 만듭니다. +- 목록은 차량별 최신 1건을 보여줍니다. + +#### 구현 로직 + +1. `DefectTransferAnalysisService.get_predictions()`가 날짜 옵션을 읽고, 요청 날짜가 없으면 최신 날짜를 선택합니다. +2. `ProcessAnalysisSearchRepository.list_defect_transfer_date_options()`가 ES의 `predictedAt` 날짜를 집계합니다. +3. ES가 가능하면 `list_defect_prediction_page()`에서 차량별 최신 1건을 가져옵니다. +4. ES가 실패하면 Redis 캐시를 먼저 보고, 없으면 DB의 `list_prediction_page()`로 fallback합니다. +5. 저장 단계에서 같은 이벤트가 다시 들어오면 기존 row를 덮어써 중복 예측을 줄입니다. +6. 재색인 시 해당 날짜의 문서를 다시 읽어 ES에 최신 상태를 맞춥니다. + +#### ML 모델링 + +- `ColumnTransformer`로 수치형과 범주형 feature를 분리 처리합니다. +- 범주형은 `OneHotEncoder`로 변환하고, 희귀 범주는 `min_frequency`를 활용해 묶습니다. +- 후보 모델은 `LightGBM`, `XGBoost`, `CatBoost`, `Logistic Regression` 계열을 비교합니다. +- 평가 지표는 `accuracy`, `precision`, `recall`, `f1`, `PR-AUC`, `ROC-AUC`를 함께 봅니다. +- 최종 결과는 차량별 `predictedDefectProcess`, `transferProbability`, `riskLevel` 형태로 내려갑니다. +- SHAP으로 주요 원인을 계산하고, API에서는 `main_causes`, `detailCauses`로 제공합니다. +- 예측 결과는 Kafka 분석 이벤트로 이어져 ES와 화면이 동기화됩니다. + +불량 예측 및 전이 예측에서 함께 보는 맥락은 아래와 같습니다. + +- 현재 공정 +- 다음 공정으로의 전이 가능성 +- 설비 신호 +- 사이클 타임 +- 대기 시간 +- 재공 수량 +- 진동, 온도, 도막 두께 같은 공정 특성 + +즉, 차량 단위 예측이지만 실제 판단은 제조 이벤트 feature 전체를 보는 구조입니다. + +#### 흐름 + +1. `sampledb.manufacturing_event_json`에서 SENT 이벤트를 읽습니다. +2. 모델이 차량별 전이 확률을 계산합니다. +3. 예측 결과를 DB와 ES에 저장합니다. +4. ES의 `predictedAt`을 기준으로 최신 1건을 보여줍니다. + +#### SHAP 원인 분석 +image + +- 원인 분석은 불량 탐지 및 전이 예측 결과를 해석하는 단계입니다. +- SHAP 값을 이용해 주요 원인 1개와 상세 원인 여러 개를 분리합니다. +- `main_causes`는 대표 원인, `detailCauses`는 보조 원인입니다. + +##### 구현 로직 + +1. `DefectTransferAnalysisService.get_cause_analysis()`가 차량 ID와 날짜 옵션을 기준으로 조회 대상을 결정합니다. +2. ES가 있으면 `get_latest_defect_cause_document()`에서 차량별 최신 문서를 가져옵니다. +3. 조회된 문서의 대표 원인과 상세 원인을 분리합니다. +4. 대표 원인은 화면의 summary 영역으로, 상세 원인은 리스트 형태로 보여줍니다. +5. 차량 ID가 없으면 최신 차량 기준으로 조회할 수 있습니다. + +##### 흐름 + +1. 최신 불량 탐지 및 전이 예측 문서를 찾습니다. +2. SHAP 기반 원인을 정리합니다. +3. 대표 원인과 상세 원인을 나눠 반환합니다. + + +  +### 2. 병목 분석 + +image + +- `sampledb.manufacturing_event_json`의 제조 이벤트를 읽어 공정별 병목을 계산합니다. +- 결과는 공정 순위, 지연 시간, 영향 차량 수, 위험도 형태로 정리됩니다. +- 결과는 `bottleneck_analysis_result`에 저장됩니다. +- 조회 시에는 ES의 `detectedAt` 날짜를 기준으로 날짜 옵션을 만듭니다. +- Elasticsearch가 살아 있으면 ES 우선으로 조회하고, 실패하면 DB와 Redis에서 다시 읽습니다. +- 같은 날짜 구간을 다시 계산하는 백필 / 재색인 기능도 함께 제공합니다. + +#### 구현 로직 + +1. `BottleneckAnalysisService.get_realtime_bottlenecks()`가 날짜 옵션을 읽고, 요청 날짜가 없으면 최신 날짜를 선택합니다. +2. `ProcessAnalysisSearchRepository.list_bottleneck_date_options()`가 ES의 `detectedAt` 날짜를 집계해 날짜 옵션을 만듭니다. +3. `BottleneckAnalysisService`는 ES에서 `list_bottleneck_page()`를 먼저 호출해 최신 병목 row를 가져옵니다. +4. ES 조회가 실패하면 Redis 캐시를 확인하고, 캐시도 없으면 DB 조회로 fallback합니다. +5. 백필이나 재색인이 실행되면 해당 날짜의 기존 결과를 지우고 다시 계산해서 저장합니다. +6. 따라서 병목 화면은 최신 분석 결과를 기본으로 보여주되, 날짜 선택 시 과거 분석도 다시 볼 수 있습니다. + +#### 모델링 + +- 기본 모델은 `IsolationForest`입니다. +- 연속형 공정 지표는 `StandardScaler`로 정규화한 뒤 학습합니다. +- 공정별 지연 특성을 반영한 규칙 기반 feature를 함께 사용합니다. +- `bottleneck_station`처럼 병목이 발생한 공정을 설명 가능한 형태로 정리합니다. +- 결과는 공정 단위로 집계하고, station 요약과 KPI 요약도 함께 생성합니다. +- SHAP은 `IsolationForest`의 `decision_function`이 어떤 feature에 반응했는지를 설명하는 용도로 사용됩니다. + +병목에서 보는 핵심 feature는 아래와 같습니다. + +- 공정 체류 시간 +- 최대 station span +- 활성 공정 수 +- rule risk score +- iforest risk score + +병목은 단일 점수만 보는 게 아니라, `어느 공정이 막혔는지`와 `왜 그렇게 판단했는지`를 같이 보여주는 구조입니다. + +#### 흐름 + +1. `sampledb.manufacturing_event_json`에서 제조 이벤트를 읽습니다. +2. 공정별 지연 feature를 계산합니다. +3. `IsolationForest`와 규칙 기반 점수로 병목 순위를 산출합니다. +4. 결과를 DB와 ES에 저장합니다. +5. ES의 `detectedAt`을 기준으로 날짜 옵션과 목록을 만듭니다. + +  +### 3. 🤖 AI 메뉴얼 +| 이상 이벤트 발생 | 주니어 | 시니어 | +|---|---|---| +| 이상 이벤트 발생 | 주니어 | 시니어 | + +- JWT 인증을 통과한 사용자만 메뉴얼을 생성합니다. +- 이벤트, 설비 맥락, 사내 지침, 검색된 문서를 함께 사용합니다. +- 메뉴얼은 현장 조치용 설명서로 반환됩니다. +- 사용자는 `Junior` / `Senior`로 구분되며, `Junior`는 실행 절차 중심, `Senior`는 원인·판단 근거와 운영 관점까지 포함한 메뉴얼을 받습니다. + +#### 구현 로직 + +1. `ManualService.generate_manual(user_id)`가 요청의 시작점입니다. +2. 현재 위험도가 높은 알람 이벤트를 `AlertEventRepository`에서 먼저 가져옵니다. +3. 사용자의 ID로 사용자의 권한을 읽고, 없으면 `Junior`로 기본 처리합니다. +4. `CriticalEvent`, `OperatorInfo`, `FactoryContext`, `RagContext`를 묶어 LLM 입력 객체를 만듭니다. +5. `VectorStore.search()`로 관련 문서를 검색해 RAG 컨텍스트를 구성합니다. +6. 권한이 `Junior`면 즉시 수행할 점검 항목과 순서를 강조하고, `Senior`면 원인 해석과 판단 근거를 더 자세히 포함하도록 프롬프트를 구성합니다. +7. `manual_prompt`에 컨텍스트를 넣고 `ChatOpenAI`로 응답을 생성합니다. +8. 최종적으로 이벤트 정보와 권한별로 다른 깊이의 메뉴얼을 함께 반환합니다. + +#### 흐름 + +1. JWT와 권한을 확인합니다. +2. 현재 알람과 관련 이벤트를 가져옵니다. +3. 운영 문서를 검색해 RAG 컨텍스트를 구성합니다. +4. 권한에 따라 프롬프트의 상세 수준을 다르게 구성합니다. +5. LLM이 역할별 메뉴얼을 생성합니다. +6. 운영자 조치 가이드로 반환합니다. + +  +## 🔄 Kafka / Elasticsearch 아키텍처 상세 + +### Kafka 기반 비동기 데이터 파이프라인 + +- Kafka raw topic(`factory.manufacturing.raw`)은 외부 제조 시스템의 원천 이벤트 진입점입니다. +- `raw_event_consumer`는 raw topic을 읽어 `sampledb.manufacturing_event_json`에 저장합니다. +- 분석 대상 이벤트는 병목 / 불량 전이 추론을 수행하고, 결과를 `factory.manufacturing.analysis` topic으로 발행합니다. +- `analysis_sync_consumer`는 `factory.manufacturing.analysis` topic을 다시 받아 Elasticsearch에 색인합니다. + +### Elasticsearch 기반 실시간 검색 및 집계 + +- Elasticsearch는 분석 결과를 빠르게 조회하기 위한 검색 인덱스입니다. +- 병목 인덱스는 `detectedAt` 기준으로 날짜 옵션과 목록 조회에 사용됩니다. +- 불량 전이 인덱스는 `predictedAt` 기준으로 날짜 옵션, 목록 조회, 원인 조회에 사용됩니다. +- 조회 API는 ES 우선으로 응답하고, ES가 실패하면 DB/Redis로 fallback합니다. +- ES에서는 날짜 집계를 `date_histogram`으로 처리하고, 차량별 최신 결과는 대표 문서 1건만 보여줍니다. + +### Kafka -> ES 색인 흐름 + +```mermaid +flowchart TD + A["외부 제조 시스템"] --> B["Kafka Raw Topic\nfactory.manufacturing.raw"] + B --> C["raw_event_consumer"] + C --> D["sampledb.manufacturing_event_json"] + D --> E["병목 / 불량 전이 추론"] + E --> F["Kafka Analysis Topic\nfactory.manufacturing.analysis"] + F --> G["analysis_sync_consumer"] + G --> H1["Elasticsearch Bottleneck Index"] + G --> H2["Elasticsearch Defect Transfer Index"] + H1 --> I1["병목 조회 API"] + H2 --> I2["불량 전이 / 원인 조회 API"] ``` -### 패키지 역할 - -- `app/core/config.py`: `.env` 기반 애플리케이션 설정 관리 -- `app/core/logging.py`: 공통 로깅 설정 -- `app/core/exceptions.py`: 공통 예외 클래스 및 FastAPI 예외 핸들러 등록 -- `app/api/router.py`: 전체 API 라우터 집계 -- `app/api/routers`: 기능별 FastAPI 라우터 모듈 -- `app/api/routers/root.py`: 루트 상태 응답 라우터 -- `app/api/routers/health.py`: 헬스 체크 라우터 -- `app/service/orchestrator`: ChatGPT API, AI 매뉴얼 API, colleague-skill 연계 흐름 제어 -- `app/service/llm`: LLM API 연동 및 프롬프트 처리 -- `app/service/analysis`: 요청 분석, 응답 후처리, 분석 로직 -- `app/ml/datasets`: 학습 및 평가 데이터셋 관리 -- `app/ml/preprocessing`: 데이터 전처리 로직 -- `app/ml/features`: 피처 생성 및 변환 로직 -- `app/ml/training`: 모델 학습 로직 -- `app/ml/evaluation`: 모델 평가 로직 -- `app/ml/inference`: 모델 추론 로직 -- `app/ml/registry`: 모델 버전 및 메타데이터 관리 -- `app/ml/artifacts`: 모델 산출물 및 관련 파일 관리 -- `app/kafka`: Kafka 메시지 발행 및 구독 연동 -- `app/dto/request`: 요청 DTO 정의 -- `app/dto/response/common_response.py`: 공통 API 응답 DTO 정의 -- `app/utils/datetime_utils.py`: UTC 날짜/시간 공통 함수 -- `app/utils/json_utils.py`: JSON 직렬화 및 역직렬화 공통 함수 -- `app/utils/response_utils.py`: 공통 성공/실패 응답 생성 함수 - -## 공통 응답 형식 - -모든 API 응답은 아래 구조를 기본 형식으로 사용합니다. - -```json -{ - "success": true, - "data": {}, - "message": "로그인 성공", - "timestamp": "2026-06-08T16:00:00" -} +### 주요 Kafka / ES 엔터티 + +| 구분 | 이름 | 역할 | +| --- | --- | --- | +| Raw Topic | `factory.manufacturing.raw` | 제조 원천 이벤트 입력 | +| Analysis Topic | `factory.manufacturing.analysis` | 분석 결과 발행 및 ES 동기화 입력 | +| Raw Consumer Group | `ai-analysis-consumer-group` | 원천 이벤트 소비 | +| Sync Consumer Group | `ai-analysis-sync-consumer-group` | 분석 결과 ES 동기화 | +| Bottleneck Index | `settings.elasticsearch_bottleneck_index` | 병목 결과 검색 | +| Defect Transfer Index | `settings.elasticsearch_defect_transfer_index` | 불량 전이 / 원인 검색 | + + +  +## 🛠 전체 데이터 기능 흐름 +데이터 기능 흐름도 + +## 🧭 시스템 다이어그램 + +### AI 서비스 분석 흐름 + +```mermaid +flowchart LR + A["외부 제조 시스템"] --> B["Kafka Raw Topic"] + B --> C["raw_event_consumer"] + C --> D["DB / 원천 저장"] + D --> E["병목 / 불량 전이 추론"] + E --> F["Kafka Analysis Topic"] + F --> G["analysis_sync_consumer"] + G --> H["Elasticsearch"] + H --> I["조회 API"] ``` -필드 설명: +### ES 조회 우선순위 + +```mermaid +sequenceDiagram + participant API as API + participant ES as Elasticsearch + participant Cache as Redis + participant DB as DB + + API->>ES: dateOptions / content 조회 + alt ES success + ES-->>API: 최신 결과 + else ES fail + API->>Cache: 캐시 조회 + alt Cache hit + Cache-->>API: cached page + else Cache miss + API->>DB: fallback query + DB-->>API: db rows + end + end +``` + +  +## 🏗️ 프로젝트 구조 + +```text +app/ +├─ api/ # FastAPI router 계층 +│ ├─ routers/ +│ │ ├─ process.py # 병목 / 불량 전이 조회 +│ │ ├─ defect_transfer.py # 불량 전이 / 원인 조회 +│ │ ├─ analysis_maintenance.py # 병목 / 불량 전이 백필·재색인 +│ │ ├─ manual.py # AI 메뉴얼 +│ │ └─ health.py # 헬스 체크 +├─ service/ +│ ├─ analysis/ # 분석 조회 / 백필 / 재색인 +│ ├─ manufacturing/ # 제조 이벤트 처리 +│ └─ llm/ # LLM 연동 +├─ repository/ # DB 접근 계층 +├─ search/ # Elasticsearch 저장 / 조회 +├─ kafka/ # Kafka 소비 / 발행 +├─ ml/ # 모델 학습 / 추론 / SHAP +├─ ai_manual/ # AI 메뉴얼 생성 +├─ dto/ # 요청 / 응답 스키마 +├─ batch/ # 배치 / 백필 작업 +└─ scheduler/ # 주기 실행 작업 +``` + +### 역할 요약 + +- `app/service/analysis`: 분석 결과 조회와 관리 작업을 담당합니다. +- `app/search`: Elasticsearch 인덱싱과 조회를 담당합니다. +- `app/kafka`: 제조 이벤트 수집과 분석 결과 동기화를 담당합니다. +- `app/ml`: 병목 탐지와 불량 전이 모델을 담당합니다. +- `app/ai_manual`: 메뉴얼 생성 로직을 담당합니다. + +  +## 📡 API 요약 + +### 분석 조회 + +- `GET /api/ai/process/bottleneck` +- `GET /api/ai/process/defect-transfer/predictions` +- `GET /api/ai/process/defect-transfer/causes` + +#### 병목 조회 API -- `success`: 요청 성공 여부 -- `data`: 응답 데이터 -- `message`: 응답 메시지 -- `timestamp`: 응답 생성 시간 +- 병목 목록과 날짜 옵션을 함께 조회합니다. +- 기본적으로 ES의 `detectedAt` 기준 최신 날짜를 우선 보여줍니다. +- 응답에는 공정 순위, 지연 시간, 영향 차량 수, 위험도, 다음 페이지 여부가 포함됩니다. +- 날짜를 지정하면 해당 일자의 병목 결과만 다시 조회합니다. -관련 코드: +예시 응답 필드: -- `app/dto/response/common_response.py`: `CommonResponse` DTO -- `app/utils/response_utils.py`: `success_response`, `error_response` 헬퍼 +- `mostBottleneckProcess` +- `mostBottleneckRiskLevel` +- `date` +- `dateOptions` +- `content` +- `hasNext` +- `nextCursor` +#### 불량 예측 및 전이 예측 API -## 가상환경 생성 및 실행 +- 차량별 불량 예측 결과와 전이 경로를 조회합니다. +- 기본적으로 ES의 `predictedAt` 기준 최신 날짜를 우선 보여줍니다. +- 응답에는 차량 ID, 현재 공정, 예측 공정, 전이 확률, 위험도, 다음 페이지 여부가 포함됩니다. +- 날짜를 지정하면 해당 일자의 예측 결과만 다시 조회합니다. + +예시 응답 필드: + +- `date` +- `dateOptions` +- `content` +- `vehicleId` +- `carMasterId` +- `currentProcess` +- `predictedDefectProcess` +- `defectProbability` +- `riskLevel` +- `hasNext` +- `nextCursor` + +#### 원인 분석 API + +- 특정 차량의 최신 불량 예측 결과를 기반으로 원인을 조회합니다. +- `main_causes`는 대표 원인, `detailCauses`는 상세 원인입니다. +- 차량 ID가 없으면 최신 차량 기준으로 조회할 수 있습니다. +- 응답은 `대표 원인`과 `상세 원인`을 분리해 화면에 바로 뿌릴 수 있는 형태입니다. + +### 관리 API + +- `POST /api/ai/admin/analysis/backfill/bottleneck` +- `POST /api/ai/admin/analysis/backfill/defect-transfer` +- `POST /api/ai/admin/analysis/reindex/bottleneck` +- `POST /api/ai/admin/analysis/reindex/defect-transfer` + +### AI 메뉴얼 + +- `GET /api/ai/manual` + + +  +## 🔧 기술 스택 +![FastAPI](https://img.shields.io/badge/FastAPI-005571?style=for-the-badge&logo=fastapi&logoColor=white) +![Python](https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white) +![Kafka](https://img.shields.io/badge/Apache%20Kafka-231F20?style=for-the-badge&logo=apachekafka&logoColor=white) +![Elasticsearch](https://img.shields.io/badge/Elasticsearch-005571?style=for-the-badge&logo=elasticsearch&logoColor=white) +![MySQL](https://img.shields.io/badge/MySQL-4479A1?style=for-the-badge&logo=mysql&logoColor=white) +![Redis](https://img.shields.io/badge/Redis-DC382D?style=for-the-badge&logo=redis&logoColor=white) +![scikit-learn](https://img.shields.io/badge/scikit--learn-F7931E?style=for-the-badge&logo=scikitlearn&logoColor=white) +![LightGBM](https://img.shields.io/badge/LightGBM-00A86B?style=for-the-badge&logo=lightgbm&logoColor=white) +![XGBoost](https://img.shields.io/badge/XGBoost-1E1E1E?style=for-the-badge&logo=xgboost&logoColor=white) +![CatBoost](https://img.shields.io/badge/CatBoost-FF9D00?style=for-the-badge&logo=catboost&logoColor=white) +![LightGBM](https://img.shields.io/badge/LightGBM-00A86B?style=for-the-badge&logo=lightgbm&logoColor=white) +![SHAP](https://img.shields.io/badge/SHAP-4B5563?style=for-the-badge&logo=shap&logoColor=white) +![OpenAI](https://img.shields.io/badge/OpenAI-412991?style=for-the-badge&logo=openai&logoColor=white) + + +  +## ⚙️ 가상환경 생성 및 실행 PowerShell 기준: @@ -133,12 +401,6 @@ Windows에서 Python 3.14를 사용하는 경우 일부 패키지의 사전 빌 개발 서버 실행: -```powershell -uvicorn main:app --reload -``` - -또는 패키지 경로를 직접 지정해 실행할 수 있습니다. - ```powershell uvicorn app.main:app --reload ``` @@ -156,90 +418,8 @@ uvicorn app.main:app --reload deactivate ``` -## FastAPI 역할 - -FastAPI는 AI 서비스의 API Gateway 및 Orchestrator 역할을 수행합니다. - -주요 역할: - -- ChatGPT API 연동 -- AI 매뉴얼 API 연동 -- colleague-skill(dot-skill) 연동 -- API Orchestration 및 서비스 연계 -- 사용자 요청의 중앙 집중 처리 -- 외부 AI 서비스와 내부 지식 서비스의 응답 조합 - -배포 형태: - -- Kubernetes `ai-services` Namespace 내 Pod 형태로 배포 +주요 주소: -## ai-services Namespace 구성 - -### 1. FastAPI - -FastAPI는 API Gateway / Orchestrator 역할을 담당합니다. - -주요 역할: - -- 사용자 요청 수신 -- ChatGPT API 호출 -- AI 매뉴얼 API 호출 -- colleague-skill(dot-skill) 연계 -- 각 서비스 응답 조합 및 최종 응답 반환 - -배포 형태: - -- Pod 형태로 배포 - -### 2. 외부 AI/API 연동 영역 - -#### ChatGPT API - -- 자연어 질의 처리 -- AI 응답 생성 -- FastAPI와 연동 - -#### AI 매뉴얼 API - -- 매뉴얼 및 문서 기반 질의응답 제공 -- ChatGPT API와 연계하여 결과 생성 - -#### colleague-skill(dot-skill) - -- 사내 업무 지식 및 스킬셋 제공 -- AI 매뉴얼 API와 연동 - -### 3. 데이터 흐름 - -```text -사용자 요청 - ↓ -FastAPI -(API Gateway / Orchestrator) - ↓ -┌─────────────────────┐ -│ ChatGPT API │ -└─────────────────────┘ - ↕ -┌─────────────────────┐ -│ AI 매뉴얼 API │ -└─────────────────────┘ - ↕ -┌─────────────────────┐ -│ colleague-skill │ -│ (dot-skill) │ -└─────────────────────┘ - ↓ -FastAPI - ↓ -응답 반환 -``` - -### 4. 아키텍처 요약 - -- FastAPI가 AI 서비스의 API Gateway 및 Orchestrator 역할을 수행합니다. -- FastAPI는 ChatGPT API, AI 매뉴얼 API, colleague-skill 서비스를 통합 관리합니다. -- 외부 AI 서비스와 내부 지식 서비스를 조합하여 응답을 생성합니다. -- 모든 요청 흐름은 FastAPI를 통해 중앙 집중적으로 처리됩니다. -- Kubernetes 환경에서는 `ai-services` Namespace 내 Pod로 배포됩니다. -- 향후 AI 서비스 추가 시 FastAPI에서 Orchestration만 확장하면 되므로 확장성이 높습니다. +- API Root: `http://127.0.0.1:8000/` +- Health: `http://127.0.0.1:8000/api/health` +- Swagger: `http://127.0.0.1:8000/docs` diff --git a/app/ai_manual/data/system_description.md b/app/ai_manual/data/system_description.md new file mode 100644 index 0000000..bd78130 --- /dev/null +++ b/app/ai_manual/data/system_description.md @@ -0,0 +1,136 @@ +# AIMS Smart Factory + +## 프로젝트 소개 + +AIMS Smart Factory는 자동차 제조 공정을 실시간으로 모니터링하는 AI 기반 스마트팩토리 시스템이다. + +Watchy AI는 공정 이상이 발생했을 때 +현장 담당자에게 조치 매뉴얼을 제공하는 역할을 수행한다. + +--- + +## 제조 공정 + +PRESS + +차체 패널을 프레스 설비로 성형한다. + +BODY + +산업용 Robot이 차체를 용접한다. + +PAINT + +차체를 도장한다. + +ASSEMBLY + +부품을 조립한다. + +--- + +## 설비 + +Robot + +Conveyor + +Vision Camera + +PLC + +Sensor + +AGV + +--- + +## 시스템 구조 + +Event 발생 + +↓ + +Kafka + +↓ + +Main Backend Service + +↓ + +Priority Score 계산 + +↓ + +MainDB(alert_event) + +↓ + +AI Service + +↓ + +Watchy + +↓ + +React + +--- + +## AI 역할 + +Watchy는 + +- 현재 발생한 가장 높은 Priority Event만 분석한다. + +- Priority가 해결되면 다음 Priority Event를 분석한다. + +- RAG 문서를 기반으로만 답변한다. + +- 추측하지 않는다. + +--- + +## 담당자 + +Junior + +현장 초급 담당자 + +쉬운 설명과 조치를 위한 상세하고 순차적인 구체적 설명 필요 + +Senior + +현장 숙련 담당자 + +원인 분석 포함한 간단 요약 설명 필요 + +--- + +## 이벤트 + +PROCESS + +공정 이상 + +EQUIPMENT + +설비 이상 + +--- + +## Severity + +DANGER + +즉시 조치 필요 + +WARNING + +빠른 확인 필요 + +CAUTION + +모니터링 필요 \ No newline at end of file diff --git a/app/ai_manual/prompt/prompt_template.py b/app/ai_manual/prompt/prompt_template.py new file mode 100644 index 0000000..3008ad3 --- /dev/null +++ b/app/ai_manual/prompt/prompt_template.py @@ -0,0 +1,138 @@ +# ai_manual/prompt/prompt_template.py + +from langchain_core.prompts import ChatPromptTemplate + + +SYSTEM_PROMPT = """ +당신은 자동차 스마트팩토리의 AI 유지보수 전문가 'Watchy'입니다. + +## 역할 + +당신의 역할은 생산 설비에서 발생한 Critical Event를 분석하고, +담당자의 숙련도에 맞는 조치 매뉴얼을 생성하는 것입니다. + +당신은 다음 정보를 기반으로 답변합니다. + +1. 현재 발생한 Critical Event +2. 스마트팩토리 시스템 정보 +3. RAG 검색 결과 +4. 담당자의 숙련도(Junior / Senior) + +-------------------------------------------- + +## 답변 규칙 + +1. +반드시 전달받은 정보만 사용하십시오. + +2. +추측하지 마십시오. + +3. +RAG에 없는 내용은 +"관련 정보가 존재하지 않습니다." +라고 작성하십시오. + +4. +설비명을 임의로 변경하지 마십시오. + +5. +Error Code를 임의 생성하지 마십시오. + +6. +반드시 단계별 조치 최소 3단계, 최대 5단계로 방법을 작성하고 각 단계별 글자 수는 30자로 제한하시오. + +7. +반드시 안전 관련 주의사항을 포함하십시오. + +8. +항상 JSON 형식으로만 응답하십시오. + +9. +summary는 반드시 2~3문장으로 작성하시오. + +10. +summary는 최대 50자 내외로 작성하시오. + +11. +말풍선(UI)에 표시되므로 긴 설명은 금지하십시오. + +-------------------------------------------- + +## Junior 담당자 + +Junior 담당자에게는 + +- 쉬운 표현 사용 +- 작업 순서를 상세히 설명 +- 전문용어 최소화 +- 위험한 작업은 수행하지 않도록 안내 + +-------------------------------------------- + +## Senior 담당자 + +Senior 담당자에게는 + +- 원인 분석 포함 +- 예방 방법 포함 +- 추가 점검 항목 포함 +- 가능한 원인까지 설명 + +-------------------------------------------- + +## 반드시 반환해야 하는 JSON 형식 + +{{ + "title": "...", + "summary": "...", + "difficulty": "...", + "estimated_time": "...", + "precautions": [], + "steps": [], + "completion_check": [], + "escalation": "...", + "prevention": [] +}} + +JSON 외의 어떠한 문장도 출력하지 마십시오. +""" + + +HUMAN_PROMPT = """ +# 현재 Critical Event + +{critical_event} + +------------------------------------------------ + +# 담당자 + +{operator} + +------------------------------------------------ + +# 스마트팩토리 시스템 정보 + +{factory_context} + +------------------------------------------------ + +# RAG 검색 결과 + +{rag_context} + +------------------------------------------------ + +위 정보를 기반으로 +담당자의 숙련도에 맞는 +조치 매뉴얼을 생성하십시오. +""" + + +manual_prompt = ChatPromptTemplate.from_messages( + [ + ("system", SYSTEM_PROMPT), + ("human", HUMAN_PROMPT), + ] +) \ No newline at end of file diff --git a/app/ai_manual/rag/vector_store.py b/app/ai_manual/rag/vector_store.py new file mode 100644 index 0000000..1f5ce2c --- /dev/null +++ b/app/ai_manual/rag/vector_store.py @@ -0,0 +1,58 @@ +# ai_manual/rag/vector_store.py + +from typing import List + +from app.ai_manual.schema.request import CriticalEvent + + +class VectorStore: + """ + RAG 검색 클래스 + + 현재는 Mock 데이터를 반환하며, + 추후 FAISS / Chroma / OpenSearch 등으로 + 교체할 수 있도록 인터페이스 역할을 수행한다. + """ + + def __init__(self): + pass + + def search( + self, + event: CriticalEvent, + top_k: int = 5 + ) -> List[str]: + """ + Critical Event를 기반으로 + 관련 문서를 검색한다. + """ + + documents = [] + + # 공정 정보 + documents.append( + f"{event.process_code} 공정은 자동차 제조의 핵심 공정입니다." + ) + + # 설비 정보 + if event.equipment is not None: + documents.append( + f"{event.equipment.name} 설비 매뉴얼입니다." + ) + + # 이벤트 정보 + documents.append( + f"{event.title} 발생 시 안전 절차를 우선 수행합니다." + ) + + # 위험도 + documents.append( + f"Risk Score는 {event.risk_score}입니다." + ) + + # 심각도 + documents.append( + f"Severity는 {event.severity}입니다." + ) + + return documents[:top_k] \ No newline at end of file diff --git a/app/ai_manual/repository/alert_event_repository.py b/app/ai_manual/repository/alert_event_repository.py new file mode 100644 index 0000000..08cb841 --- /dev/null +++ b/app/ai_manual/repository/alert_event_repository.py @@ -0,0 +1,85 @@ +from sqlalchemy import text +from app.db import main_engine + + +class AlertEventRepository: + + def get_highest_risk_event(self): + query = text(""" + SELECT + log_no, + event_id, + alert_type, + process_code, + equipment_id, + event_key, + risk_score, + occurrence_score, + detection_score, + priority_score, + severity, + title, + contents, + action_by, + action_status, + reason, + score_calculated_at, + created_at, + resolved_at + FROM alert_event + WHERE severity = 'DANGER' + AND action_status = 'INCOMPLETE' + AND resolved_at IS NULL + ORDER BY risk_score DESC + LIMIT 1 + """) + + with main_engine.connect() as conn: + row = conn.execute(query).mappings().first() + + print("조회 결과:", row) + print("타입:", type(row)) + + if not row: + return None + + return dict(row) + + def get_events(self): + + sql = """ + SELECT + event_id, + title, + contents, + severity, + priority_score, + risk_score, + process_code, + equipment_id, + created_at + FROM alert_event + ORDER BY priority_score DESC + """ + + with main_engine.connect() as conn: + + result = conn.execute(text(sql)) + + return [dict(row._mapping) for row in result] + + def get_user_role(self, user_id: int): + + sql = text(""" + SELECT role + FROM users + WHERE id = :user_id + """) + + with main_engine.connect() as conn: + role = conn.execute( + sql, + {"user_id": user_id} + ).scalar() + + return role or "Junior" \ No newline at end of file diff --git a/app/ai_manual/schema/request.py b/app/ai_manual/schema/request.py new file mode 100644 index 0000000..985e5ae --- /dev/null +++ b/app/ai_manual/schema/request.py @@ -0,0 +1,118 @@ +# ai_manual/schema/request.py + +from typing import List, Optional + +from pydantic import BaseModel, Field + + +class EquipmentInfo(BaseModel): + """ + 설비 정보 + """ + id: Optional[int] = Field( + default=None, + description="설비 ID" + ) + + name: Optional[str] = Field( + default=None, + description="설비명" + ) + + type: Optional[str] = Field( + default=None, + description="설비 종류" + ) + + +class CriticalEvent(BaseModel): + """ + AI가 처리해야 하는 현재 Critical Event + """ + + event_id: str = Field( + description="Kafka Event ID" + ) + + priority_score: float = Field( + description="우선순위 점수" + ) + + risk_score: float = Field( + description="위험도 점수" + ) + + severity: str = Field( + description="심각도" + ) + + alert_type: str = Field( + description="PROCESS / EQUIPMENT" + ) + + process_code: str = Field( + description="공정 코드" + ) + + equipment: Optional[EquipmentInfo] = None + + title: str = Field( + description="알람 제목" + ) + + description: str = Field( + description="알람 상세 내용" + ) + + occurred_at: str = Field( + description="발생 시간" + ) + + +class OperatorInfo(BaseModel): + """ + 담당자 정보 + """ + + grade: str = Field( + description="Junior 또는 Senior" + ) + + +class RagContext(BaseModel): + """ + RAG 검색 결과 + """ + + documents: List[str] = Field( + default_factory=list, + description="Vector Search 결과" + ) + + +class FactoryContext(BaseModel): + """ + 공장 기본 정보 + """ + + system_name: str = Field( + description="시스템 이름" + ) + + description: str = Field( + description="스마트팩토리 설명" + ) + + +class ManualRequest(BaseModel): + """ + GPT에게 전달하는 최종 Request + """ + + critical_event: CriticalEvent + + operator: OperatorInfo + + factory_context: FactoryContext + + rag_context: RagContext \ No newline at end of file diff --git a/app/ai_manual/schema/response.py b/app/ai_manual/schema/response.py new file mode 100644 index 0000000..3108040 --- /dev/null +++ b/app/ai_manual/schema/response.py @@ -0,0 +1,87 @@ +# ai_manual/schema/response.py + +from typing import List + +from pydantic import BaseModel, Field + + +class ManualStep(BaseModel): + """ + 조치 절차 + """ + + step: int = Field( + description="순서" + ) + + action: str = Field( + description="수행할 작업" + ) + + reason: str = Field( + description="작업 이유" + ) + + warning: str = Field( + description="주의사항" + ) + + +class CompletionCheck(BaseModel): + """ + 조치 완료 확인 항목 + """ + + item: str = Field( + description="확인 항목" + ) + + expected_result: str = Field( + description="정상 상태" + ) + + +class ManualResponse(BaseModel): + """ + GPT가 반환하는 최종 Manual + """ + + title: str = Field( + description="매뉴얼 제목" + ) + + summary: str = Field( + description="현재 상황 요약" + ) + + difficulty: str = Field( + description="Junior 또는 Senior" + ) + + estimated_time: str = Field( + description="예상 작업 시간" + ) + + precautions: List[str] = Field( + default_factory=list, + description="작업 전 주의사항" + ) + + steps: List[ManualStep] = Field( + default_factory=list, + description="조치 절차" + ) + + completion_check: List[CompletionCheck] = Field( + default_factory=list, + description="조치 완료 확인" + ) + + escalation: str = Field( + description="상위 담당자 호출 기준" + ) + + prevention: List[str] = Field( + default_factory=list, + description="재발 방지 방법" + ) \ No newline at end of file diff --git a/app/ai_manual/service/manual_service.py b/app/ai_manual/service/manual_service.py new file mode 100644 index 0000000..27a2c82 --- /dev/null +++ b/app/ai_manual/service/manual_service.py @@ -0,0 +1,164 @@ +from langchain_openai import ChatOpenAI + +from app.ai_manual.prompt.prompt_template import manual_prompt +from app.ai_manual.rag.vector_store import VectorStore +from app.ai_manual.repository.alert_event_repository import AlertEventRepository +from app.core.config import settings + +from app.ai_manual.schema.request import ( + CriticalEvent, + EquipmentInfo, + FactoryContext, + ManualRequest, + OperatorInfo, + RagContext, +) + +from app.ai_manual.schema.response import ManualResponse + + +class ManualService: + + def __init__(self): + + self.repository = AlertEventRepository() + self.vector_store = VectorStore() + + if not settings.openai_api_key: + raise ValueError( + "OPENAI_API_KEY is not configured" + ) + + self.llm = ChatOpenAI( + api_key=settings.openai_api_key, + model="gpt-5-mini", + temperature=0.2 + ).with_structured_output(ManualResponse) + + + # ====================================================== + # MAIN ENTRY + # ====================================================== + def generate_manual( + self, + user_id: int + ) -> ManualResponse | None: + + # 1. EVENT FETCH + event = self.repository.get_highest_risk_event() + + if event is None: + return None + + # 2. BUILD STRONG REQUEST OBJECT + operator_grade = self.repository.get_user_role(user_id) + + if operator_grade is None: + operator_grade = "Junior" + request = self._build_request(event, operator_grade) + + # 3. PROMPT BUILD + prompt = manual_prompt.invoke({ + "critical_event": self._format_json(request.critical_event), + "operator": self._format_json(request.operator), + "factory_context": self._format_json(request.factory_context), + "rag_context": self._format_rag(request.rag_context) + }) + + # 4. LLM CALL + response = self.llm.invoke(prompt) + + return { + "event": { + "eventId": event["event_id"], + "title": event["title"], + "severity": event["severity"], + "process": event["process_code"], + "equipmentId": event["equipment_id"], + "riskScore": event["risk_score"], + }, + "manual": response.model_dump() + } + + # ====================================================== + # REQUEST BUILDER + # ====================================================== + def _build_request( + self, + event: dict, + operator_grade: str + ) -> ManualRequest: + + # -------------------------- + # 1. Equipment mapping (safe) + # -------------------------- + equipment = None + + if event.get("equipment_id") is not None: + equipment = EquipmentInfo( + id=event["equipment_id"], + name=f"EQ-{event['equipment_id']}", # fallback only + type="Industrial Equipment" + ) + + # -------------------------- + # 2. Critical Event DTO + # -------------------------- + critical_event = CriticalEvent( + event_id=event["event_id"], + priority_score=float(event.get("priority_score") or 0), + risk_score=float(event.get("risk_score") or 0), + severity=event["severity"], + alert_type=event["alert_type"], + process_code=event["process_code"], + equipment=equipment, + title=event["title"], + description=event["contents"], + occurred_at=str(event["created_at"]) + ) + + # -------------------------- + # 3. RAG SEARCH + # -------------------------- + rag_documents = self.vector_store.search(critical_event) + + # -------------------------- + # 4. FINAL REQUEST + # -------------------------- + return ManualRequest( + critical_event=critical_event, + operator=OperatorInfo( + grade=operator_grade + ), + factory_context=FactoryContext( + system_name="AIMS Smart Factory", + description=( + "자동차 제조 스마트팩토리 시스템\n\n" + "공정: PRESS / BODY / PAINT / ASSEMBLY\n" + "시스템: Kafka / AI-Service / Main-Service / PLC / Robot / Vision" + ) + ), + rag_context=RagContext( + documents=rag_documents + ) + ) + + # ====================================================== + # HELPERS + # ====================================================== + def _format_json(self, obj) -> str: + """ + LLM readability 개선용 JSON formatter + """ + return obj.model_dump_json( + indent=2, + ensure_ascii=False + ) + + def _format_rag(self, rag: RagContext) -> str: + """ + RAG 문서 readable string 변환 + """ + return "\n".join( + f"- {doc}" for doc in rag.documents + ) \ No newline at end of file diff --git a/app/api/router.py b/app/api/router.py index 31277be..8195205 100644 --- a/app/api/router.py +++ b/app/api/router.py @@ -1,8 +1,26 @@ from fastapi import APIRouter -from app.api.routers import health, process, root +from app.api.routers import ( + analysis_maintenance, + defect_transfer, + health, + manufacturing_event, + ml_dataset, + process, + process_analysis_ws, + root, + manual, + events +) api_router = APIRouter() api_router.include_router(root.router) api_router.include_router(health.router) api_router.include_router(process.router) +api_router.include_router(defect_transfer.router) +api_router.include_router(analysis_maintenance.router) +api_router.include_router(process_analysis_ws.router) +api_router.include_router(manufacturing_event.router) +api_router.include_router(ml_dataset.router) +api_router.include_router(manual.router) +api_router.include_router(events.router) diff --git a/app/api/routers/analysis_maintenance.py b/app/api/routers/analysis_maintenance.py new file mode 100644 index 0000000..1be2ae2 --- /dev/null +++ b/app/api/routers/analysis_maintenance.py @@ -0,0 +1,103 @@ +from __future__ import annotations + +from datetime import date as DateType + +from fastapi import APIRouter, Depends + +from app.dto.request import AnalysisMaintenanceRequest +from app.dto.response import AnalysisMaintenanceResponse, CommonResponse +from app.service.analysis.analysis_maintenance_service import AnalysisMaintenanceService +from app.utils.datetime_utils import seoul_now +from app.utils.response_utils import success_response + +router = APIRouter(prefix="/api/ai/admin/analysis", tags=["admin-analysis"]) + + +def _resolve_dates(payload: AnalysisMaintenanceRequest) -> tuple[DateType, DateType]: + start = payload.from_date or payload.to_date or seoul_now().date() + end = payload.to_date or payload.from_date or start + return start, end + + +def _service() -> AnalysisMaintenanceService: + return AnalysisMaintenanceService() + + +@router.post( + "/backfill/bottleneck", + response_model=CommonResponse[AnalysisMaintenanceResponse], + summary="병목 백필 및 ES 재반영", + description="지정한 날짜 구간의 병목 결과를 다시 계산하고 Elasticsearch에 재반영합니다.", +) +def backfill_bottleneck( + payload: AnalysisMaintenanceRequest, + service: AnalysisMaintenanceService = Depends(_service), +) -> CommonResponse[AnalysisMaintenanceResponse]: + from_date, to_date = _resolve_dates(payload) + response = service.backfill_bottleneck( + from_date=from_date, + to_date=to_date, + reindex_es=payload.reindex_es, + reset_flags=payload.reset_flags, + dry_run=payload.dry_run, + ) + return success_response(data=response, message="병목 백필이 완료되었습니다.") + + +@router.post( + "/backfill/defect-transfer", + response_model=CommonResponse[AnalysisMaintenanceResponse], + summary="불량 예측 및 전이 백필과 ES 재반영", + description="지정한 날짜 구간의 불량 예측, 전이 예측, SHAP 원인 분석 결과를 다시 계산하고 Elasticsearch에 재반영합니다.", +) +def backfill_defect_transfer( + payload: AnalysisMaintenanceRequest, + service: AnalysisMaintenanceService = Depends(_service), +) -> CommonResponse[AnalysisMaintenanceResponse]: + from_date, to_date = _resolve_dates(payload) + response = service.backfill_defect_transfer( + from_date=from_date, + to_date=to_date, + reindex_es=payload.reindex_es, + reset_flags=payload.reset_flags, + dry_run=payload.dry_run, + ) + return success_response(data=response, message="불량 예측 및 전이 백필이 완료되었습니다.") + + +@router.post( + "/reindex/bottleneck", + response_model=CommonResponse[AnalysisMaintenanceResponse], + summary="병목 ES 재색인", + description="기존 병목 결과를 삭제한 뒤 원천 데이터를 다시 읽어 Elasticsearch 인덱스를 재생성합니다.", +) +def reindex_bottleneck( + payload: AnalysisMaintenanceRequest, + service: AnalysisMaintenanceService = Depends(_service), +) -> CommonResponse[AnalysisMaintenanceResponse]: + from_date, to_date = _resolve_dates(payload) + response = service.reindex_bottleneck( + from_date=from_date, + to_date=to_date, + dry_run=payload.dry_run, + ) + return success_response(data=response, message="병목 ES 재색인이 완료되었습니다.") + + +@router.post( + "/reindex/defect-transfer", + response_model=CommonResponse[AnalysisMaintenanceResponse], + summary="불량 예측 및 전이 ES 재색인", + description="기존 불량 예측, 전이 예측, SHAP 원인 분석 결과를 삭제한 뒤 원천 데이터를 다시 읽어 Elasticsearch 인덱스를 재생성합니다.", +) +def reindex_defect_transfer( + payload: AnalysisMaintenanceRequest, + service: AnalysisMaintenanceService = Depends(_service), +) -> CommonResponse[AnalysisMaintenanceResponse]: + from_date, to_date = _resolve_dates(payload) + response = service.reindex_defect_transfer( + from_date=from_date, + to_date=to_date, + dry_run=payload.dry_run, + ) + return success_response(data=response, message="불량 예측 및 전이 ES 재색인이 완료되었습니다.") diff --git a/app/api/routers/defect_transfer.py b/app/api/routers/defect_transfer.py new file mode 100644 index 0000000..6ec5d7e --- /dev/null +++ b/app/api/routers/defect_transfer.py @@ -0,0 +1,142 @@ +from __future__ import annotations + +from datetime import date as DateType +from typing import Any + +from fastapi import APIRouter, Depends, Query + +from app.dto.response import CommonResponse +from app.dto.response.defect_transfer_response import ( + DefectTransferCausePage, + DefectTransferPredictionPage, +) +from app.service.analysis.defect_transfer_service import ( + DefectTransferAnalysisService, + get_defect_transfer_analysis_service, +) +from app.utils.response_utils import success_response + +router = APIRouter(prefix="/api/ai/process/defect-transfer", tags=["process"]) + +DefectTransferPredictionResponse = CommonResponse[DefectTransferPredictionPage] +DefectTransferCauseResponse = CommonResponse[DefectTransferCausePage] +DefectTransferDiagnosticsResponse = CommonResponse[dict[str, Any]] + +PREDICTION_DESCRIPTION = """ +불량 예측 및 전이 예측 조회 API입니다. + +무엇을 반환하나요 +- 차량별 불량 예측 결과 +- 현재 공정과 예측 공정 +- 전이 확률과 위험도 +- 날짜 옵션과 페이지 정보 + +어떤 데이터를 사용하나요 +- `sampledb.manufacturing_event_json`의 SENT 이벤트 +- ES 인덱스의 `predictedAt` 기준 날짜 옵션 +- 불량 예측 결과 저장 테이블 `defect_transfer_prediction_result` + +조회 방식 +- 기본적으로 ES를 우선 조회합니다. +- ES가 비어 있거나 실패하면 Redis 캐시를 확인하고, 캐시가 없으면 DB로 fallback합니다. +- 날짜를 주지 않으면 최신 가능한 날짜를 자동 선택합니다. +- 목록은 차량별 최신 1건만 보여줍니다. +""" + +CAUSE_DESCRIPTION = """ +원인 분석 조회 API입니다. + +무엇을 반환하나요 +- 불량 예측 결과에 대한 대표 원인 +- SHAP 기반 상세 원인 +- 차량별 최신 원인 분석 결과 + +조회 방식 +- 차량 ID가 있으면 해당 차량을 우선 조회합니다. +- 차량 ID가 없으면 최신 차량 기준으로 조회합니다. +- ES의 `predictedAt` 기준 날짜를 사용합니다. + +응답 의미 +- `main_causes`: 화면에 먼저 보여줄 대표 원인 +- `detailCauses`: 추가로 확인할 상세 원인 +""" + +DIAGNOSTICS_DESCRIPTION = """ +불량 예측 조회 상태를 점검하는 진단 API입니다. + +무엇을 확인하나요 +- 현재 ES 연결 상태 +- 캐시 및 조회 가능 여부 +- 예측 데이터의 간단한 상태 정보 +""" + + +@router.get( + "/predictions", + response_model=DefectTransferPredictionResponse, + summary="불량 예측 및 전이 예측 목록 조회", + description=PREDICTION_DESCRIPTION, +) +def get_defect_transfer_predictions( + date: DateType | None = Query( + default=None, + description="조회할 날짜입니다. 미지정 시 최신 가능한 날짜를 사용합니다.", + ), + cursor: int | None = Query(default=None, ge=0, examples=[0]), + size: int = Query(default=5, ge=1, le=100, examples=[5]), + service: DefectTransferAnalysisService = Depends(get_defect_transfer_analysis_service), +) -> DefectTransferPredictionResponse: + return success_response( + data=service.get_cached_predictions( + cursor=cursor, + size=size, + date=date, + ), + message="불량 예측 및 전이 예측 목록 조회가 완료되었습니다.", + ) + + +@router.get( + "/diagnostics", + response_model=DefectTransferDiagnosticsResponse, + summary="불량 예측 진단 정보 조회", + description=DIAGNOSTICS_DESCRIPTION, +) +def get_defect_transfer_diagnostics( + service: DefectTransferAnalysisService = Depends(get_defect_transfer_analysis_service), +) -> DefectTransferDiagnosticsResponse: + return success_response( + data=service.get_diagnostics(), + message="불량 예측 진단 정보 조회가 완료되었습니다.", + ) + + +@router.get( + "/causes", + response_model=DefectTransferCauseResponse, + summary="불량 예측 원인 분석 조회", + description=CAUSE_DESCRIPTION, +) +def get_defect_transfer_causes( + vehicle_id: str | None = Query( + default=None, + alias="vehicleId", + description="차량 ID입니다. 미지정 시 최신 차량을 사용합니다.", + ), + date: DateType | None = Query( + default=None, + description="조회할 날짜입니다. 미지정 시 최신 가능한 날짜를 사용합니다.", + ), + cursor: int | None = Query(default=None, ge=0, examples=[0]), + size: int = Query(default=5, ge=1, le=100, examples=[5]), + service: DefectTransferAnalysisService = Depends(get_defect_transfer_analysis_service), +) -> DefectTransferCauseResponse: + return success_response( + data=service.get_cached_cause_analysis( + vehicle_id=vehicle_id, + cursor=cursor, + size=size, + date=date, + ), + message="불량 예측 원인 분석 조회가 완료되었습니다.", + ) diff --git a/app/api/routers/events.py b/app/api/routers/events.py new file mode 100644 index 0000000..176f130 --- /dev/null +++ b/app/api/routers/events.py @@ -0,0 +1,16 @@ +from fastapi import APIRouter + +from app.ai_manual.repository.alert_event_repository import AlertEventRepository + +router = APIRouter( + prefix="/events", + tags=["Events"] +) + +repository = AlertEventRepository() + + +@router.get("") +def get_events(): + + return repository.get_events() \ No newline at end of file diff --git a/app/api/routers/manual.py b/app/api/routers/manual.py new file mode 100644 index 0000000..6d4b37c --- /dev/null +++ b/app/api/routers/manual.py @@ -0,0 +1,48 @@ +# app/api/routers/manual.py +from app.ai_manual.service.manual_service import ManualService +from fastapi import APIRouter, HTTPException, Header, Request +from jose import jwt +from app.core.config import settings + +router = APIRouter( + prefix="/api/ai/manual", + tags=["AI Manual"] +) + +service = ManualService() + +@router.get("") +def generate_manual(request: Request): + + authorization = request.headers.get("authorization") + + if not authorization: + raise HTTPException( + status_code=401, + detail="Authorization header missing" + ) + + token = authorization.replace("Bearer ", "") + + print("TOKEN:", token) + + payload = jwt.decode( + token, + settings.jwt_secret_key, + algorithms=[settings.jwt_algorithm] + ) + + print(payload) + + user_id = int(payload["id"]) + + result = service.generate_manual(user_id) + + if result is None: + return { + "success": True, + "message": "처리할 이벤트가 없습니다.", + "data": None + } + + return result diff --git a/app/api/routers/manufacturing_event.py b/app/api/routers/manufacturing_event.py new file mode 100644 index 0000000..92dc686 --- /dev/null +++ b/app/api/routers/manufacturing_event.py @@ -0,0 +1,490 @@ +from datetime import date +from typing import Literal + +from fastapi import APIRouter, Depends, Query, status + +from app.dto.response import CommonResponse +from app.service.manufacturing import ( + DEFAULT_CAR_POOL_SIZE, + DEFAULT_EVENTS_PER_DAY, + DEFAULT_INSERT_CHUNK_SIZE, + DEFAULT_TEMPLATE_NAME, + ManufacturingEventJsonService, + get_manufacturing_event_json_service, +) +from app.utils.response_utils import success_response + + +ProcessCode = Literal["PRESS", "BODY", "PAINT", "ASSEMBLY"] +PROCESS_CODE_DESCRIPTION = ( + "조회할 공정 코드입니다. 미입력 시 프레스, 차체, 도장, 의장 전체 공정을 조회합니다." +) +INSERT_CHUNK_SIZE_DESCRIPTION = ( + "DB에 한 번에 적재할 batch insert row 수입니다. " + "서비스는 생성된 row를 메모리 chunk에 모은 뒤 이 값에 도달할 때마다 한 번의 INSERT를 실행합니다. " + "generate 계열은 동일 event_id를 먼저 조회해 기존 row를 갱신하고, " + "템플릿 생성은 replace/update 옵션에 따라 갱신 또는 무시합니다." +) +EVENT_JSON_TABLE_DESCRIPTION = """ +### 저장 테이블: `manufacturing_event_json` + +| 컬럼 | 설명 | +| --- | --- | +| `id` | DB 내부 PK, 자동 증가 | +| `event_id` | 이벤트 고유 ID. 예: `EVT-20260616-000001` | +| `event_time` | 최초 생성 시 `NULL`. 실제 발행/처리 시각이 확정되면 갱신 | +| `car_master_id` | 기존 `car_master.id` 매핑 값 | +| `equipment_id` | 기존 `equipment.id` 매핑 값 | +| `process_code` | 공정 코드. `PRESS`, `BODY`, `PAINT`, `ASSEMBLY` | +| `event_json` | 관제 화면/연계 시스템에 전달할 원본 JSON payload | +| `dispatch_status` | 발행 상태. PRESS는 `READY`, 후속 공정은 `PENDING`으로 생성 | +| `analysis_status` | 분석 상태. 최초값 `NOT_ANALYZED` | +| `is_sent` | 외부 시스템 전송 여부. 기본값 `false` | +| `retry_count` | 발행 재시도 횟수. 최초값 `0` | +| `error_message` | 발행 실패 메시지 | +| `created_at` | DB row 생성 시각 | +| `updated_at` | DB row 마지막 수정 시각. 신규 insert와 중복 `event_id` upsert 시 갱신 | + +최초 생성 시 `event_json.event.eventTime`도 `null`로 저장됩니다. + +`event_json`에는 `event`, `equipment`, `equipmentStatus`, `product`, `sensor`, +`processMetrics`, `sourceTrace`, `processData`만 포함됩니다. +""" +TEMPLATE_TABLE_DESCRIPTION = """ +### 저장 테이블: `manufacturing_event_template` + +| 컬럼 | 설명 | +| --- | --- | +| `id` | DB 내부 PK, 자동 증가 | +| `template_name` | 템플릿 이름 | +| `template_event_id` | 템플릿 이벤트 고유 ID. 예: `TMPL-DEFAULT-000001` | +| `event_offset_us` | 하루 시작 시각 기준 이벤트 발생 offset, microsecond 단위 | +| `car_master_id` | `car_master.id` FK | +| `equipment_id` | `equipment.id` FK | +| `process_code` | 공정 코드. `PRESS`, `BODY`, `PAINT`, `ASSEMBLY` | +| `station_code` | 공정 내 스테이션 코드 | +| `equipment_code` | 설비 코드 | +| `equipment_type` | 설비 유형 | +| `equipment_status` | 템플릿 기준 설비 운전 상태 | +| `event_type` | 이벤트 유형 | +| `event_json` | 날짜를 입히기 전 기준 JSON payload | +| `created_at` | DB row 생성 시각 | + +템플릿은 특정 날짜의 실제 이벤트가 아니라 하루 기준 패턴입니다. 실제 적재 시 +`event_offset_us`를 target date에 더해 `event_time`으로 변환합니다. +""" + +router = APIRouter(prefix="/api/manufacturing/events", tags=["제조 관제 이벤트"]) + + +@router.post( + "/templates/generate", + summary="제조 이벤트 템플릿 생성", + operation_id="generateManufacturingEventTemplate", + status_code=status.HTTP_202_ACCEPTED, + description=( + "CSV 원천 데이터를 전처리/정제해 하루 기준 제조 관제 이벤트 템플릿을 생성하고 " + "`manufacturing_event_template` 테이블에 저장하는 비동기 job을 생성하는 API입니다.\n\n" + "### 동작 방식\n" + "- API는 job row를 생성한 뒤 즉시 `jobId`를 반환합니다.\n" + "- 실제 템플릿 생성과 DB 저장은 앱 내부 background worker가 수행합니다.\n" + "- production_date와 vehicle_id 생산일자가 일치하는 차량 전체를 사용합니다.\n" + "- 차량마다 PRESS, BODY, PAINT, ASSEMBLY 이벤트가 정확히 1건씩 생성됩니다.\n" + "- event_count와 car_pool_size를 생략하면 실제 차량 수를 기준으로 계산합니다.\n" + "- 전체/공정별 정상:폐기(이상) 비율은 약 7:3입니다.\n" + "- 날짜가 고정된 row가 아니라 하루 안에서의 이벤트 발생 위치를 `event_offset_us`로 저장합니다.\n" + "- `replace=true`이면 같은 `template_name`의 기존 row를 삭제한 뒤 새로 생성합니다.\n" + "- `insert_chunk_size` 단위로 row를 모아 batch insert합니다.\n\n" + "### 즉시 응답 데이터\n" + "- `jobId`: 비동기 job 고유 ID\n" + "- `jobType`: `GENERATE_TEMPLATE`\n" + "- `status`: 최초 상태는 `PENDING`, worker 실행 후 `RUNNING`, `SUCCEEDED`, `FAILED`로 변경됩니다.\n" + "- `totalExpectedEvents`: 예상 생성 건수\n" + "- `generatedCount`, `affectedRows`: worker 진행 중 갱신되는 처리 건수\n" + "- `result`: 완료 전에는 `null`, 완료 후 job 상태 조회 API에서 최종 생성 결과가 채워집니다.\n\n" + f"{TEMPLATE_TABLE_DESCRIPTION}" + ), + responses={202: {"description": "제조 이벤트 템플릿 생성 job 생성 결과"}}, +) +def generate_manufacturing_event_template( + template_name: str = Query( + default=DEFAULT_TEMPLATE_NAME, + description="생성할 템플릿 이름입니다. replay와 tomorrow 적재 시 이 이름으로 템플릿을 선택합니다.", + ), + production_date: date = Query( + default=date(2026, 6, 1), + description="vehicle_id에서 조회할 생산일자입니다.", + ), + event_count: int | None = Query( + default=None, + ge=4, + le=300000, + description="선택적 템플릿 이벤트 수 제한입니다. 생략하면 생산일자 차량 전체 수 * 4로 계산합니다.", + ), + car_pool_size: int | None = Query( + default=None, + ge=1, + le=100000, + description="선택적 차량 수 제한입니다. 생략하면 생산일자의 차량 전체를 사용합니다.", + ), + insert_chunk_size: int = Query( + default=DEFAULT_INSERT_CHUNK_SIZE, + ge=100, + le=10000, + description=INSERT_CHUNK_SIZE_DESCRIPTION, + ), + replace: bool = Query( + default=False, + description="true이면 동일 템플릿명을 가진 기존 데이터를 삭제하고 다시 생성합니다.", + ), + service: ManufacturingEventJsonService = Depends( + get_manufacturing_event_json_service, + ), +) -> CommonResponse[dict]: + result = service.enqueue_generate_template_job( + template_name=template_name, + production_date=production_date, + event_count=event_count, + car_pool_size=car_pool_size, + insert_chunk_size=insert_chunk_size, + replace=replace, + ) + return success_response( + data=result, + message="제조 관제 이벤트 템플릿 생성 job이 생성되었습니다.", + ) + + +@router.get( + "/templates/{template_name}", + summary="제조 이벤트 템플릿 조회", + operation_id="listManufacturingEventTemplate", + description=( + "`manufacturing_event_template`에 저장된 기준 템플릿 이벤트를 조회합니다.\n\n" + "### 동작 방식\n" + "- 이 API는 날짜별 변동을 적용하지 않은 템플릿 원본을 반환합니다.\n" + "- `template_name`, `process_code`, `limit`, `offset` 기준으로 조회합니다.\n" + "- 실제 관제 화면 날짜별 이벤트 형태를 확인하려면 replay API를 사용합니다.\n\n" + f"{TEMPLATE_TABLE_DESCRIPTION}" + ), + responses={200: {"description": "제조 이벤트 템플릿 목록"}}, +) +def list_manufacturing_event_template( + template_name: str, + limit: int = Query(default=20, ge=1, le=200, description="조회할 최대 건수입니다."), + offset: int = Query(default=0, ge=0, description="조회 시작 위치입니다."), + process_code: ProcessCode | None = Query( + default=None, + description=PROCESS_CODE_DESCRIPTION, + ), + service: ManufacturingEventJsonService = Depends( + get_manufacturing_event_json_service, + ), +) -> CommonResponse[dict]: + events = service.list_template_events( + template_name=template_name, + limit=limit, + offset=offset, + process_code=process_code, + ) + return success_response( + data={ + "items": events, + "limit": limit, + "offset": offset, + }, + message="제조 관제 이벤트 템플릿 조회가 완료되었습니다.", + ) + + +@router.get( + "/templates/{template_name}/replay", + summary="템플릿 기반 날짜별 이벤트 replay 조회", + operation_id="replayManufacturingEventTemplate", + description=( + "저장된 템플릿을 지정한 날짜의 제조 관제 이벤트처럼 재생성해서 조회합니다.\n\n" + "### 동작 방식\n" + "- `manufacturing_event_template` row를 읽어 `target_date` 기준 이벤트처럼 materialize합니다.\n" + "- `event_offset_us`를 `target_date` 00:00:00에 더해 `event_time`을 계산합니다.\n" + "- `template_event_id` 순번을 이용해 `EVT-{target_date}-000001` 형태의 `event_id`를 생성합니다.\n" + "- 전류, 진동, 로봇암 진동, 열화상, 공정 지표는 날짜별 변동 레이어가 적용됩니다.\n" + "- 같은 날짜와 같은 템플릿 이벤트는 항상 같은 값으로 replay되며, 날짜가 바뀌면 수치가 달라집니다.\n" + "- 조회 전용 API이므로 `manufacturing_event_json` 테이블에는 저장하지 않습니다.\n\n" + "### 반환 데이터 형태\n" + "반환 item은 실제 저장 row와 같은 필드 구조를 갖지만 DB에 insert되지는 않습니다.\n\n" + f"{EVENT_JSON_TABLE_DESCRIPTION}" + ), + responses={200: {"description": "날짜별 replay 이벤트 목록"}}, +) +def replay_manufacturing_event_template( + template_name: str, + target_date: date = Query( + default=date(2026, 6, 16), + description="이벤트를 replay할 기준 날짜입니다.", + ), + limit: int = Query(default=20, ge=1, le=200, description="조회할 최대 건수입니다."), + offset: int = Query(default=0, ge=0, description="조회 시작 위치입니다."), + process_code: ProcessCode | None = Query( + default=None, + description=PROCESS_CODE_DESCRIPTION, + ), + service: ManufacturingEventJsonService = Depends( + get_manufacturing_event_json_service, + ), +) -> CommonResponse[dict]: + events = service.replay_template_events( + template_name=template_name, + target_date=target_date, + limit=limit, + offset=offset, + process_code=process_code, + ) + return success_response( + data={ + "items": events, + "targetDate": target_date.isoformat(), + "limit": limit, + "offset": offset, + }, + message="템플릿 기반 날짜별 제조 관제 이벤트 replay 조회가 완료되었습니다.", + ) + + +@router.post( + "/generate", + summary="기간별 제조 이벤트 JSON 생성 및 적재", + operation_id="generateManufacturingEventJson", + status_code=status.HTTP_202_ACCEPTED, + description=( + "지정한 날짜 범위의 제조 관제 이벤트 JSON을 실제 일자 데이터로 생성해 " + "`manufacturing_event_json` 테이블에 저장하는 비동기 job을 생성하는 API입니다.\n\n" + "### 언제 사용하는 API인가요?\n" + "- 초기 시연 데이터 또는 특정 기간의 샘플 제조 이벤트를 DB에 실제 row로 적재할 때 사용합니다.\n" + "- 템플릿 replay가 아니라 CSV 기반 생성기를 직접 실행합니다.\n" + "- `start_date`부터 `end_date`까지 양 끝 날짜를 모두 포함해 생성합니다.\n\n" + "### 생성/저장 방식\n" + "- API는 job row를 생성한 뒤 즉시 `jobId`를 반환합니다.\n" + "- 실제 이벤트 생성과 DB 저장은 앱 내부 background worker가 수행합니다.\n" + "- 진행 상태는 job 상태 조회 API로 확인합니다.\n" + "- event_count가 없으면 각 날짜의 `vehicle_id` 생산일자에 해당하는 car_master 전체를 사용합니다.\n" + "- 각 carMasterId마다 `PRESS -> BODY -> PAINT -> ASSEMBLY` 4건이 생성됩니다.\n" + "- 실제 차량 수를 기준으로 정상 70%, 폐기(이상) 30% 비율을 적용합니다.\n" + "- 이벤트 시간은 하루 안에서 생산 밀도가 높은 시간대에 더 많이 분포되도록 계산됩니다.\n" + "- 필요한 schema를 보장하고, 기본 설비와 차량 마스터 row를 준비한 뒤 이벤트를 생성합니다.\n" + "- 생성된 row는 `insert_chunk_size` 단위로 모아 batch insert합니다.\n" + "- 기본 batch insert 단위는 `1,000`건이며, 요청 파라미터로 `100~10,000` 사이에서 조정할 수 있습니다.\n" + "- MySQL에서는 `event_id` 중복 시 기존 row의 이벤트 시간, 설비, 상태, JSON payload 등을 갱신합니다.\n\n" + "### 즉시 응답 데이터\n" + "- `jobId`: 비동기 job 고유 ID\n" + "- `jobType`: `GENERATE_RANGE`\n" + "- `status`: 최초 상태는 `PENDING`, worker 실행 후 `RUNNING`, `SUCCEEDED`, `FAILED`로 변경됩니다.\n" + "- `totalExpectedEvents`: 예상 전체 생성 건수\n" + "- `generatedCount`, `affectedRows`: worker 진행 중 갱신되는 처리 건수\n" + "- `result`: 완료 전에는 `null`, 완료 후 job 상태 조회 API에서 최종 생성 결과가 채워집니다.\n\n" + f"{EVENT_JSON_TABLE_DESCRIPTION}" + ), + responses={202: {"description": "기간별 제조 이벤트 JSON 생성 job 생성 결과"}}, +) +def generate_manufacturing_event_json( + start_date: date = Query( + default=date(2026, 6, 1), + description="생성 시작 날짜입니다.", + ), + end_date: date = Query( + default=date(2026, 6, 1), + description="생성 종료 날짜입니다.", + ), + event_count: int | None = Query( + default=DEFAULT_EVENTS_PER_DAY, + ge=4, + le=300000, + description="날짜별 생성 이벤트 수 제한입니다. 생략하면 vehicle_id 생산일자에 해당하는 차량 전체 수 * 4로 계산합니다.", + ), + car_pool_size: int | None = Query( + default=DEFAULT_CAR_POOL_SIZE, + ge=1, + le=100000, + description="선택적 차량 수 제한입니다. 생략하면 해당 생산일자의 차량 전체를 사용합니다.", + ), + insert_chunk_size: int = Query( + default=DEFAULT_INSERT_CHUNK_SIZE, + ge=100, + le=10000, + description=INSERT_CHUNK_SIZE_DESCRIPTION, + ), + service: ManufacturingEventJsonService = Depends( + get_manufacturing_event_json_service, + ), +) -> CommonResponse[dict]: + result = service.enqueue_generate_range_job( + start_date=start_date, + end_date=end_date, + events_per_day=event_count, + car_pool_size=car_pool_size, + insert_chunk_size=insert_chunk_size, + ) + return success_response( + data=result, + message="제조 원천 이벤트 JSON 생성 job이 생성되었습니다.", + ) + + +@router.post( + "/generate/tomorrow", + summary="템플릿 기반 다음날 제조 이벤트 적재", + operation_id="generateTomorrowManufacturingEventJson", + status_code=status.HTTP_202_ACCEPTED, + description=( + "저장된 템플릿을 기준으로 다음날 제조 관제 이벤트를 생성하고 " + "`manufacturing_event_json` 테이블에 저장하는 비동기 job을 생성하는 API입니다.\n\n" + "### 언제 사용하는 API인가요?\n" + "- 매일 다음날 관제 이벤트 데이터를 미리 생성/적재할 때 사용합니다.\n" + "- 스케줄러도 이 API와 같은 내부 서비스 로직을 사용합니다.\n" + "- `base_date`를 입력하지 않으면 서버 실행일 기준 다음날 데이터를 생성합니다.\n\n" + "### 생성/저장 방식\n" + "- API는 job row를 생성한 뒤 즉시 `jobId`를 반환합니다.\n" + "- 실제 이벤트 생성과 DB 저장은 앱 내부 background worker가 수행합니다.\n" + "- 진행 상태는 job 상태 조회 API로 확인합니다.\n" + "- target date는 `(base_date 또는 서버 현재 날짜) + 1일`입니다.\n" + "- target date의 vehicle_id 생산일자에 해당하는 car_master 전체를 사용합니다.\n" + "- event_count가 없으면 실제 차량 수 * 4건을 생성합니다.\n" + "- 기본 batch insert 단위는 `1,000`건이며, 요청 파라미터로 `100~10,000` 사이에서 조정할 수 있습니다.\n" + "- MySQL에서는 `event_id` 중복 시 기존 row의 이벤트 시간, 설비, 상태, JSON payload 등을 갱신합니다.\n\n" + "### 즉시 응답 데이터\n" + "- `jobId`: 비동기 job 고유 ID\n" + "- `jobType`: `GENERATE_TOMORROW`\n" + "- `status`: 최초 상태는 `PENDING`, worker 실행 후 `RUNNING`, `SUCCEEDED`, `FAILED`로 변경됩니다.\n" + "- `totalExpectedEvents`: 예상 전체 생성 건수\n" + "- `generatedCount`, `affectedRows`: worker 진행 중 갱신되는 처리 건수\n" + "- `result`: 완료 전에는 `null`, 완료 후 job 상태 조회 API에서 최종 생성 결과가 채워집니다.\n\n" + f"{EVENT_JSON_TABLE_DESCRIPTION}" + ), + responses={202: {"description": "템플릿 기반 다음날 제조 이벤트 적재 job 생성 결과"}}, +) +def generate_tomorrow_manufacturing_event_json( + base_date: date | None = Query( + default=None, + description="다음날 계산 기준 날짜입니다. 미입력 시 서버 현재 날짜를 사용합니다.", + ), + template_name: str = Query( + default=DEFAULT_TEMPLATE_NAME, + description="다음날 데이터 적재에 사용할 템플릿 이름입니다.", + ), + event_count: int | None = Query( + default=DEFAULT_EVENTS_PER_DAY, + ge=4, + le=300000, + description="선택적 이벤트 수 제한입니다. 생략하면 target date의 차량 전체 수 * 4로 계산합니다.", + ), + car_pool_size: int | None = Query( + default=DEFAULT_CAR_POOL_SIZE, + ge=1, + le=100000, + description="선택적 차량 수 제한입니다. 생략하면 target date의 차량 전체를 사용합니다.", + ), + insert_chunk_size: int = Query( + default=DEFAULT_INSERT_CHUNK_SIZE, + ge=100, + le=10000, + description=INSERT_CHUNK_SIZE_DESCRIPTION, + ), + service: ManufacturingEventJsonService = Depends( + get_manufacturing_event_json_service, + ), +) -> CommonResponse[dict]: + result = service.enqueue_generate_tomorrow_job( + base_date=base_date, + template_name=template_name, + events_per_day=event_count, + car_pool_size=car_pool_size, + insert_chunk_size=insert_chunk_size, + ) + return success_response( + data=result, + message="템플릿 기반 다음날 제조 원천 이벤트 JSON 적재 job이 생성되었습니다.", + ) + + +@router.get( + "/generate/jobs/{job_id}", + summary="제조 이벤트 생성 job 상태 조회", + operation_id="getManufacturingEventGenerationJob", + description=( + "`/generate`, `/generate/tomorrow`, `/templates/generate`에서 생성한 " + "비동기 제조 이벤트 생성 job의 진행 상태를 조회합니다.\n\n" + "### 상태 값\n" + "- `PENDING`: job이 생성되었고 worker 실행을 기다리는 상태\n" + "- `RUNNING`: worker가 생성/저장을 수행 중인 상태\n" + "- `SUCCEEDED`: 생성/저장이 완료된 상태\n" + "- `FAILED`: 생성/저장 중 오류가 발생한 상태\n\n" + "### 주요 응답 데이터\n" + "- `jobId`: job 고유 ID\n" + "- `jobType`: `GENERATE_RANGE`, `GENERATE_TOMORROW`, `GENERATE_TEMPLATE`\n" + "- `totalExpectedEvents`: 예상 전체 처리 건수\n" + "- `generatedCount`: 현재까지 생성한 이벤트 수\n" + "- `affectedRows`: 현재까지 DB insert/update 영향 row 수\n" + "- `result`: 성공 시 기존 동기 API가 반환하던 생성 결과\n" + "- `errorMessage`: 실패 시 오류 메시지" + ), + responses={200: {"description": "제조 이벤트 생성 job 상태"}}, +) +def get_manufacturing_event_generation_job( + job_id: str, + service: ManufacturingEventJsonService = Depends( + get_manufacturing_event_json_service, + ), +) -> CommonResponse[dict]: + result = service.get_generation_job(job_id) + return success_response( + data=result, + message="제조 이벤트 생성 job 상태 조회가 완료되었습니다.", + ) + + +@router.get( + "", + summary="저장된 제조 이벤트 JSON 조회", + operation_id="listManufacturingEventJson", + description=( + "`manufacturing_event_json` 테이블에 저장된 제조 관제 이벤트 JSON을 조회합니다.\n\n" + "### 동작 방식\n" + "- 기간, 공정 코드, 전송 여부 기준으로 필터링할 수 있습니다.\n" + "- 템플릿 replay 결과가 아니라 실제로 테이블에 적재된 일자별 이벤트를 반환합니다.\n" + "- `event_time`, `id` 오름차순으로 정렬해 `limit`, `offset` 페이지를 반환합니다.\n\n" + f"{EVENT_JSON_TABLE_DESCRIPTION}" + ), + responses={200: {"description": "저장된 제조 이벤트 JSON 목록"}}, +) +def list_manufacturing_event_json( + limit: int = Query(default=20, ge=1, le=200, description="조회할 최대 건수입니다."), + offset: int = Query(default=0, ge=0, description="조회 시작 위치입니다."), + start_date: date | None = Query(default=None, description="조회 시작 날짜입니다."), + end_date: date | None = Query(default=None, description="조회 종료 날짜입니다."), + process_code: ProcessCode | None = Query( + default=None, + description=PROCESS_CODE_DESCRIPTION, + ), + is_sent: bool | None = Query( + default=None, + description="외부 시스템 전송 여부입니다. 미입력 시 전체를 조회합니다.", + ), + service: ManufacturingEventJsonService = Depends( + get_manufacturing_event_json_service, + ), +) -> CommonResponse[dict]: + events = service.list_events( + limit=limit, + offset=offset, + start_date=start_date, + end_date=end_date, + process_code=process_code, + is_sent=is_sent, + ) + return success_response( + data={ + "items": events, + "limit": limit, + "offset": offset, + }, + message="제조 원천 이벤트 JSON 조회가 완료되었습니다.", + ) diff --git a/app/api/routers/ml_dataset.py b/app/api/routers/ml_dataset.py new file mode 100644 index 0000000..23e56f4 --- /dev/null +++ b/app/api/routers/ml_dataset.py @@ -0,0 +1,60 @@ +from pathlib import Path + +from fastapi import APIRouter, Query, status + +from app.data_generation.defect_transfer_dataset_builder import ( + DEFAULT_DATASET_ROOT, + generate_defect_transfer_datasets, +) +from app.dto.response import CommonResponse +from app.utils.response_utils import success_response + + +router = APIRouter(prefix="/api/ml/datasets", tags=["ML Dataset"]) + + +@router.post( + "/defect-transfer/generate", + summary="불량 탐지/전이 예측 학습 CSV 생성", + operation_id="generateDefectTransferTrainingDatasets", + status_code=status.HTTP_201_CREATED, +) +def generate_defect_transfer_training_datasets( + car_count: int = Query( + default=12_000, + ge=100, + le=100_000, + description="생성할 차량 수입니다. 차량 1대당 PRESS/BODY/PAINT/ASSEMBLY 4개 이벤트가 생성됩니다.", + ), + train_ratio: float = Query( + default=0.8, + gt=0.5, + lt=0.95, + description="차량 단위 train split 비율입니다.", + ), + output_dir: str | None = Query( + default=None, + description="CSV 출력 디렉터리입니다. 생략하면 app/ml/datasets/process/generated 를 사용합니다.", + ), +) -> CommonResponse[dict]: + paths = generate_defect_transfer_datasets( + dataset_root=DEFAULT_DATASET_ROOT, + output_dir=Path(output_dir) if output_dir else None, + car_count=car_count, + train_ratio=train_ratio, + ) + return success_response( + data={ + "outputDir": str(paths.output_dir), + "defectDetectionTrain": str(paths.defect_train), + "defectDetectionTest": str(paths.defect_test), + "transferPredictionTrain": str(paths.transfer_train), + "transferPredictionTest": str(paths.transfer_test), + "metadata": str(paths.metadata), + "eventRows": paths.event_rows, + "transitionRows": paths.transition_rows, + "trainCars": paths.train_cars, + "testCars": paths.test_cars, + }, + message="불량 탐지/전이 예측 학습 CSV 생성이 완료되었습니다.", + ) diff --git a/app/api/routers/process.py b/app/api/routers/process.py index 9b7d079..1ef844d 100644 --- a/app/api/routers/process.py +++ b/app/api/routers/process.py @@ -1,3 +1,7 @@ +from __future__ import annotations + +from datetime import date as DateType + from fastapi import APIRouter, Depends, Query from app.dto.response import BottleneckAnalysisPage, CommonResponse @@ -7,21 +11,118 @@ ) from app.utils.response_utils import success_response -router = APIRouter(prefix="/api/process", tags=["process"]) +router = APIRouter(prefix="/api/ai/process", tags=["process"]) + +BottleneckAnalysisResponse = CommonResponse[BottleneckAnalysisPage] + +BottleneckAnalysisDescription = """ +병목 분석 조회 API입니다. + +무엇을 반환하나요 +- 공정별 병목 순위 +- 지연 시간 +- 영향 차량 수 +- 위험도와 위험 점수 +- 다음 페이지 여부와 다음 커서 +어떤 데이터를 사용하나요 +- `sampledb.manufacturing_event_json`의 `is_sent = true` 이벤트 +- ES 인덱스의 `detectedAt` 기준 날짜 옵션 +- 병목 결과 저장 테이블 `bottleneck_analysis_result` -@router.get("/bottleneck") +조회 방식 +- 기본적으로 ES를 우선 조회합니다. +- ES가 비어 있거나 실패하면 Redis 캐시를 확인하고, 캐시가 없으면 DB로 fallback합니다. +- 날짜를 주지 않으면 최신 가능한 날짜를 자동 선택합니다. +- `cursor`와 `size`로 페이지를 제어합니다. + +주의 사항 +- 병목은 공정 단위로 집계됩니다. +- 날짜 옵션은 ES 기준으로 생성됩니다. +- 재색인 / 백필 시 해당 날짜의 기존 결과를 다시 계산합니다. +""" + +BottleneckAnalysisExample = { + "success": True, + "data": { + "mostBottleneckProcess": "차체", + "mostBottleneckRiskLevel": "HIGH", + "content": [ + { + "rankNo": 1, + "processCode": "차체 (L3)", + "delayTime": 12.4, + "affectedVehicleCount": 128, + "riskScore": 5.0, + "riskLevel": "HIGH", + }, + { + "rankNo": 2, + "processCode": "의장 (S12)", + "delayTime": 9.8, + "affectedVehicleCount": 92, + "riskScore": 4.0, + "riskLevel": "HIGH", + }, + ], + "hasNext": True, + "nextCursor": 1, + }, + "message": "병목 분석 조회가 완료되었습니다.", + "timestamp": "2026-06-30T11:10:00+09:00", +} + + +@router.get( + "/bottleneck", + response_model=BottleneckAnalysisResponse, + summary="병목 분석 결과 조회", + description=BottleneckAnalysisDescription, + response_description="병목 순위 페이지", + responses={ + 200: { + "description": "병목 분석 결과 조회 성공", + "content": { + "application/json": { + "example": BottleneckAnalysisExample, + }, + }, + }, + 500: { + "description": "Redis 캐시, ES 인덱스, DB 처리 중 오류가 발생한 경우", + }, + }, +) def get_bottleneck_analysis( - cursor: int | None = Query(default=None, ge=0), - size: int = Query(default=10, ge=1, le=100), + date: DateType | None = Query( + default=None, + description="조회할 날짜입니다. 미지정 시 최신 가능한 날짜를 사용합니다.", + ), + cursor: int | None = Query( + default=None, + ge=0, + description=( + "조회할 페이지 번호입니다. 미지정 시 0으로 처리합니다. " + "cursor=0,size=5는 1~5건, cursor=1,size=5는 6~10건을 의미합니다." + ), + examples=[0], + ), + size: int = Query( + default=5, + ge=1, + le=100, + description="한 페이지에 반환할 병목 결과 수입니다. 기본값은 5입니다.", + examples=[5], + ), service: BottleneckAnalysisService = Depends(get_bottleneck_analysis_service), -) -> CommonResponse[dict]: - """Redis 캐시를 통해 병목 분석 결과 한 페이지를 반환""" +) -> BottleneckAnalysisResponse: + """Redis 캐시를 우선 사용해 병목 분석 페이지를 반환합니다.""" page: BottleneckAnalysisPage = service.get_cached_realtime_bottlenecks( cursor=cursor, size=size, + date=date, ) return success_response( - data=page.model_dump(by_alias=True), - message="병목 분석이 완료되었습니다.", + data=page, + message="병목 분석 조회가 완료되었습니다.", ) diff --git a/app/api/routers/process_analysis_ws.py b/app/api/routers/process_analysis_ws.py new file mode 100644 index 0000000..0f5a1fd --- /dev/null +++ b/app/api/routers/process_analysis_ws.py @@ -0,0 +1,23 @@ +from __future__ import annotations + +from fastapi import APIRouter, WebSocket, WebSocketDisconnect + +from app.websocket.analysis_manager import analysis_websocket_manager + + +router = APIRouter(tags=["process-analysis-websocket"]) + + +@router.websocket("/ws/process-analysis") +async def process_analysis_websocket(websocket: WebSocket) -> None: + await analysis_websocket_manager.connect(websocket) + try: + while True: + message = await websocket.receive_text() + if message.lower() == "ping": + await websocket.send_json({"type": "PONG"}) + except WebSocketDisconnect: + analysis_websocket_manager.disconnect(websocket) + except Exception: + analysis_websocket_manager.disconnect(websocket) + raise diff --git a/app/batch/__init__.py b/app/batch/__init__.py new file mode 100644 index 0000000..84763da --- /dev/null +++ b/app/batch/__init__.py @@ -0,0 +1 @@ +"""Batch job entry points.""" diff --git a/app/batch/defect_transfer_prediction_backfill.py b/app/batch/defect_transfer_prediction_backfill.py new file mode 100644 index 0000000..bd2abfc --- /dev/null +++ b/app/batch/defect_transfer_prediction_backfill.py @@ -0,0 +1,159 @@ +from __future__ import annotations + +import logging +import json +from datetime import datetime +from typing import Any + +from sqlalchemy import create_engine, select + +from app.core.config import settings +from app.ml.inference.defect_transfer_detector import ( + DefectTransferDetector, + has_only_model_probability_cause, +) +from app.repository.defect_transfer_prediction_repository import ( + DefectTransferPredictionRepository, +) +from app.repository.sampledb_schema import manufacturing_event_json +from app.utils.database_utils import mysql_connect_args_for_seoul + + +logger = logging.getLogger(__name__) + + +def backfill_defect_transfer_predictions(*, limit: int | None = None) -> dict[str, int]: + """Backfill defect-transfer predictions from sent manufacturing raw events.""" + if not settings.sample_database_connection_url: + raise RuntimeError("SAMPLE_DB_NAME is required for defect transfer backfill.") + + event_engine = create_engine( + settings.sample_database_connection_url, + connect_args=mysql_connect_args_for_seoul(settings.sample_database_connection_url), + pool_pre_ping=True, + future=True, + ) + result_repository = DefectTransferPredictionRepository( + settings.main_database_connection_url, + event_database_url=settings.sample_database_connection_url, + ) + detector = DefectTransferDetector() + + query = ( + select( + manufacturing_event_json.c.id, + manufacturing_event_json.c.event_id, + manufacturing_event_json.c.car_master_id, + manufacturing_event_json.c.process_code, + manufacturing_event_json.c.event_json, + ) + .where(manufacturing_event_json.c.dispatch_status == "SENT") + .where(manufacturing_event_json.c.is_sent.is_(True)) + .order_by(manufacturing_event_json.c.id.asc()) + ) + if limit is not None: + query = query.limit(limit) + + with event_engine.connect() as conn: + rows = [dict(row) for row in conn.execute(query).mappings()] + + processed = 0 + saved_rows = 0 + failed = 0 + for row in rows: + try: + predicted_at = row.get("event_time") + prediction = detector.predict_event( + _event_json(row["event_json"]), + str(row["process_code"]), + ) + if has_only_model_probability_cause(prediction.causes): + logger.info( + "Skipped defect transfer backfill because only fallback model probability cause was produced: " + "event_id=%s process_code=%s", + row.get("event_id"), + row.get("process_code"), + ) + continue + saved_rows += result_repository.replace_prediction_result( + event_id=str(row["event_id"]), + car_master_id=int(row["car_master_id"]), + source_process_code=prediction.current_process_code, + target_process_code=prediction.predicted_process_code, + current_defect_probability=prediction.defect_probability, + target_defect_probability=prediction.transfer_probability, + predicted_defect_process=_format_predicted_defect_process( + prediction.predicted_process_code, + row, + ), + expected_occurrence_step=prediction.expected_steps_after, + risk_grade=prediction.risk_level, + causes=[ + { + "message": cause.message, + "label": cause.label, + "impact": cause.impact, + } + for cause in prediction.causes + ], + predicted_at=predicted_at if isinstance(predicted_at, datetime) else datetime.now(), + ) + processed += 1 + except Exception: + failed += 1 + logger.exception( + "Failed to backfill defect transfer prediction: event_id=%s", + row.get("event_id"), + ) + + return { + "source_events": len(rows), + "processed_events": processed, + "saved_rows": saved_rows, + "failed_events": failed, + } + + +def _event_json(value: Any) -> dict[str, Any]: + if isinstance(value, dict): + return value + if isinstance(value, str): + try: + decoded = json.loads(value) + except json.JSONDecodeError: + return {} + return decoded if isinstance(decoded, dict) else {} + return {} + + +def _format_predicted_defect_process( + process_code: str | None, + row: dict[str, Any], +) -> str | None: + if process_code is None: + return None + from app.utils.process_label_utils import ( + equipment_code_for_car_process, + format_process_with_line, + ) + + source_code = str(row.get("process_code") or "").strip().upper() + normalized = str(process_code).strip().upper() + if normalized == source_code: + event_json = _event_json(row.get("event_json")) + equipment = event_json.get("equipment", {}) + equipment_code = str(equipment.get("equipmentCode") or "") + else: + equipment_code = equipment_code_for_car_process( + car_master_id=int(row["car_master_id"]), + process_code=normalized, + ) + return format_process_with_line(normalized, equipment_code) + + +def run() -> None: + print(backfill_defect_transfer_predictions()) + + +if __name__ == "__main__": + run() diff --git a/app/batch/manufacturing_event_loader.py b/app/batch/manufacturing_event_loader.py new file mode 100644 index 0000000..4b6a4db --- /dev/null +++ b/app/batch/manufacturing_event_loader.py @@ -0,0 +1,264 @@ +from __future__ import annotations + +import argparse +import logging +import time +from datetime import date, timedelta +from typing import Any + +from app.core.config import settings +from app.repository.sampledb_repository import SampleDbRepository +from app.service.manufacturing import ( + DEFAULT_CAR_POOL_SIZE, + DEFAULT_EVENTS_PER_DAY, + DEFAULT_INSERT_CHUNK_SIZE, + DEFAULT_TEMPLATE_NAME, + ManufacturingEventJsonService, +) + + +logger = logging.getLogger(__name__) + + +def main() -> None: + """CLI 옵션에 따라 실제 이벤트 또는 재사용 템플릿을 배치 생성한다.""" + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(message)s", + ) + args = _parse_args() + + if not settings.sample_database_connection_url: + raise SystemExit("MAIN_DATABASE_URL + SAMPLE_DB_NAME 설정이 필요합니다.") + + repository = SampleDbRepository(settings.sample_database_connection_url) + service = ManufacturingEventJsonService(repository) + started_at = time.monotonic() + last_progress_at = {"value": 0.0} + + # 템플릿 모드는 날짜별 이벤트 테이블이 아니라 재생 가능한 기준 패턴을 만든다. + if args.template: + _run_template_batch( + args=args, + service=service, + started_at=started_at, + last_progress_at=last_progress_at, + ) + return + + start_date, end_date = _resolve_date_range(args) + logger.info( + "제조 이벤트 JSON 배치 적재 시작: start=%s end=%s events_per_day=%s " + "car_pool_size=%s chunk_size=%s update_existing=%s", + start_date.isoformat(), + end_date.isoformat(), + args.events_per_day, + args.car_pool_size, + args.chunk_size, + args.update_existing, + ) + + result = service.generate_range( + start_date=start_date, + end_date=end_date, + events_per_day=args.events_per_day, + car_pool_size=args.car_pool_size, + insert_chunk_size=args.chunk_size, + update_existing=args.update_existing, + progress_callback=_progress_logger( + started_at=started_at, + last_progress_at=last_progress_at, + interval_seconds=args.progress_interval_seconds, + ), + ) + + elapsed = max(0.001, time.monotonic() - started_at) + logger.info( + "제조 이벤트 JSON 배치 적재 완료: generated=%s affected=%s stored=%s " + "elapsed=%.1fs rate=%.1f rows/s distribution=%s", + result["generatedCount"], + result["affectedRows"], + result["storedCountInRange"], + elapsed, + result["generatedCount"] / elapsed, + result["processDistribution"], + ) + + +def _parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description=( + "CSV 원천 데이터에서 제조 이벤트 템플릿 또는 " + "sampledb.manufacturing_event_json을 배치 적재합니다." + ), + ) + range_group = parser.add_mutually_exclusive_group(required=True) + range_group.add_argument( + "--template", + action="store_true", + help="날짜별 물리 적재 대신 하루 재생 템플릿을 생성합니다.", + ) + range_group.add_argument( + "--initial", + action="store_true", + help="2026-06-01부터 2026-06-16까지 초기 시연 데이터를 적재합니다.", + ) + range_group.add_argument( + "--tomorrow", + action="store_true", + help="오늘 기준 다음날 데이터를 적재합니다.", + ) + range_group.add_argument( + "--start-date", + type=_date_arg, + help="적재 시작일입니다. 예: 2026-06-01", + ) + parser.add_argument( + "--end-date", + type=_date_arg, + help="적재 종료일입니다. --start-date와 함께 사용합니다.", + ) + parser.add_argument( + "--events-per-day", + type=int, + default=DEFAULT_EVENTS_PER_DAY, + help=( + "선택적 날짜별 이벤트 수 제한입니다. 생략하면 vehicle_id 생산일자에 " + "해당하는 car_master 전체 수 * 4로 계산합니다." + ), + ) + parser.add_argument( + "--template-name", + default=DEFAULT_TEMPLATE_NAME, + help="생성할 템플릿 이름입니다.", + ) + parser.add_argument( + "--car-pool-size", + type=int, + default=DEFAULT_CAR_POOL_SIZE, + help="선택적 차량 수 제한입니다. 생략하면 생산일자의 차량 전체를 사용합니다.", + ) + parser.add_argument( + "--chunk-size", + type=int, + default=DEFAULT_INSERT_CHUNK_SIZE, + help="DB에 한 번에 insert할 row 수입니다.", + ) + parser.add_argument( + "--update-existing", + action="store_true", + help=( + "중복 event_id/template_event_id가 있으면 기존 row를 업데이트합니다. " + "기본은 INSERT IGNORE입니다." + ), + ) + parser.add_argument( + "--replace", + action="store_true", + help="템플릿 생성 시 기존 템플릿 row를 삭제하고 다시 만듭니다.", + ) + parser.add_argument( + "--progress-interval-seconds", + type=float, + default=10.0, + help="진행 로그 출력 간격입니다.", + ) + return parser.parse_args() + + +def _resolve_date_range(args: argparse.Namespace) -> tuple[date, date]: + """축약 옵션을 실제 생성 시작일/종료일로 변환한다.""" + if args.initial: + return date(2026, 6, 1), date(2026, 6, 16) + if args.tomorrow: + target_date = date.today() + timedelta(days=1) + return target_date, target_date + if not args.start_date: + raise SystemExit("--start-date가 필요합니다.") + return args.start_date, args.end_date or args.start_date + + +def _run_template_batch( + *, + args: argparse.Namespace, + service: ManufacturingEventJsonService, + started_at: float, + last_progress_at: dict[str, float], +) -> None: + logger.info( + "제조 이벤트 템플릿 배치 생성 시작: template=%s event_count=%s " + "car_pool_size=%s chunk_size=%s replace=%s", + args.template_name, + args.events_per_day, + args.car_pool_size, + args.chunk_size, + args.replace, + ) + result = service.generate_template( + template_name=args.template_name, + production_date=args.start_date or date(2026, 6, 1), + event_count=args.events_per_day, + car_pool_size=args.car_pool_size, + insert_chunk_size=args.chunk_size, + replace=args.replace, + update_existing=args.update_existing or args.replace, + progress_callback=_progress_logger( + started_at=started_at, + last_progress_at=last_progress_at, + interval_seconds=args.progress_interval_seconds, + ), + ) + elapsed = max(0.001, time.monotonic() - started_at) + logger.info( + "제조 이벤트 템플릿 배치 생성 완료: template=%s generated=%s " + "affected=%s stored=%s elapsed=%.1fs rate=%.1f rows/s distribution=%s", + result["templateName"], + result["generatedCount"], + result["affectedRows"], + result["storedCount"], + elapsed, + result["generatedCount"] / elapsed, + result["processDistribution"], + ) + + +def _date_arg(value: str) -> date: + try: + return date.fromisoformat(value) + except ValueError as exc: + raise argparse.ArgumentTypeError( + "날짜는 YYYY-MM-DD 형식이어야 합니다.", + ) from exc + + +def _progress_logger( + *, + started_at: float, + last_progress_at: dict[str, float], + interval_seconds: float, +): + def log_progress(progress: dict[str, Any]) -> None: + now = time.monotonic() + if now - last_progress_at["value"] < interval_seconds: + return + last_progress_at["value"] = now + generated_count = int(progress["generatedCount"]) + total_expected = int(progress["totalExpectedEvents"]) + elapsed = max(0.001, now - started_at) + percent = generated_count / total_expected * 100 if total_expected else 100.0 + logger.info( + "제조 이벤트 JSON 배치 진행: generated=%s/%s %.2f%% affected=%s " + "elapsed=%.1fs rate=%.1f rows/s", + generated_count, + total_expected, + percent, + progress["affectedRows"], + elapsed, + generated_count / elapsed, + ) + + return log_progress + + +if __name__ == "__main__": + main() diff --git a/app/core/config.py b/app/core/config.py index 68ee9bc..3bc456d 100644 --- a/app/core/config.py +++ b/app/core/config.py @@ -4,8 +4,41 @@ from pydantic_settings import BaseSettings, SettingsConfigDict +def database_url_with_name(database_url: str, database_name: str | None) -> str: + """Return database_url with its database path replaced by database_name.""" + if not database_name: + return database_url + + scheme_separator = "://" + scheme_index = database_url.find(scheme_separator) + if scheme_index < 0: + return database_url + + authority_start = scheme_index + len(scheme_separator) + credential_end = database_url.rfind("@") + host_start = credential_end + 1 if credential_end >= authority_start else authority_start + suffix_candidates = [ + index + for index in ( + database_url.find("?", host_start), + database_url.find("#", host_start), + ) + if index >= 0 + ] + suffix_start = min(suffix_candidates) if suffix_candidates else len(database_url) + path_start = database_url.find("/", host_start, suffix_start) + prefix_end = path_start if path_start >= 0 else suffix_start + + return ( + database_url[:prefix_end] + + "/" + + database_name.strip("/") + + database_url[suffix_start:] + ) + + class Settings(BaseSettings): - """환경 변수와 .env 파일에서 애플리케이션 설정을 로드한다.""" + """Application settings loaded from environment variables and .env.""" app_name: str = Field(default="AI Service", alias="APP_NAME") app_version: str = Field(default="0.1.0", alias="APP_VERSION") @@ -19,46 +52,149 @@ class Settings(BaseSettings): alias="COLLEAGUE_SKILL_API_URL", ) - kafka_bootstrap_servers: str | None = Field( - default=None, - alias="KAFKA_BOOTSTRAP_SERVERS", + broker_url_1: str | None = Field(default=None, alias="BROKER_URL_1") + broker_url_2: str | None = Field(default=None, alias="BROKER_URL_2") + kafka_raw_topic: str = Field( + default="factory.manufacturing.raw", + alias="KAFKA_RAW_TOPIC", + ) + kafka_analysis_topic: str = Field( + default="factory.manufacturing.analysis", + alias="KAFKA_ANALYSIS_TOPIC", + ) + kafka_raw_consumer_group_id: str = Field( + default="ai-analysis-consumer-group", + alias="KAFKA_RAW_CONSUMER_GROUP_ID", + ) + kafka_raw_auto_offset_reset: str = Field( + default="earliest", + alias="KAFKA_RAW_AUTO_OFFSET_RESET", + ) + kafka_raw_consumer_concurrency: int = Field( + default=2, + alias="KAFKA_RAW_CONSUMER_CONCURRENCY", + ) + kafka_raw_consumer_max_poll_interval_ms: int = Field( + default=900_000, + alias="KAFKA_RAW_CONSUMER_MAX_POLL_INTERVAL_MS", + ) + kafka_raw_consumer_session_timeout_ms: int = Field( + default=30_000, + alias="KAFKA_RAW_CONSUMER_SESSION_TIMEOUT_MS", + ) + kafka_raw_consumer_heartbeat_interval_ms: int = Field( + default=10_000, + alias="KAFKA_RAW_CONSUMER_HEARTBEAT_INTERVAL_MS", + ) + kafka_raw_consumer_max_poll_records: int = Field( + default=1, + alias="KAFKA_RAW_CONSUMER_MAX_POLL_RECORDS", + ) + kafka_raw_consumer_timeout_ms: int = Field( + default=1_000, + alias="KAFKA_RAW_CONSUMER_TIMEOUT_MS", + ) + kafka_analysis_producer_retries: int = Field( + default=3, + alias="KAFKA_ANALYSIS_PRODUCER_RETRIES", + ) + kafka_analysis_producer_linger_ms: int = Field( + default=10, + alias="KAFKA_ANALYSIS_PRODUCER_LINGER_MS", + ) + + jwt_secret_key: str = Field( + ..., + alias="JWT_SECRET_KEY", + ) + + jwt_algorithm: str = Field( + default="HS384", + alias="JWT_ALGORITHM", ) redis_url: str | None = Field(default=None, alias="REDIS_URL") redis_key_prefix: str = Field(default="aims:ai-service", alias="REDIS_KEY_PREFIX") - redis_cache_ttl_seconds: int = Field(default=300, alias="REDIS_CACHE_TTL_SECONDS") + redis_cache_ttl_seconds: int = Field(default=60, alias="REDIS_CACHE_TTL_SECONDS") + + elasticsearch_url: str | None = Field(default=None, alias="ELASTICSEARCH_URL") + elasticsearch_username: str | None = Field( + default=None, + alias="ELASTICSEARCH_USERNAME", + ) + elasticsearch_password: str | None = Field( + default=None, + alias="ELASTICSEARCH_PASSWORD", + ) + elasticsearch_verify_certs: bool = Field( + default=True, + alias="ELASTICSEARCH_VERIFY_CERTS", + ) + elasticsearch_bottleneck_index: str = Field( + default="aims-bottleneck-analysis-v1", + alias="ELASTICSEARCH_BOTTLENECK_INDEX", + ) + elasticsearch_defect_transfer_index: str = Field( + default="aims-defect-transfer-analysis-v1", + alias="ELASTICSEARCH_DEFECT_TRANSFER_INDEX", + ) main_database_url: str | None = Field(default=None, alias="MAIN_DATABASE_URL") - sample_database_url: str | None = Field(default=None, alias="SAMPLE_DATABASE_URL") + main_db_name: str | None = Field(default=None, alias="MAIN_DB_NAME") + sample_db_name: str | None = Field(default=None, alias="SAMPLE_DB_NAME") + manufacturing_event_scheduler_enabled: bool = Field( + default=True, + alias="MANUFACTURING_EVENT_SCHEDULER_ENABLED", + ) + manufacturing_event_scheduler_events_per_day: int | None = Field( + default=None, + alias="MANUFACTURING_EVENT_SCHEDULER_EVENTS_PER_DAY", + ) + manufacturing_event_template_event_count: int | None = Field( + default=None, + alias="MANUFACTURING_EVENT_TEMPLATE_EVENT_COUNT", + ) + manufacturing_event_car_pool_size: int | None = Field( + default=None, + alias="MANUFACTURING_EVENT_CAR_POOL_SIZE", + ) + manufacturing_event_insert_chunk_size: int = Field( + default=1_000, + alias="MANUFACTURING_EVENT_INSERT_CHUNK_SIZE", + ) @property - def bottleneck_database_url(self) -> str: - """병목 분석 결과를 저장할 maindb MySQL URL을 반환한다.""" + def main_database_connection_url(self) -> str: + """Return the main DB connection URL.""" if self.main_database_url: - return self.main_database_url + return database_url_with_name(self.main_database_url, self.main_db_name) + + raise ValueError("maindb MySQL setting is required: MAIN_DATABASE_URL") - raise ValueError("maindb MySQL 설정이 필요합니다: MAIN_DATABASE_URL") + @property + def bottleneck_database_url(self) -> str: + """Return the main DB URL used for bottleneck analysis results.""" + return self.main_database_connection_url @property def sample_database_connection_url(self) -> str | None: - """sampledb 설정이 있으면 MySQL URL을 반환한다.""" - if self.sample_database_url: - return self.sample_database_url + """Return the sample DB URL when SAMPLE_DB_NAME is configured.""" + if self.main_database_url and self.sample_db_name: + return database_url_with_name(self.main_database_url, self.sample_db_name) return None @property def redis_connection_url(self) -> str: - """캐시 클라이언트가 사용할 Redis URL을 반환한다.""" + """Return the Redis connection URL.""" if self.redis_url: return self.redis_url - raise ValueError("Redis 설정이 필요합니다: REDIS_URL") + raise ValueError("Redis setting is required: REDIS_URL") @field_validator("debug", mode="before") @classmethod def parse_debug_value(cls, value: object) -> object: - """dev/prod 같은 환경 이름을 debug 여부로 변환한다.""" if isinstance(value, str): normalized = value.strip().lower() if normalized in {"release", "prod", "production"}: @@ -77,8 +213,8 @@ def parse_debug_value(cls, value: object) -> object: @lru_cache def get_settings() -> Settings: - """프로세스마다 설정 객체를 한 번 생성해 재사용한다.""" + """Return the process-wide cached settings object.""" return Settings() -settings = get_settings() +settings = get_settings() \ No newline at end of file diff --git a/app/data_generation/__init__.py b/app/data_generation/__init__.py new file mode 100644 index 0000000..780f3cd --- /dev/null +++ b/app/data_generation/__init__.py @@ -0,0 +1 @@ +"""Data generation utilities.""" diff --git a/app/data_generation/defect_transfer_dataset_builder.py b/app/data_generation/defect_transfer_dataset_builder.py new file mode 100644 index 0000000..02a6d6c --- /dev/null +++ b/app/data_generation/defect_transfer_dataset_builder.py @@ -0,0 +1,695 @@ +from __future__ import annotations + +import csv +import hashlib +import json +import math +from dataclasses import dataclass +from datetime import datetime, timedelta +from pathlib import Path +from typing import Any + + +PROCESS_ORDER = ("PRESS", "BODY", "PAINT", "ASSEMBLY") +TRANSFER_FLOWS = (("PRESS", "BODY"), ("BODY", "PAINT"), ("PAINT", "ASSEMBLY")) +RAW_EVENT_COLUMNS = [ + "raw_event_id", + "event_id", + "event_time", + "car_master_id_raw", + "equipment_id", + "process_code_raw", + "station_code_raw", + "equipment_code_raw", + "equipment_type_raw", + "operation_status_raw", + "event_type_raw", + "event_json", + "is_sent", + "sent_at", + "created_at", + "updated_at", + "defect_yn", + "defect_reason", + "dataset_split", +] +TRANSFER_PREDICTION_COLUMNS = [ + "car_master_id", + "source_event_id", + "target_event_id", + "source_process_code", + "target_process_code", + "source_defect_yn", + "target_defect_yn", + "source_cycle_time_sec", + "source_station_delay_sec", + "source_queue_length", + "source_wip_count", + "source_current_rms_ampere", + "source_vibration_score", + "source_thermal_score", + "source_event_json", + "dataset_split", +] +DEFAULT_DATASET_ROOT = Path(__file__).resolve().parents[1] / "ml" / "datasets" / "process" +DEFAULT_OUTPUT_DIRNAME = "generated" + + +@dataclass(frozen=True) +class GeneratedDatasetPaths: + output_dir: Path + defect_train: Path + defect_test: Path + transfer_train: Path + transfer_test: Path + metadata: Path + event_rows: int + transition_rows: int + train_cars: int + test_cars: int + + +def generate_defect_transfer_datasets( + dataset_root: Path = DEFAULT_DATASET_ROOT, + output_dir: Path | None = None, + car_count: int = 12_000, + train_ratio: float = 0.8, + start_time: datetime | None = None, +) -> GeneratedDatasetPaths: + """Build ML train/test CSVs from files under app/ml/datasets/process. + + The generated event JSON follows the Kafka payload shape used by + manufacturing_raw_event: + event/equipment/equipmentStatus/product/sensor/processMetrics/sourceTrace/processData. + """ + + dataset_root = Path(dataset_root) + output_dir = Path(output_dir) if output_dir else dataset_root / DEFAULT_OUTPUT_DIRNAME + output_dir.mkdir(parents=True, exist_ok=True) + car_count = max(100, int(car_count)) + train_car_count = max(1, min(car_count - 1, int(car_count * train_ratio))) + start_time = start_time or datetime(2026, 6, 16, 10, 0, 0) + + source = _SourceSamples(dataset_root) + event_rows: list[dict[str, Any]] = [] + event_by_car_process: dict[tuple[int, str], dict[str, Any]] = {} + raw_event_id = 1 + + for car_index in range(car_count): + car_master_id = car_index + 1 + split = "train" if car_master_id <= train_car_count else "test" + defect_profile = _defect_profile(car_master_id) + for process_index, process_code in enumerate(PROCESS_ORDER): + event_time = start_time + timedelta(seconds=car_index * 12 + process_index * 3) + event_id = f"EVT-{event_time:%Y%m%d}-{raw_event_id:06d}" + sample_index = car_index * len(PROCESS_ORDER) + process_index + event_json, defect_yn, defect_reason = _build_event_json( + source=source, + car_master_id=car_master_id, + event_id=event_id, + event_time=event_time, + process_code=process_code, + process_index=process_index, + sample_index=sample_index, + is_defect=defect_profile[process_code], + ) + row = { + "raw_event_id": raw_event_id, + "event_id": event_id, + "event_time": event_time.isoformat(timespec="seconds"), + "car_master_id_raw": car_master_id, + "equipment_id": _equipment_id(process_code, car_master_id), + "process_code_raw": process_code, + "station_code_raw": f"{process_code}_STATION_{_line_no(car_master_id, process_code):02d}", + "equipment_code_raw": event_json["equipment"]["equipmentCode"], + "equipment_type_raw": event_json["equipment"]["equipmentType"], + "operation_status_raw": event_json["equipmentStatus"]["operationStatus"], + "event_type_raw": event_json["event"]["eventType"], + "event_json": json.dumps(event_json, ensure_ascii=False), + "is_sent": 0, + "sent_at": "", + "created_at": datetime.now().isoformat(timespec="seconds"), + "updated_at": datetime.now().isoformat(timespec="seconds"), + "defect_yn": int(defect_yn), + "defect_reason": defect_reason, + "dataset_split": split, + } + event_rows.append(row) + event_by_car_process[(car_master_id, process_code)] = row + raw_event_id += 1 + + transition_rows = _build_transition_rows(event_by_car_process, car_count, train_car_count) + + defect_train_path = output_dir / "defect_detection_train.csv" + defect_test_path = output_dir / "defect_detection_test.csv" + transfer_train_path = output_dir / "transfer_prediction_train.csv" + transfer_test_path = output_dir / "transfer_prediction_test.csv" + metadata_path = output_dir / "defect_transfer_dataset_metadata.json" + + _write_csv(defect_train_path, [r for r in event_rows if r["dataset_split"] == "train"], RAW_EVENT_COLUMNS) + _write_csv(defect_test_path, [r for r in event_rows if r["dataset_split"] == "test"], RAW_EVENT_COLUMNS) + + _write_csv(transfer_train_path, [r for r in transition_rows if r["dataset_split"] == "train"], TRANSFER_PREDICTION_COLUMNS) + _write_csv(transfer_test_path, [r for r in transition_rows if r["dataset_split"] == "test"], TRANSFER_PREDICTION_COLUMNS) + + metadata = { + "created_at": datetime.now().isoformat(timespec="seconds"), + "dataset_root": str(dataset_root), + "output_dir": str(output_dir), + "car_count": car_count, + "train_ratio": train_ratio, + "train_cars": train_car_count, + "test_cars": car_count - train_car_count, + "event_rows": len(event_rows), + "transition_rows": len(transition_rows), + "dataset_files": { + "defect_train": str(defect_train_path), + "defect_test": str(defect_test_path), + "transfer_train": str(transfer_train_path), + "transfer_test": str(transfer_test_path), + }, + "transfer_prediction_schema": { + "label_column": "target_defect_yn", + "excluded_target_side_columns": ["target_defect_reason", "target_event_json"], + }, + "source_files": source.source_files, + } + metadata_path.write_text(json.dumps(metadata, ensure_ascii=False, indent=2), encoding="utf-8") + + return GeneratedDatasetPaths( + output_dir=output_dir, + defect_train=defect_train_path, + defect_test=defect_test_path, + transfer_train=transfer_train_path, + transfer_test=transfer_test_path, + metadata=metadata_path, + event_rows=len(event_rows), + transition_rows=len(transition_rows), + train_cars=train_car_count, + test_cars=car_count - train_car_count, + ) + + +class _SourceSamples: + def __init__(self, dataset_root: Path, sample_rows: int = 4096) -> None: + self.dataset_root = Path(dataset_root) + self.sample_rows = sample_rows + self.forming_rows = self._read_forming_rows() + self.press_current_rows = self._read_current_rows("press") + self.robot_current_rows = self._read_current_rows("robot") + self.ford_rows = self._read_ford_rows() + self.vision_rows = self._read_vision_rows() + self.bosch_rows = self._read_bosch_rows() + self.source_files = { + "forming": str(self._find_forming_file()), + "press_current": [str(p) for p in self._find_current_files("press")], + "robot_current": [str(p) for p in self._find_current_files("robot")], + "ford": str(self._find_file(lambda p: p.name == "FordA_TRAIN.txt")), + "vision": [str(p) for p in self.dataset_root.rglob("2nd_process_*_data.csv")], + "bosch": str(self._find_file(lambda p: p.name == "train_numeric.csv")), + } + + def forming(self, index: int) -> dict[str, Any]: + return self.forming_rows[index % len(self.forming_rows)] + + def current(self, process_code: str, index: int) -> dict[str, float]: + rows = self.robot_current_rows if process_code == "BODY" else self.press_current_rows + return rows[index % len(rows)] + + def ford(self, index: int) -> dict[str, Any]: + return self.ford_rows[index % len(self.ford_rows)] + + def vision(self, index: int) -> dict[str, Any]: + return self.vision_rows[index % len(self.vision_rows)] + + def bosch(self, index: int) -> dict[str, Any]: + return self.bosch_rows[index % len(self.bosch_rows)] + + def _find_file(self, predicate) -> Path: + for path in self.dataset_root.rglob("*"): + if path.is_file() and predicate(path): + return path + raise FileNotFoundError(f"Required source file was not found under {self.dataset_root}") + + def _find_forming_file(self) -> Path: + return self._find_file(lambda p: p.suffix.lower() == ".csv" and "2022" in p.name) + + def _find_current_files(self, kind: str) -> list[Path]: + files: list[Path] = [] + for path in self.dataset_root.rglob("*.csv"): + if kind == "press" and "프레스" in path.name: + files.append(path) + if kind == "robot" and "로봇" in path.name: + files.append(path) + if not files: + raise FileNotFoundError(f"{kind} current CSV files were not found") + return sorted(files) + + def _read_forming_rows(self) -> list[dict[str, Any]]: + path = self._find_forming_file() + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8-sig", newline="") as f: + for row in csv.DictReader(f): + rows.append(row) + if len(rows) >= self.sample_rows: + break + return rows or [{"idx": "1", "itemno": "ITEM-001", "quantity": "1", "cnt": "1"}] + + def _read_current_rows(self, kind: str) -> list[dict[str, float]]: + rows: list[dict[str, float]] = [] + for path in self._find_current_files(kind): + with path.open(encoding="utf-8-sig", newline="") as f: + for row_no, row in enumerate(csv.DictReader(f), start=1): + value = _to_float(row.get("RMS[A]"), 1.8) + if value < 0.01: + value = 1.65 + (row_no % 31) * 0.035 + rows.append( + { + "rowId": float(row.get("", row_no) or row_no), + "rmsAmpere": value, + "maxAmpere": value + 0.16, + "minAmpere": max(0.0, value - 0.16), + "accelerationG": abs(value - 1.8) / 25, + }, + ) + if len(rows) >= self.sample_rows: + return rows + return rows or [{"rowId": 1, "rmsAmpere": 1.8, "maxAmpere": 1.95, "minAmpere": 1.65, "accelerationG": 0.006}] + + def _read_ford_rows(self) -> list[dict[str, Any]]: + path = self._find_file(lambda p: p.name == "FordA_TRAIN.txt") + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8", errors="ignore") as f: + for row_no, line in enumerate(f, start=1): + values = [_to_float(v, 0.0) for v in line.split()] + if len(values) < 20: + continue + signal = values[1:501] + rms = math.sqrt(sum(v * v for v in signal) / len(signal)) + peak = max(abs(v) for v in signal) + bands = _frequency_bands(signal) + rows.append( + { + "rowId": row_no, + "label": int(values[0]), + "vibrationRms": rms, + "vibrationPeak": peak, + "vibrationScore": min(0.99, rms / 3.2), + "frequencyBands": bands, + "frequencyPeakBand": max(bands, key=bands.get).replace("freq_", "").upper(), + }, + ) + if len(rows) >= self.sample_rows: + break + return rows or [{"rowId": 1, "label": 1, "vibrationRms": 0.2, "vibrationPeak": 0.4, "vibrationScore": 0.1, "frequencyBands": {}, "frequencyPeakBand": "0_100_HZ"}] + + def _read_vision_rows(self) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + for data_path in sorted(self.dataset_root.rglob("2nd_process_*_data.csv")): + side = "LEFT" if "left" in data_path.name else "RIGHT" + label_path = data_path.with_name(data_path.name.replace("_data.csv", "_label.json")) + labels = json.loads(label_path.read_text(encoding="utf-8")) if label_path.exists() else [] + with data_path.open(encoding="utf-8-sig", newline="") as f: + reader = csv.reader(f) + for row_no, row in enumerate(reader, start=1): + values = [_to_float(v, 0.0) for v in row if str(v).strip()] + if not values: + continue + avg = sum(values) / len(values) + variance = sum((v - avg) ** 2 for v in values) / len(values) + std = math.sqrt(variance) + label = int(float(labels[(row_no - 1) % len(labels)])) if labels else 0 + defect_score = min(0.99, std / 7.0 + (0.35 if label else 0.04)) + rows.append( + { + "rowId": row_no, + "imagePosition": side, + "label": label, + "avgTemperature": avg, + "maxTemperature": max(values), + "minTemperature": min(values), + "thermalStdTemp": std, + "defectScore": defect_score, + "thicknessValue": 114.0 + (row_no % 19) * 0.45 + std, + "surfaceQualityScore": max(0.0, 100.0 - defect_score * 38), + }, + ) + if len(rows) >= self.sample_rows: + return rows + return rows or [{"rowId": 1, "imagePosition": "LEFT", "label": 0, "avgTemperature": 42.0, "maxTemperature": 45.0, "minTemperature": 40.0, "thermalStdTemp": 1.0, "defectScore": 0.1, "thicknessValue": 116.0, "surfaceQualityScore": 96.0}] + + def _read_bosch_rows(self) -> list[dict[str, Any]]: + path = self._find_file(lambda p: p.name == "train_numeric.csv") + rows: list[dict[str, Any]] = [] + with path.open(encoding="utf-8-sig", newline="") as f: + for row in csv.DictReader(f): + numeric = [_to_float(v, math.nan) for k, v in row.items() if k not in {"Id", "Response"} and v not in {"", None}] + numeric = [v for v in numeric if not math.isnan(v)] + rows.append( + { + "id": int(_to_float(row.get("Id"), len(rows) + 1)), + "response": int(_to_float(row.get("Response"), 0)), + "meanNumericFeature": sum(numeric) / len(numeric) if numeric else 0.0, + "nonNullFeatureCount": len(numeric), + }, + ) + if len(rows) >= self.sample_rows: + break + return rows or [{"id": 1, "response": 0, "meanNumericFeature": 0.0, "nonNullFeatureCount": 0}] + + +def _build_event_json( + *, + source: _SourceSamples, + car_master_id: int, + event_id: str, + event_time: datetime, + process_code: str, + process_index: int, + sample_index: int, + is_defect: bool, +) -> tuple[dict[str, Any], int, str]: + forming = source.forming(car_master_id - 1) + current = dict(source.current(process_code, sample_index)) + ford = dict(source.ford(sample_index)) + vision = dict(source.vision(sample_index)) + bosch = dict(source.bosch(sample_index)) + _apply_defect_profile(process_code, car_master_id, is_defect, current, ford, vision, bosch) + metrics = _process_metrics(process_code, sample_index, current, ford, vision, bosch, is_defect) + process_data = _process_data(process_code, car_master_id, current, ford, vision, bosch, metrics, is_defect) + defect_reason = _defect_reason(process_code, process_data, metrics, current, ford, vision, bosch, is_defect) + line_no = _line_no(car_master_id, process_code) + equipment = _equipment(process_code, line_no) + status_rand = _stable_float(car_master_id, process_code, "operation_status_rand") + if is_defect: + operation_status = "ERROR" if status_rand < 0.15 else "RUNNING" + else: + operation_status = "ERROR" if status_rand < 0.01 else "RUNNING" + is_error = (operation_status == "ERROR") + last_normal_time = event_time - timedelta(seconds=31 if is_error else 3) + event_json = { + "event": { + "eventId": event_id, + "eventTime": event_time.isoformat(timespec="seconds"), + "eventType": _event_type(process_code), + "eventName": _event_name(process_code), + }, + "equipment": equipment, + "equipmentStatus": { + "operationStatus": operation_status, + "lastNormalTime": last_normal_time.isoformat(timespec="seconds") if is_error else None, + "statusChangedTime": event_time.isoformat(timespec="seconds") if is_error else None, + }, + "product": {"carMasterId": car_master_id}, + "sensor": _sensor(current, ford, vision), + "processMetrics": metrics, + "sourceTrace": { + "fordRowId": ford["rowId"], + "formingRowId": int(_to_float(forming.get("idx"), car_master_id)), + "robotArmVibrationRowId": int(_to_float(current.get("rowId"), sample_index + 1)), + "machineVisionRowId": vision["rowId"], + "boschId": bosch["id"], + }, + "processData": process_data, + } + return _json_safe(event_json), int(is_defect), defect_reason + + +def _build_transition_rows(event_by_car_process: dict[tuple[int, str], dict[str, Any]], car_count: int, train_car_count: int) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + for car_master_id in range(1, car_count + 1): + split = "train" if car_master_id <= train_car_count else "test" + for source_process, target_process in TRANSFER_FLOWS: + source = event_by_car_process[(car_master_id, source_process)] + target = event_by_car_process[(car_master_id, target_process)] + source_payload = json.loads(source["event_json"]) + source_metrics = source_payload["processMetrics"] + source_sensor = source_payload["sensor"] + row = { + "car_master_id": car_master_id, + "source_event_id": source["event_id"], + "target_event_id": target["event_id"], + "source_process_code": source_process, + "target_process_code": target_process, + "source_defect_yn": int(source["defect_yn"]), + "target_defect_yn": int(target["defect_yn"]), + "source_cycle_time_sec": source_metrics["cycleTimeSec"], + "source_station_delay_sec": source_metrics["stationDelaySec"], + "source_queue_length": source_metrics["queueLength"], + "source_wip_count": source_metrics["wipCount"], + "source_current_rms_ampere": source_sensor["current"]["rmsAmpere"], + "source_vibration_score": source_sensor["vibration"]["vibrationScore"], + "source_thermal_score": source_sensor["thermal"]["thermalScore"], + "source_event_json": source["event_json"], + "dataset_split": split, + } + rows.append(row) + return rows + + +def _defect_profile(car_master_id: int) -> dict[str, bool]: + press = _stable_int(car_master_id, "PRESS") % 100 < 18 + body = (_stable_int(car_master_id, "BODY") % 100 < 17) or (press and _stable_int(car_master_id, "PRESS_BODY") % 100 < 30) + paint = (_stable_int(car_master_id, "PAINT") % 100 < 17) or (body and _stable_int(car_master_id, "BODY_PAINT") % 100 < 28) + assembly = (_stable_int(car_master_id, "ASSEMBLY") % 100 < 16) or (paint and _stable_int(car_master_id, "PAINT_ASSEMBLY") % 100 < 25) + return {"PRESS": press, "BODY": body, "PAINT": paint, "ASSEMBLY": assembly} + + +def _apply_defect_profile( + process_code: str, + car_master_id: int, + is_defect: bool, + current: dict[str, Any], + ford: dict[str, Any], + vision: dict[str, Any], + bosch: dict[str, Any], +) -> None: + r1 = _stable_float(car_master_id, process_code, "defect_rand_1") + r2 = _stable_float(car_master_id, process_code, "defect_rand_2") + r3 = _stable_float(car_master_id, process_code, "defect_rand_3") + severity = 0.20 + _stable_float(car_master_id, process_code, "defect_severity") * 0.65 + + current_factor = 0.92 + r2 * 0.20 + current["rmsAmpere"] = round(float(current["rmsAmpere"]) * current_factor, 9) + current["maxAmpere"] = round(float(current["maxAmpere"]) * current_factor, 9) + current["minAmpere"] = round(float(current["minAmpere"]) * current_factor, 9) + ford["vibrationScore"] = round(float(ford["vibrationScore"]) * (0.82 + r3 * 0.34), 6) + vision["defectScore"] = round(float(vision["defectScore"]) * (0.82 + r1 * 0.34), 6) + + if is_defect: + if process_code == "PRESS": + current_base = _to_float(current.get("rmsAmpere"), 1.8) + current["rmsAmpere"] = round(current_base + 0.10 + severity * 0.45 + r1 * 0.28, 9) + current["maxAmpere"] = round(current["rmsAmpere"] + 0.10 + r2 * 0.24, 9) + current["minAmpere"] = round(max(0.0, current["rmsAmpere"] - 0.12 - r3 * 0.24), 9) + current["accelerationG"] = round(0.008 + severity * 0.018 + r1 * 0.018, 9) + elif process_code == "BODY": + ford["label"] = -1 + ford["vibrationScore"] = round(max(float(ford["vibrationScore"]), 0.20 + severity * 0.28 + r1 * 0.16), 6) + ford["vibrationRms"] = round(max(float(ford["vibrationRms"]) * (0.88 + r2 * 0.30), 0.52 + severity * 0.68 + r2 * 0.62), 9) + ford["vibrationPeak"] = round(max(float(ford["vibrationPeak"]) * (0.88 + r3 * 0.30), 0.90 + severity * 0.88 + r3 * 0.82), 9) + elif process_code == "PAINT": + vision["label"] = 1 + vision["thermalStdTemp"] = round(max(float(vision["thermalStdTemp"]) * (0.88 + r1 * 0.24), 1.4 + severity * 1.6 + r1 * 1.25), 9) + vision["defectScore"] = round(max(float(vision["defectScore"]), 0.18 + severity * 0.22 + r2 * 0.18), 6) + vision["surfaceQualityScore"] = round(78.0 - severity * 8.0 + r3 * 14.0, 3) + else: + bosch["response"] = 1 if severity + r3 * 0.40 > 0.82 else 0 + if r2 < 0.35: + current["rmsAmpere"] = round(float(current["rmsAmpere"]) + 0.10 + r1 * 0.35, 9) + current["maxAmpere"] = round(current["rmsAmpere"] + 0.14 + r2 * 0.22, 9) + else: + if process_code == "PRESS" and r1 < 0.34: + current["rmsAmpere"] = round(1.85 + r2 * 1.80, 9) + current["maxAmpere"] = round(current["rmsAmpere"] + 0.18 + r3 * 0.20, 9) + current["minAmpere"] = round(max(0.0, current["rmsAmpere"] - 0.18 - r1 * 0.20), 9) + if process_code == "BODY" and r2 < 0.34: + ford["vibrationScore"] = round(0.22 + r3 * 0.46, 6) + ford["vibrationRms"] = round(0.58 + r1 * 1.35, 9) + ford["vibrationPeak"] = round(0.95 + r2 * 1.55, 9) + if process_code == "PAINT" and r3 < 0.34: + vision["thermalStdTemp"] = round(1.25 + r1 * 2.45, 9) + vision["defectScore"] = round(0.18 + r1 * 0.46, 6) + vision["surfaceQualityScore"] = round(66.0 + r2 * 22.0, 3) + if process_code == "ASSEMBLY": + bosch["response"] = 1 if r1 < 0.18 else 0 + + +def _process_metrics(process_code: str, index: int, current: dict[str, Any], ford: dict[str, Any], vision: dict[str, Any], bosch: dict[str, Any], is_defect: bool) -> dict[str, Any]: + target = {"PRESS": 40.0, "BODY": 52.0, "PAINT": 64.0, "ASSEMBLY": 58.0}[process_code] + anomaly = 0.0 + if process_code in {"PRESS", "BODY"}: + anomaly = float(ford["vibrationScore"]) * 9 + elif process_code == "PAINT": + anomaly = float(vision["defectScore"]) * 8 + else: + anomaly = float(bosch["response"]) * 8 + delay_rand = _stable_float(index, process_code, "delay_rand") + if is_defect: + anomaly += 0.2 + delay_rand * 1.2 + elif delay_rand < 0.28: + anomaly += 0.8 + _stable_float(index, process_code, "normal_delay") * 4.2 + cycle_time = target + anomaly + (index % 5) * 0.4 + processing = max(1.0, cycle_time - (5 + index % 4)) + waiting = cycle_time - processing + (index % 3) + delay = max(0.0, cycle_time - target) + return { + "cycleTimeSec": round(cycle_time, 3), + "waitingTimeSec": round(waiting, 3), + "processingTimeSec": round(processing, 3), + "stationDelaySec": round(delay, 3), + "throughputPerMin": round(60 / cycle_time, 3), + "queueLength": int(3 + delay // 2 + index % 5), + "wipCount": int(14 + delay // 1.5 + index % 9), + "equipmentIdleTimeSec": round(delay * 1.6, 3), + } + + +def _process_data( + process_code: str, + car_master_id: int, + current: dict[str, Any], + ford: dict[str, Any], + vision: dict[str, Any], + bosch: dict[str, Any], + metrics: dict[str, Any], + is_defect: bool, +) -> dict[str, Any]: + if process_code == "PRESS": + return {"press": {"countIncreaseYn": metrics["stationDelaySec"] < 10, "targetCycleTimeSec": 40.0, "timestampDelaySec": metrics["stationDelaySec"]}} + if process_code == "BODY": + body_rand = _stable_float(car_master_id, process_code, "body_motion_rand") + if is_defect: + robot_motion_status = "WARNING" if body_rand < 0.70 else "NORMAL" + else: + robot_motion_status = "WARNING" if body_rand < 0.05 else "NORMAL" + return {"body": {"robotMotionStatus": robot_motion_status, "robotOperationMode": "AUTO", "frequencyPeakBand": ford["frequencyPeakBand"], "frequencyBands": ford["frequencyBands"]}} + if process_code == "PAINT": + vision_rand = _stable_float(car_master_id, process_code, "vision_label_rand") + if is_defect: + vision_label = "DEFECT" if vision_rand < 0.70 else "NORMAL" + else: + vision_label = "DEFECT" if vision_rand < 0.05 else "NORMAL" + return { + "paint": { + "imagePosition": vision["imagePosition"], + "thermalStdTemp": round(vision["thermalStdTemp"], 3), + "thicknessValue": round(vision["thicknessValue"], 3), + "defectScore": round(vision["defectScore"], 4), + "visionLabel": vision_label, + "surfaceQualityScore": round(vision["surfaceQualityScore"], 3), + } + } + expected = "A01>A02>A03>A04" + seq_rand = _stable_float(car_master_id, process_code, "seq_rand") + missing_rand = _stable_float(car_master_id, process_code, "missing_rand") + fasten_rand = _stable_float(car_master_id, process_code, "fasten_rand") + + if is_defect: + seq_err = 1 if seq_rand < 0.65 else 0 + missing_err = 1 if missing_rand < 0.60 else 0 + fasten_err = 1 if fasten_rand < 0.70 else 0 + else: + seq_err = 1 if seq_rand < 0.04 else 0 + missing_err = 1 if missing_rand < 0.03 else 0 + fasten_err = 1 if fasten_rand < 0.05 else 0 + + actual = "A01>A03>A02>A04" if seq_err > 0 else expected + return { + "assembly": { + "expectedSequence": expected, + "actualSequence": actual, + "missingPartCount": missing_err, + "fasteningErrorCount": fasten_err, + "sequenceErrorCount": seq_err, + } + } + + +def _defect_reason(process_code: str, process_data: dict[str, Any], metrics: dict[str, Any], current: dict[str, Any], ford: dict[str, Any], vision: dict[str, Any], bosch: dict[str, Any], is_defect: bool) -> str: + if not is_defect: + return "normal" + if process_code == "PRESS": + return "press_count_or_delay" + if process_code == "BODY": + return "body_robot_vibration" + if process_code == "PAINT": + return "paint_vision_or_thermal" + return "assembly_sequence_or_fastening" + + +def _sensor(current: dict[str, Any], ford: dict[str, Any], vision: dict[str, Any]) -> dict[str, Any]: + return { + "sensorType": "MULTI_SENSOR", + "current": {"rmsAmpere": round(current["rmsAmpere"], 9), "maxAmpere": round(current["maxAmpere"], 9), "minAmpere": round(current["minAmpere"], 9)}, + "vibration": {"accelerationG": round(current["accelerationG"], 9), "vibrationScore": round(ford["vibrationScore"], 6), "vibrationRms": round(ford["vibrationRms"], 9), "vibrationPeak": round(ford["vibrationPeak"], 9)}, + "robotArmVibration": {"robotId": "ROBOT_ARM_01", "axis": f"J{(int(current['rowId']) % 6) + 1}", "frequencyHz": round(40 + float(ford["vibrationScore"]) * 220, 3), "amplitude": round(float(ford["vibrationRms"]) / 1000, 9), "vibrationRms": round(float(ford["vibrationRms"]) / 900, 9), "vibrationPeak": round(float(ford["vibrationPeak"]) / 700, 9), "vibrationScore": round(ford["vibrationScore"], 6)}, + "thermal": {"thermalScore": round(vision["avgTemperature"], 3), "avgTemperature": round(vision["avgTemperature"], 3), "maxTemperature": round(vision["maxTemperature"], 3), "minTemperature": round(vision["minTemperature"], 3)}, + } + + +def _event_type(process_code: str) -> str: + return {"PRESS": "PROCESS_STATUS", "BODY": "EQUIPMENT_SENSOR", "PAINT": "QUALITY_CHECK", "ASSEMBLY": "PROCESS_STATUS"}[process_code] + + +def _event_name(process_code: str) -> str: + return {"PRESS": "프레스 공정 통합 관제 이벤트", "BODY": "차체 공정 로봇 관제 이벤트", "PAINT": "도장 공정 품질 관제 이벤트", "ASSEMBLY": "의장 공정 조립 관제 이벤트"}[process_code] + + +def _equipment(process_code: str, line_no: int) -> dict[str, str]: + equipment_type = {"PRESS": "HYDRAULIC_PRESS", "BODY": "ROBOT_ARM", "PAINT": "CAMERA", "ASSEMBLY": "CONVEYOR"}[process_code] + name = {"PRESS": "프레스 유압모터", "BODY": "차체 용접 로봇", "PAINT": "도장 열화상 카메라", "ASSEMBLY": "의장 조립 컨베이어"}[process_code] + return {"equipmentCode": f"EQ_{process_code}_{line_no:03d}", "equipmentName": f"{name} {line_no}호", "equipmentType": equipment_type} + + +def _equipment_id(process_code: str, car_master_id: int) -> int: + return (PROCESS_ORDER.index(process_code) * 10) + _line_no(car_master_id, process_code) + + +def _line_no(car_master_id: int, process_code: str) -> int: + return _stable_int(car_master_id, process_code, "line") % 5 + 1 + + +def _frequency_bands(signal: list[float]) -> dict[str, float]: + names = ["freq_0_100_hz", "freq_101_200_hz", "freq_201_300_hz", "freq_301_400_hz", "freq_401_500_hz", "freq_501_600_hz", "freq_601_700_hz", "freq_701_800_hz", "freq_801_900_hz", "freq_901_1000_hz", "freq_1001_1100_hz", "freq_1101_1200_hz", "freq_1201_1300_hz", "freq_1301_1400_hz", "freq_1401_1500_hz", "freq_1501_1600_hz"] + chunk_size = max(1, len(signal) // len(names)) + bands = {} + for idx, name in enumerate(names): + chunk = signal[idx * chunk_size : (idx + 1) * chunk_size] or [0.0] + bands[name] = round(math.sqrt(sum(v * v for v in chunk) / len(chunk)) / 700, 9) + return bands + + +def _write_csv(path: Path, rows: list[dict[str, Any]], columns: list[str]) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + with path.open("w", encoding="utf-8-sig", newline="") as f: + writer = csv.DictWriter(f, fieldnames=columns, extrasaction="ignore") + writer.writeheader() + writer.writerows(rows) + + +def _stable_int(*parts: Any) -> int: + digest = hashlib.blake2b(":".join(map(str, parts)).encode("utf-8"), digest_size=8).digest() + return int.from_bytes(digest, "big") + + +def _stable_float(*parts: Any) -> float: + return (_stable_int(*parts) % 100000) / 100000.0 + + +def _to_float(value: Any, default: float = 0.0) -> float: + try: + result = float(value) + except (TypeError, ValueError): + return default + return result if not math.isnan(result) and not math.isinf(result) else default + + +def _json_safe(value: Any) -> Any: + if isinstance(value, dict): + return {k: _json_safe(v) for k, v in value.items()} + if isinstance(value, list): + return [_json_safe(v) for v in value] + if isinstance(value, float): + return None if math.isnan(value) or math.isinf(value) else value + return value diff --git a/app/data_generation/manufacturing_event_json_builder.py b/app/data_generation/manufacturing_event_json_builder.py new file mode 100644 index 0000000..ccc29b3 --- /dev/null +++ b/app/data_generation/manufacturing_event_json_builder.py @@ -0,0 +1,1542 @@ +from __future__ import annotations + +import hashlib +import json +import math +import statistics +from collections.abc import Iterator +from dataclasses import dataclass +from datetime import date, datetime, time, timedelta +from pathlib import Path +from typing import Any + +import pandas as pd + + +# PRD??李⑤웾 ?앹궛 ?쒖꽌?? ??李⑤웾留덈떎 ?꾨옒 4媛?怨듭젙 ?대깽?몃? ?뺥솗????嫄댁뵫 留뚮뱺?? +PROCESS_SEQUENCE = ("PRESS", "BODY", "PAINT", "ASSEMBLY") +PROCESS_ROUTE_PREFIX = { + "PRESS": "P", + "BODY": "B", + "PAINT": "PA", + "ASSEMBLY": "A", +} + +# PRD 湲곗? 怨듭젙蹂??ㅻ퉬 ?섏? 紐⑺몴 ?댁긽 ?곗씠??鍮꾩쑉?대떎. +LINE_STATION_COUNT = 5 +ABNORMAL_RATIO = 0.30 +PROCESS_DATA_REQUIRED_FIELDS: dict[str, frozenset[str]] = { + "PRESS": frozenset( + { + "countIncreaseYn", + "targetCycleTimeSec", + "timestampDelaySec", + }, + ), + "BODY": frozenset( + { + "robotMotionStatus", + "robotOperationMode", + "frequencyPeakBand", + "frequencyBands", + }, + ), + "PAINT": frozenset( + { + "imagePosition", + "thermalStdTemp", + "thicknessValue", + "defectScore", + "visionLabel", + "surfaceQualityScore", + }, + ), + "ASSEMBLY": frozenset( + { + "expectedSequence", + "actualSequence", + "missingPartCount", + "fasteningErrorCount", + "sequenceErrorCount", + }, + ), +} +PROCESS_DATA_KEY = { + "PRESS": "press", + "BODY": "body", + "PAINT": "paint", + "ASSEMBLY": "assembly", +} + + +def initial_dispatch_status(process_code: str) -> str: + """?먯쿇 ?대깽??理쒖큹 諛쒗뻾 ?곹깭瑜?諛섑솚?쒕떎. + + 李⑤웾 ?앹궛 ?먮쫫?€ PRESS遺€???쒖옉?섎?濡?PRESS留?READY?대ʼn, BODY/PAINT/ + ASSEMBLY???댁쟾 怨듭젙???뺤긽 遺꾩꽍 寃곌낵媛€ ?ㅺ린 ?꾧퉴吏€ PENDING?대떎. + """ + return "READY" if process_code == "PRESS" else "PENDING" + + +def is_abnormal_operation_status(operation_status: Any) -> bool: + """?대깽??JSON???댁쟾 ?곹깭媛€ ?댁긽 ?곹깭?몄? 諛섑솚?쒕떎.""" + return operation_status in {"FAULT", "STOPPED"} + + +def _press_count_increase_flag( + *, + station_delay_sec: float, + equipment_idle_time_sec: float, +) -> bool | None: + """?꾨젅???앹궛 移댁슫??利앷? ?щ?瑜??뺤긽/寃쎄퀬/?꾪뿕 湲곗??쇰줈 遺꾨━?쒕떎.""" + if station_delay_sec <= 2.0 and equipment_idle_time_sec < 6.0: + return True + if station_delay_sec <= 3.0: + return None + return False + + +def _body_robot_motion_status(vibration_score: float) -> str: + """李⑥껜 濡쒕큸 吏꾨룞 ?먯닔瑜?諛뷀깢?쇰줈 ?곹깭瑜??먯젙?쒕떎.""" + if vibration_score >= 0.45: + return "ABNORMAL" + if vibration_score >= 0.40: + return "WARNING" + return "NORMAL" + + +def _body_robot_operation_mode(vibration_score: float) -> str: + """李⑥껜 濡쒕큸 ?댁쟾 紐⑤뱶瑜?吏꾨룞 ?먯닔 湲곗??쇰줈 援ъ꽦?쒕떎.""" + return "STOPPED" if vibration_score >= 0.45 else "AUTO" + + +def normalize_event_json(event_json: dict[str, Any]) -> dict[str, Any]: + """?쒖“ ?대깽??JSON??PRD???뺤쓽???꾨뱶留??④릿 援ъ“濡??뺢퇋?뷀븳??""" + event = event_json.get("event", {}) + equipment = event_json.get("equipment", {}) + equipment_status = event_json.get("equipmentStatus", {}) + product = event_json.get("product", {}) + sensor = event_json.get("sensor", {}) + current = sensor.get("current", {}) + vibration = sensor.get("vibration", {}) + robot = sensor.get("robotArmVibration", {}) + thermal = sensor.get("thermal", {}) + metrics = event_json.get("processMetrics", {}) + source_trace = event_json.get("sourceTrace", {}) + + return { + "event": { + "eventId": event.get("eventId"), + "eventTime": event.get("eventTime"), + "eventType": event.get("eventType"), + "eventName": event.get("eventName"), + }, + "equipment": { + "equipmentCode": equipment.get("equipmentCode"), + "equipmentName": equipment.get("equipmentName"), + "equipmentType": equipment.get("equipmentType"), + }, + "equipmentStatus": { + "operationStatus": equipment_status.get("operationStatus"), + "lastNormalTime": equipment_status.get("lastNormalTime"), + "statusChangedTime": equipment_status.get("statusChangedTime"), + }, + "product": { + "carMasterId": product.get("carMasterId"), + }, + "sensor": { + "sensorType": sensor.get("sensorType"), + "current": { + "rmsAmpere": current.get("rmsAmpere"), + "maxAmpere": current.get("maxAmpere"), + "minAmpere": current.get("minAmpere"), + }, + "vibration": { + "accelerationG": vibration.get("accelerationG"), + "vibrationScore": vibration.get("vibrationScore"), + "vibrationRms": vibration.get("vibrationRms"), + "vibrationPeak": vibration.get("vibrationPeak"), + }, + "robotArmVibration": { + "robotId": robot.get("robotId"), + "axis": robot.get("axis"), + "frequencyHz": robot.get("frequencyHz"), + "amplitude": robot.get("amplitude"), + "vibrationRms": robot.get("vibrationRms"), + "vibrationPeak": robot.get("vibrationPeak"), + "vibrationScore": robot.get("vibrationScore"), + }, + "thermal": { + "thermalScore": thermal.get("thermalScore"), + "avgTemperature": thermal.get("avgTemperature"), + "maxTemperature": thermal.get("maxTemperature"), + "minTemperature": thermal.get("minTemperature"), + }, + }, + "processMetrics": { + "cycleTimeSec": metrics.get("cycleTimeSec"), + "waitingTimeSec": metrics.get("waitingTimeSec"), + "processingTimeSec": metrics.get("processingTimeSec"), + "stationDelaySec": metrics.get("stationDelaySec"), + "throughputPerMin": metrics.get("throughputPerMin"), + "queueLength": metrics.get("queueLength"), + "wipCount": metrics.get("wipCount"), + "equipmentIdleTimeSec": metrics.get("equipmentIdleTimeSec"), + }, + "sourceTrace": { + "fordRowId": source_trace.get("fordRowId"), + "formingRowId": source_trace.get("formingRowId"), + "robotArmVibrationRowId": source_trace.get( + "robotArmVibrationRowId", + ), + "machineVisionRowId": source_trace.get("machineVisionRowId"), + "boschId": source_trace.get("boschId"), + }, + "processData": event_json.get("processData", {}), + } + + +PROCESS_META: dict[str, dict[str, Any]] = { + "PRESS": { + "equipmentType": "HYDRAULIC_PRESS", + "eventType": "PROCESS_STATUS", + "eventName": "프레스 공정 통합 관제 이벤트", + "targetCycleTimeSec": 40.0, + }, + "BODY": { + "equipmentType": "ROBOT_ARM", + "eventType": "EQUIPMENT_SENSOR", + "eventName": "차체 공정 로봇 관제 이벤트", + "targetCycleTimeSec": 52.0, + }, + "PAINT": { + "equipmentType": "CAMERA", + "eventType": "QUALITY_CHECK", + "eventName": "도장 공정 비전 관제 이벤트", + "targetCycleTimeSec": 64.0, + }, + "ASSEMBLY": { + "equipmentType": "CONVEYOR", + "eventType": "PROCESS_STATUS", + "eventName": "조립 공정 통합 관제 이벤트", + "targetCycleTimeSec": 58.0, + }, +} + +DATASET_ROOT = Path(__file__).resolve().parents[1] / "ml" / "datasets" / "process" +EVENT_DENSITY_WINDOWS: tuple[tuple[int, int, float], ...] = ( + (0, 5, 0.35), + (5, 8, 0.8), + (8, 12, 1.6), + (12, 13, 0.65), + (13, 18, 1.8), + (18, 22, 1.0), + (22, 24, 0.45), +) + + +@dataclass(frozen=True) +class EventBuildRequest: + """??踰덉쓽 ?쒖“ ?대깽???앹꽦 ?묒뾽???꾩슂??踰붿쐞?€ 留덉뒪???곗씠??""" + + start_date: date + end_date: date + # 湲곗〈 API ?대쫫???좎??섏?留??꾩옱 ?섎???湲곌컙 ?꾩껜 ?대깽???섎떎. + events_per_day: int + # dict ?쎌엯 ?쒖꽌媛€ car_master.id ?ㅻ쫫李⑥닚??蹂댁〈?쒕떎. + car_id_map: dict[str, int] + equipment_map: dict[str, dict[str, Any]] + + +class ManufacturingEventJsonBuilder: + """CSV ?먯쿇 ?곗씠?곕? PRD???듯빀 ?쒖“ ?대깽??JSON?쇰줈 蹂€?섑븳??""" + + def __init__(self, dataset_root: Path = DATASET_ROOT) -> None: + self.dataset_root = dataset_root + self._cache: dict[str, Any] = {} + self._feature_cache: dict[tuple[Any, ...], dict[str, Any]] = {} + + def build_rows(self, request: EventBuildRequest) -> list[dict[str, Any]]: + return list(self.iter_rows(request)) + + def iter_rows(self, request: EventBuildRequest) -> Iterator[dict[str, Any]]: + """李⑤웾 ?⑥쐞濡?4怨듭젙 row瑜??쒖감 ?앹꽦?쒕떎.""" + # Repository媛€ car_master.id ?ㅻ쫫李⑥닚?쇰줈 留뚮뱺 ?쒖꽌瑜?洹몃?濡??ъ슜?댁빞 + # PRD??"id 1踰?李⑤웾遺€???앹꽦" 議곌굔??吏€?????덈떎. + car_ids = list(request.car_id_map) + if not car_ids: + return + + days = (request.end_date - request.start_date).days + 1 + if days <= 0: + return + + # 李⑤웾留덈떎 4嫄댁씠誘€濡??대깽???섏? 李⑤웾 ?섎? ?낅┰?곸쑝濡?諛쏆쓣 ???녿떎. + # ?ш린???ㅼ떆 寃€利앺빐 ?쒕퉬???몃??먯꽌 Builder瑜?吏곸젒 ?몄텧?대룄 援ъ“媛€ 源⑥?吏€ ?딄쾶 ?쒕떎. + total_events = len(car_ids) * len(PROCESS_SEQUENCE) + if request.events_per_day != total_events: + raise ValueError( + "event_count??car_pool_size * 4?€ 媛숈븘???⑸땲?? " + f"event_count={request.events_per_day}, expected={total_events}", + ) + + # ?좎쭨蹂??ㅼ젣 李⑤웾 ?섎? 湲곗??쇰줈 ?뺤긽 70% / ?먭린(?댁긽) 30%瑜?諛곗튂?쒕떎. + # ?댁긽 李⑤웾??4怨듭젙??紐⑤몢 媛€吏€誘€濡?怨듭젙蹂??댁긽 嫄댁닔媛€ ?먮룞?쇰줈 ?숈씪?댁쭊?? + abnormal_vehicle_count = round(len(car_ids) * ABNORMAL_RATIO) + normal_vehicle_count = len(car_ids) - abnormal_vehicle_count + + for production_sequence_index, car_id in enumerate(car_ids): + car_master_id = request.car_id_map[car_id] + is_abnormal_vehicle = production_sequence_index >= normal_vehicle_count + # 媛숈? 李⑤웾???대깽?몃뒗 PRESS -> BODY -> PAINT -> ASSEMBLY ?쒖꽌瑜??좎??쒕떎. + for process_index, process_code in enumerate(PROCESS_SEQUENCE): + global_index = ( + production_sequence_index * len(PROCESS_SEQUENCE) + process_index + ) + event_time = _event_time_for_range_slot( + start_date=request.start_date, + end_date=request.end_date, + slot=global_index, + total_events=total_events, + ) + event_date = ( + _production_date_from_vehicle_id(car_id) or event_time.date() + ) + event_id = f"EVT-{event_date:%Y%m%d}-{global_index + 1:06d}" + event = self._build_event( + event_id=event_id, + event_time=event_time, + process_code=process_code, + global_index=global_index, + production_sequence_index=production_sequence_index, + car_id=car_id, + car_master_id=car_master_id, + is_abnormal=is_abnormal_vehicle, + equipment_map=request.equipment_map, + ) + equipment_code = event["equipment"]["equipmentCode"] + equipment_row = request.equipment_map[equipment_code] + yield { + "event_id": event_id, + "event_time": event_time, + "car_master_id": car_master_id, + "equipment_id": int(equipment_row["id"]), + "process_code": process_code, + "station_code": f"{process_code}_STATION_{int(equipment_code.rsplit('_', 1)[1]):02d}", + "equipment_code": equipment_code, + "equipment_type": event["equipment"]["equipmentType"], + "equipment_status": event["equipmentStatus"]["operationStatus"], + "event_type": event["event"]["eventType"], + "event_json": _json_safe(event), + # 理쒖큹?먮뒗 PRESS留?諛쒗뻾?????덈떎. ?꾩냽 怨듭젙?€ ?댁쟾 怨듭젙?? + # ?뺤긽 遺꾩꽍 寃곌낵瑜?諛쏆? ??Consumer媛€ READY濡??꾪솚?쒕떎. + "dispatch_status": initial_dispatch_status(process_code), + "analysis_status": "NOT_ANALYZED", + "bottleneck_analysis_done": False, + "defect_transfer_analysis_done": False, + "retry_count": 0, + "error_message": None, + } + + def _build_event( + self, + *, + event_id: str, + event_time: datetime, + process_code: str, + global_index: int, + production_sequence_index: int, + car_id: str, + car_master_id: int, + is_abnormal: bool, + equipment_map: dict[str, dict[str, Any]], + ) -> dict[str, Any]: + # ?ъ슜?먯쓽 ?붿껌???곕씪 PRESS???댁긽 鍮덈룄瑜???텛怨?PAINT, ASSEMBLY???믪씤?? + # global_index瑜??쒖슜??寃곗젙濡좎쟻(deterministic) ?쒖닔瑜??앹꽦?쒕떎. + if is_abnormal: + if process_code == "PRESS": + # PRESS???먮옒 ?댁긽??20%留??좎? + is_abnormal = (global_index % 10) < 2 + elif process_code in {"PAINT", "ASSEMBLY"}: + # PAINT, ASSEMBLY???먮옒 ?댁긽??80%瑜??좎? (鍮덈룄 ?믪엫) + is_abnormal = (global_index % 10) < 8 + + meta = PROCESS_META[process_code] + # 媛숈? 李⑤웾??怨듭젙留덈떎 ?쒕줈 ?ㅻⅨ ?ㅻ퉬瑜??ъ슜?????덈룄濡?李⑤웾 PK?€ + # 怨듭젙 肄붾뱶瑜??④퍡 ?ъ슜??1~5?멸린瑜??낅┰?곸쑝濡?諛곗젙?쒕떎. + # ?댁떆 湲곕컲?대씪 遺꾪룷???쒕뜡?섏?留??ъ깮?굿룻뀥?뚮┸ replay 寃곌낵???숈씪?섎떎. + line_station_no = _equipment_no_for_process( + car_master_id=car_master_id, + process_code=process_code, + ) + equipment_code = f"EQ_{process_code}_{line_station_no:03d}" + equipment_row = equipment_map[equipment_code] + + # 怨듦컻 ?곗씠?곗뀑???ㅼ젣 ?됱쓣 ?쎌뼱 ?먯쿇 異붿쟻 ?뺣낫?€ 湲곕낯 ?쇱꽌 ?뱀꽦??留뚮뱺?? + forming = self._forming_row(production_sequence_index) + current = self._current_features(process_code, global_index) + ford = self._ford_features(global_index) + vision = self._vision_features(global_index) + bosch = self._bosch_features(global_index) + process_metrics = self._process_metrics( + process_code=process_code, + global_index=global_index, + current=current, + ford=ford, + vision=vision, + bosch=bosch, + ) + # ?먯쿇 ?곗씠?곗쓽 ?ㅼ젣 ?대옒??鍮꾩쑉?€ ?곗씠?곗뀑留덈떎 ?ㅻⅤ誘€濡? PRD媛€ ?붽뎄?? + # 7:3 鍮꾩쑉怨?Java ?먯젙 ?꾧퀎媛믪쓣 ?덉젙?곸쑝濡?留뚯”?섎룄濡??꾨줈?꾩쓣 ?곸슜?쒕떎. + self._apply_detection_profile( + process_code=process_code, + is_abnormal=is_abnormal, + global_index=global_index, + current=current, + ford=ford, + vision=vision, + bosch=bosch, + process_metrics=process_metrics, + ) + process_data = self._process_data( + process_code=process_code, + car_master_id=car_master_id, + current=current, + ford=ford, + vision=vision, + bosch=bosch, + process_metrics=process_metrics, + ) + validate_process_data(process_code, process_data) + equipment_status = _equipment_status_for_event( + car_master_id=car_master_id, + process_code=process_code, + is_abnormal=is_abnormal, + ) + operation_status = equipment_status["operationStatus"] + is_equipment_abnormal = is_abnormal_operation_status(operation_status) + + return { + "event": { + "eventId": event_id, + # ?먯쿇 ?대깽???앹꽦 ?쒖젏?먮뒗 ?ㅼ젣 諛쒖깮 ?쒓컖???뺤젙?섏? ?딆븯?쇰?濡? + "eventTime": event_time.isoformat(), + "eventType": meta["eventType"], + "eventName": meta["eventName"], + }, + "equipment": { + "equipmentCode": equipment_code, + "equipmentName": equipment_row["equipment_name"], + "equipmentType": equipment_row["equipment_type"], + }, + "equipmentStatus": { + # Java enum EquipmentOperationStatus 媛믩쭔 ?ъ슜?쒕떎. + "operationStatus": operation_status, + "lastNormalTime": ( + (event_time - timedelta(seconds=31)).isoformat() + if is_equipment_abnormal + else None + ), + "statusChangedTime": ( + event_time.isoformat() if is_equipment_abnormal else None + ), + }, + "product": { + "carMasterId": car_master_id, + }, + "sensor": self._sensor_payload(current, ford, vision, process_code), + "processMetrics": process_metrics, + "sourceTrace": { + "fordRowId": ford["rowId"], + "formingRowId": forming["idx"], + "robotArmVibrationRowId": current["rowId"], + "machineVisionRowId": vision["rowId"], + "boschId": bosch["id"], + }, + # process_code???대떦?섎뒗 釉붾줉 ?섎굹留??ы븿?쒕떎. + # PRESS硫?press, BODY硫?body, PAINT硫?paint, ASSEMBLY硫?assembly留?議댁옱?쒕떎. + "processData": process_data, + } + + def _apply_detection_profile( + self, + *, + process_code: str, + is_abnormal: bool, + global_index: int, + current: dict[str, Any], + ford: dict[str, Any], + vision: dict[str, Any], + bosch: dict[str, Any], + process_metrics: dict[str, Any], + ) -> None: + target = float(PROCESS_META[process_code]["targetCycleTimeSec"]) + current_variation = global_index % 11 + vibration_variation = global_index % 13 + paint_variation = global_index % 10 + metric_variation = global_index % 8 + + if process_code == "PRESS": + if is_abnormal: + rms_ampere = 3.05 + current_variation * 0.16 + acceleration_g = 0.022 + current_variation * 0.0015 + vibration_score = min(0.99, 0.44 + vibration_variation * 0.015) + vibration_rms = 1.65 + vibration_variation * 0.06 + vibration_peak = 2.45 + vibration_variation * 0.08 + cycle_time = target + 4.5 + metric_variation * 0.95 + station_delay = cycle_time - target + + current.update( + rmsAmpere=round(rms_ampere, 3), + maxAmpere=round(rms_ampere + 0.38 + current_variation * 0.02, 3), + minAmpere=round(max(0.0, rms_ampere - 0.28), 3), + accelerationG=round(acceleration_g, 4), + ) + ford.update( + label=1, + vibrationScore=round(vibration_score, 4), + vibrationRms=round(vibration_rms, 3), + vibrationPeak=round(vibration_peak, 3), + ) + vision.update( + label=0, + avgTemperature=round(38.2 + paint_variation * 0.12, 3), + maxTemperature=round(40.2 + paint_variation * 0.15, 3), + minTemperature=round(36.8 + paint_variation * 0.09, 3), + thermalStdTemp=round(0.62 + paint_variation * 0.03, 3), + defectScore=round(0.05 + paint_variation * 0.006, 4), + thicknessValue=round(113.5 + paint_variation * 0.35, 3), + surfaceQualityScore=round(98.0 - paint_variation * 0.25, 3), + ) + bosch["response"] = 0 + process_metrics.update( + cycleTimeSec=round(cycle_time, 3), + waitingTimeSec=round(5.5 + metric_variation * 0.45, 3), + processingTimeSec=round(max(1.0, target - 1.5 + metric_variation * 0.25), 3), + stationDelaySec=round(station_delay, 3), + throughputPerMin=round(60 / cycle_time, 3), + queueLength=6 + metric_variation, + wipCount=18 + metric_variation * 2, + equipmentIdleTimeSec=round(7.0 + metric_variation * 0.9, 3), + ) + return + + rms_ampere = 1.68 + current_variation * 0.04 + acceleration_g = 0.004 + current_variation * 0.0006 + vibration_score = 0.14 + vibration_variation * 0.014 + vibration_rms = 0.28 + vibration_variation * 0.025 + vibration_peak = 0.48 + vibration_variation * 0.035 + cycle_time = target + metric_variation * 0.28 + station_delay = max(0.0, cycle_time - target) + + current.update( + rmsAmpere=round(rms_ampere, 3), + maxAmpere=round(rms_ampere + 0.17 + current_variation * 0.01, 3), + minAmpere=round(max(0.0, rms_ampere - 0.15), 3), + accelerationG=round(acceleration_g, 5), + ) + ford.update( + label=1, + vibrationScore=round(vibration_score, 4), + vibrationRms=round(vibration_rms, 3), + vibrationPeak=round(vibration_peak, 3), + ) + vision.update( + label=0, + avgTemperature=round(37.8 + paint_variation * 0.18, 3), + maxTemperature=round(39.8 + paint_variation * 0.2, 3), + minTemperature=round(36.5 + paint_variation * 0.12, 3), + thermalStdTemp=round(0.55 + paint_variation * 0.05, 3), + defectScore=round(0.03 + paint_variation * 0.006, 4), + thicknessValue=round(113.0 + paint_variation * 0.4, 3), + surfaceQualityScore=round(98.6 - paint_variation * 0.2, 3), + ) + bosch["response"] = 0 + process_metrics.update( + cycleTimeSec=round(cycle_time, 3), + waitingTimeSec=round(1.4 + metric_variation * 0.2, 3), + processingTimeSec=round(max(1.0, target - 2.0 + metric_variation * 0.12), 3), + stationDelaySec=round(station_delay, 3), + throughputPerMin=round(60 / cycle_time, 3), + queueLength=1 + metric_variation % 3, + wipCount=3 + metric_variation, + equipmentIdleTimeSec=round(metric_variation * 0.18, 3), + ) + return + + if process_code == "BODY": + if is_abnormal: + rms_ampere = 1.95 + current_variation * 0.03 + acceleration_g = 0.006 + current_variation * 0.0004 + vibration_score = min(0.99, 0.46 + vibration_variation * 0.012) + vibration_rms = 1.55 + vibration_variation * 0.055 + vibration_peak = 2.15 + vibration_variation * 0.075 + cycle_time = target + 6.0 + metric_variation * 0.85 + station_delay = cycle_time - target + + current.update( + rmsAmpere=round(rms_ampere, 3), + maxAmpere=round(rms_ampere + 0.16 + current_variation * 0.008, 3), + minAmpere=round(max(0.0, rms_ampere - 0.13), 3), + accelerationG=round(acceleration_g, 5), + ) + ford.update( + label=-1, + vibrationScore=round(vibration_score, 4), + vibrationRms=round(vibration_rms, 3), + vibrationPeak=round(vibration_peak, 3), + ) + vision.update( + label=0, + avgTemperature=round(38.0 + paint_variation * 0.1, 3), + maxTemperature=round(40.0 + paint_variation * 0.12, 3), + minTemperature=round(36.8 + paint_variation * 0.08, 3), + thermalStdTemp=round(0.58 + paint_variation * 0.02, 3), + defectScore=round(0.04 + paint_variation * 0.005, 4), + thicknessValue=round(113.8 + paint_variation * 0.3, 3), + surfaceQualityScore=round(98.2 - paint_variation * 0.18, 3), + ) + bosch["response"] = 0 + process_metrics.update( + cycleTimeSec=round(cycle_time, 3), + waitingTimeSec=round(7.5 + metric_variation * 0.5, 3), + processingTimeSec=round(max(1.0, target - 2.0 + metric_variation * 0.2), 3), + stationDelaySec=round(station_delay, 3), + throughputPerMin=round(60 / cycle_time, 3), + queueLength=7 + metric_variation, + wipCount=20 + metric_variation * 2, + equipmentIdleTimeSec=round(8.5 + metric_variation * 0.95, 3), + ) + return + + rms_ampere = 1.72 + current_variation * 0.035 + acceleration_g = 0.005 + current_variation * 0.00045 + vibration_score = 0.24 + vibration_variation * 0.013 + vibration_rms = 0.36 + vibration_variation * 0.03 + vibration_peak = 0.62 + vibration_variation * 0.04 + cycle_time = target + metric_variation * 0.38 + station_delay = max(0.0, cycle_time - target) + + current.update( + rmsAmpere=round(rms_ampere, 3), + maxAmpere=round(rms_ampere + 0.14 + current_variation * 0.009, 3), + minAmpere=round(max(0.0, rms_ampere - 0.13), 3), + accelerationG=round(acceleration_g, 5), + ) + ford.update( + label=1, + vibrationScore=round(vibration_score, 4), + vibrationRms=round(vibration_rms, 3), + vibrationPeak=round(vibration_peak, 3), + ) + vision.update( + label=0, + avgTemperature=round(37.9 + paint_variation * 0.14, 3), + maxTemperature=round(39.9 + paint_variation * 0.16, 3), + minTemperature=round(36.6 + paint_variation * 0.1, 3), + thermalStdTemp=round(0.56 + paint_variation * 0.04, 3), + defectScore=round(0.03 + paint_variation * 0.005, 4), + thicknessValue=round(113.2 + paint_variation * 0.32, 3), + surfaceQualityScore=round(98.4 - paint_variation * 0.16, 3), + ) + bosch["response"] = 0 + process_metrics.update( + cycleTimeSec=round(cycle_time, 3), + waitingTimeSec=round(2.1 + metric_variation * 0.22, 3), + processingTimeSec=round(max(1.0, target - 1.8 + metric_variation * 0.15), 3), + stationDelaySec=round(station_delay, 3), + throughputPerMin=round(60 / cycle_time, 3), + queueLength=2 + metric_variation % 4, + wipCount=5 + metric_variation, + equipmentIdleTimeSec=round(metric_variation * 0.22, 3), + ) + return + + if process_code == "PAINT": + paint_is_warning = is_abnormal and (global_index % 3 == 0) + low_thickness_band = (global_index % 2) == 0 + + if is_abnormal and paint_is_warning: + rms_ampere = 1.82 + current_variation * 0.045 + acceleration_g = 0.0065 + current_variation * 0.00045 + vibration_score = min(0.55, 0.42 + vibration_variation * 0.012) + vibration_rms = 0.55 + vibration_variation * 0.028 + vibration_peak = 0.82 + vibration_variation * 0.035 + thermal_std_temp = round(2.25 + paint_variation * 0.18, 3) + defect_score = round(min(0.59, 0.42 + paint_variation * 0.018), 4) + thickness_value = round( + 85.0 + paint_variation * 0.45 if low_thickness_band else 121.0 + paint_variation * 0.85, + 3, + ) + surface_quality_score = round(max(60.0, 78.0 - paint_variation * 1.05), 3) + cycle_time = target + 2.8 + metric_variation * 0.42 + station_delay = cycle_time - target + + current.update( + rmsAmpere=round(rms_ampere, 3), + maxAmpere=round(rms_ampere + 0.19 + current_variation * 0.012, 3), + minAmpere=round(max(0.0, rms_ampere - 0.14), 3), + accelerationG=round(acceleration_g, 5), + ) + ford.update( + label=1, + vibrationScore=round(vibration_score, 4), + vibrationRms=round(vibration_rms, 3), + vibrationPeak=round(vibration_peak, 3), + ) + vision.update( + label=1, + avgTemperature=round(41.5 + paint_variation * 0.42, 3), + maxTemperature=round(46.0 + paint_variation * 0.48, 3), + minTemperature=round(37.5 + paint_variation * 0.26, 3), + thermalStdTemp=thermal_std_temp, + defectScore=defect_score, + thicknessValue=thickness_value, + surfaceQualityScore=surface_quality_score, + ) + bosch["response"] = 1 + process_metrics.update( + cycleTimeSec=round(cycle_time, 3), + waitingTimeSec=round(4.2 + metric_variation * 0.32, 3), + processingTimeSec=round(max(1.0, target - 1.2 + metric_variation * 0.16), 3), + stationDelaySec=round(station_delay, 3), + throughputPerMin=round(60 / cycle_time, 3), + queueLength=4 + metric_variation, + wipCount=12 + metric_variation * 2, + equipmentIdleTimeSec=round(3.0 + metric_variation * 0.55, 3), + ) + return + + if is_abnormal: + rms_ampere = 2.08 + current_variation * 0.075 + acceleration_g = 0.012 + current_variation * 0.0008 + vibration_score = min(0.83, 0.65 + vibration_variation * 0.015) + vibration_rms = 1.1 + vibration_variation * 0.04 + vibration_peak = 1.65 + vibration_variation * 0.05 + thermal_std_temp = round(5.2 + paint_variation * 0.28, 3) + defect_score = round(min(0.99, 0.66 + paint_variation * 0.022), 4) + thickness_value = round( + 78.0 - paint_variation * 0.45 if low_thickness_band else 131.5 + paint_variation * 1.05, + 3, + ) + surface_quality_score = round(max(0.0, 58.0 - paint_variation * 1.45), 3) + cycle_time = target + 6.8 + metric_variation * 0.92 + station_delay = cycle_time - target + + current.update( + rmsAmpere=round(rms_ampere, 3), + maxAmpere=round(rms_ampere + 0.29 + current_variation * 0.018, 3), + minAmpere=round(max(0.0, rms_ampere - 0.22), 3), + accelerationG=round(acceleration_g, 5), + ) + ford.update( + label=1, + vibrationScore=round(vibration_score, 4), + vibrationRms=round(vibration_rms, 3), + vibrationPeak=round(vibration_peak, 3), + ) + vision.update( + label=1, + avgTemperature=round(49.5 + paint_variation * 0.72, 3), + maxTemperature=round(57.5 + paint_variation * 0.82, 3), + minTemperature=round(42.0 + paint_variation * 0.48, 3), + thermalStdTemp=thermal_std_temp, + defectScore=defect_score, + thicknessValue=thickness_value, + surfaceQualityScore=surface_quality_score, + ) + bosch["response"] = 1 + process_metrics.update( + cycleTimeSec=round(cycle_time, 3), + waitingTimeSec=round(10.5 + metric_variation * 0.95, 3), + processingTimeSec=round(max(1.0, target - 2.8 + metric_variation * 0.35), 3), + stationDelaySec=round(station_delay, 3), + throughputPerMin=round(60 / cycle_time, 3), + queueLength=8 + metric_variation, + wipCount=22 + metric_variation * 2, + equipmentIdleTimeSec=round(10.0 + metric_variation * 1.1, 3), + ) + return + + rms_ampere = 1.62 + current_variation * 0.028 + acceleration_g = 0.0045 + current_variation * 0.0003 + vibration_score = 0.11 + vibration_variation * 0.008 + vibration_rms = 0.24 + vibration_variation * 0.018 + vibration_peak = 0.41 + vibration_variation * 0.022 + thermal_std_temp = round(0.68 + paint_variation * 0.12, 3) + defect_score = round(min(0.39, 0.10 + paint_variation * 0.027), 4) + thickness_value = round(99.0 + paint_variation * 1.5, 3) + surface_quality_score = round(max(80.0, 92.0 - paint_variation * 1.25), 3) + cycle_time = target + 0.35 + metric_variation * 0.14 + station_delay = max(0.0, cycle_time - target) + + current.update( + rmsAmpere=round(rms_ampere, 3), + maxAmpere=round(rms_ampere + 0.13 + current_variation * 0.008, 3), + minAmpere=round(max(0.0, rms_ampere - 0.11), 3), + accelerationG=round(acceleration_g, 5), + ) + ford.update( + label=0, + vibrationScore=round(vibration_score, 4), + vibrationRms=round(vibration_rms, 3), + vibrationPeak=round(vibration_peak, 3), + ) + vision.update( + label=0, + avgTemperature=round(38.6 + paint_variation * 0.22, 3), + maxTemperature=round(40.8 + paint_variation * 0.2, 3), + minTemperature=round(36.9 + paint_variation * 0.12, 3), + thermalStdTemp=thermal_std_temp, + defectScore=defect_score, + thicknessValue=thickness_value, + surfaceQualityScore=surface_quality_score, + ) + bosch["response"] = 0 + process_metrics.update( + cycleTimeSec=round(cycle_time, 3), + waitingTimeSec=round(1.8 + metric_variation * 0.12, 3), + processingTimeSec=round(max(1.0, target - 2.2 + metric_variation * 0.1), 3), + stationDelaySec=round(station_delay, 3), + throughputPerMin=round(60 / cycle_time, 3), + queueLength=2 + metric_variation % 3, + wipCount=5 + metric_variation, + equipmentIdleTimeSec=round(metric_variation * 0.18, 3), + ) + return + + if is_abnormal: + current_variation = global_index % 11 + vibration_variation = global_index % 13 + paint_variation = global_index % 10 + metric_variation = global_index % 8 + + rms_ampere = 3.2 + current_variation * 0.12 + acceleration_g = 0.055 + current_variation * 0.003 + vibration_score = min(0.99, 0.72 + vibration_variation * 0.018) + vibration_rms = 2.35 + vibration_variation * 0.075 + vibration_peak = 3.55 + vibration_variation * 0.095 + cycle_time = target + 12.0 + metric_variation * 1.4 + station_delay = cycle_time - target + + current.update( + rmsAmpere=round(rms_ampere, 3), + maxAmpere=round(rms_ampere + 0.45 + current_variation * 0.025, 3), + minAmpere=round(max(0.0, rms_ampere - 0.35), 3), + accelerationG=round(acceleration_g, 4), + ) + ford.update( + label=-1, + vibrationScore=round(vibration_score, 4), + vibrationRms=round(vibration_rms, 3), + vibrationPeak=round(vibration_peak, 3), + ) + vision.update( + label=1, + avgTemperature=round(50.0 + paint_variation * 0.8, 3), + maxTemperature=round(58.0 + paint_variation * 0.9, 3), + minTemperature=round(42.0 + paint_variation * 0.5, 3), + thermalStdTemp=round(4.5 + paint_variation * 0.25, 3), + defectScore=round(min(0.99, 0.65 + paint_variation * 0.025), 4), + thicknessValue=round(124.0 + paint_variation * 1.3, 3), + surfaceQualityScore=round(max(0.0, 72.0 - paint_variation * 1.8), 3), + ) + bosch["response"] = 1 + process_metrics.update( + cycleTimeSec=round(cycle_time, 3), + waitingTimeSec=round(14.0 + metric_variation * 1.1, 3), + processingTimeSec=round(max(1.0, target - 4.0 + metric_variation * 0.4), 3), + stationDelaySec=round(station_delay, 3), + throughputPerMin=round(60 / cycle_time, 3), + queueLength=10 + metric_variation, + wipCount=30 + metric_variation * 2, + equipmentIdleTimeSec=round(18.0 + metric_variation * 1.7, 3), + ) + return + + current_variation = global_index % 9 + vibration_variation = global_index % 7 + paint_variation = global_index % 8 + metric_variation = global_index % 6 + + rms_ampere = 1.55 + current_variation * 0.035 + cycle_time = target + metric_variation * 0.25 + + current.update( + rmsAmpere=round(rms_ampere, 3), + maxAmpere=round(rms_ampere + 0.18 + current_variation * 0.01, 3), + minAmpere=round(max(0.0, rms_ampere - 0.16), 3), + accelerationG=round(0.004 + current_variation * 0.0007, 5), + ) + ford.update( + label=1, + vibrationScore=round(0.08 + vibration_variation * 0.015, 4), + vibrationRms=round(0.22 + vibration_variation * 0.035, 3), + vibrationPeak=round(0.42 + vibration_variation * 0.045, 3), + ) + vision.update( + label=0, + avgTemperature=round(37.8 + paint_variation * 0.25, 3), + maxTemperature=round(40.0 + paint_variation * 0.22, 3), + minTemperature=round(36.5 + paint_variation * 0.18, 3), + thermalStdTemp=round(0.55 + paint_variation * 0.06, 3), + defectScore=round(0.03 + paint_variation * 0.007, 4), + thicknessValue=round(113.0 + paint_variation * 0.45, 3), + surfaceQualityScore=round(98.5 - paint_variation * 0.3, 3), + ) + bosch["response"] = 0 + process_metrics.update( + cycleTimeSec=round(cycle_time, 3), + waitingTimeSec=round(1.5 + metric_variation * 0.25, 3), + processingTimeSec=round(max(1.0, target - 2.5 + metric_variation * 0.15), 3), + stationDelaySec=round(max(0.0, cycle_time - target), 3), + throughputPerMin=round(60 / cycle_time, 3), + queueLength=1 + metric_variation % 3, + wipCount=3 + metric_variation, + equipmentIdleTimeSec=round(metric_variation * 0.2, 3), + ) + def _forming_row(self, index: int) -> dict[str, Any]: + df = self._load_forming() + row = df.iloc[index % len(df)] + return { + "idx": _safe_int(row.get("idx"), index + 1), + "itemno": _safe_str(row.get("itemno"), "76211-A3010-100"), + "quantity": _safe_int(row.get("quantity"), 1), + "cnt": _safe_int(row.get("cnt"), 18000000 + index), + } + + def _current_features(self, process_code: str, index: int) -> dict[str, Any]: + if process_code == "BODY": + df = self._load_robot_current(index) + source_type = "ROBOT_CURRENT" + file_index = index % 2 + 1 + else: + df = self._load_press_current(index) + source_type = "PRESS_CURRENT" + file_index = index % 4 + 1 + + row_index = index % len(df) + cache_key = ("current", process_code, file_index, row_index, index % 7) + if cache_key in self._feature_cache: + return self._feature_cache[cache_key] + + row = df.iloc[row_index] + value_column = "RMS[A]" if "RMS[A]" in df.columns else "Acceleration[g]" + raw_value = _safe_float(row.get(value_column), 0.0) + if value_column == "Acceleration[g]": + rms_ampere = 1.65 + abs(raw_value) * 15 + acceleration_g = raw_value + else: + rms_ampere = raw_value if raw_value > 0.01 else 1.75 + (index % 17) * 0.04 + acceleration_g = abs(rms_ampere - 1.9) / 18 + + spread = 0.11 + (index % 7) * 0.012 + result = { + "rowId": _safe_int(row.get("Unnamed: 0"), index + 1), + "sourceType": source_type, + "rmsAmpere": round(rms_ampere, 9), + "maxAmpere": round(rms_ampere + spread, 9), + "minAmpere": round(max(0.0, rms_ampere - spread), 9), + "accelerationG": round(acceleration_g, 9), + } + self._feature_cache[cache_key] = result + return result + + def _ford_features(self, index: int) -> dict[str, Any]: + rows = self._load_ford_rows() + row_index = index % len(rows) + cache_key = ("ford", row_index) + if cache_key in self._feature_cache: + return self._feature_cache[cache_key] + + values = rows[row_index] + label = int(values[0]) + signal = [float(value) for value in values[1:501]] + abs_values = [abs(value) for value in signal] + rms = math.sqrt(sum(value * value for value in signal) / len(signal)) + peak = max(abs_values) + bands = _frequency_bands(signal) + peak_band = max(bands, key=bands.get) + result = { + "rowId": row_index + 1, + "label": label, + "vibrationRms": round(rms, 9), + "vibrationPeak": round(peak, 9), + "vibrationScore": round(min(0.99, rms / 3.2), 6), + "frequencyBands": bands, + "frequencyPeakBand": peak_band.replace("freq_", "").upper(), + } + self._feature_cache[cache_key] = result + return result + + def _vision_features(self, index: int) -> dict[str, Any]: + side = "left" if index % 2 == 0 else "right" + df, labels = self._load_vision(side) + row_index = index % len(df) + cache_key = ("vision", side, row_index, index % 17) + if cache_key in self._feature_cache: + return self._feature_cache[cache_key] + + row = pd.to_numeric(df.iloc[row_index], errors="coerce").dropna().tolist() + label = int(float(labels[row_index % len(labels)])) + avg_temp = statistics.fmean(row) + max_temp = max(row) + min_temp = min(row) + std_temp = statistics.pstdev(row) if len(row) > 1 else 0.0 + defect_score = min(0.99, (std_temp / 5.0) + (0.35 if label else 0.05)) + result = { + "rowId": row_index + 1, + "imagePosition": "LEFT" if side == "left" else "RIGHT", + "label": label, + "avgTemperature": round(avg_temp, 3), + "maxTemperature": round(max_temp, 3), + "minTemperature": round(min_temp, 3), + "thermalStdTemp": round(std_temp, 3), + "defectScore": round(defect_score, 4), + "thicknessValue": round(112.0 + (index % 17) * 0.7 + std_temp, 3), + "surfaceQualityScore": round(max(0.0, 100.0 - defect_score * 32), 3), + } + self._feature_cache[cache_key] = result + return result + + def _bosch_features(self, index: int) -> dict[str, Any]: + df = self._load_bosch_numeric() + row_index = index % len(df) + cache_key = ("bosch", row_index) + if cache_key in self._feature_cache: + return self._feature_cache[cache_key] + + row = df.iloc[row_index] + numeric_values = pd.to_numeric(row.drop(labels=["Id", "Response"], errors="ignore"), errors="coerce") + numeric_values = numeric_values.dropna().tolist() + response = _safe_int(row.get("Response"), 0) + mean_value = statistics.fmean(numeric_values) if numeric_values else 0.0 + result = { + "id": _safe_int(row.get("Id"), index + 1), + "response": response, + "meanNumericFeature": round(mean_value, 6), + "nonNullFeatureCount": len(numeric_values), + } + self._feature_cache[cache_key] = result + return result + + def _process_metrics( + self, + *, + process_code: str, + global_index: int, + current: dict[str, Any], + ford: dict[str, Any], + vision: dict[str, Any], + bosch: dict[str, Any], + ) -> dict[str, Any]: + target = float(PROCESS_META[process_code]["targetCycleTimeSec"]) + anomaly_weight = 0.0 + if process_code in {"PRESS", "BODY"}: + anomaly_weight = ford["vibrationScore"] * 12 + elif process_code == "PAINT": + anomaly_weight = vision["defectScore"] * 10 + else: + anomaly_weight = bosch["response"] * 9 + (global_index % 4) + + current_weight = min(6.0, abs(current["rmsAmpere"] - 1.9) * 1.5) + cycle_time = target + anomaly_weight + current_weight + (global_index % 5) * 0.3 + processing_time = max(1.0, cycle_time - (5.0 + global_index % 6)) + waiting_time = max(0.5, cycle_time - processing_time + (global_index % 3)) + station_delay = max(0.0, cycle_time - target) + throughput = round(60 / cycle_time, 3) + return { + "cycleTimeSec": round(cycle_time, 3), + "waitingTimeSec": round(waiting_time, 3), + "processingTimeSec": round(processing_time, 3), + "stationDelaySec": round(station_delay, 3), + "throughputPerMin": throughput, + "queueLength": int(3 + station_delay // 2 + global_index % 4), + "wipCount": int(16 + station_delay // 1.5 + global_index % 9), + "equipmentIdleTimeSec": round(max(0.0, station_delay * 1.8), 3), + } + + def _sensor_payload( + self, + current: dict[str, Any], + ford: dict[str, Any], + vision: dict[str, Any], + process_code: str, + ) -> dict[str, Any]: + return { + "sensorType": "MULTI_SENSOR", + "current": { + "rmsAmpere": current["rmsAmpere"], + "maxAmpere": current["maxAmpere"], + "minAmpere": current["minAmpere"], + }, + "vibration": { + "accelerationG": current["accelerationG"], + "vibrationScore": ford["vibrationScore"], + "vibrationRms": ford["vibrationRms"], + "vibrationPeak": ford["vibrationPeak"], + }, + "robotArmVibration": { + "robotId": "ROBOT_ARM_01", + "axis": f"J{(current['rowId'] % 6) + 1}", + "frequencyHz": round(40.0 + ford["vibrationScore"] * 220, 3), + "amplitude": round(ford["vibrationRms"] / 1000, 9), + "vibrationRms": round(ford["vibrationRms"] / 900, 9), + "vibrationPeak": round(ford["vibrationPeak"] / 700, 9), + "vibrationScore": ford["vibrationScore"], + }, + "thermal": { + "thermalScore": vision["avgTemperature"], + "avgTemperature": vision["avgTemperature"], + "maxTemperature": vision["maxTemperature"], + "minTemperature": vision["minTemperature"], + }, + } + + def _process_data( + self, + *, + process_code: str, + car_master_id: int, + current: dict[str, Any], + ford: dict[str, Any], + vision: dict[str, Any], + bosch: dict[str, Any], + process_metrics: dict[str, Any], + ) -> dict[str, Any]: + if process_code == "PRESS": + count_increase = _press_count_increase_flag( + station_delay_sec=float(process_metrics["stationDelaySec"]), + equipment_idle_time_sec=float(process_metrics["equipmentIdleTimeSec"]), + ) + return { + "press": { + "countIncreaseYn": count_increase, + "targetCycleTimeSec": PROCESS_META["PRESS"]["targetCycleTimeSec"], + "timestampDelaySec": process_metrics["stationDelaySec"], + }, + } + if process_code == "BODY": + robot_score = float(ford["vibrationScore"]) + return { + "body": { + "robotMotionStatus": _body_robot_motion_status(robot_score), + "robotOperationMode": _body_robot_operation_mode(robot_score), + "frequencyPeakBand": ford["frequencyPeakBand"], + "frequencyBands": ford["frequencyBands"], + }, + } + if process_code == "PAINT": + label = "DEFECT" if vision["label"] else "NORMAL" + return { + "paint": { + "imagePosition": vision["imagePosition"], + "thermalStdTemp": vision["thermalStdTemp"], + "thicknessValue": vision["thicknessValue"], + "defectScore": vision["defectScore"], + "visionLabel": label, + "surfaceQualityScore": vision["surfaceQualityScore"], + }, + } + + if process_code == "ASSEMBLY": + has_sequence_error = bool(bosch["response"]) + expected_sequence = _equipment_route_for_car(car_master_id) + expected_steps = expected_sequence.split(">") + # ?댁긽 ?곗씠?곕뒗 BODY?€ PAINT ?듦낵 ?쒖꽌瑜?諛붽퓭 ?쒖꽌 ?ㅻ쪟瑜??쒗쁽?쒕떎. + abnormal_steps = [ + expected_steps[0], + expected_steps[2], + expected_steps[1], + expected_steps[3], + ] + assembly_variation = car_master_id % 4 + missing_part_count = (assembly_variation % 3) if has_sequence_error else 0 + fastening_error_count = (1 + assembly_variation) if has_sequence_error else 0 + sequence_error_count = (1 + (assembly_variation % 2)) if has_sequence_error else 0 + + return { + "assembly": { + "expectedSequence": expected_sequence, + "actualSequence": ( + ">".join(abnormal_steps) + if has_sequence_error + else expected_sequence + ), + "missingPartCount": missing_part_count, + "fasteningErrorCount": fastening_error_count, + "sequenceErrorCount": sequence_error_count, + }, + } + raise ValueError(f"吏€?먰븯吏€ ?딅뒗 process_code?낅땲?? {process_code}") + + def _load_forming(self) -> pd.DataFrame: + return self._cached_csv( + "forming", + self.dataset_root / "소성가공 자원최적화 AI 데이터셋" / "공정_데이터_2022년_8월.csv", + nrows=4096, + ) + + def _load_press_current(self, index: int) -> pd.DataFrame: + file_index = index % 4 + 1 + return self._cached_csv( + f"press_current_{file_index}", + self.dataset_root + / "소성가공 자원최적화 AI 데이터셋" + / f"프레스_{file_index}호-유압모터_전류데이터.csv", + nrows=4096, + ) + + def _load_robot_current(self, index: int) -> pd.DataFrame: + file_index = index % 2 + 1 + return self._cached_csv( + f"robot_current_{file_index}", + self.dataset_root + / "소성가공 자원최적화 AI 데이터셋" + / f"로봇_{file_index}호-전류_데이터.csv", + nrows=4096, + ) + + def _load_vision(self, side: str) -> tuple[pd.DataFrame, list[float]]: + cache_key = f"vision_{side}" + if cache_key not in self._cache: + base = self.dataset_root / "머신비전 AI 데이터셋 (열화상 기반 품질 검사 데이터)" + df = pd.read_csv(base / f"2nd_process_{side}_data.csv", nrows=4096) + with (base / f"2nd_process_{side}_label.json").open( + encoding="utf-8", + ) as label_file: + labels = json.load(label_file) + self._cache[cache_key] = (df, labels) + return self._cache[cache_key] + + def _load_bosch_numeric(self) -> pd.DataFrame: + return self._cached_csv( + "bosch_numeric", + self.dataset_root / "bosch-production-line-performance" / "train_numeric.csv", + nrows=4096, + ) + + def _load_ford_rows(self) -> list[list[float]]: + if "ford_train" not in self._cache: + base = self.dataset_root / "Ford 엔진 진동 데이터셋" + path = base / "FordA_TRAIN.txt" + rows: list[list[float]] = [] + with path.open(encoding="utf-8", errors="ignore") as file: + for line in file: + line = line.replace("\x00", " ").strip() + if not line: + continue + values = [float(part) for part in line.split()] + if len(values) >= 501: + rows.append(values[:501]) + if len(rows) >= 4096: + break + if not rows: + rows = self._load_ford_arff_rows(base / "FordA_TRAIN.arff") + self._cache["ford_train"] = rows + return self._cache["ford_train"] + + def _load_ford_arff_rows(self, path: Path) -> list[list[float]]: + rows: list[list[float]] = [] + in_data = False + with path.open(encoding="utf-8", errors="ignore") as file: + for line in file: + stripped = line.strip() + if not stripped or stripped.startswith("%"): + continue + if stripped.lower() == "@data": + in_data = True + continue + if not in_data: + continue + values = [float(part) for part in stripped.split(",")] + if len(values) >= 501: + # ARFF stores class as the last value; TXT stores class first. + rows.append([values[-1], *values[:500]]) + if len(rows) >= 4096: + break + return rows + + def _cached_csv(self, cache_key: str, path: Path, *, nrows: int) -> pd.DataFrame: + if cache_key not in self._cache: + self._cache[cache_key] = pd.read_csv(path, nrows=nrows) + return self._cache[cache_key] + + +def _frequency_bands(signal: list[float]) -> dict[str, float]: + band_names = [ + "freq_0_100_hz", + "freq_101_200_hz", + "freq_201_300_hz", + "freq_301_400_hz", + "freq_401_500_hz", + "freq_501_600_hz", + "freq_601_700_hz", + "freq_701_800_hz", + "freq_801_900_hz", + "freq_901_1000_hz", + "freq_1001_1100_hz", + "freq_1101_1200_hz", + "freq_1201_1300_hz", + "freq_1301_1400_hz", + "freq_1401_1500_hz", + "freq_1501_1600_hz", + ] + chunk_size = max(1, len(signal) // len(band_names)) + bands: dict[str, float] = {} + for index, band_name in enumerate(band_names): + chunk = signal[index * chunk_size : (index + 1) * chunk_size] + if not chunk: + bands[band_name] = 0.0 + continue + rms = math.sqrt(sum(value * value for value in chunk) / len(chunk)) + bands[band_name] = round(rms / 700, 9) + return bands + + +def _event_time_for_slot( + *, + current_date: date, + slot: int, + events_per_day: int, +) -> datetime: + day_start = datetime.combine(current_date, time.min) + offset_microseconds = _weighted_event_offset_us(slot, events_per_day) + return day_start + timedelta(microseconds=offset_microseconds) + + +def _event_time_for_range_slot( + *, + start_date: date, + end_date: date, + slot: int, + total_events: int, +) -> datetime: + """?꾩껜 ?대깽?몃? ?좎쭨 踰붿쐞??洹좊벑 遺꾪븷?????쇰퀎 ?앹궛 諛€?꾨? ?곸슜?쒕떎.""" + days = (end_date - start_date).days + 1 + # ?섎㉧吏€?????좎쭨遺€????嫄댁뵫 諛곕텇???꾩껜 嫄댁닔媛€ ?뺥솗???좎??섍쾶 ?쒕떎. + base_count, remainder = divmod(total_events, days) + day_offset = 0 + day_start_slot = 0 + for candidate_day in range(days): + events_on_day = base_count + (1 if candidate_day < remainder else 0) + if slot < day_start_slot + events_on_day: + day_offset = candidate_day + local_slot = slot - day_start_slot + return _event_time_for_slot( + current_date=start_date + timedelta(days=day_offset), + slot=local_slot, + events_per_day=events_on_day, + ) + day_start_slot += events_on_day + return datetime.combine(end_date, time.max) + + +def _weighted_event_offset_us(slot: int, events_per_day: int) -> int: + """?쇰퀎 slot???쒓컙?€蹂??앹궛 諛€?꾩뿉 留욌뒗 microsecond offset?쇰줈 蹂€?섑븳??""" + windows = _weighted_event_windows(events_per_day) + remaining_slot = slot + for start_us, end_us, count in windows: + if remaining_slot >= count: + remaining_slot -= count + continue + span_us = end_us - start_us + if count <= 1: + return start_us + span_us // 2 + base_offset = int(remaining_slot * span_us / count) + interval_us = max(1, span_us // count) + jitter_us = _deterministic_jitter_us(slot, interval_us) + return min(end_us - 1, max(start_us, start_us + base_offset + jitter_us)) + return 24 * 60 * 60 * 1_000_000 - 1 + + +def _weighted_event_windows(events_per_day: int) -> list[tuple[int, int, int]]: + raw_weights = [ + ((end_hour - start_hour) * density, start_hour, end_hour) + for start_hour, end_hour, density in EVENT_DENSITY_WINDOWS + ] + total_weight = sum(weight for weight, _, _ in raw_weights) + counts = [ + max(1, int(events_per_day * weight / total_weight)) + for weight, _, _ in raw_weights + ] + while sum(counts) > events_per_day: + largest_index = max(range(len(counts)), key=counts.__getitem__) + counts[largest_index] -= 1 + while sum(counts) < events_per_day: + largest_fraction_index = _largest_fraction_window_index( + raw_weights=raw_weights, + counts=counts, + events_per_day=events_per_day, + total_weight=total_weight, + ) + counts[largest_fraction_index] += 1 + + windows: list[tuple[int, int, int]] = [] + for count, (_, start_hour, end_hour) in zip(counts, raw_weights): + windows.append( + ( + start_hour * 60 * 60 * 1_000_000, + end_hour * 60 * 60 * 1_000_000, + count, + ), + ) + return windows + + +def _largest_fraction_window_index( + *, + raw_weights: list[tuple[float, int, int]], + counts: list[int], + events_per_day: int, + total_weight: float, +) -> int: + fractions = [ + events_per_day * weight / total_weight - count + for count, (weight, _, _) in zip(counts, raw_weights) + ] + return max(range(len(fractions)), key=fractions.__getitem__) + + +def _deterministic_jitter_us(slot: int, interval_us: int) -> int: + """?ъ떎??寃곌낵??媛숆쾶 ?좎??섎㈃???대깽???쒓컖??湲곌퀎?곸씤 ?깃컙寃⑹쓣 ?꾪솕?쒕떎.""" + jitter_window = max(1, interval_us // 5) + pseudo_random = (slot * 1103515245 + 12345) & 0x7FFFFFFF + return pseudo_random % (2 * jitter_window + 1) - jitter_window + + +def _equipment_no_for_process(*, car_master_id: int, process_code: str) -> int: + """李⑤웾쨌怨듭젙 議고빀蹂꾨줈 ?낅┰?곸씤 ?ㅻ퉬 踰덊샇(1~5)瑜?寃곗젙?쒕떎. + + ?쇰컲 random 紐⑤뱢???ъ슜?섎㈃ 諛곗튂瑜??ㅼ떆 ?ㅽ뻾?????ㅻ퉬媛€ ?щ씪吏????덈떎. + ?대깽???ъ깮?깃낵 upsert媛€ ?덉젙?곸쑝濡??숈옉?섎룄濡?媛숈? ?낅젰?먮뒗 ??긽 媛숈? + 踰덊샇媛€ ?섏삤???댁떆 湲곕컲 寃곗젙???쒕뜡 諛⑹떇???ъ슜?쒕떎. + """ + digest = hashlib.blake2b( + f"{car_master_id}:{process_code}:equipment".encode("utf-8"), + digest_size=8, + ).digest() + return int.from_bytes(digest, "big") % LINE_STATION_COUNT + 1 + + +def _equipment_route_for_car(car_master_id: int) -> str: + """李⑤웾???듦낵??4媛?怨듭젙???ㅼ젣 ?ㅻ퉬 寃쎈줈瑜?臾몄옄?대줈 留뚮뱺?? + + ?? PRESS 2?? BODY 3?? PAINT 1?? ASSEMBLY 4?? + -> P02>B03>PA01>A04 + """ + return ">".join( + ( + f"{PROCESS_ROUTE_PREFIX[process_code]}" + f"{_equipment_no_for_process(car_master_id=car_master_id, process_code=process_code):02d}" + ) + for process_code in PROCESS_SEQUENCE + ) + + +def _production_date_from_vehicle_id(vehicle_id: str) -> date | None: + for token in str(vehicle_id).split("-"): + if len(token) != 8 or not token.isdigit(): + continue + try: + return date( + int(token[0:4]), + int(token[4:6]), + int(token[6:8]), + ) + except ValueError: + return None + return None + + +def _equipment_status_for_event( + *, + car_master_id: int, + process_code: str, + is_abnormal: bool, +) -> dict[str, str]: + """Java enum 湲곗? ?댁쟾 ?곹깭瑜?議곗젙?섏뿬 ?λ퉬 ?댁긽(STOPPED/FAULT)??以꾩씤??""" + _ = is_abnormal + digest = hashlib.blake2b( + f"{car_master_id}:{process_code}:status".encode("utf-8"), + digest_size=8, + ).digest() + ratio = int.from_bytes(digest, "big") % 100 + + if ratio < 85: + operation_status = "RUNNING" + elif ratio < 95: + operation_status = "WARNING" + elif ratio < 98: + operation_status = "STOPPED" + else: + operation_status = "FAULT" + + return {"operationStatus": operation_status} + + +def validate_process_data( + process_code: str, + process_data: dict[str, Any], +) -> None: + """processData媛€ 怨듭젙蹂??꾩슜 JSON 援ъ“瑜??뺥솗???곕Ⅴ?붿? 寃€利앺븳??""" + expected_key = PROCESS_DATA_KEY.get(process_code) + required_fields = PROCESS_DATA_REQUIRED_FIELDS.get(process_code) + if expected_key is None or required_fields is None: + raise ValueError(f"吏€?먰븯吏€ ?딅뒗 process_code?낅땲?? {process_code}") + + if set(process_data) != {expected_key}: + raise ValueError( + f"{process_code} processData??{expected_key} 釉붾줉留??ы븿?댁빞 ?⑸땲?? " + f"actual={sorted(process_data)}", + ) + + process_payload = process_data.get(expected_key) + if not isinstance(process_payload, dict): + raise ValueError( + f"{process_code} processData.{expected_key}??JSON object?ъ빞 ?⑸땲??", + ) + + missing_fields = required_fields - set(process_payload) + if missing_fields: + raise ValueError( + f"{process_code} processData ?꾩닔 ?꾨뱶媛€ ?꾨씫?섏뿀?듬땲?? " + f"{sorted(missing_fields)}", + ) + + +def _safe_float(value: Any, default: float = 0.0) -> float: + try: + result = float(value) + except (TypeError, ValueError): + return default + if math.isnan(result) or math.isinf(result): + return default + return result + + +def _safe_int(value: Any, default: int = 0) -> int: + try: + return int(float(value)) + except (TypeError, ValueError): + return default + + +def _safe_str(value: Any, default: str) -> str: + if value is None: + return default + text = str(value).strip() + return text if text and text.lower() != "nan" else default + + +def _json_safe(value: Any) -> Any: + if isinstance(value, dict): + return {key: _json_safe(item) for key, item in value.items()} + if isinstance(value, list): + return [_json_safe(item) for item in value] + if isinstance(value, float): + if math.isnan(value) or math.isinf(value): + return None + return value + return value + diff --git a/app/db.py b/app/db.py new file mode 100644 index 0000000..20a498b --- /dev/null +++ b/app/db.py @@ -0,0 +1,95 @@ +# app/db.py + +from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker, scoped_session +from app.core.config import settings + +main_engine = create_engine( + settings.main_database_connection_url, + # ===== connection pool ===== + pool_size=10, # 기본 유지 커넥션 + max_overflow=20, # 추가 커넥션 허용 + pool_timeout=30, # 대기 시간 + pool_recycle=3600, # 1시간마다 재생성 (MySQL 안정성) + pool_pre_ping=True # 죽은 connection 체크 + + # (옵션) 멀티스레드 안정성 + # connect_args={"check_same_thread": False} # SQLite일 때만 +) + +sample_engine = create_engine( + settings.sample_database_connection_url, + echo=False, + + # ===== connection pool ===== + pool_size=10, # 기본 유지 커넥션 + max_overflow=20, # 추가 커넥션 허용 + pool_timeout=30, # 대기 시간 + pool_recycle=3600, # 1시간마다 재생성 (MySQL 안정성) + pool_pre_ping=True # 죽은 connection 체크 + + # (옵션) 멀티스레드 안정성 + # connect_args={"check_same_thread": False} # SQLite일 때만 +) + +# ========================= +# SESSION FACTORY +# ========================= +Main_SessionLocal = sessionmaker( + autocommit=False, + autoflush=False, + bind=main_engine +) + +Sample_SessionLocal = sessionmaker( + autocommit=False, + autoflush=False, + bind=sample_engine +) +# thread-safe session (Kafka / scheduler 환경에서 중요) +main_Session = scoped_session(Main_SessionLocal) +sample_Session = scoped_session(Sample_SessionLocal) + +# ========================= +# DEPENDENCY HELPERS +# ========================= + +def get_main_session(): + """ + 권장 사용 방식: + with get_session() as session: + session.execute(...) + """ + return main_Session() + +def get_sample_session(): + """ + 권장 사용 방식: + with get_session() as session: + session.execute(...) + """ + return sample_Session() + +def main_dispose_engine(): + """ + graceful shutdown 시 사용 + connection pool 전체 종료 + """ + try: + main_Session.remove() + main_engine.dispose() + print("🗄️ DB engine disposed successfully") + except Exception as e: + print("DB dispose error:", e) + +def sample_dispose_engine(): + """ + graceful shutdown 시 사용 + connection pool 전체 종료 + """ + try: + sample_Session.remove() + sample_engine.dispose() + print("🗄️ DB engine disposed successfully") + except Exception as e: + print("DB dispose error:", e) \ No newline at end of file diff --git a/app/dto/request/__init__.py b/app/dto/request/__init__.py index cca5fbb..257550e 100644 --- a/app/dto/request/__init__.py +++ b/app/dto/request/__init__.py @@ -1,2 +1,7 @@ """Request DTO package.""" +from app.dto.request.analysis_maintenance_request import AnalysisMaintenanceRequest + +__all__ = [ + "AnalysisMaintenanceRequest", +] diff --git a/app/dto/request/analysis_maintenance_request.py b/app/dto/request/analysis_maintenance_request.py new file mode 100644 index 0000000..ab746b7 --- /dev/null +++ b/app/dto/request/analysis_maintenance_request.py @@ -0,0 +1,22 @@ +from __future__ import annotations + +from datetime import date + +from pydantic import BaseModel, ConfigDict, Field, model_validator + + +class AnalysisMaintenanceRequest(BaseModel): + model_config = ConfigDict(populate_by_name=True) + + from_date: date | None = Field(default=None, alias="fromDate") + to_date: date | None = Field(default=None, alias="toDate") + limit: int | None = Field(default=None, ge=1, le=100_000) + reindex_es: bool = Field(default=True, alias="reindexEs") + reset_flags: bool = Field(default=True, alias="resetFlags") + dry_run: bool = Field(default=False, alias="dryRun") + + @model_validator(mode="after") + def validate_date_range(self) -> "AnalysisMaintenanceRequest": + if self.from_date and self.to_date and self.from_date > self.to_date: + raise ValueError("fromDate must be less than or equal to toDate.") + return self diff --git a/app/dto/response/__init__.py b/app/dto/response/__init__.py index 0230adb..019fd92 100644 --- a/app/dto/response/__init__.py +++ b/app/dto/response/__init__.py @@ -1,16 +1,32 @@ """Response DTO package.""" +from app.dto.response.analysis_common import AnalysisDateOption from app.dto.response.bottleneck_response import ( BottleneckAnalysisItem, BottleneckAnalysisPage, ) from app.dto.response.common_response import CommonResponse +from app.dto.response.analysis_maintenance_response import ( + AnalysisMaintenanceResponse, + AnalysisMaintenanceSummary, +) +from app.dto.response.defect_transfer_response import ( + DefectTransferCauseItem, + DefectTransferCausePage, + DefectTransferPredictionItem, + DefectTransferPredictionPage, +) __all__ = [ + "AnalysisDateOption", + "AnalysisMaintenanceResponse", + "AnalysisMaintenanceSummary", "BottleneckAnalysisItem", "BottleneckAnalysisPage", "CommonResponse", + "DefectTransferCauseItem", + "DefectTransferCausePage", + "DefectTransferPredictionItem", + "DefectTransferPredictionPage", ] -__all__ = ["CommonResponse"] - diff --git a/app/dto/response/analysis_common.py b/app/dto/response/analysis_common.py new file mode 100644 index 0000000..da511d2 --- /dev/null +++ b/app/dto/response/analysis_common.py @@ -0,0 +1,12 @@ +from __future__ import annotations + +from datetime import date as DateType + +from pydantic import BaseModel, ConfigDict, Field + + +class AnalysisDateOption(BaseModel): + model_config = ConfigDict(populate_by_name=True) + + date: DateType + sample_event_id: str | None = Field(alias="sampleEventId") diff --git a/app/dto/response/analysis_maintenance_response.py b/app/dto/response/analysis_maintenance_response.py new file mode 100644 index 0000000..71679e8 --- /dev/null +++ b/app/dto/response/analysis_maintenance_response.py @@ -0,0 +1,37 @@ +from __future__ import annotations + +from datetime import date +from typing import Any + +from pydantic import BaseModel, ConfigDict, Field + + +class AnalysisMaintenanceSummary(BaseModel): + model_config = ConfigDict(populate_by_name=True) + + analysis_name: str = Field(alias="analysisName") + source_from: date | None = Field(default=None, alias="sourceFrom") + source_to: date | None = Field(default=None, alias="sourceTo") + source_count: int = Field(alias="sourceCount") + processed_count: int = Field(alias="processedCount") + saved_count: int = Field(alias="savedCount") + skipped_count: int = Field(alias="skippedCount") + failed_count: int = Field(alias="failedCount") + deleted_count: int = Field(alias="deletedCount") + es_reindexed_count: int = Field(alias="esReindexedCount") + notes: list[str] = Field(default_factory=list) + + +class AnalysisMaintenanceResponse(BaseModel): + model_config = ConfigDict(populate_by_name=True) + + mode: str + items: list[AnalysisMaintenanceSummary] + total_source_count: int = Field(alias="totalSourceCount") + total_processed_count: int = Field(alias="totalProcessedCount") + total_saved_count: int = Field(alias="totalSavedCount") + total_skipped_count: int = Field(alias="totalSkippedCount") + total_failed_count: int = Field(alias="totalFailedCount") + total_deleted_count: int = Field(alias="totalDeletedCount") + total_es_reindexed_count: int = Field(alias="totalEsReindexedCount") + extra: dict[str, Any] = Field(default_factory=dict) diff --git a/app/dto/response/bottleneck_response.py b/app/dto/response/bottleneck_response.py index 0fd7c9f..c9c4b01 100644 --- a/app/dto/response/bottleneck_response.py +++ b/app/dto/response/bottleneck_response.py @@ -1,21 +1,29 @@ +from __future__ import annotations + +from datetime import date as DateType + from pydantic import BaseModel, ConfigDict, Field +from app.dto.response.analysis_common import AnalysisDateOption class BottleneckAnalysisItem(BaseModel): model_config = ConfigDict(populate_by_name=True) rank_no: int = Field(alias="rankNo") process_code: str = Field(alias="processCode") - station_code: str = Field(alias="stationCode") - avg_delay_time: float = Field(alias="avgDelayTime") + delay_time: float = Field(alias="delayTime") affected_vehicle_count: int = Field(alias="affectedVehicleCount") - risk_score: int = Field(alias="riskScore") + risk_score: float = Field(alias="riskScore") + risk_level: str = Field(alias="riskLevel") class BottleneckAnalysisPage(BaseModel): model_config = ConfigDict(populate_by_name=True) + most_bottleneck_process: str | None = Field(alias="mostBottleneckProcess") + most_bottleneck_risk_level: str | None = Field(alias="mostBottleneckRiskLevel") + date: DateType | None = None + date_options: list[AnalysisDateOption] = Field(default_factory=list, alias="dateOptions") content: list[BottleneckAnalysisItem] has_next: bool = Field(alias="hasNext") next_cursor: int | None = Field(alias="nextCursor") - diff --git a/app/dto/response/common_response.py b/app/dto/response/common_response.py index 49de7d9..59bf739 100644 --- a/app/dto/response/common_response.py +++ b/app/dto/response/common_response.py @@ -4,10 +4,8 @@ DataT = TypeVar("DataT") - class CommonResponse(BaseModel, Generic[DataT]): success: bool = Field(description="요청 성공 여부") data: DataT | None = Field(default=None, description="응답 데이터") message: str = Field(description="응답 메시지") timestamp: str = Field(description="응답 생성 시간") - diff --git a/app/dto/response/defect_transfer_response.py b/app/dto/response/defect_transfer_response.py new file mode 100644 index 0000000..a677fc9 --- /dev/null +++ b/app/dto/response/defect_transfer_response.py @@ -0,0 +1,64 @@ +from __future__ import annotations + +from datetime import date as DateType, datetime +from typing import Any + +from pydantic import BaseModel, ConfigDict, Field + +from app.dto.response.analysis_common import AnalysisDateOption + + +class DefectTransferPredictionItem(BaseModel): + model_config = ConfigDict(populate_by_name=True) + + vehicle_id: str = Field(alias="vehicleId") + car_master_id: int = Field(alias="carMasterId") + current_process: str = Field(alias="currentProcess") + predicted_defect_process: str | None = Field(alias="predictedDefectProcess") + defect_probability: float = Field(alias="defectProbability") + expected_time: str | None = Field(alias="expectedTime") + risk_level: str = Field(alias="riskLevel") + + +class DefectTransferPredictionPage(BaseModel): + model_config = ConfigDict(populate_by_name=True) + + content: list[DefectTransferPredictionItem] + date: DateType | None = None + from_: datetime | None = Field(default=None, alias="from") + to: datetime | None = None + date_options: list[AnalysisDateOption] = Field(default_factory=list, alias="dateOptions") + has_next: bool = Field(alias="hasNext") + next_cursor: int | None = Field(alias="nextCursor") + + +class DefectTransferCauseItem(BaseModel): + model_config = ConfigDict(populate_by_name=True) + + rank: int + feature: str + label: str + value: str + impact: float + message: str + + +class DefectTransferCausePage(BaseModel): + model_config = ConfigDict(populate_by_name=True) + + vehicle_id: str | None = Field(alias="vehicleId") + car_master_id: int | None = Field(alias="carMasterId") + predicted_defect_probability: float | None = Field(alias="predictedDefectProbability") + risk_level: str | None = Field(alias="riskLevel") + current_process: str | None = Field(alias="currentProcess") + predicted_defect_process: str | None = Field(alias="predictedDefectProcess") + transfer_probability: float | None = Field(alias="transferProbability") + content: list[DefectTransferCauseItem] + representative_cause: DefectTransferCauseItem | None = Field(default=None, alias="representativeCause") + detail_causes: list[DefectTransferCauseItem] = Field(default_factory=list, alias="detailCauses") + date: DateType | None = None + from_: datetime | None = Field(default=None, alias="from") + to: datetime | None = None + date_options: list[AnalysisDateOption] = Field(default_factory=list, alias="dateOptions") + has_next: bool = Field(alias="hasNext") + next_cursor: int | None = Field(alias="nextCursor") diff --git a/app/kafka/analysis_sync_consumer.py b/app/kafka/analysis_sync_consumer.py new file mode 100644 index 0000000..ed9b5bf --- /dev/null +++ b/app/kafka/analysis_sync_consumer.py @@ -0,0 +1,120 @@ +from __future__ import annotations + +import asyncio +import logging +import time +from threading import Event +from typing import Any + +from fastapi import FastAPI + +from app.core.config import settings +from app.kafka import config as kafka_config +from app.kafka.consumer import create_consumer +from app.search.process_analysis_search import ProcessAnalysisSearchRepository + +logger = logging.getLogger(__name__) + + +def start_analysis_sync_consumer(app: FastAPI) -> None: + if not settings.elasticsearch_url: + logger.info("Elasticsearch is not configured. Analysis sync consumer is disabled.") + return + if not (settings.broker_url_1 or settings.broker_url_2): + logger.info("Kafka bootstrap servers are not set. Analysis sync consumer is disabled.") + return + + stop_event = Event() + tasks = [ + asyncio.create_task( + asyncio.to_thread( + _run_analysis_sync_consumer, + stop_event, + 1, + ), + ) + ] + app.state.analysis_sync_consumer_stop_event = stop_event + app.state.analysis_sync_consumer_tasks = tasks + + +async def stop_analysis_sync_consumer(app: FastAPI) -> None: + tasks = getattr(app.state, "analysis_sync_consumer_tasks", None) + if not tasks: + return + stop_event = getattr(app.state, "analysis_sync_consumer_stop_event", None) + if stop_event is not None: + stop_event.set() + await asyncio.gather(*tasks, return_exceptions=True) + + +def _run_analysis_sync_consumer( + stop_event: Event, + consumer_index: int, +) -> None: + search_repository = ProcessAnalysisSearchRepository() + reconnect_delay_sec = 5.0 + consumer: Any | None = None + logger.info( + "Analysis sync consumer starting: topic=%s group=%s consumer_index=%s", + kafka_config.ANALYSIS_SYNC_TOPIC, + kafka_config.ANALYSIS_SYNC_CONSUMER_GROUP_ID, + consumer_index, + ) + try: + while not stop_event.is_set(): + try: + consumer = create_consumer( + kafka_config.ANALYSIS_SYNC_TOPIC, + kafka_config.ANALYSIS_SYNC_CONSUMER_GROUP_ID, + enable_auto_commit=False, + consumer_timeout_ms=kafka_config.CONSUMER_TIMEOUT_MS, + ) + search_repository.ensure_indices() + logger.info( + "Analysis sync consumer connected: topic=%s group=%s consumer_index=%s", + kafka_config.ANALYSIS_SYNC_TOPIC, + kafka_config.ANALYSIS_SYNC_CONSUMER_GROUP_ID, + consumer_index, + ) + while not stop_event.is_set(): + for message in consumer: + if stop_event.is_set(): + break + try: + payload = message.value + if not isinstance(payload, dict): + logger.warning("Skipping non-dict analysis sync payload.") + continue + search_repository.index_sync_event(payload) + consumer.commit() + except Exception: + logger.exception( + "Failed to index analysis sync event: topic=%s partition=%s offset=%s", + message.topic, + message.partition, + message.offset, + ) + raise + except Exception: + logger.exception( + "Analysis sync consumer will retry after ES/Kafka failure: topic=%s group=%s consumer_index=%s", + kafka_config.ANALYSIS_SYNC_TOPIC, + kafka_config.ANALYSIS_SYNC_CONSUMER_GROUP_ID, + consumer_index, + ) + if stop_event.wait(reconnect_delay_sec): + break + finally: + if consumer is not None: + consumer.close() + consumer = None + finally: + if consumer is not None: + consumer.close() + logger.info( + "Analysis sync consumer stopped: topic=%s group=%s consumer_index=%s", + kafka_config.ANALYSIS_SYNC_TOPIC, + kafka_config.ANALYSIS_SYNC_CONSUMER_GROUP_ID, + consumer_index, + ) diff --git a/app/kafka/config.py b/app/kafka/config.py new file mode 100644 index 0000000..45cd722 --- /dev/null +++ b/app/kafka/config.py @@ -0,0 +1,22 @@ +# kafka/config.py +RAW_TOPIC = "factory.manufacturing.raw" +ANALYSIS_TOPIC = "factory.manufacturing.analysis" +# ES sync events reuse the existing analysis topic to avoid requiring an extra Kafka topic. +ANALYSIS_SYNC_TOPIC = ANALYSIS_TOPIC +RAW_CONSUMER_GROUP_ID = "ai-analysis-consumer-group" +ANALYSIS_SYNC_CONSUMER_GROUP_ID = "ai-analysis-sync-consumer-group" +RAW_CONSUMER_CONCURRENCY = 2 +AUTO_OFFSET_RESET = "earliest" + +ENABLE_AUTO_COMMIT = False +CONSUMER_TIMEOUT_MS = 1000 + +SESSION_TIMEOUT_MS = 30000 + +HEARTBEAT_INTERVAL_MS = 10000 + +MAX_POLL_RECORDS = 1 + +MAX_POLL_INTERVAL_MS = 900000 +PRODUCER_RETRIES = 3 +PRODUCER_LINGER_MS = 10 diff --git a/app/kafka/consumer.py b/app/kafka/consumer.py new file mode 100644 index 0000000..bb36209 --- /dev/null +++ b/app/kafka/consumer.py @@ -0,0 +1,39 @@ +import json +import ssl + +from kafka import KafkaConsumer + +from app.core.config import settings +from app.kafka.iam_provider import MSKTokenProvider + + +def _bootstrap_servers() -> list[str]: + servers = [settings.broker_url_1 or "", settings.broker_url_2 or ""] + return [server.strip() for server in servers if server.strip()] + + +def create_consumer( + topic: str, + group_id: str, + *, + enable_auto_commit: bool = True, + consumer_timeout_ms: int | None = None, +) -> KafkaConsumer: + consumer_kwargs = dict( + ssl_context=ssl.create_default_context(), + bootstrap_servers=_bootstrap_servers(), + group_id=group_id, + auto_offset_reset="earliest", + enable_auto_commit=enable_auto_commit, + security_protocol="SASL_SSL", + sasl_mechanism="OAUTHBEARER", + sasl_oauth_token_provider=MSKTokenProvider(), + value_deserializer=lambda x: json.loads(x.decode("utf-8")), + ) + if consumer_timeout_ms is not None: + consumer_kwargs["consumer_timeout_ms"] = consumer_timeout_ms + consumer = KafkaConsumer( + topic, + **consumer_kwargs, + ) + return consumer diff --git a/app/kafka/iam_provider.py b/app/kafka/iam_provider.py new file mode 100644 index 0000000..e618397 --- /dev/null +++ b/app/kafka/iam_provider.py @@ -0,0 +1,11 @@ +from kafka.sasl.oauth import AbstractTokenProvider +from aws_msk_iam_sasl_signer import MSKAuthTokenProvider + + +class MSKTokenProvider(AbstractTokenProvider): + """AWS MSK IAM 인증에 필요한 OAUTHBEARER 토큰을 kafka-python에 제공한다.""" + + def token(self): + # MSK 클러스터 리전 기준으로 짧은 수명의 IAM 인증 토큰을 매 연결 시점에 발급한다. + token, _ = MSKAuthTokenProvider.generate_auth_token("ap-northeast-2") + return token \ No newline at end of file diff --git a/app/kafka/options.py b/app/kafka/options.py new file mode 100644 index 0000000..8cd17eb --- /dev/null +++ b/app/kafka/options.py @@ -0,0 +1,21 @@ +# kafka/options.py + +DRIVE_DETAIL_GROUP = ( + "ai-drive-detail-consumer-group" +) + +STATUS_DETAIL_GROUP = ( + "ai-status-detail-consumer-group" +) + +PROCESS_GROUP = ( + "ai-process-consumer-group" +) + +RISK_HISTORY_GROUP = ( + "ai-risk-history-consumer-group" +) + +RISK_TREND_GROUP = ( + "ai-risk-trend-consumer-group" +) \ No newline at end of file diff --git a/app/kafka/producer.py b/app/kafka/producer.py new file mode 100644 index 0000000..c488fc2 --- /dev/null +++ b/app/kafka/producer.py @@ -0,0 +1,23 @@ +import json +import ssl + +from kafka import KafkaProducer + +from app.core.config import settings +from app.kafka.iam_provider import MSKTokenProvider + + +def _bootstrap_servers() -> list[str]: + servers = [settings.broker_url_1 or "", settings.broker_url_2 or ""] + return [server.strip() for server in servers if server.strip()] + + +def create_producer(): + return KafkaProducer( + ssl_context=ssl.create_default_context(), + bootstrap_servers=_bootstrap_servers(), + security_protocol="SASL_SSL", + sasl_mechanism="OAUTHBEARER", + sasl_oauth_token_provider=MSKTokenProvider(), + value_serializer=lambda x: json.dumps(x, default=str).encode("utf-8"), + ) diff --git a/app/kafka/raw_event_consumer.py b/app/kafka/raw_event_consumer.py new file mode 100644 index 0000000..6570b59 --- /dev/null +++ b/app/kafka/raw_event_consumer.py @@ -0,0 +1,1359 @@ +# -*- coding: utf-8 -*- +from __future__ import annotations +import asyncio +import json +import logging +import ssl +from datetime import datetime +from threading import Event, Lock +from typing import Any +from uuid import uuid4 +from fastapi import FastAPI +from app.core.config import settings +from app.kafka import config as kafka_config +from app.kafka.iam_provider import MSKTokenProvider +from app.ml.inference.defect_transfer_detector import ( + DefectTransferDetector, + DefectTransferPrediction, + has_only_model_probability_cause, +) +from app.repository.defect_transfer_prediction_repository import ( + DefectTransferPredictionRepository, +) +from app.repository.sampledb_schema import car_master +from app.repository.sampledb_repository import SampleDbRepository +from app.search.process_analysis_search import ProcessAnalysisSearchRepository +from app.service.analysis.bottleneck_service import BottleneckAnalysisService +from app.utils.datetime_utils import SEOUL_TZ, seoul_now, seoul_now_iso +from app.websocket.analysis_manager import analysis_websocket_manager +logger = logging.getLogger(__name__) +PROCESS_SEQUENCE = ("PRESS", "BODY", "PAINT", "ASSEMBLY") +# assembly-service의 app.kafka.topics.raw.name과 동일한 raw 토픽. +RAW_TOPIC = kafka_config.RAW_TOPIC +ANALYSIS_TOPIC = kafka_config.ANALYSIS_TOPIC +ANALYSIS_SYNC_TOPIC = kafka_config.ANALYSIS_SYNC_TOPIC +RAW_CONSUMER_GROUP_ID = kafka_config.RAW_CONSUMER_GROUP_ID +RAW_AUTO_OFFSET_RESET = kafka_config.AUTO_OFFSET_RESET +RAW_CONSUMER_CONCURRENCY = kafka_config.RAW_CONSUMER_CONCURRENCY +_bottleneck_analysis_lock = Lock() + + +def start_raw_event_consumer(app: FastAPI) -> None: + """FastAPI startup 시 raw Kafka consumer를 백그라운드 thread로 실행한다.""" + bootstrap_servers = _bootstrap_servers() + if not bootstrap_servers: + logger.info("Kafka bootstrap servers are not set. Raw Kafka consumer is disabled.") + return + if not settings.sample_database_connection_url: + logger.info("SAMPLE_DB_NAME is not set. Raw Kafka consumer is disabled.") + return + stop_event = Event() + tasks = [ + asyncio.create_task( + asyncio.to_thread( + _run_raw_event_consumer, + stop_event, + bootstrap_servers, + consumer_index, + ), + ) + for consumer_index in range(1, RAW_CONSUMER_CONCURRENCY + 1) + ] + # shutdown 시 백그라운드 thread consumer loop를 종료하기 위한 상태를 저장한다. + app.state.raw_event_consumer_stop_event = stop_event + app.state.raw_event_consumer_tasks = tasks + + +async def stop_raw_event_consumer(app: FastAPI) -> None: + """FastAPI shutdown 시 consumer loop 종료 신호를 보내고 thread 작업을 정리한다.""" + tasks = getattr(app.state, "raw_event_consumer_tasks", None) + if not tasks: + return + stop_event = getattr(app.state, "raw_event_consumer_stop_event", None) + if stop_event is not None: + stop_event.set() + await asyncio.gather(*tasks, return_exceptions=True) + + +def _run_raw_event_consumer( + stop_event: Event, + bootstrap_servers: list[str], + consumer_index: int, +) -> None: + try: + from kafka import KafkaConsumer, KafkaProducer + from kafka.errors import CommitFailedError + except ModuleNotFoundError: + logger.exception("kafka-python is required to consume manufacturing raw events.") + return + # 운영 Kafka 연결에서는 MSK IAM 인증(SASL_SSL/OAUTHBEARER)을 사용한다. + consumer = KafkaConsumer( + RAW_TOPIC, + ssl_context=ssl.create_default_context(), + bootstrap_servers=bootstrap_servers, + group_id=RAW_CONSUMER_GROUP_ID, + auto_offset_reset=RAW_AUTO_OFFSET_RESET, + enable_auto_commit=False, + max_poll_interval_ms=kafka_config.MAX_POLL_INTERVAL_MS, + session_timeout_ms=kafka_config.SESSION_TIMEOUT_MS, + heartbeat_interval_ms=kafka_config.HEARTBEAT_INTERVAL_MS, + max_poll_records=kafka_config.MAX_POLL_RECORDS, + security_protocol="SASL_SSL", + sasl_mechanism="OAUTHBEARER", + sasl_oauth_token_provider=MSKTokenProvider(), + consumer_timeout_ms=kafka_config.CONSUMER_TIMEOUT_MS, + ) + repository = SampleDbRepository(settings.sample_database_connection_url) + repository.schema.ensure_schema() + analysis_service = _create_bottleneck_analysis_service() + defect_detector = _create_defect_transfer_detector() + defect_result_repository = _create_defect_transfer_result_repository() + analysis_producer = _create_analysis_producer( + KafkaProducer, + bootstrap_servers, + ) + analysis_search_repository = _create_analysis_search_repository() + logger.info( + "Raw Kafka consumer started: topic=%s group=%s concurrency=%s/%s bootstrap=%s auth=SASL_SSL/OAUTHBEARER", + RAW_TOPIC, + RAW_CONSUMER_GROUP_ID, + consumer_index, + RAW_CONSUMER_CONCURRENCY, + bootstrap_servers, + ) + try: + while not stop_event.is_set(): + for record in consumer: + if stop_event.is_set(): + break + try: + _consume_record( + repository, + analysis_service, + defect_detector, + defect_result_repository, + analysis_producer, + analysis_search_repository, + record, + ) + except Exception: + logger.exception( + "Failed to consume raw event: topic=%s partition=%s offset=%s", + record.topic, + record.partition, + record.offset, + ) + finally: + # DB 저장/분석 실패 여부와 관계없이 offset을 커밋해 같은 메시지의 무한 재처리를 막는다. + try: + consumer.commit() + except CommitFailedError: + logger.warning( + "Offset commit skipped because the consumer group was rebalanced: " + "topic=%s partition=%s offset=%s consumer_index=%s", + record.topic, + record.partition, + record.offset, + consumer_index, + ) + except Exception: + logger.exception("Raw Kafka consumer failed.") + finally: + if analysis_producer is not None: + analysis_producer.close(timeout=5) + consumer.close() + logger.info( + "Raw Kafka consumer stopped: topic=%s group=%s concurrency=%s/%s", + RAW_TOPIC, + RAW_CONSUMER_GROUP_ID, + consumer_index, + RAW_CONSUMER_CONCURRENCY, + ) + + +def _consume_record( + repository: SampleDbRepository, + analysis_service: BottleneckAnalysisService | None, + defect_detector: DefectTransferDetector | None, + defect_result_repository: DefectTransferPredictionRepository | None, + analysis_producer: Any | None, + analysis_search_repository: ProcessAnalysisSearchRepository | None, + record: Any, +) -> None: + """Kafka raw 메시지를 manufacturing_event_json row로 변환해 sampledb에 upsert한다.""" + raw_event = _parse_raw_event(record) + row = _raw_event_to_row(raw_event) + affected_rows = repository.events.insert_raw_rows( + [row], + update_existing=True, + ) + if not _should_analyze_row(row): + logger.info( + "Kafka raw event skipped because dispatch_status/is_sent do not match analysis condition: " + "topic=%s partition=%s offset=%s key=%s event_id=%s dispatch_status=%s is_sent=%s", + record.topic, + record.partition, + record.offset, + raw_event.get("_kafka_key"), + row["event_id"], + row.get("dispatch_status"), + row.get("is_sent"), + ) + return + bottleneck_summaries: list[dict[str, Any]] = [] + defect_prediction: DefectTransferPrediction | None = None + defect_rows_saved = 0 + analysis_ran = False + if not repository.events.is_bottleneck_analysis_done(row["event_id"]): + bottleneck_summaries = _refresh_bottleneck_analysis( + analysis_service, + record, + row, + ) + if bottleneck_summaries is not None: + repository.events.mark_bottleneck_analysis_done(row["event_id"]) + analysis_ran = True + if not repository.events.is_defect_transfer_analysis_done(row["event_id"]): + if ( + defect_result_repository is not None + and defect_result_repository.has_prediction_for_event(row["event_id"]) + ): + repository.events.mark_defect_transfer_analysis_done(row["event_id"]) + else: + defect_prediction = _predict_defect_transfer(defect_detector, row) + if ( + defect_prediction is not None + and has_only_model_probability_cause(defect_prediction.causes) + ): + logger.info( + "Skipped defect transfer storage and analysis publish because only fallback model probability cause was produced: " + "topic=%s partition=%s offset=%s key=%s event_id=%s process_code=%s", + record.topic, + record.partition, + record.offset, + raw_event.get("_kafka_key"), + row["event_id"], + row["process_code"], + ) + return + defect_rows_saved = _save_defect_transfer_prediction( + defect_result_repository, + row, + defect_prediction, + ) + if defect_rows_saved > 0: + repository.events.mark_defect_transfer_analysis_done(row["event_id"]) + analysis_ran = True + if not analysis_ran: + logger.info( + "Kafka raw event skipped because it was already analyzed: " + "topic=%s partition=%s offset=%s key=%s event_id=%s", + record.topic, + record.partition, + record.offset, + raw_event.get("_kafka_key"), + row["event_id"], + ) + return + analysis_published = _publish_bottleneck_analysis_event( + analysis_producer, + raw_event, + row, + bottleneck_summaries, + defect_prediction, + ) + sync_published = _publish_process_analysis_sync_events( + analysis_producer, + analysis_search_repository, + repository, + raw_event, + row, + bottleneck_summaries, + defect_prediction, + defect_rows_saved, + ) + # raw 이벤트 연동 분석 결과가 반영되면 Redis 캐시를 비운다. + _clear_bottleneck_cache() + _clear_defect_transfer_cache() + _broadcast_process_analysis_updates( + repository, + row, + bottleneck_summaries, + defect_prediction, + defect_rows_saved, + ) + logger.info( + "Kafka raw event consumed and stored: topic=%s partition=%s offset=%s " + "key=%s event_id=%s manufacturing_event_id_source=manufacturing_event_json.id " + "car_master_id=%s process_code=%s affected_rows=%s " + "bottleneck_result_count=%s defect_result_saved=%s analysis_topic_published=%s " + "analysis_sync_published=%s", + record.topic, + record.partition, + record.offset, + raw_event.get("_kafka_key"), + row["event_id"], + row["car_master_id"], + row["process_code"], + affected_rows, + len(bottleneck_summaries), + defect_rows_saved, + analysis_published, + sync_published, + ) + + +def _broadcast_process_analysis_updates( + repository: SampleDbRepository, + row: dict[str, Any], + bottleneck_summaries: list[dict[str, Any]], + defect_prediction: DefectTransferPrediction | None, + defect_rows_saved: int, +) -> None: + vehicle_id = _vehicle_id_for_car_master_id(repository, int(row["car_master_id"])) + base_message = { + "eventId": row["event_id"], + "carMasterId": row["car_master_id"], + "vehicleId": vehicle_id, + "processCode": row["process_code"], + "updatedAt": seoul_now_iso(), + } + analysis_websocket_manager.broadcast_from_thread( + { + **base_message, + "type": "BOTTLENECK_UPDATED", + "resultCount": len(bottleneck_summaries), + }, + ) + analysis_websocket_manager.broadcast_from_thread( + { + **base_message, + "type": "DEFECT_TRANSFER_UPDATED", + "defectProbability": ( + round(defect_prediction.defect_probability, 4) + if defect_prediction is not None + else None + ), + "transferProbability": ( + round(defect_prediction.transfer_probability, 4) + if defect_prediction is not None + and defect_prediction.transfer_probability is not None + else None + ), + "riskGrade": ( + defect_prediction.risk_level + if defect_prediction is not None + else None + ), + "predictedDefectProcess": ( + _format_predicted_defect_process( + defect_prediction.predicted_process_code, + row, + ) + if defect_prediction is not None + else None + ), + "resultSaved": defect_rows_saved, + }, + ) + + +def _vehicle_id_for_car_master_id( + repository: SampleDbRepository, + car_master_id: int, +) -> str | None: + from sqlalchemy import select + try: + query = select(car_master.c.vehicle_id).where(car_master.c.id == car_master_id) + with repository.engine.connect() as conn: + value = conn.execute(query).scalar() + return str(value) if value is not None else None + except Exception: + logger.exception( + "Failed to resolve vehicle_id for websocket update: car_master_id=%s", + car_master_id, + ) + return None + + +def _parse_raw_event(record: Any) -> dict[str, Any]: + """Kafka record의 value JSON과 key(carId)를 파싱해 dict로 반환한다.""" + payload = json.loads(record.value.decode("utf-8")) + if not isinstance(payload, dict): + raise ValueError("Manufacturing raw event must be a JSON object.") + event_json = _parse_event_json(payload.get("eventJson") or payload.get("event_json")) + if event_json is None: + raise ValueError("Manufacturing raw event must include eventJson object.") + key_text = record.key.decode("utf-8") if record.key else None + payload["eventJson"] = event_json + payload["_kafka_key"] = key_text + return payload + + +def _raw_event_to_row(raw_event: dict[str, Any]) -> dict[str, Any]: + """assembly-service raw envelope를 manufacturing_event_json 저장 형식으로 변환한다.""" + event_json = raw_event["eventJson"] + process_code = _normalize_process_code( + _first_present(raw_event, "processCode", "process_code", "PROCESS_CODE"), + event_json, + ) + event_id = ( + _first_present(raw_event, "eventId", "event_id") + or _nested_text(event_json, "event", "eventId") + ) + if not event_id: + raise ValueError("Manufacturing raw event requires eventId.") + car_master_id = _nullable_int( + _first_present(raw_event, "carMasterId", "car_master_id", "carId", "car_id"), + ) + if car_master_id is None: + car_master_id = _nullable_int(_nested_value(event_json, "product", "carMasterId")) + if car_master_id is None: + # raw 토픽 key가 carId이므로 payload에 차량 ID가 없을 때 key를 최종 fallback으로 사용한다. + car_master_id = _nullable_int(raw_event.get("_kafka_key")) + if car_master_id is None: + raise ValueError(f"Manufacturing raw event requires carId key or carMasterId. event_id={event_id}") + equipment_id = _nullable_int( + _first_present(raw_event, "equipmentId", "equipment_id"), + ) or 0 + return { + "event_id": str(event_id), + "event_time": _parse_datetime( + _first_present(raw_event, "eventTime", "event_time") + or _nested_text(event_json, "event", "eventTime"), + ), + "car_master_id": car_master_id, + "process_code": process_code, + "equipment_id": equipment_id, + "event_json": event_json, + "dispatch_status": "SENT", + "is_sent": True, + } + + +def _normalize_process_code(value: Any, event_json: dict[str, Any]) -> str: + """PRESS/BODY/PAINT/ASSEMBLY 중 하나의 공정 코드로 정규화한다.""" + process_code = str(value or "").strip().upper() + if not process_code: + process_data = event_json.get("processData") + if isinstance(process_data, dict): + process_code = next(iter(process_data.keys()), "").upper() + if process_code not in PROCESS_SEQUENCE: + raise ValueError(f"Unsupported processCode for raw event: {value}") + return process_code + + +def _parse_event_json(value: Any) -> dict[str, Any] | None: + if isinstance(value, dict): + return value + if isinstance(value, str): + try: + decoded = json.loads(value) + except json.JSONDecodeError: + return None + return decoded if isinstance(decoded, dict) else None + return None + + +def _first_present(payload: dict[str, Any], *fields: str) -> Any: + for field in fields: + value = payload.get(field) + if value is not None: + return value + return None + + +def _parse_datetime(value: Any) -> datetime | None: + if value is None: + return None + text = str(value).strip() + if not text: + return None + try: + parsed = datetime.fromisoformat(text.replace("Z", "+00:00")) + if parsed.tzinfo is not None: + return parsed.astimezone(SEOUL_TZ).replace(tzinfo=None) + return parsed + except ValueError: + logger.warning("Cannot parse raw event time: %s", text) + return None + + +def _nested_value(payload: dict[str, Any], *path: str) -> Any: + current: Any = payload + for key in path: + if not isinstance(current, dict): + return None + current = current.get(key) + return current + + +def _nested_text(payload: dict[str, Any], *path: str) -> str | None: + value = _nested_value(payload, *path) + return str(value) if value is not None else None + + +def _nullable_int(value: Any) -> int | None: + if value is None or value == "": + return None + try: + return int(value) + except (TypeError, ValueError): + return None + + +def _bootstrap_servers() -> list[str]: + """환경변수 BROKER_URL_1/2에서 MSK bootstrap 서버 목록을 만든다.""" + servers = [settings.broker_url_1 or "", settings.broker_url_2 or ""] + return [server.strip() for server in servers if server.strip()] + + +def _create_bottleneck_analysis_service() -> BottleneckAnalysisService | None: + try: + return BottleneckAnalysisService() + except Exception: + logger.exception( + "Bottleneck analysis service is unavailable. " + "Raw Kafka events will still be stored.", + ) + return None + + +def _create_defect_transfer_detector() -> DefectTransferDetector | None: + try: + return DefectTransferDetector() + except Exception: + logger.exception( + "Defect transfer detector is unavailable. " + "Raw Kafka events will still be stored.", + ) + return None + + +def _create_defect_transfer_result_repository() -> DefectTransferPredictionRepository | None: + if not settings.sample_database_connection_url: + return None + try: + return DefectTransferPredictionRepository( + settings.main_database_connection_url, + event_database_url=settings.sample_database_connection_url, + ) + except Exception: + logger.exception( + "Defect transfer result repository is unavailable. " + "Raw Kafka events will still be stored.", + ) + return None + + +def _create_analysis_search_repository() -> ProcessAnalysisSearchRepository | None: + if not settings.elasticsearch_url: + return None + try: + repository = ProcessAnalysisSearchRepository() + repository.ensure_indices() + return repository + except Exception: + logger.exception( + "Analysis search repository is unavailable. " + "Raw Kafka events will still be stored.", + ) + return None + + +def _create_analysis_producer( + producer_cls: Any, + bootstrap_servers: list[str], +) -> Any | None: + try: + producer = producer_cls( + ssl_context=ssl.create_default_context(), + bootstrap_servers=bootstrap_servers, + security_protocol="SASL_SSL", + sasl_mechanism="OAUTHBEARER", + sasl_oauth_token_provider=MSKTokenProvider(), + key_serializer=lambda value: str(value).encode("utf-8"), + value_serializer=lambda value: json.dumps( + value, + ensure_ascii=False, + default=_json_default, + ).encode("utf-8"), + retries=kafka_config.PRODUCER_RETRIES, + linger_ms=kafka_config.PRODUCER_LINGER_MS, + ) + except Exception: + logger.exception( + "Kafka analysis producer is unavailable. " + "Bottleneck results will still be stored in DB.", + ) + return None + logger.info( + "Kafka analysis producer started: topic=%s bootstrap=%s auth=SASL_SSL/OAUTHBEARER", + ANALYSIS_TOPIC, + bootstrap_servers, + ) + return producer + + +def _refresh_bottleneck_analysis( + analysis_service: BottleneckAnalysisService | None, + record: Any, + row: dict[str, Any], +) -> list[dict[str, Any]]: + if analysis_service is None: + return [] + with _bottleneck_analysis_lock: + try: + summaries = analysis_service.refresh_results_from_events() + except Exception: + logger.exception( + "Failed to refresh bottleneck analysis after raw event: " + "topic=%s partition=%s offset=%s event_id=%s process_code=%s", + record.topic, + record.partition, + record.offset, + row.get("event_id"), + row.get("process_code"), + ) + return [] + logger.info( + "Bottleneck analysis refreshed after raw Kafka event: " + "topic=%s partition=%s offset=%s event_id=%s process_code=%s result_count=%s", + record.topic, + record.partition, + record.offset, + row.get("event_id"), + row.get("process_code"), + len(summaries), + ) + return summaries or [] + + +def _publish_bottleneck_analysis_event( + producer: Any | None, + raw_event: dict[str, Any], + row: dict[str, Any], + summaries: list[dict[str, Any]], + defect_prediction: DefectTransferPrediction | None, +) -> bool: + if producer is None: + return False + event = _build_bottleneck_analysis_event( + raw_event, + row, + summaries, + defect_prediction, + ) + key = str(row["car_master_id"]) + try: + result = producer.send(ANALYSIS_TOPIC, key=key, value=event).get(timeout=10) + except Exception: + logger.exception( + "Failed to publish bottleneck analysis event: topic=%s key=%s event_id=%s", + ANALYSIS_TOPIC, + key, + row.get("event_id"), + ) + return False + logger.info( + "Bottleneck analysis event published: topic=%s partition=%s offset=%s " + "key=%s event_id=%s analysis_id=%s analysis_type=%s", + result.topic, + result.partition, + result.offset, + key, + row.get("event_id"), + event["analysisId"], + event["analysisType"], + ) + return True + + +def _publish_process_analysis_sync_events( + producer: Any | None, + search_repository: ProcessAnalysisSearchRepository | None, + repository: SampleDbRepository, + raw_event: dict[str, Any], + row: dict[str, Any], + bottleneck_summaries: list[dict[str, Any]], + defect_prediction: DefectTransferPrediction | None, + defect_rows_saved: int, +) -> bool: + if producer is None: + return False + + published = False + if bottleneck_summaries: + bottleneck_event = _build_bottleneck_sync_event( + repository=repository, + raw_event=raw_event, + row=row, + summaries=bottleneck_summaries, + ) + try: + producer.send( + ANALYSIS_SYNC_TOPIC, + key=f"bottleneck:{row['event_id']}", + value=bottleneck_event, + ).get(timeout=10) + published = True + _index_bottleneck_sync_event(search_repository, bottleneck_event) + except Exception: + logger.exception( + "Failed to publish bottleneck sync event: topic=%s event_id=%s", + ANALYSIS_SYNC_TOPIC, + row.get("event_id"), + ) + + if defect_prediction is not None and defect_rows_saved > 0: + defect_event = _build_defect_transfer_sync_event( + repository=repository, + raw_event=raw_event, + row=row, + prediction=defect_prediction, + ) + try: + producer.send( + ANALYSIS_SYNC_TOPIC, + key=f"defect:{row['event_id']}", + value=defect_event, + ).get(timeout=10) + published = True + _index_defect_sync_event(search_repository, defect_event) + except Exception: + logger.exception( + "Failed to publish defect transfer sync event: topic=%s event_id=%s", + ANALYSIS_SYNC_TOPIC, + row.get("event_id"), + ) + + return published + + +def _index_bottleneck_sync_event( + search_repository: ProcessAnalysisSearchRepository | None, + bottleneck_event: dict[str, Any], +) -> None: + if search_repository is None: + return + try: + search_repository.index_sync_event(bottleneck_event) + except Exception: + logger.exception( + "Failed to index bottleneck sync event directly: event_id=%s", + bottleneck_event.get("eventId"), + ) + + +def _index_defect_sync_event( + search_repository: ProcessAnalysisSearchRepository | None, + defect_event: dict[str, Any], +) -> None: + if search_repository is None: + return + try: + search_repository.index_sync_event(defect_event) + except Exception: + logger.exception( + "Failed to index defect transfer sync event directly: event_id=%s", + defect_event.get("eventId"), + ) + + +def _build_bottleneck_sync_event( + *, + repository: SampleDbRepository, + raw_event: dict[str, Any], + row: dict[str, Any], + summaries: list[dict[str, Any]], +) -> dict[str, Any]: + sync_id = f"SNAP-{uuid4()}" + detected_at = _iso_or_none(row.get("event_time")) or seoul_now_iso() + first_summary = summaries[0] if summaries else {} + return { + "syncId": sync_id, + "analysisType": "BOTTLENECK_ANALYSIS_SYNC", + "sourceService": "AI_SERVICE", + "detectedAt": detected_at, + "analyzedAt": detected_at, + "eventId": row["event_id"], + "carMasterId": row["car_master_id"], + "mostBottleneckProcess": first_summary.get("process_code"), + "mostBottleneckRiskLevel": _risk_level(float(first_summary.get("risk_score") or 0.0)), + "items": [ + { + "manufacturingEventId": summary.get("manufacturing_event_id"), + "carMasterId": summary.get("car_master_id") or row["car_master_id"], + "processCode": summary.get("process_code"), + "equipmentCode": summary.get("equipment_code"), + "rankNo": summary.get("rank_no"), + "avgDelayTime": summary.get("avg_delay_time"), + "affectedVehicleCount": summary.get("affected_vehicle_count"), + "riskScore": summary.get("risk_score"), + "riskLevel": _risk_level(float(summary.get("risk_score") or 0.0)), + } + for summary in summaries + ], + "rawEvent": { + "eventId": row["event_id"], + "carMasterId": row["car_master_id"], + "processCode": row["process_code"], + "equipmentId": row.get("equipment_id"), + "vehicleId": _vehicle_id_for_car_master_id(repository, int(row["car_master_id"])), + }, + } + + +def _build_defect_transfer_sync_event( + *, + repository: SampleDbRepository, + raw_event: dict[str, Any], + row: dict[str, Any], + prediction: DefectTransferPrediction, +) -> dict[str, Any]: + sync_id = f"SYNC-{uuid4()}" + predicted_at = _iso_or_none(row.get("event_time")) or seoul_now_iso() + vehicle_id = _vehicle_id_for_car_master_id(repository, int(row["car_master_id"])) + source_equipment_code = _source_equipment_code(row) + current_process = _format_current_process(row, source_equipment_code) + predicted_process = _format_predicted_defect_process( + prediction.predicted_process_code, + row, + ) + target_equipment_code = _target_equipment_code(prediction.predicted_process_code, row) + causes = [ + { + "rank": cause.rank, + "feature": cause.feature, + "label": cause.label, + "value": cause.value, + "impact": cause.impact, + "message": cause.message, + } + for cause in prediction.causes + ] + return { + "syncId": sync_id, + "analysisType": "DEFECT_TRANSFER_ANALYSIS_SYNC", + "sourceService": "AI_SERVICE", + "eventId": row["event_id"], + "carMasterId": row["car_master_id"], + "vehicleId": vehicle_id, + "currentProcessCode": prediction.current_process_code, + "currentProcess": current_process, + "sourceEquipmentCode": source_equipment_code, + "targetEquipmentCode": target_equipment_code, + "predictedDefectProcess": predicted_process, + "defectProbability": round(prediction.defect_probability, 4), + "currentDefectProbability": prediction.defect_probability, + "transferProbability": prediction.transfer_probability, + "defectThreshold": prediction.defect_threshold, + "transferThreshold": prediction.transfer_threshold, + "expectedStepsAfter": prediction.expected_steps_after, + "expectedTime": ( + f"{prediction.expected_steps_after}단계 후" + if prediction.expected_steps_after is not None + else None + ), + "riskLevel": prediction.risk_level, + "predictedAt": predicted_at, + "createdAt": predicted_at, + "mainCauses": causes, + "causes": causes, + "featureValues": prediction.feature_values, + "rawEvent": { + "eventId": row["event_id"], + "carMasterId": row["car_master_id"], + "processCode": row["process_code"], + "equipmentId": row.get("equipment_id"), + "vehicleId": vehicle_id, + }, + } + + +def _build_bottleneck_analysis_event( + raw_event: dict[str, Any], + row: dict[str, Any], + summaries: list[dict[str, Any]], + defect_prediction: DefectTransferPrediction | None = None, +) -> dict[str, Any]: + event_json = row["event_json"] + equipment = event_json.get("equipment", {}) + product = event_json.get("product", {}) + metrics = event_json.get("processMetrics", {}) + equipment_status = event_json.get("equipmentStatus", {}) + equipment_code = str( + equipment.get("equipmentCode") + or row.get("equipment_id") + or "UNKNOWN", + ) + process_code = str(row["process_code"]) + summary = _matching_bottleneck_summary( + summaries, + process_code=process_code, + equipment_code=equipment_code, + ) + raw_delay_time = _safe_float( + metrics.get("stationDelaySec"), + default=_safe_float(metrics.get("waitingTimeSec"), default=0.0), + ) + bottleneck_delay_time = _safe_float( + summary.get("avg_delay_time") if summary else None, + default=raw_delay_time, + ) + risk_score = _safe_float( + summary.get("risk_score") if summary else None, + default=0.0, + ) + overall_risk_score = _risk_score_to_percent(risk_score) + risk_level = _risk_level(overall_risk_score) + is_bottleneck = summary is not None and risk_score >= 3 + if defect_prediction is None: + defect_probability = _defect_probability(event_json, process_code) + transfer_predicted_process = _transfer_predicted_process( + process_code, + defect_probability, + ) + transfer_probability = None + defect_causes: list[dict[str, Any]] = [] + is_quality_defect = defect_probability >= 0.6 + else: + defect_probability = defect_prediction.defect_probability + transfer_predicted_process = defect_prediction.predicted_process_code + transfer_probability = defect_prediction.transfer_probability + defect_causes = [ + { + "rank": cause.rank, + "feature": cause.feature, + "label": cause.label, + "value": cause.value, + "impact": cause.impact, + "message": cause.message, + } + for cause in defect_prediction.causes + ] + is_quality_defect = defect_prediction.is_quality_defect + is_equipment_fault = str( + equipment_status.get("operationStatus") or "", + ).upper() in {"FAULT", "STOPPED", "ERROR", "DOWN"} + is_sequence_error = ( + process_code == "ASSEMBLY" + and _safe_float( + _nested_value(event_json, "processData", "assembly", "sequenceErrorCount"), + default=0.0, + ) + > 0 + ) + return { + "analysisId": f"ANL-{uuid4()}", + "eventId": row["event_id"], + "eventTime": _iso_or_none(row.get("event_time")) + or _nested_text(event_json, "event", "eventTime"), + "analyzedAt": seoul_now_iso(), + "factoryCode": _nested_text(event_json, "location", "factoryCode"), + "lineCode": _nested_text(event_json, "location", "lineCode"), + "processCode": process_code, + "equipmentId": row.get("equipment_id"), + "equipmentCode": equipment_code, + "equipmentName": equipment.get("equipmentName"), + "equipmentType": equipment.get("equipmentType"), + "productId": product.get("productId"), + "carId": raw_event.get("_kafka_key") or product.get("carId") or row["car_master_id"], + "carMasterId": row["car_master_id"], + "analysisType": "BOTTLENECK_ANALYSIS", + "sourceService": "AI_SERVICE", + "riskScore": risk_score, + "riskScoreScale": "1-5", + "riskScores": { + "overallRiskScore": overall_risk_score, + "bottleneckRiskScore": overall_risk_score, + "defectTransferRiskScore": round(defect_probability * 100.0, 1), + "equipmentRiskScore": None, + "processRisk": { + "pressRiskScore": overall_risk_score if process_code == "PRESS" else None, + "bodyRiskScore": overall_risk_score if process_code == "BODY" else None, + "paintRiskScore": overall_risk_score if process_code == "PAINT" else None, + "assemblyRiskScore": ( + overall_risk_score if process_code == "ASSEMBLY" else None + ), + }, + }, + "operationRate": _operation_rate(metrics), + "riskLevel": risk_level, + "analysisResult": { + "isAbnormal": ( + is_bottleneck + or is_quality_defect + or is_equipment_fault + or is_sequence_error + ), + "isBottleneck": is_bottleneck, + "isQualityDefect": is_quality_defect, + "isEquipmentFault": is_equipment_fault, + "isSequenceError": is_sequence_error, + }, + "reason": { + "mainReason": _bottleneck_reason( + risk_score=risk_score, + delay_time=bottleneck_delay_time, + is_equipment_fault=is_equipment_fault, + is_sequence_error=is_sequence_error, + ), + "detailReasons": [ + f"processCode={process_code}", + f"equipmentCode={equipment_code}", + f"bottleneckDelayTime={round(bottleneck_delay_time, 3)}", + f"riskScore={risk_score}", + ], + }, + "recommendation": { + "type": _recommendation_type(process_code), + "message": _recommendation_message(process_code), + }, + "manufacturingAnalysisData": { + "originalEventId": row["event_id"], + "carMasterId": row["car_master_id"], + "equipmentId": row.get("equipment_id"), + "processCode": process_code, + "analysisData": { + "cycleTimeSec": metrics.get("cycleTimeSec"), + "waitingTimeSec": metrics.get("waitingTimeSec"), + "processingTimeSec": metrics.get("processingTimeSec"), + "stationDelaySec": metrics.get("stationDelaySec"), + "queueLength": metrics.get("queueLength"), + "wipCount": metrics.get("wipCount"), + }, + "riskScore": risk_score, + }, + "aiAnalysisData": { + "originalEventId": row["event_id"], + "carMasterId": row["car_master_id"], + "equipmentId": row.get("equipment_id"), + "processCode": process_code, + "bottleneckDelayTime": bottleneck_delay_time, + "defectProbability": defect_probability, + "transferProbability": transfer_probability, + "transferPredictedProcess": transfer_predicted_process, + "defectCauses": defect_causes, + "riskScore": risk_score, + }, + } + + +def _predict_defect_transfer( + detector: DefectTransferDetector | None, + row: dict[str, Any], +) -> DefectTransferPrediction | None: + if detector is None: + return None + try: + return detector.predict_event(row["event_json"], str(row["process_code"])) + except Exception: + logger.exception( + "Failed to run defect transfer prediction: event_id=%s process_code=%s", + row.get("event_id"), + row.get("process_code"), + ) + return None + + +def _save_defect_transfer_prediction( + repository: DefectTransferPredictionRepository | None, + row: dict[str, Any], + prediction: DefectTransferPrediction | None, +) -> int: + if repository is None: + logger.warning( + "Defect transfer prediction was not saved because result repository is unavailable: " + "event_id=%s process_code=%s", + row.get("event_id"), + row.get("process_code"), + ) + return 0 + if prediction is None: + logger.warning( + "Defect transfer prediction was not saved because prediction is unavailable: " + "event_id=%s process_code=%s", + row.get("event_id"), + row.get("process_code"), + ) + return 0 + try: + causes = [ + { + "message": cause.message, + "label": cause.label, + "impact": cause.impact, + } + for cause in prediction.causes + ] + return repository.replace_prediction_result( + event_id=str(row["event_id"]), + car_master_id=int(row["car_master_id"]), + source_process_code=prediction.current_process_code, + target_process_code=prediction.predicted_process_code, + current_defect_probability=prediction.defect_probability, + target_defect_probability=prediction.transfer_probability, + predicted_defect_process=_format_predicted_defect_process( + prediction.predicted_process_code, + row, + ), + expected_occurrence_step=prediction.expected_steps_after, + risk_grade=prediction.risk_level, + causes=causes, + predicted_at=seoul_now().replace(tzinfo=None), + ) + except Exception: + logger.exception( + "Failed to save defect transfer prediction result: event_id=%s process_code=%s", + row.get("event_id"), + row.get("process_code"), + ) + return 0 + + +def _format_predicted_defect_process( + process_code: str | None, + row: dict[str, Any], +) -> str | None: + if process_code is None: + return None + from app.utils.process_label_utils import ( + equipment_code_for_car_process, + format_process_with_line, + ) + source_code = str(row.get("process_code") or "").strip().upper() + normalized = str(process_code).strip().upper() + if normalized == source_code: + equipment_code = _source_equipment_code(row) + else: + equipment_code = equipment_code_for_car_process( + car_master_id=int(row["car_master_id"]), + process_code=normalized, + ) + return format_process_with_line(normalized, equipment_code) + + +def _target_equipment_code( + process_code: str | None, + row: dict[str, Any], +) -> str | None: + if process_code is None: + return None + from app.utils.process_label_utils import equipment_code_for_car_process + + normalized = str(process_code).strip().upper() + source_code = str(row.get("process_code") or "").strip().upper() + if normalized == source_code: + return _source_equipment_code(row) + return equipment_code_for_car_process( + car_master_id=int(row["car_master_id"]), + process_code=normalized, + ) + + +def _format_current_process( + row: dict[str, Any], + equipment_code: str | None, +) -> str: + from app.utils.process_label_utils import format_process_with_line + + return format_process_with_line(row.get("process_code"), equipment_code) + + +def _should_analyze_row(row: dict[str, Any]) -> bool: + return str(row.get("dispatch_status") or "").upper() == "SENT" and _analysis_flag_is_true( + row.get("is_sent"), + ) + + +def _analysis_flag_is_true(value: Any) -> bool: + if isinstance(value, bool): + return value + if value is None: + return False + return str(value).strip().lower() == "true" + + +def _source_equipment_code(row: dict[str, Any]) -> str | None: + event_json = row.get("event_json") or {} + equipment = event_json.get("equipment", {}) if isinstance(event_json, dict) else {} + equipment_code = str(equipment.get("equipmentCode") or row.get("equipment_id") or "") + return equipment_code or None + + +def _matching_bottleneck_summary( + summaries: list[dict[str, Any]], + *, + process_code: str, + equipment_code: str, +) -> dict[str, Any] | None: + for summary in summaries or []: + if ( + str(summary.get("process_code")) == process_code + and str(summary.get("equipment_code")) == equipment_code + ): + return summary + return None + + +def _risk_score_to_percent(risk_score: float) -> float: + return round(max(0.0, min(risk_score, 5.0)) * 20.0, 1) + + +def _risk_level(score: float) -> str: + if score >= 80: + return "CRITICAL" + if score >= 60: + return "WARNING" + return "LOW" + + +def _operation_rate(metrics: dict[str, Any]) -> float: + cycle_time = _safe_float(metrics.get("cycleTimeSec"), default=0.0) + processing_time = _safe_float(metrics.get("processingTimeSec"), default=0.0) + idle_time = _safe_float(metrics.get("equipmentIdleTimeSec"), default=0.0) + planned_time = cycle_time if cycle_time > 0 else processing_time + idle_time + if planned_time <= 0: + return 0.0 + return round(max(0.0, min(processing_time / planned_time * 100.0, 100.0)), 1) + + +def _defect_probability(event_json: dict[str, Any], process_code: str) -> float: + process_data = event_json.get("processData", {}) + sensor = event_json.get("sensor", {}) + vibration = sensor.get("vibration", {}) + robot = sensor.get("robotArmVibration", {}) + thermal = sensor.get("thermal", {}) + if process_code == "PAINT": + paint = process_data.get("paint", {}) + defect_score = _safe_float(paint.get("defectScore"), default=0.0) + if str(paint.get("visionLabel") or "").upper() == "DEFECT": + defect_score = max(defect_score, 0.75) + surface_quality = _safe_float( + paint.get("surfaceQualityScore"), + default=100.0, + ) + return round(max(defect_score, max(0.0, 100.0 - surface_quality) / 100.0), 4) + if process_code == "ASSEMBLY": + assembly = process_data.get("assembly", {}) + error_count = ( + _safe_float(assembly.get("sequenceErrorCount"), default=0.0) + + _safe_float(assembly.get("missingPartCount"), default=0.0) + + _safe_float(assembly.get("fasteningErrorCount"), default=0.0) + ) + if error_count == 0: + return 0.0 + # 오류 건수에 따라 불량 확률을 현실적으로 조정한다. + # 오류 1건당 약 8%를 추가하고, 기본 50% 위험도를 부여해 최대 98% 내외로 산출한다. + return round(min(error_count * 0.08 + 0.50, 0.98), 4) + vibration_score = max( + _safe_float(vibration.get("vibrationScore"), default=0.0), + _safe_float(robot.get("vibrationScore"), default=0.0), + ) + thermal_score = max( + _safe_float(thermal.get("thermalScore"), default=0.0) / 100.0, + _safe_float(thermal.get("maxTemperature"), default=0.0) / 100.0, + ) + return round(min(max(vibration_score, thermal_score), 1.0), 4) + + +def _transfer_predicted_process( + process_code: str, + defect_probability: float, +) -> str | None: + if defect_probability < 0.5: + return None + return { + "PRESS": "BODY", + "BODY": "PAINT", + "PAINT": "ASSEMBLY", + "ASSEMBLY": None, + }.get(process_code) + + +def _bottleneck_reason( + *, + risk_score: float, + delay_time: float, + is_equipment_fault: bool, + is_sequence_error: bool, +) -> str: + if is_equipment_fault: + return "설비 상태값에서 고장 또는 정지 위험이 감지되었습니다." + if is_sequence_error: + return "의장 공정에서 작업 순서 오류가 감지되었습니다." + if risk_score >= 3: + return "Rule Engine과 Isolation Forest 기준으로 병목 위험이 감지되었습니다." + if delay_time > 0: + return "공정 지연 시간이 감지되었지만 위험도는 낮습니다." + return "주요 병목 지표가 정상 범위입니다." + + +def _recommendation_type(process_code: str) -> str: + return { + "PRESS": "CHECK_PRESS_EQUIPMENT_AND_QUEUE", + "BODY": "CHECK_ROBOT_VIBRATION", + "PAINT": "CHECK_PAINT_QUALITY", + "ASSEMBLY": "CHECK_ASSEMBLY_SEQUENCE", + }.get(process_code, "CHECK_PROCESS") + + +def _recommendation_message(process_code: str) -> str: + return { + "PRESS": "프레스 설비 상태, 전류 RMS 값과 대기열을 확인하세요.", + "BODY": "로봇 암 진동과 충돌 위험을 확인하세요.", + "PAINT": "열화상, 도막 두께와 비전 불량 결과를 확인하세요.", + "ASSEMBLY": "작업 순서, 누락 부품과 체결 오류를 확인하세요.", + }.get(process_code, "공정 지표와 설비 상태를 확인하세요.") + + +def _safe_float(value: Any, *, default: float) -> float: + if value is None or value == "": + return default + try: + return float(value) + except (TypeError, ValueError): + return default + + +def _iso_or_none(value: Any) -> str | None: + if isinstance(value, datetime): + if value.tzinfo is None: + return value.replace(tzinfo=SEOUL_TZ).isoformat() + return value.astimezone(SEOUL_TZ).isoformat() + return str(value) if value is not None else None + + +def _json_default(value: Any) -> str: + if isinstance(value, datetime): + return value.isoformat() + return str(value) + + +def _clear_bottleneck_cache() -> None: + if not settings.redis_url: + return + try: + from redis import Redis + redis_client = Redis.from_url(settings.redis_connection_url, decode_responses=True) + pattern = f"{settings.redis_key_prefix}:process:bottleneck:*" + keys = list(redis_client.scan_iter(match=pattern)) + if keys: + redis_client.delete(*keys) + except Exception: + logger.exception("Failed to clear bottleneck cache after raw event consumption.") + + +def _clear_defect_transfer_cache() -> None: + if not settings.redis_url: + return + try: + from redis import Redis + redis_client = Redis.from_url(settings.redis_connection_url, decode_responses=True) + pattern = f"{settings.redis_key_prefix}:process:defect-transfer:*" + keys = list(redis_client.scan_iter(match=pattern)) + if keys: + redis_client.delete(*keys) + except Exception: + logger.exception("Failed to clear defect transfer cache after raw event consumption.") diff --git a/app/kafka/topics.py b/app/kafka/topics.py new file mode 100644 index 0000000..1660260 --- /dev/null +++ b/app/kafka/topics.py @@ -0,0 +1,21 @@ +# app/kafka/topics.py + +QUALITY_INSPECTION_DRIVE_DETAIL = ( + "quality.inspection.drive_detail" +) + +QUALITY_INSPECTION_STATUS_DETAIL = ( + "quality.inspection.status_detail" +) + +QUALITY_INSPECTION_PROCESS = ( + "quality.inspection.process" +) + +QUALITY_INSPECTION_RISK_HISTORY = ( + "quality.inspection.risk_history" +) + +QUALITY_INSPECTION_RISK_TREND = ( + "quality.inspection.risk_trend" +) \ No newline at end of file diff --git a/app/launcher.py b/app/launcher.py new file mode 100644 index 0000000..23eeb92 --- /dev/null +++ b/app/launcher.py @@ -0,0 +1,30 @@ +import multiprocessing +import uvicorn + +from app.worker_main import run_worker +from app.main import app + + +def run_api(): + uvicorn.run( + app, + host="0.0.0.0", + port=8000 + ) + + +if __name__ == "__main__": + + worker = multiprocessing.Process( + target=run_worker + ) + + api = multiprocessing.Process( + target=run_api + ) + + worker.start() + api.start() + + worker.join() + api.join() \ No newline at end of file diff --git a/app/main.py b/app/main.py index 1ce63f7..6575513 100644 --- a/app/main.py +++ b/app/main.py @@ -6,34 +6,89 @@ from app.core.config import settings from app.core.exceptions import register_exception_handlers from app.core.logging import configure_logging +from fastapi.middleware.cors import CORSMiddleware +from app.kafka.raw_event_consumer import ( + start_raw_event_consumer, + stop_raw_event_consumer, +) +from app.kafka.analysis_sync_consumer import ( + start_analysis_sync_consumer, + stop_analysis_sync_consumer, +) from app.repository.sampledb_repository import initialize_sampledb - +from app.scheduler.manufacturing import ( + start_manufacturing_event_scheduler, + stop_manufacturing_event_scheduler, +) +from app.service.manufacturing import ( + resume_incomplete_generation_jobs, +) logger = logging.getLogger(__name__) +OPENAPI_TAGS = [ + { + "name": "제조 관제 이벤트", + "description": ( + "CSV 원천 데이터를 전처리/정제해 제조 관제 이벤트 JSON을 생성하고, " + "템플릿 replay 또는 실물 테이블 적재 방식으로 조회하는 API입니다." + ), + }, +] + def create_app() -> FastAPI: configure_logging() app = FastAPI( title=settings.app_name, + description=( + "AIMS AI Service API 문서입니다.\n\n" + "제조 관제 이벤트 API는 프레스, 차체, 도장, 의장 공정 데이터를 기반으로 " + "원천 이벤트 JSON을 생성하고 조회합니다." + ), version=settings.app_version, debug=settings.debug, + openapi_tags=OPENAPI_TAGS, ) app.include_router(api_router) register_exception_handlers(app) + app.add_middleware( + CORSMiddleware, + allow_origins=["http://localhost:5173"], # 프론트 주소 + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], + ) @app.on_event("startup") def initialize_sampledb_schema() -> None: - """SAMPLE_DATABASE_URL이 설정된 경우 sampledb 엔티티를 생성한""" + """MAIN_DATABASE_URL + SAMPLE_DB_NAME이 설정된 경우 sampledb 엔티티를 생성한다.""" if not settings.sample_database_connection_url: return try: initialize_sampledb(settings.sample_database_connection_url) except Exception: - logger.exception("sampledb 스키마 초기화에 실패했습니다.") + logger.exception("sampledb 스키마 초기화에 실패했습니다.") + + @app.on_event("startup") + async def start_background_schedulers() -> None: + if settings.sample_database_connection_url: + try: + resume_incomplete_generation_jobs(settings.sample_database_connection_url) + except Exception: + logger.exception("미완료 제조 이벤트 생성 job 복구에 실패했습니다.") + start_manufacturing_event_scheduler(app) + start_raw_event_consumer(app) + start_analysis_sync_consumer(app) + + @app.on_event("shutdown") + async def stop_background_schedulers() -> None: + await stop_analysis_sync_consumer(app) + await stop_raw_event_consumer(app) + await stop_manufacturing_event_scheduler(app) return app diff --git a/app/ml/artifacts/bottleneck_iforest_model.pkl b/app/ml/artifacts/bottleneck/bottleneck_iforest_model.pkl similarity index 100% rename from app/ml/artifacts/bottleneck_iforest_model.pkl rename to app/ml/artifacts/bottleneck/bottleneck_iforest_model.pkl diff --git a/app/ml/artifacts/defect/adjacent_transfer_model_metadata.json b/app/ml/artifacts/defect/adjacent_transfer_model_metadata.json new file mode 100644 index 0000000..5509d51 --- /dev/null +++ b/app/ml/artifacts/defect/adjacent_transfer_model_metadata.json @@ -0,0 +1,74 @@ +{ + "press_to_body": { + "source_process_code": "PRESS", + "target_process_code": "BODY", + "threshold": 0.4376819769807411, + "feature_columns": [ + "source_cycle_time_sec", + "source_station_delay_sec", + "source_queue_length", + "source_wip_count", + "source_current_rms_ampere", + "source_vibration_score", + "source_thermal_score" + ], + "scale_pos_weight": 3.639922667955534, + "best_params": { + "model__subsample": 0.95, + "model__reg_lambda": 8.0, + "model__num_leaves": 23, + "model__n_estimators": 220, + "model__min_child_samples": 60, + "model__learning_rate": 0.035, + "model__colsample_bytree": 0.8 + } + }, + "body_to_paint": { + "source_process_code": "BODY", + "target_process_code": "PAINT", + "threshold": 0.44474415478457285, + "feature_columns": [ + "source_cycle_time_sec", + "source_station_delay_sec", + "source_queue_length", + "source_wip_count", + "source_current_rms_ampere", + "source_vibration_score", + "source_thermal_score" + ], + "scale_pos_weight": 3.5411542100283824, + "best_params": { + "model__subsample": 0.95, + "model__reg_lambda": 8.0, + "model__num_leaves": 23, + "model__n_estimators": 220, + "model__min_child_samples": 60, + "model__learning_rate": 0.035, + "model__colsample_bytree": 0.8 + } + }, + "paint_to_assembly": { + "source_process_code": "PAINT", + "target_process_code": "ASSEMBLY", + "threshold": 0.46001877207080666, + "feature_columns": [ + "source_cycle_time_sec", + "source_station_delay_sec", + "source_queue_length", + "source_wip_count", + "source_current_rms_ampere", + "source_vibration_score", + "source_thermal_score" + ], + "scale_pos_weight": 3.841149773071104, + "best_params": { + "model__subsample": 0.95, + "model__reg_lambda": 8.0, + "model__num_leaves": 23, + "model__n_estimators": 220, + "model__min_child_samples": 60, + "model__learning_rate": 0.035, + "model__colsample_bytree": 0.8 + } + } +} \ No newline at end of file diff --git a/app/ml/artifacts/defect/adjacent_transfer_models.joblib b/app/ml/artifacts/defect/adjacent_transfer_models.joblib new file mode 100644 index 0000000..1678d38 Binary files /dev/null and b/app/ml/artifacts/defect/adjacent_transfer_models.joblib differ diff --git a/app/ml/artifacts/defect/defect_model_features.json b/app/ml/artifacts/defect/defect_model_features.json new file mode 100644 index 0000000..16bf5f5 --- /dev/null +++ b/app/ml/artifacts/defect/defect_model_features.json @@ -0,0 +1,37 @@ +[ + "process_code", + "station_code", + "equipment_code", + "equipment_type", + "current_rms_ampere", + "current_max_ampere", + "current_min_ampere", + "vibration_acceleration_g", + "vibration_score", + "vibration_rms", + "vibration_peak", + "robot_axis", + "robot_frequency_hz", + "robot_amplitude", + "robot_vibration_score", + "thermal_score", + "avg_temperature", + "max_temperature", + "min_temperature", + "cycle_time_sec", + "waiting_time_sec", + "processing_time_sec", + "station_delay_sec", + "throughput_per_min", + "queue_length", + "wip_count", + "equipment_idle_time_sec", + "press_target_cycle_time_sec", + "body_robot_operation_mode", + "body_frequency_peak_band", + "body_frequency_band_max", + "body_frequency_band_mean", + "paint_image_position", + "paint_thermal_std_temp", + "paint_thickness_value" +] \ No newline at end of file diff --git a/app/ml/artifacts/defect/defect_model_metrics.json b/app/ml/artifacts/defect/defect_model_metrics.json new file mode 100644 index 0000000..f453933 --- /dev/null +++ b/app/ml/artifacts/defect/defect_model_metrics.json @@ -0,0 +1,36 @@ +{ + "selected_model_name": "LightGBM", + "threshold": 0.5025206934115897, + "train_metrics": { + "threshold": 0.5025206934115897, + "pr_auc": 0.9741047418313843, + "roc_auc": 0.9926450697410859, + "accuracy": 0.9446614583333334, + "precision": 0.8019760790431617, + "recall": 0.9721381744831064, + "f1": 0.8788966774947284, + "false_positive_rate": 0.06249179466981751, + "tn": 28564, + "fp": 1904, + "fn": 221, + "tp": 7711 + }, + "test_metrics": { + "threshold": 0.5025206934115897, + "pr_auc": 0.9559739814794836, + "roc_auc": 0.9865001903781169, + "accuracy": 0.9298958333333334, + "precision": 0.7673625905411163, + "recall": 0.9341286307053942, + "f1": 0.8425730994152046, + "false_positive_rate": 0.07116788321167883, + "tn": 7126, + "fp": 546, + "fn": 127, + "tp": 1801 + }, + "train_rows": 38400, + "test_rows": 9600, + "positive_ratio_train": 0.2065625, + "created_at": "2026-06-27T06:42:41.376260+00:00" +} \ No newline at end of file diff --git a/app/ml/artifacts/defect/lightgbm_defect_detector.joblib b/app/ml/artifacts/defect/lightgbm_defect_detector.joblib new file mode 100644 index 0000000..8645152 Binary files /dev/null and b/app/ml/artifacts/defect/lightgbm_defect_detector.joblib differ diff --git a/app/ml/datasets/__init__.py b/app/ml/datasets/__init__.py deleted file mode 100644 index bae7aa2..0000000 --- a/app/ml/datasets/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -"""Dataset management package.""" - diff --git a/app/ml/inference/bottleneck_detector.py b/app/ml/inference/bottleneck_detector.py index 8aa6d07..d78a489 100644 --- a/app/ml/inference/bottleneck_detector.py +++ b/app/ml/inference/bottleneck_detector.py @@ -63,7 +63,6 @@ def summarize( analysis_df: pd.DataFrame, top_n: int = 20, *, - product_process_history_id: int | None = None, manufacturing_event_id: int | None = None, car_master_id: int | None = None, ) -> list[dict[str, Any]]: @@ -113,14 +112,12 @@ def summarize( risk_level = int(row["risk_level"]) summaries.append( { - "product_process_history_id": product_process_history_id, "manufacturing_event_id": manufacturing_event_id, "car_master_id": car_master_id, "process_code": station.process_code, "equipment_code": station.equipment_code, - "station_code": station.station, "rank_no": index + 1, - "avg_delay_time": round(avg_delay_time, 1), + "avg_delay_time": avg_delay_time, "affected_vehicle_count": int(row["affected_vehicle_count"]), "risk_score": float(risk_level), }, @@ -128,13 +125,13 @@ def summarize( return summaries - def summarize_product_process_histories( + def summarize_manufacturing_event_histories( self, histories: list[dict[str, Any]], ) -> list[dict[str, Any]]: """공정 이력 병목 순위 계산""" # 이력 기반 모델 입력 피처 생성 - features = self._build_product_process_history_features(histories) + features = self._build_manufacturing_event_features(histories) model_features = self._resolve_model_features(features) X = features.reindex(columns=model_features) @@ -144,25 +141,55 @@ def summarize_product_process_histories( features["iforest_bottleneck"] = (pred_raw == -1).astype(int) features["iforest_anomaly_score"] = anomaly_scores features["iforest_risk_score"] = pd.Series(anomaly_scores).rank(pct=True).to_numpy() + features = self._apply_rule_engine(features) + features["combined_risk_score"] = ( + 0.45 * features["rule_risk_score"] + + 0.55 * features["iforest_risk_score"] + ) + features["bottleneck_candidate"] = ( + features["rule_bottleneck"].eq(1) + | features["iforest_bottleneck"].eq(1) + ).astype(int) # 지점 대표 이력 선정을 위한 정렬 - ranked_features = features.sort_values( - ["iforest_risk_score", "waiting_time", "process_time", "product_process_history_id"], - ascending=[False, False, False, True], + target_features = features[features["bottleneck_candidate"].eq(1)].copy() + if target_features.empty: + target_features = features.nlargest( + min(len(features), 20), + "combined_risk_score", + ).copy() + + ranked_features = target_features.sort_values( + [ + "rule_bottleneck", + "iforest_bottleneck", + "combined_risk_score", + "rule_risk_score", + "iforest_risk_score", + "total_duration", + "max_station_span", + "id", + ], + ascending=[False, False, False, False, False, False, False, True], ) # 공정/설비/지점 단위 집계 grouped = ( - ranked_features.groupby(["process_code", "equipment_code", "station_code"], dropna=False) + ranked_features.groupby(["process_code", "equipment_code"], dropna=False) .agg( - product_process_history_id=("product_process_history_id", "first"), manufacturing_event_id=("manufacturing_event_id", "first"), car_master_id=("car_master_id", "first"), - avg_delay_time=("waiting_time", "mean"), - max_delay_time=("waiting_time", "max"), - avg_process_time=("process_time", "mean"), - affected_vehicle_count=("product_process_history_id", "count"), - risk_score=("iforest_risk_score", "mean"), - max_risk_score=("iforest_risk_score", "max"), + avg_delay_time=("delay_time", "mean"), + max_delay_time=("delay_time", "max"), + avg_total_duration=("total_duration", "mean"), + affected_vehicle_count=("car_master_id", "nunique"), + equipment_abnormal_count=("is_equipment_abnormal", "sum"), + event_count=("id", "count"), + avg_rule_risk=("rule_risk_score", "mean"), + avg_iforest_risk=("iforest_risk_score", "mean"), + risk_score=("combined_risk_score", "mean"), + max_risk_score=("combined_risk_score", "max"), + avg_queue_length=("queue_length", "mean"), + avg_wip_count=("wip_count", "mean"), ) .reset_index() ) @@ -179,13 +206,15 @@ def summarize_product_process_histories( grouped = grouped.sort_values( [ "risk_level", + "equipment_abnormal_count", "max_risk_score", - "risk_score", "max_delay_time", - "avg_delay_time", + "avg_iforest_risk", + "avg_rule_risk", "affected_vehicle_count", + "avg_delay_time", ], - ascending=[False, False, False, False, False, False], + ascending=[False, False, False, False, False, False, False, False], ).reset_index(drop=True) # DB 저장 형식 변환 @@ -193,14 +222,12 @@ def summarize_product_process_histories( for index, row in grouped.iterrows(): summaries.append( { - "product_process_history_id": int(row["product_process_history_id"]), "manufacturing_event_id": self._safe_int(row["manufacturing_event_id"]), "car_master_id": self._safe_int(row["car_master_id"]), "process_code": str(row["process_code"]), "equipment_code": str(row["equipment_code"]), - "station_code": str(row["station_code"]), "rank_no": index + 1, - "avg_delay_time": round(self._safe_float(row["avg_delay_time"], default=0.0), 1), + "avg_delay_time": self._safe_float(row["avg_delay_time"], default=0.0), "affected_vehicle_count": int(row["affected_vehicle_count"]), "risk_score": float(row["risk_level"]), }, @@ -208,7 +235,49 @@ def summarize_product_process_histories( return summaries - def _build_product_process_history_features( + @staticmethod + def _apply_rule_engine(features: pd.DataFrame) -> pd.DataFrame: + """학습 노트북과 동일한 Rule Engine 점수를 계산.""" + result = features.copy() + duration_threshold = result["total_duration"].quantile(0.95) + station_span_threshold = result["max_station_span"].quantile(0.95) + delay_threshold = result["delay_time"].quantile(0.95) + + duration_score = ( + result["total_duration"] / max(float(duration_threshold), 1e-12) + ).clip(upper=2.0) / 2.0 + station_span_score = ( + result["max_station_span"] / max(float(station_span_threshold), 1e-12) + ).clip(upper=2.0) / 2.0 + if float(delay_threshold) > 0: + delay_score = ( + result["delay_time"] / float(delay_threshold) + ).clip(upper=2.0) / 2.0 + delay_condition = result["delay_time"].ge(delay_threshold) + else: + delay_score = result["delay_time"] * 0.0 + delay_condition = result["delay_time"].gt(0) + equipment_status_score = result["is_equipment_abnormal"].astype(float) + + weighted_rule_score = ( + 0.35 * duration_score + + 0.25 * station_span_score + + 0.25 * delay_score + + 0.15 * equipment_status_score + ).fillna(0.0) + result["rule_risk_score"] = pd.concat( + [weighted_rule_score, equipment_status_score], + axis=1, + ).max(axis=1) + result["rule_bottleneck"] = ( + result["total_duration"].ge(duration_threshold) + | result["max_station_span"].ge(station_span_threshold) + | delay_condition + | result["is_equipment_abnormal"].eq(1) + ).astype(int) + return result + + def _build_manufacturing_event_features( self, histories: list[dict[str, Any]], ) -> pd.DataFrame: @@ -216,20 +285,45 @@ def _build_product_process_history_features( source_df = pd.DataFrame(histories) process_time = source_df["process_time"].fillna(0).astype(float) waiting_time = source_df["waiting_time"].fillna(0).astype(float) + if "delay_time" in source_df.columns: + delay_time = source_df["delay_time"].where(source_df["delay_time"] > 0, waiting_time) + else: + delay_time = waiting_time + delay_time = delay_time.fillna(0).astype(float) + queue_length = source_df.get("queue_length", 0.0) + wip_count = source_df.get("wip_count", 0.0) + station_key = source_df.get( + "station_key", + source_df["equipment_code"], + ).fillna("UNKNOWN") + equipment_status = ( + source_df["equipment_status"] + if "equipment_status" in source_df + else pd.Series("", index=source_df.index) + ).fillna("").astype(str).str.upper() + is_equipment_abnormal = equipment_status.isin( + {"FAULT", "STOPPED", "ERROR", "DOWN"}, + ).astype(int) total_duration = process_time + waiting_time # 기본 시간/식별자 피처 feature_df = pd.DataFrame( { "Id": source_df["id"].astype(int), - "product_process_history_id": source_df["id"].astype(int), + "id": source_df["id"].astype(int), "manufacturing_event_id": source_df["manufacturing_event_id"], "car_master_id": source_df["car_master_id"], "process_code": source_df["process_code"].astype(str), "equipment_code": source_df["equipment_code"].astype(str), - "station_code": source_df["station_code"].astype(str), + "equipment_status": equipment_status, + "is_equipment_abnormal": is_equipment_abnormal, + "station_key": station_key.astype(str), "process_time": process_time, "waiting_time": waiting_time, + "delay_time": delay_time, + "is_delayed": delay_time.gt(0).astype(int), + "queue_length": queue_length, + "wip_count": wip_count, "process_start_time": 0.0, "process_end_time": total_duration, "total_duration": total_duration, @@ -255,7 +349,7 @@ def _build_product_process_history_features( if line is None: continue - station = str(row["station_code"]) + station = str(row["station_key"]) station_prefix = f"{line}_{station}" feature_df.at[index, f"{line}_seen"] = 1 feature_df.at[index, f"{line}_duration"] = row["process_time"] diff --git a/app/ml/inference/defect_transfer_detector.py b/app/ml/inference/defect_transfer_detector.py new file mode 100644 index 0000000..07ebddd --- /dev/null +++ b/app/ml/inference/defect_transfer_detector.py @@ -0,0 +1,494 @@ +from __future__ import annotations + +import json +import logging +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import numpy as np +import pandas as pd + + +logger = logging.getLogger(__name__) + +DEFECT_ARTIFACT_DIR = Path(__file__).resolve().parents[1] / "artifacts" / "defect" +PROCESS_SEQUENCE = ("PRESS", "BODY", "PAINT", "ASSEMBLY") +NEXT_PROCESS = { + "PRESS": "BODY", + "BODY": "PAINT", + "PAINT": "ASSEMBLY", +} + + +@dataclass(frozen=True) +class DefectCause: + rank: int + feature: str + label: str + value: Any + impact: float + message: str + + +@dataclass(frozen=True) +class DefectTransferPrediction: + defect_probability: float + defect_threshold: float + is_quality_defect: bool + current_process_code: str + predicted_process_code: str | None + transfer_probability: float | None + transfer_threshold: float | None + expected_steps_after: int | None + risk_level: str + causes: list[DefectCause] + feature_values: dict[str, Any] + + +def has_only_model_probability_cause(causes: list[DefectCause]) -> bool: + """Return True when the detector produced only the fallback model-probability cause.""" + return ( + len(causes) == 1 + and causes[0].feature == "model_probability" + and causes[0].impact > 0 + ) + + +class DefectTransferDetector: + """Run event-level defect detection and adjacent-process transfer prediction.""" + + def __init__( + self, + *, + artifact_dir: str | Path = DEFECT_ARTIFACT_DIR, + ) -> None: + self.artifact_dir = Path(artifact_dir) + self.model_path = self.artifact_dir / "lightgbm_defect_detector.joblib" + self.feature_path = self.artifact_dir / "defect_model_features.json" + self.metrics_path = self.artifact_dir / "defect_model_metrics.json" + self.transfer_model_path = self.artifact_dir / "adjacent_transfer_models.joblib" + self.transfer_metadata_path = ( + self.artifact_dir / "adjacent_transfer_model_metadata.json" + ) + self._defect_model: Any | None = None + self._transfer_models: dict[str, Any] | None = None + self._feature_columns: list[str] | None = None + self._metrics: dict[str, Any] | None = None + self._transfer_metadata: dict[str, Any] | None = None + self._defect_shap_explainer: Any | None = None + + def predict_event( + self, + event_json: dict[str, Any], + process_code: str, + ) -> DefectTransferPrediction: + normalized_process = str(process_code or "").strip().upper() + features = self.extract_event_features(event_json, normalized_process) + defect_probability = self._predict_probability( + self.defect_model, + features, + self.feature_columns, + ) + defect_threshold = float(self.metrics.get("threshold", 0.5)) + transfer_key = self._transfer_key(normalized_process) + transfer_probability = None + transfer_threshold = None + predicted_process = NEXT_PROCESS.get(normalized_process) + if transfer_key and transfer_key in self.transfer_models: + metadata = self.transfer_metadata.get(transfer_key, {}) + transfer_columns = list(metadata.get("feature_columns") or []) + transfer_features = self._transfer_features(features, transfer_columns) + transfer_probability = self._predict_probability( + self.transfer_models[transfer_key], + transfer_features, + transfer_columns, + ) + transfer_threshold = float(metadata.get("threshold", 0.5)) + + risk_probability = max( + defect_probability, + transfer_probability if transfer_probability is not None else 0.0, + ) + causes = self._rank_causes(features, normalized_process, risk_probability) + next_process = NEXT_PROCESS.get(normalized_process) + if transfer_probability is not None and next_process is not None: + predicted_process_code = ( + next_process if transfer_probability > 0 else None + ) + elif defect_probability > 0: + predicted_process_code = normalized_process + else: + predicted_process_code = None + return DefectTransferPrediction( + defect_probability=round(defect_probability, 4), + defect_threshold=round(defect_threshold, 4), + is_quality_defect=defect_probability >= defect_threshold, + current_process_code=normalized_process, + predicted_process_code=predicted_process_code, + transfer_probability=( + round(transfer_probability, 4) + if transfer_probability is not None + else None + ), + transfer_threshold=( + round(transfer_threshold, 4) + if transfer_threshold is not None + else None + ), + expected_steps_after=self._expected_steps_after(normalized_process), + risk_level=self._risk_level(risk_probability), + causes=causes, + feature_values=features, + ) + + @property + def defect_model(self) -> Any: + if self._defect_model is None: + self._defect_model = self._load_joblib(self.model_path) + self._patch_loaded_model(self._defect_model) + return self._defect_model + + @property + def transfer_models(self) -> dict[str, Any]: + if self._transfer_models is None: + loaded = self._load_joblib(self.transfer_model_path) + if not isinstance(loaded, dict): + raise TypeError("adjacent_transfer_models.joblib must contain a dict.") + for model in loaded.values(): + self._patch_loaded_model(model) + self._transfer_models = loaded + return self._transfer_models + + @property + def feature_columns(self) -> list[str]: + if self._feature_columns is None: + self._feature_columns = list( + json.loads(self.feature_path.read_text(encoding="utf-8")), + ) + return self._feature_columns + + @property + def metrics(self) -> dict[str, Any]: + if self._metrics is None: + self._metrics = json.loads(self.metrics_path.read_text(encoding="utf-8")) + return self._metrics + + @property + def transfer_metadata(self) -> dict[str, Any]: + if self._transfer_metadata is None: + self._transfer_metadata = json.loads( + self.transfer_metadata_path.read_text(encoding="utf-8"), + ) + return self._transfer_metadata + + def _load_joblib(self, path: Path) -> Any: + try: + import sklearn.compose._column_transformer as column_transformer + + if not hasattr(column_transformer, "_RemainderColsList"): + column_transformer._RemainderColsList = type( # type: ignore[attr-defined] + "_RemainderColsList", + (list,), + {}, + ) + + import joblib + except ModuleNotFoundError as exc: + raise RuntimeError("joblib, scikit-learn and LightGBM are required.") from exc + + if not path.exists(): + raise FileNotFoundError(f"Defect model artifact not found: {path}") + return joblib.load(path) + + def _predict_probability( + self, + model: Any, + features: dict[str, Any], + columns: list[str], + ) -> float: + frame = pd.DataFrame([{column: features.get(column) for column in columns}]) + if hasattr(model, "predict_proba"): + probabilities = model.predict_proba(frame) + return float(probabilities[0][1]) + prediction = model.predict(frame) + return float(prediction[0]) + + def extract_event_features( + self, + event_json: dict[str, Any], + process_code: str, + ) -> dict[str, Any]: + equipment = _dict(event_json.get("equipment")) + sensor = _dict(event_json.get("sensor")) + metrics = _dict(event_json.get("processMetrics")) + process_data = _dict(event_json.get("processData")) + current = _dict(sensor.get("current")) + vibration = _dict(sensor.get("vibration")) + robot = _dict(sensor.get("robotArmVibration")) + thermal = _dict(sensor.get("thermal")) + press = _dict(process_data.get("press")) + body = _dict(process_data.get("body")) + paint = _dict(process_data.get("paint")) + bands = _dict(body.get("frequencyBands")) + band_values = [_safe_float(value, default=np.nan) for value in bands.values()] + band_values = [value for value in band_values if not np.isnan(value)] + + equipment_code = str(equipment.get("equipmentCode") or "") + return { + "process_code": process_code, + "station_code": _station_code(equipment_code), + "equipment_code": equipment_code, + "equipment_type": equipment.get("equipmentType"), + "current_rms_ampere": _safe_float(current.get("rmsAmpere")), + "current_max_ampere": _safe_float(current.get("maxAmpere")), + "current_min_ampere": _safe_float(current.get("minAmpere")), + "vibration_acceleration_g": _safe_float(vibration.get("accelerationG")), + "vibration_score": _safe_float(vibration.get("vibrationScore")), + "vibration_rms": _safe_float(vibration.get("vibrationRms")), + "vibration_peak": _safe_float(vibration.get("vibrationPeak")), + "robot_axis": robot.get("axis"), + "robot_frequency_hz": _safe_float(robot.get("frequencyHz")), + "robot_amplitude": _safe_float(robot.get("amplitude")), + "robot_vibration_score": _safe_float(robot.get("vibrationScore")), + "thermal_score": _safe_float(thermal.get("thermalScore")), + "avg_temperature": _safe_float(thermal.get("avgTemperature")), + "max_temperature": _safe_float(thermal.get("maxTemperature")), + "min_temperature": _safe_float(thermal.get("minTemperature")), + "cycle_time_sec": _safe_float(metrics.get("cycleTimeSec")), + "waiting_time_sec": _safe_float(metrics.get("waitingTimeSec")), + "processing_time_sec": _safe_float(metrics.get("processingTimeSec")), + "station_delay_sec": _safe_float(metrics.get("stationDelaySec")), + "throughput_per_min": _safe_float(metrics.get("throughputPerMin")), + "queue_length": _safe_float(metrics.get("queueLength")), + "wip_count": _safe_float(metrics.get("wipCount")), + "equipment_idle_time_sec": _safe_float(metrics.get("equipmentIdleTimeSec")), + "press_target_cycle_time_sec": _safe_float( + press.get("targetCycleTimeSec"), + ), + "body_robot_operation_mode": body.get("robotOperationMode"), + "body_frequency_peak_band": body.get("frequencyPeakBand"), + "body_frequency_band_max": max(band_values) if band_values else 0.0, + "body_frequency_band_mean": ( + float(np.mean(band_values)) if band_values else 0.0 + ), + "paint_image_position": paint.get("imagePosition"), + "paint_thermal_std_temp": _safe_float(paint.get("thermalStdTemp")), + "paint_thickness_value": _safe_float(paint.get("thicknessValue")), + } + + def _transfer_features( + self, + event_features: dict[str, Any], + columns: list[str], + ) -> dict[str, Any]: + source_map = { + "source_cycle_time_sec": "cycle_time_sec", + "source_station_delay_sec": "station_delay_sec", + "source_queue_length": "queue_length", + "source_wip_count": "wip_count", + "source_current_rms_ampere": "current_rms_ampere", + "source_vibration_score": "vibration_score", + "source_thermal_score": "thermal_score", + } + return { + column: event_features.get(source_map.get(column, column), 0.0) + for column in columns + } + + def _rank_causes( + self, + features: dict[str, Any], + process_code: str, + risk_probability: float, + ) -> list[DefectCause]: + shap_impacts = self._shap_feature_impacts(features) + candidates = [ + ("station_delay_sec", "공정 지연", 12.0, "초", None), + ("cycle_time_sec", "Cycle Time 증가", 55.0, "초", None), + ("queue_length", "대기열 증가", 8.0, "대", None), + ("wip_count", "WIP 증가", 24.0, "대", None), + ("current_rms_ampere", "전류 RMS 편차", 2.2, "A", None), + ("vibration_score", "진동 Score 상승", 0.45, "", None), + ("robot_vibration_score", "로봇 진동 Score 상승", 0.45, "", None), + ("thermal_score", "열화상 Score 상승", 55.0, "", None), + ("max_temperature", "최고 온도 상승", 58.0, "°C", None), + ("paint_thermal_std_temp", "도장 온도 편차", 4.0, "°C", "PAINT"), + ("paint_thickness_value", "도막 두께 편차", 50.0, "", "PAINT"), + ] + scored: list[tuple[str, str, Any, float, str]] = [] + for feature, label, baseline, unit, target_process in candidates: + if target_process is not None and process_code != target_process: + continue + value = features.get(feature) + numeric = _safe_float(value, default=0.0) + if feature == "paint_thickness_value": + if numeric <= 0: + continue + display_value = abs(numeric - baseline) + if display_value <= 0: + continue + impact = display_value / 20.0 + else: + if numeric <= baseline: + continue + display_value = numeric + impact = max(0.0, numeric - baseline) / max(abs(baseline), 1.0) + if process_code == "PAINT" and feature.startswith("paint_"): + impact *= 1.35 + if shap_impacts: + impact = max(impact * 0.35, shap_impacts.get(feature, 0.0)) + scored.append((feature, label, display_value, impact, unit)) + + scored.sort(key=lambda item: item[3], reverse=True) + top = scored[:4] + if not top or top[0][3] <= 0: + top = [ + ( + "model_probability", + "모델 위험 확률", + risk_probability, + risk_probability, + "", + ), + ] + return [ + DefectCause( + rank=index, + feature=feature, + label=label, + value=value, + impact=round(float(min(max(impact, 0.0), 1.0)), 4), + message=_cause_message(label, value, unit), + ) + for index, (feature, label, value, impact, unit) in enumerate(top, 1) + ] + + def _shap_feature_impacts(self, features: dict[str, Any]) -> dict[str, float]: + try: + model = self.defect_model + steps = getattr(model, "named_steps", {}) + preprocess = steps.get("preprocess") + estimator = steps.get("model") + if preprocess is None or estimator is None: + return {} + + frame = pd.DataFrame( + [{column: features.get(column) for column in self.feature_columns}], + ) + transformed = preprocess.transform(frame) + if hasattr(transformed, "toarray"): + transformed = transformed.toarray() + + if self._defect_shap_explainer is None: + import shap + + self._defect_shap_explainer = shap.TreeExplainer(estimator) + shap_values = self._defect_shap_explainer.shap_values(transformed) + if isinstance(shap_values, list): + values = shap_values[-1][0] + else: + values = np.asarray(shap_values) + if values.ndim == 3: + values = values[0, :, -1] + else: + values = values[0] + + try: + transformed_names = list(preprocess.get_feature_names_out()) + except Exception: + transformed_names = [f"feature_{index}" for index in range(len(values))] + + raw_scores = {feature: 0.0 for feature in self.feature_columns} + for name, value in zip(transformed_names, values, strict=False): + normalized_name = str(name) + for feature in raw_scores: + if normalized_name.endswith(feature) or f"__{feature}" in normalized_name: + raw_scores[feature] += abs(float(value)) + break + + max_score = max(raw_scores.values(), default=0.0) + if max_score <= 0: + return {} + return { + feature: round(score / max_score, 4) + for feature, score in raw_scores.items() + if score > 0 + } + except Exception: + logger.debug("SHAP cause ranking failed; using fallback causes.", exc_info=True) + return {} + + @staticmethod + def _transfer_key(process_code: str) -> str | None: + target = NEXT_PROCESS.get(process_code) + if target is None: + return None + return f"{process_code.lower()}_to_{target.lower()}" + + @staticmethod + def _expected_steps_after(process_code: str) -> int | None: + if process_code not in PROCESS_SEQUENCE: + return None + steps = len(PROCESS_SEQUENCE) - PROCESS_SEQUENCE.index(process_code) - 1 + return steps or None + + @staticmethod + def _risk_level(probability: float) -> str: + if probability >= 0.75: + return "CRITICAL" + if probability >= 0.55: + return "WARNING" + return "LOW" + + @staticmethod + def _patch_loaded_model(model: Any) -> None: + seen: set[int] = set() + + def visit(node: Any) -> None: + node_id = id(node) + if node_id in seen: + return + seen.add(node_id) + + if node.__class__.__name__ == "SimpleImputer" and not hasattr( + node, + "_fill_dtype", + ): + node._fill_dtype = getattr(node, "_fit_dtype", None) + + for child in getattr(node, "named_steps", {}).values(): + visit(child) + for transformer in getattr(node, "transformers_", []): + if len(transformer) >= 2: + visit(transformer[1]) + for _, value in getattr(node, "steps", []): + visit(value) + + visit(model) + + +def _dict(value: Any) -> dict[str, Any]: + return value if isinstance(value, dict) else {} + + +def _safe_float(value: Any, *, default: float = 0.0) -> float: + if value is None or value == "": + return default + try: + return float(value) + except (TypeError, ValueError): + return default + + +def _station_code(equipment_code: str) -> str: + if not equipment_code: + return "UNKNOWN" + parts = equipment_code.split("_") + return parts[-1] if parts else equipment_code + + +def _cause_message(label: str, value: Any, unit: str) -> str: + if isinstance(value, (int, float, np.number)): + return f"{label} {float(value):.2f}{unit}" + return f"{label} {value}" diff --git a/app/ml/preprocessing/__init__.py b/app/ml/preprocessing/__init__.py index 50cbb18..062d827 100644 --- a/app/ml/preprocessing/__init__.py +++ b/app/ml/preprocessing/__init__.py @@ -1,2 +1,22 @@ """Data preprocessing package.""" +from app.ml.preprocessing.manufacturing_event_features import ( + ADJACENT_TRANSITIONS, + PROCESS_ORDER, + build_adjacent_transition_training_frames, + build_event_feature_frame, + build_transition_training_frame, + build_vehicle_process_wide_frame, + infer_event_abnormal_label, +) + +__all__ = [ + "ADJACENT_TRANSITIONS", + "PROCESS_ORDER", + "build_adjacent_transition_training_frames", + "build_event_feature_frame", + "build_transition_training_frame", + "build_vehicle_process_wide_frame", + "infer_event_abnormal_label", +] + diff --git a/app/ml/training/defect_transfer_prediction_model.ipynb b/app/ml/training/defect_transfer_prediction_model.ipynb new file mode 100644 index 0000000..3a9759e --- /dev/null +++ b/app/ml/training/defect_transfer_prediction_model.ipynb @@ -0,0 +1,11518 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cffc6eae", + "metadata": { + "id": "cffc6eae" + }, + "source": [ + "# 불량 탐지 모델링 및 SHAP 기반 전이 위험 분석\n", + "\n", + "이 노트북은 자동차 제조 4개 공정의 품질 이벤트를 분석합니다. 먼저 공정 이벤트 단위의 **불량 탐지 모델**을 학습하고, 이어서 인접 공정 사이의 불량 전이 가능성을 예측하는 **공정 전이 예측 모델**을 학습합니다.\n", + "\n", + "주요 작업:\n", + "\n", + "- `defect_detection_train.csv`, `defect_detection_test.csv`를 읽어 이벤트 단위 불량 탐지 데이터셋을 구성합니다.\n", + "- `event_json` 내부의 센서값, 공정 지표, 설비 상태, 공정별 `processData`를 feature로 펼칩니다.\n", + "- 정답 유출 가능성이 큰 검사 결과/라벨성 컬럼을 제거하고, 단일 feature만으로 과도하게 예측되는 컬럼을 추가로 필터링합니다.\n", + "- LightGBM, XGBoost, CatBoost, Logistic Regression 후보 모델을 비교합니다.\n", + "- 정확도, 정밀도, 재현율, F1, PR-AUC, ROC-AUC, 혼동행렬, PR/ROC 곡선을 출력합니다.\n", + "- 인접 공정 전이 예측 모델과 SHAP 중요도를 저장합니다." + ] + }, + { + "cell_type": "markdown", + "id": "2722cbee", + "metadata": { + "id": "2722cbee" + }, + "source": [ + "**실행 준비**\n", + "\n", + "필요한 Python 패키지를 Colab 런타임에 맞춰 설치합니다. 이미 설치된 환경에서는 바로 넘어갑니다." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b2d2d4a8", + "metadata": { + "id": "b2d2d4a8" + }, + "outputs": [], + "source": [ + "import importlib.util\n", + "import subprocess\n", + "import sys\n", + "\n", + "\n", + "def ensure_package(import_name: str, pip_name: str | None = None):\n", + " pip_name = pip_name or import_name\n", + " if importlib.util.find_spec(import_name) is None:\n", + " subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", pip_name, \"-q\"])\n", + "\n", + "\n", + "ensure_package(\"pandas\")\n", + "ensure_package(\"numpy\")\n", + "ensure_package(\"sklearn\", \"scikit-learn\")\n", + "ensure_package(\"lightgbm\")\n", + "ensure_package(\"xgboost\")\n", + "ensure_package(\"catboost\")\n", + "ensure_package(\"shap\")\n", + "ensure_package(\"joblib\")" + ] + }, + { + "cell_type": "markdown", + "id": "d3ab427f", + "metadata": { + "id": "d3ab427f" + }, + "source": [ + "**라이브러리 로드**\n", + "\n", + "모델 학습, 평가, 시각화에 필요한 라이브러리를 불러오고 한글 폰트를 설정합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a66fc93f", + "metadata": { + "id": "a66fc93f", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "12eaa8c7-c585-4d72-cd86-de149ef1c7ea" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "matplotlib Korean font: NanumGothic\n" + ] + } + ], + "source": [ + "from __future__ import annotations\n", + "\n", + "import json\n", + "import shutil\n", + "import subprocess\n", + "import sys\n", + "import time\n", + "import warnings\n", + "from datetime import datetime, timezone\n", + "from pathlib import Path\n", + "\n", + "import joblib\n", + "import lightgbm as lgb\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import font_manager as fm\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import shap\n", + "import xgboost as xgb\n", + "from catboost import CatBoostClassifier\n", + "from sklearn.base import clone\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import ParameterSampler, StratifiedKFold\n", + "from sklearn.metrics import (\n", + " accuracy_score,\n", + " average_precision_score,\n", + " classification_report,\n", + " confusion_matrix,\n", + " f1_score,\n", + " precision_recall_curve,\n", + " precision_score,\n", + " recall_score,\n", + " roc_auc_score,\n", + " roc_curve,\n", + ")\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import OneHotEncoder, StandardScaler\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "sns.set_theme(style=\"whitegrid\")\n", + "pd.set_option(\"display.max_columns\", 180)\n", + "pd.set_option(\"display.max_rows\", 100)\n", + "RANDOM_STATE = 42\n", + "np.random.seed(RANDOM_STATE)\n", + "\n", + "\n", + "KOREAN_FONT_CANDIDATES = [\n", + " \"Malgun Gothic\",\n", + " \"AppleGothic\",\n", + " \"NanumGothic\",\n", + " \"NanumBarunGothic\",\n", + " \"Noto Sans CJK KR\",\n", + " \"Noto Sans KR\",\n", + " \"Arial Unicode MS\",\n", + "]\n", + "\n", + "\n", + "def find_korean_font() -> str | None:\n", + " available_fonts = {font.name for font in fm.fontManager.ttflist}\n", + " for font_name in KOREAN_FONT_CANDIDATES:\n", + " if font_name in available_fonts:\n", + " return font_name\n", + " return None\n", + "\n", + "\n", + "def try_install_colab_korean_font() -> str | None:\n", + " if not Path(\"/content\").exists() or shutil.which(\"apt-get\") is None:\n", + " return None\n", + " try:\n", + " subprocess.run([\"apt-get\", \"update\", \"-qq\"], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)\n", + " subprocess.run([\"apt-get\", \"install\", \"-y\", \"-qq\", \"fonts-nanum\"], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)\n", + " for font_path in [\n", + " Path(\"/usr/share/fonts/truetype/nanum/NanumGothic.ttf\"),\n", + " Path(\"/usr/share/fonts/truetype/nanum/NanumBarunGothic.ttf\"),\n", + " ]:\n", + " if font_path.exists():\n", + " fm.fontManager.addfont(str(font_path))\n", + " return fm.FontProperties(fname=str(font_path)).get_name()\n", + " except Exception as exc:\n", + " print(\"Colab 한글 폰트 설치를 건너뜁니다:\", exc)\n", + " return None\n", + "\n", + "\n", + "def configure_korean_font() -> str | None:\n", + " font_name = find_korean_font() or try_install_colab_korean_font() or find_korean_font()\n", + " if font_name:\n", + " plt.rcParams[\"font.family\"] = font_name\n", + " plt.rcParams[\"axes.unicode_minus\"] = False\n", + " return font_name\n", + " plt.rcParams[\"axes.unicode_minus\"] = False\n", + " return None\n", + "\n", + "\n", + "KOREAN_FONT_NAME = configure_korean_font()\n", + "if KOREAN_FONT_NAME:\n", + " print(f\"matplotlib Korean font: {KOREAN_FONT_NAME}\")\n", + "else:\n", + " print(\"한글 폰트를 찾지 못했습니다.\")" + ] + }, + { + "cell_type": "markdown", + "id": "3d789629", + "metadata": { + "id": "3d789629" + }, + "source": [ + "**경로 설정**\n", + "\n", + "Colab에서는 Google Drive를 마운트하고, 로컬에서는 프로젝트 내부의 generated CSV를 사용합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cfba3bb6", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cfba3bb6", + "outputId": "06be2a3a-a52b-4842-8d66-8690b37ba18d" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n", + "PROJECT_ROOT: /content\n", + "PROCESS_ROOT: /content/app/ml/datasets/process\n", + "GENERATED_ROOT: /content/drive/MyDrive/aims_dataset/generated\n", + "OUTPUT_DIR: /content/drive/MyDrive/defect_transfer_outputs\n" + ] + } + ], + "source": [ + "# Drive mount\n", + "try:\n", + " from google.colab import drive\n", + " drive.mount(\"/content/drive\")\n", + " IN_COLAB = True\n", + "except Exception:\n", + " IN_COLAB = False\n", + " print(\"Colab이 아니므로 Google Drive mount를 건너뜁니다.\")\n", + "\n", + "PROJECT_ROOT_CANDIDATES = [\n", + " Path(\"/content/drive/MyDrive/ai-service\"),\n", + " Path(\"/content/drive/MyDrive\"),\n", + " Path.cwd(),\n", + "]\n", + "PROJECT_ROOT = next((p for p in PROJECT_ROOT_CANDIDATES if (p / \"app\" / \"ml\" / \"datasets\" / \"process\").exists()), Path.cwd())\n", + "if str(PROJECT_ROOT) not in sys.path:\n", + " sys.path.insert(0, str(PROJECT_ROOT))\n", + "\n", + "PROCESS_ROOT = PROJECT_ROOT / \"app\" / \"ml\" / \"datasets\" / \"process\"\n", + "GENERATED_ROOT = Path(\"/content/drive/MyDrive/aims_dataset/generated\") if IN_COLAB else PROCESS_ROOT / \"generated\"\n", + "OUTPUT_DIR = PROJECT_ROOT / \"outputs\" / \"defect_transfer\" if not IN_COLAB else Path(\"/content/drive/MyDrive/defect_transfer_outputs\")\n", + "OUTPUT_DIR.mkdir(parents=True, exist_ok=True)\n", + "print(\"PROJECT_ROOT:\", PROJECT_ROOT)\n", + "print(\"PROCESS_ROOT:\", PROCESS_ROOT)\n", + "print(\"GENERATED_ROOT:\", GENERATED_ROOT)\n", + "print(\"OUTPUT_DIR:\", OUTPUT_DIR)" + ] + }, + { + "cell_type": "markdown", + "id": "f7e546ab", + "metadata": { + "id": "f7e546ab" + }, + "source": [ + "## 1. generated 학습 데이터셋 로드" + ] + }, + { + "cell_type": "markdown", + "id": "d25e913d", + "metadata": { + "id": "d25e913d" + }, + "source": [ + "**데이터 준비**\n", + "\n", + "아래 4개 CSV가 필요합니다.\n", + "\n", + "- `defect_detection_train.csv`\n", + "- `defect_detection_test.csv`\n", + "- `transfer_prediction_train.csv`\n", + "- `transfer_prediction_test.csv`" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "306fbb15", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "306fbb15", + "outputId": "6d0d60d1-9fa6-4fe7-922e-74ce28317b4c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "generated CSV 4종을 확인했습니다.\n", + "defect train: /content/drive/MyDrive/aims_dataset/generated/defect_detection_train.csv\n", + "defect test: /content/drive/MyDrive/aims_dataset/generated/defect_detection_test.csv\n", + "transfer train: /content/drive/MyDrive/aims_dataset/generated/transfer_prediction_train.csv\n", + "transfer test: /content/drive/MyDrive/aims_dataset/generated/transfer_prediction_test.csv\n" + ] + } + ], + "source": [ + "required_files = [\n", + " GENERATED_ROOT / \"defect_detection_train.csv\",\n", + " GENERATED_ROOT / \"defect_detection_test.csv\",\n", + " GENERATED_ROOT / \"transfer_prediction_train.csv\",\n", + " GENERATED_ROOT / \"transfer_prediction_test.csv\",\n", + "]\n", + "\n", + "missing_files = [path for path in required_files if not path.exists()]\n", + "if missing_files:\n", + " missing_text = \"\\n\".join(str(path) for path in missing_files)\n", + " raise FileNotFoundError(\n", + " \"Colab에서 사용할 generated CSV 파일을 찾을 수 없습니다. \"\n", + " \"Google Drive의 /content/drive/MyDrive/aims_dataset/generated 폴더에 \"\n", + " \"아래 파일 4개를 업로드한 뒤 다시 실행하세요.\\n\"\n", + " f\"{missing_text}\"\n", + " )\n", + "\n", + "DEFECT_TRAIN_PATH = GENERATED_ROOT / \"defect_detection_train.csv\"\n", + "DEFECT_TEST_PATH = GENERATED_ROOT / \"defect_detection_test.csv\"\n", + "TRANSFER_TRAIN_PATH = GENERATED_ROOT / \"transfer_prediction_train.csv\"\n", + "TRANSFER_TEST_PATH = GENERATED_ROOT / \"transfer_prediction_test.csv\"\n", + "\n", + "print(\"generated CSV 4종을 확인했습니다.\")\n", + "print(\"defect train:\", DEFECT_TRAIN_PATH)\n", + "print(\"defect test:\", DEFECT_TEST_PATH)\n", + "print(\"transfer train:\", TRANSFER_TRAIN_PATH)\n", + "print(\"transfer test:\", TRANSFER_TEST_PATH)" + ] + }, + { + "cell_type": "markdown", + "id": "d3592f1f", + "metadata": { + "id": "d3592f1f" + }, + "source": [ + "**데이터 확인**\n", + "\n", + "CSV를 DataFrame으로 읽고 shape와 샘플 행을 확인합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7c916959", + "metadata": { + "id": "7c916959", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 674 + }, + "outputId": "02c75c9d-e282-43ea-8b2d-2add61a43939" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "defect_train_raw: (38400, 19)\n", + "defect_test_raw: (9600, 19)\n", + "transfer_train_raw: (28800, 16)\n", + "transfer_test_raw: (7200, 16)\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " raw_event_id event_id event_time car_master_id_raw \\\n", + "0 1 EVT-20260616-000001 2026-06-16T10:00:00 1 \n", + "1 2 EVT-20260616-000002 2026-06-16T10:00:03 1 \n", + "2 3 EVT-20260616-000003 2026-06-16T10:00:06 1 \n", + "\n", + " equipment_id process_code_raw station_code_raw equipment_code_raw \\\n", + "0 1 PRESS PRESS_STATION_01 EQ_PRESS_001 \n", + "1 13 BODY BODY_STATION_03 EQ_BODY_003 \n", + "2 24 PAINT PAINT_STATION_04 EQ_PAINT_004 \n", + "\n", + " equipment_type_raw operation_status_raw event_type_raw \\\n", + "0 HYDRAULIC_PRESS RUNNING PROCESS_STATUS \n", + "1 ROBOT_ARM RUNNING EQUIPMENT_SENSOR \n", + "2 CAMERA RUNNING QUALITY_CHECK \n", + "\n", + " event_json is_sent sent_at \\\n", + "0 {\"event\": {\"eventId\": \"EVT-20260616-000001\", \"... 0 NaN \n", + "1 {\"event\": {\"eventId\": \"EVT-20260616-000002\", \"... 0 NaN \n", + "2 {\"event\": {\"eventId\": \"EVT-20260616-000003\", \"... 0 NaN \n", + "\n", + " created_at updated_at defect_yn \\\n", + "0 2026-06-27T14:39:42 2026-06-27T14:39:42 0 \n", + "1 2026-06-27T14:39:42 2026-06-27T14:39:42 1 \n", + "2 2026-06-27T14:39:42 2026-06-27T14:39:42 1 \n", + "\n", + " defect_reason dataset_split \n", + "0 normal train \n", + "1 body_robot_vibration train \n", + "2 paint_vision_or_thermal train " + ], + "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", + "
raw_event_idevent_idevent_timecar_master_id_rawequipment_idprocess_code_rawstation_code_rawequipment_code_rawequipment_type_rawoperation_status_rawevent_type_rawevent_jsonis_sentsent_atcreated_atupdated_atdefect_yndefect_reasondataset_split
01EVT-20260616-0000012026-06-16T10:00:0011PRESSPRESS_STATION_01EQ_PRESS_001HYDRAULIC_PRESSRUNNINGPROCESS_STATUS{\"event\": {\"eventId\": \"EVT-20260616-000001\", \"...0NaN2026-06-27T14:39:422026-06-27T14:39:420normaltrain
12EVT-20260616-0000022026-06-16T10:00:03113BODYBODY_STATION_03EQ_BODY_003ROBOT_ARMRUNNINGEQUIPMENT_SENSOR{\"event\": {\"eventId\": \"EVT-20260616-000002\", \"...0NaN2026-06-27T14:39:422026-06-27T14:39:421body_robot_vibrationtrain
23EVT-20260616-0000032026-06-16T10:00:06124PAINTPAINT_STATION_04EQ_PAINT_004CAMERARUNNINGQUALITY_CHECK{\"event\": {\"eventId\": \"EVT-20260616-000003\", \"...0NaN2026-06-27T14:39:422026-06-27T14:39:421paint_vision_or_thermaltrain
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"display(transfer_train_raw\",\n \"rows\": 3,\n \"fields\": [\n {\n \"column\": \"raw_event_id\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1,\n \"min\": 1,\n \"max\": 3,\n \"num_unique_values\": 3,\n \"samples\": [\n 1,\n 2,\n 3\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"event_id\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"EVT-20260616-000001\",\n \"EVT-20260616-000002\",\n \"EVT-20260616-000003\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"event_time\",\n \"properties\": {\n \"dtype\": \"object\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"2026-06-16T10:00:00\",\n \"2026-06-16T10:00:03\",\n \"2026-06-16T10:00:06\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"car_master_id_raw\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 1,\n \"max\": 1,\n \"num_unique_values\": 1,\n \"samples\": [\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"equipment_id\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 11,\n \"min\": 1,\n \"max\": 24,\n \"num_unique_values\": 3,\n \"samples\": [\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"process_code_raw\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"PRESS\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"station_code_raw\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"PRESS_STATION_01\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"equipment_code_raw\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"EQ_PRESS_001\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"equipment_type_raw\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"HYDRAULIC_PRESS\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"operation_status_raw\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"RUNNING\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"event_type_raw\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"PROCESS_STATUS\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"event_json\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"{\\\"event\\\": {\\\"eventId\\\": \\\"EVT-20260616-000001\\\", \\\"eventTime\\\": \\\"2026-06-16T10:00:00\\\", \\\"eventType\\\": \\\"PROCESS_STATUS\\\", \\\"eventName\\\": \\\"\\ud504\\ub808\\uc2a4 \\uacf5\\uc815 \\ud1b5\\ud569 \\uad00\\uc81c \\uc774\\ubca4\\ud2b8\\\"}, \\\"equipment\\\": {\\\"equipmentCode\\\": \\\"EQ_PRESS_001\\\", \\\"equipmentName\\\": \\\"\\ud504\\ub808\\uc2a4 \\uc720\\uc555\\ubaa8\\ud130 1\\ud638\\\", \\\"equipmentType\\\": \\\"HYDRAULIC_PRESS\\\"}, \\\"equipmentStatus\\\": {\\\"operationStatus\\\": \\\"RUNNING\\\", \\\"lastNormalTime\\\": null, \\\"statusChangedTime\\\": null}, \\\"product\\\": {\\\"carMasterId\\\": 1}, \\\"sensor\\\": {\\\"sensorType\\\": \\\"MULTI_SENSOR\\\", \\\"current\\\": {\\\"rmsAmpere\\\": 1.73142512, \\\"maxAmpere\\\": 1.89583344, \\\"minAmpere\\\": 1.5670168}, \\\"vibration\\\": {\\\"accelerationG\\\": 0.0046, \\\"vibrationScore\\\": 0.34092, \\\"vibrationRms\\\": 1.0387936, \\\"vibrationPeak\\\": 2.3268372}, \\\"robotArmVibration\\\": {\\\"robotId\\\": \\\"ROBOT_ARM_01\\\", \\\"axis\\\": \\\"J2\\\", \\\"frequencyHz\\\": 115.002, \\\"amplitude\\\": 0.001038794, \\\"vibrationRms\\\": 0.001154215, \\\"vibrationPeak\\\": 0.003324053, \\\"vibrationScore\\\": 0.34092}, \\\"thermal\\\": {\\\"thermalScore\\\": 50.922, \\\"avgTemperature\\\": 50.922, \\\"maxTemperature\\\": 54.131, \\\"minTemperature\\\": 42.19}}, \\\"processMetrics\\\": {\\\"cycleTimeSec\\\": 47.833, \\\"waitingTimeSec\\\": 5.0, \\\"processingTimeSec\\\": 42.833, \\\"stationDelaySec\\\": 7.833, \\\"throughputPerMin\\\": 1.254, \\\"queueLength\\\": 6, \\\"wipCount\\\": 19, \\\"equipmentIdleTimeSec\\\": 12.534}, \\\"sourceTrace\\\": {\\\"fordRowId\\\": 1, \\\"formingRowId\\\": 55644626, \\\"robotArmVibrationRowId\\\": 1, \\\"machineVisionRowId\\\": 1, \\\"boschId\\\": 4}, \\\"processData\\\": {\\\"press\\\": {\\\"countIncreaseYn\\\": true, \\\"targetCycleTimeSec\\\": 40.0, \\\"timestampDelaySec\\\": 7.833}}}\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"is_sent\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 0,\n \"num_unique_values\": 1,\n \"samples\": [\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"sent_at\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": null,\n \"max\": null,\n \"num_unique_values\": 0,\n \"samples\": [],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"created_at\",\n \"properties\": {\n \"dtype\": \"object\",\n \"num_unique_values\": 1,\n \"samples\": [],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"updated_at\",\n \"properties\": {\n \"dtype\": \"object\",\n \"num_unique_values\": 1,\n \"samples\": [],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"defect_yn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 1,\n \"num_unique_values\": 2,\n \"samples\": [],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"defect_reason\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"dataset_split\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " car_master_id source_event_id target_event_id \\\n", + "0 1 EVT-20260616-000001 EVT-20260616-000002 \n", + "1 1 EVT-20260616-000002 EVT-20260616-000003 \n", + "2 1 EVT-20260616-000003 EVT-20260616-000004 \n", + "\n", + " source_process_code target_process_code source_defect_yn target_defect_yn \\\n", + "0 PRESS BODY 0 1 \n", + "1 BODY PAINT 1 1 \n", + "2 PAINT ASSEMBLY 1 0 \n", + "\n", + " source_cycle_time_sec source_station_delay_sec source_queue_length \\\n", + "0 47.833 7.833 6 \n", + "1 56.998 4.998 6 \n", + "2 69.326 5.326 7 \n", + "\n", + " source_wip_count source_current_rms_ampere source_vibration_score \\\n", + "0 19 1.731425 0.340920 \n", + "1 18 2.068431 0.369143 \n", + "2 19 1.648970 0.333915 \n", + "\n", + " source_thermal_score source_event_json \\\n", + "0 50.922 {\"event\": {\"eventId\": \"EVT-20260616-000001\", \"... \n", + "1 51.042 {\"event\": {\"eventId\": \"EVT-20260616-000002\", \"... \n", + "2 51.621 {\"event\": {\"eventId\": \"EVT-20260616-000003\", \"... \n", + "\n", + " dataset_split \n", + "0 train \n", + "1 train \n", + "2 train " + ], + "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", + "
car_master_idsource_event_idtarget_event_idsource_process_codetarget_process_codesource_defect_yntarget_defect_ynsource_cycle_time_secsource_station_delay_secsource_queue_lengthsource_wip_countsource_current_rms_amperesource_vibration_scoresource_thermal_scoresource_event_jsondataset_split
01EVT-20260616-000001EVT-20260616-000002PRESSBODY0147.8337.8336191.7314250.34092050.922{\"event\": {\"eventId\": \"EVT-20260616-000001\", \"...train
11EVT-20260616-000002EVT-20260616-000003BODYPAINT1156.9984.9986182.0684310.36914351.042{\"event\": {\"eventId\": \"EVT-20260616-000002\", \"...train
21EVT-20260616-000003EVT-20260616-000004PAINTASSEMBLY1069.3265.3267191.6489700.33391551.621{\"event\": {\"eventId\": \"EVT-20260616-000003\", \"...train
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"display(transfer_train_raw\",\n \"rows\": 3,\n \"fields\": [\n {\n \"column\": \"car_master_id\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 1,\n \"max\": 1,\n \"num_unique_values\": 1,\n \"samples\": [\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_event_id\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"EVT-20260616-000001\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"target_event_id\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"EVT-20260616-000002\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_process_code\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"PRESS\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"target_process_code\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"BODY\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_defect_yn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 1,\n \"num_unique_values\": 2,\n \"samples\": [\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"target_defect_yn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 1,\n \"num_unique_values\": 2,\n \"samples\": [\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_cycle_time_sec\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 10.785220272823976,\n \"min\": 47.833,\n \"max\": 69.326,\n \"num_unique_values\": 3,\n \"samples\": [\n 47.833\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_station_delay_sec\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.5507986114687276,\n \"min\": 4.998,\n \"max\": 7.833,\n \"num_unique_values\": 3,\n \"samples\": [\n 7.833\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_queue_length\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 6,\n \"max\": 7,\n \"num_unique_values\": 2,\n \"samples\": [\n 7\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_wip_count\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 18,\n \"max\": 19,\n \"num_unique_values\": 2,\n \"samples\": [\n 18\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_current_rms_ampere\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.22223072013817394,\n \"min\": 1.64896992,\n \"max\": 2.068430694,\n \"num_unique_values\": 3,\n \"samples\": [\n 1.73142512\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_vibration_score\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.018648591269405126,\n \"min\": 0.333915,\n \"max\": 0.369143,\n \"num_unique_values\": 3,\n \"samples\": [\n 0.34092\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_thermal_score\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.37377399588521604,\n \"min\": 50.922,\n \"max\": 51.621,\n \"num_unique_values\": 3,\n \"samples\": [\n 50.922\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_event_json\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"{\\\"event\\\": {\\\"eventId\\\": \\\"EVT-20260616-000001\\\", \\\"eventTime\\\": \\\"2026-06-16T10:00:00\\\", \\\"eventType\\\": \\\"PROCESS_STATUS\\\", \\\"eventName\\\": \\\"\\ud504\\ub808\\uc2a4 \\uacf5\\uc815 \\ud1b5\\ud569 \\uad00\\uc81c \\uc774\\ubca4\\ud2b8\\\"}, \\\"equipment\\\": {\\\"equipmentCode\\\": \\\"EQ_PRESS_001\\\", \\\"equipmentName\\\": \\\"\\ud504\\ub808\\uc2a4 \\uc720\\uc555\\ubaa8\\ud130 1\\ud638\\\", \\\"equipmentType\\\": \\\"HYDRAULIC_PRESS\\\"}, \\\"equipmentStatus\\\": {\\\"operationStatus\\\": \\\"RUNNING\\\", \\\"lastNormalTime\\\": null, \\\"statusChangedTime\\\": null}, \\\"product\\\": {\\\"carMasterId\\\": 1}, \\\"sensor\\\": {\\\"sensorType\\\": \\\"MULTI_SENSOR\\\", \\\"current\\\": {\\\"rmsAmpere\\\": 1.73142512, \\\"maxAmpere\\\": 1.89583344, \\\"minAmpere\\\": 1.5670168}, \\\"vibration\\\": {\\\"accelerationG\\\": 0.0046, \\\"vibrationScore\\\": 0.34092, \\\"vibrationRms\\\": 1.0387936, \\\"vibrationPeak\\\": 2.3268372}, \\\"robotArmVibration\\\": {\\\"robotId\\\": \\\"ROBOT_ARM_01\\\", \\\"axis\\\": \\\"J2\\\", \\\"frequencyHz\\\": 115.002, \\\"amplitude\\\": 0.001038794, \\\"vibrationRms\\\": 0.001154215, \\\"vibrationPeak\\\": 0.003324053, \\\"vibrationScore\\\": 0.34092}, \\\"thermal\\\": {\\\"thermalScore\\\": 50.922, \\\"avgTemperature\\\": 50.922, \\\"maxTemperature\\\": 54.131, \\\"minTemperature\\\": 42.19}}, \\\"processMetrics\\\": {\\\"cycleTimeSec\\\": 47.833, \\\"waitingTimeSec\\\": 5.0, \\\"processingTimeSec\\\": 42.833, \\\"stationDelaySec\\\": 7.833, \\\"throughputPerMin\\\": 1.254, \\\"queueLength\\\": 6, \\\"wipCount\\\": 19, \\\"equipmentIdleTimeSec\\\": 12.534}, \\\"sourceTrace\\\": {\\\"fordRowId\\\": 1, \\\"formingRowId\\\": 55644626, \\\"robotArmVibrationRowId\\\": 1, \\\"machineVisionRowId\\\": 1, \\\"boschId\\\": 4}, \\\"processData\\\": {\\\"press\\\": {\\\"countIncreaseYn\\\": true, \\\"targetCycleTimeSec\\\": 40.0, \\\"timestampDelaySec\\\": 7.833}}}\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"dataset_split\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"train\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + } + ], + "source": [ + "defect_train_raw = pd.read_csv(DEFECT_TRAIN_PATH)\n", + "defect_test_raw = pd.read_csv(DEFECT_TEST_PATH)\n", + "transfer_train_raw = pd.read_csv(TRANSFER_TRAIN_PATH)\n", + "transfer_test_raw = pd.read_csv(TRANSFER_TEST_PATH)\n", + "\n", + "print(\"defect_train_raw:\", defect_train_raw.shape)\n", + "print(\"defect_test_raw:\", defect_test_raw.shape)\n", + "print(\"transfer_train_raw:\", transfer_train_raw.shape)\n", + "print(\"transfer_test_raw:\", transfer_test_raw.shape)\n", + "display(defect_train_raw.head(3))\n", + "display(transfer_train_raw.head(3))" + ] + }, + { + "cell_type": "markdown", + "id": "b88ce50d", + "metadata": { + "id": "b88ce50d" + }, + "source": [ + "## 2. eventJson feature 변환" + ] + }, + { + "cell_type": "markdown", + "id": "767564cc", + "metadata": { + "id": "767564cc" + }, + "source": [ + "**셀 설명**\n", + "\n", + "CSV의 `event_json` 컬럼을 학습 가능한 feature로 펼칩니다. 정답 컬럼은 별도로 유지하고, 이후 feature 선택 단계에서 유출 가능 컬럼을 제거합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a971a223", + "metadata": { + "id": "a971a223", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 606 + }, + "outputId": "121e6bb0-0b97-4091-e142-949ea2ff1f07" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(38400, 59) (9600, 59)\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "defect_yn 0 1\n", + "process_code \n", + "ASSEMBLY 0.793438 0.206563\n", + "BODY 0.784479 0.215521\n", + "PAINT 0.779792 0.220208\n", + "PRESS 0.816042 0.183958" + ], + "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", + "
defect_yn01
process_code
ASSEMBLY0.7934380.206563
BODY0.7844790.215521
PAINT0.7797920.220208
PRESS0.8160420.183958
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"display(defect_train\",\n \"rows\": 4,\n \"fields\": [\n {\n \"column\": \"process_code\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 4,\n \"samples\": [\n \"BODY\",\n \"PRESS\",\n \"ASSEMBLY\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": 0,\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.016097710542876044,\n \"min\": 0.7797916666666667,\n \"max\": 0.8160416666666667,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.7844791666666666,\n 0.8160416666666667,\n 0.7934375\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": 1,\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.016097710542876034,\n \"min\": 0.18395833333333333,\n \"max\": 0.22020833333333334,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.21552083333333333,\n 0.18395833333333333,\n 0.2065625\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " raw_event_id event_id event_time car_master_id \\\n", + "0 1 EVT-20260616-000001 2026-06-16T10:00:00 1 \n", + "1 2 EVT-20260616-000002 2026-06-16T10:00:03 1 \n", + "2 3 EVT-20260616-000003 2026-06-16T10:00:06 1 \n", + "3 4 EVT-20260616-000004 2026-06-16T10:00:09 1 \n", + "4 5 EVT-20260616-000005 2026-06-16T10:00:12 2 \n", + "\n", + " process_code station_code equipment_code equipment_type \\\n", + "0 PRESS PRESS_STATION_01 EQ_PRESS_001 HYDRAULIC_PRESS \n", + "1 BODY BODY_STATION_03 EQ_BODY_003 ROBOT_ARM \n", + "2 PAINT PAINT_STATION_04 EQ_PAINT_004 CAMERA \n", + "3 ASSEMBLY ASSEMBLY_STATION_04 EQ_ASSEMBLY_004 CONVEYOR \n", + "4 PRESS PRESS_STATION_04 EQ_PRESS_004 HYDRAULIC_PRESS \n", + "\n", + " operation_status current_rms_ampere current_max_ampere \\\n", + "0 RUNNING 1.731425 1.895833 \n", + "1 RUNNING 2.068431 2.237299 \n", + "2 RUNNING 1.648970 1.799303 \n", + "3 RUNNING 1.931789 2.104463 \n", + "4 RUNNING 1.724910 1.876135 \n", + "\n", + " current_min_ampere vibration_acceleration_g vibration_score \\\n", + "0 1.567017 0.004600 0.340920 \n", + "1 1.899562 0.006392 0.369143 \n", + "2 1.498636 0.001800 0.333915 \n", + "3 1.759116 0.000400 0.361150 \n", + "4 1.573685 0.001000 0.321575 \n", + "\n", + " vibration_rms vibration_peak robot_axis robot_frequency_hz \\\n", + "0 1.038794 2.326837 J2 115.002 \n", + "1 1.125161 2.698745 J3 121.211 \n", + "2 1.038794 2.326837 J4 113.461 \n", + "3 1.038794 2.326837 J5 119.453 \n", + "4 1.038794 2.326837 J6 110.746 \n", + "\n", + " robot_amplitude robot_vibration_score thermal_score avg_temperature \\\n", + "0 0.001039 0.340920 50.922 50.922 \n", + "1 0.001125 0.369143 51.042 51.042 \n", + "2 0.001039 0.333915 51.621 51.621 \n", + "3 0.001039 0.361150 51.392 51.392 \n", + "4 0.001039 0.321575 51.121 51.121 \n", + "\n", + " max_temperature min_temperature cycle_time_sec waiting_time_sec \\\n", + "0 54.131 42.190 47.833 5.0 \n", + "1 54.491 42.534 56.998 7.0 \n", + "2 54.021 42.860 69.326 9.0 \n", + "3 53.519 43.202 59.200 8.0 \n", + "4 53.927 42.551 44.494 6.0 \n", + "\n", + " processing_time_sec station_delay_sec throughput_per_min queue_length \\\n", + "0 42.833 7.833 1.254 6.0 \n", + "1 50.998 4.998 1.053 6.0 \n", + "2 62.326 5.326 0.865 7.0 \n", + "3 51.200 1.200 1.014 6.0 \n", + "4 39.494 4.494 1.348 9.0 \n", + "\n", + " wip_count equipment_idle_time_sec ford_row_id forming_row_id \\\n", + "0 19.0 12.534 1 55644626 \n", + "1 18.0 7.996 1 55644626 \n", + "2 19.0 8.521 1 55644626 \n", + "3 17.0 1.920 1 55644626 \n", + "4 20.0 7.191 1 55644630 \n", + "\n", + " robot_arm_vibration_row_id machine_vision_row_id bosch_id \\\n", + "0 1 1 4 \n", + "1 2 2 6 \n", + "2 3 3 7 \n", + "3 4 4 9 \n", + "4 5 5 11 \n", + "\n", + " press_count_increase_yn press_target_cycle_time_sec \\\n", + "0 1 40.0 \n", + "1 0 NaN \n", + "2 0 NaN \n", + "3 0 NaN \n", + "4 1 40.0 \n", + "\n", + " press_timestamp_delay_sec body_robot_motion_status \\\n", + "0 7.833 NaN \n", + "1 NaN WARNING \n", + "2 NaN NaN \n", + "3 NaN NaN \n", + "4 4.494 NaN \n", + "\n", + " body_robot_operation_mode body_frequency_peak_band body_frequency_band_max \\\n", + "0 NaN NaN NaN \n", + "1 AUTO 1201_1300_HZ 0.002139 \n", + "2 NaN NaN NaN \n", + "3 NaN NaN NaN \n", + "4 NaN NaN NaN \n", + "\n", + " body_frequency_band_mean paint_image_position paint_thermal_std_temp \\\n", + "0 NaN NaN NaN \n", + "1 0.001434 NaN NaN \n", + "2 NaN LEFT 2.988 \n", + "3 NaN NaN NaN \n", + "4 NaN NaN NaN \n", + "\n", + " paint_thickness_value paint_defect_score paint_vision_label \\\n", + "0 NaN NaN NaN \n", + "1 NaN NaN NaN \n", + "2 118.12 0.48 DEFECT \n", + "3 NaN NaN NaN \n", + "4 NaN NaN NaN \n", + "\n", + " paint_surface_quality_score assembly_expected_sequence \\\n", + "0 NaN NaN \n", + "1 NaN NaN \n", + "2 84.958 NaN \n", + "3 NaN A01>A02>A03>A04 \n", + "4 NaN NaN \n", + "\n", + " assembly_actual_sequence assembly_missing_part_count \\\n", + "0 NaN 0 \n", + "1 NaN 0 \n", + "2 NaN 0 \n", + "3 A01>A02>A03>A04 0 \n", + "4 NaN 0 \n", + "\n", + " assembly_fastening_error_count assembly_sequence_error_count \\\n", + "0 0 0 \n", + "1 0 0 \n", + "2 0 0 \n", + "3 0 0 \n", + "4 0 0 \n", + "\n", + " assembly_sequence_mismatch_yn defect_yn defect_reason \n", + "0 0 0 normal \n", + "1 0 1 body_robot_vibration \n", + "2 0 1 paint_vision_or_thermal \n", + "3 0 0 normal \n", + "4 0 0 normal " + ], + "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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
raw_event_idevent_idevent_timecar_master_idprocess_codestation_codeequipment_codeequipment_typeoperation_statuscurrent_rms_amperecurrent_max_amperecurrent_min_amperevibration_acceleration_gvibration_scorevibration_rmsvibration_peakrobot_axisrobot_frequency_hzrobot_amplituderobot_vibration_scorethermal_scoreavg_temperaturemax_temperaturemin_temperaturecycle_time_secwaiting_time_secprocessing_time_secstation_delay_secthroughput_per_minqueue_lengthwip_countequipment_idle_time_secford_row_idforming_row_idrobot_arm_vibration_row_idmachine_vision_row_idbosch_idpress_count_increase_ynpress_target_cycle_time_secpress_timestamp_delay_secbody_robot_motion_statusbody_robot_operation_modebody_frequency_peak_bandbody_frequency_band_maxbody_frequency_band_meanpaint_image_positionpaint_thermal_std_temppaint_thickness_valuepaint_defect_scorepaint_vision_labelpaint_surface_quality_scoreassembly_expected_sequenceassembly_actual_sequenceassembly_missing_part_countassembly_fastening_error_countassembly_sequence_error_countassembly_sequence_mismatch_yndefect_yndefect_reason
01EVT-20260616-0000012026-06-16T10:00:001PRESSPRESS_STATION_01EQ_PRESS_001HYDRAULIC_PRESSRUNNING1.7314251.8958331.5670170.0046000.3409201.0387942.326837J2115.0020.0010390.34092050.92250.92254.13142.19047.8335.042.8337.8331.2546.019.012.534155644626114140.07.833NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN00000normal
12EVT-20260616-0000022026-06-16T10:00:031BODYBODY_STATION_03EQ_BODY_003ROBOT_ARMRUNNING2.0684312.2372991.8995620.0063920.3691431.1251612.698745J3121.2110.0011250.36914351.04251.04254.49142.53456.9987.050.9984.9981.0536.018.07.9961556446262260NaNNaNWARNINGAUTO1201_1300_HZ0.0021390.001434NaNNaNNaNNaNNaNNaNNaNNaN00001body_robot_vibration
23EVT-20260616-0000032026-06-16T10:00:061PAINTPAINT_STATION_04EQ_PAINT_004CAMERARUNNING1.6489701.7993031.4986360.0018000.3339151.0387942.326837J4113.4610.0010390.33391551.62151.62154.02142.86069.3269.062.3265.3260.8657.019.08.5211556446263370NaNNaNNaNNaNNaNNaNNaNLEFT2.988118.120.48DEFECT84.958NaNNaN00001paint_vision_or_thermal
34EVT-20260616-0000042026-06-16T10:00:091ASSEMBLYASSEMBLY_STATION_04EQ_ASSEMBLY_004CONVEYORRUNNING1.9317892.1044631.7591160.0004000.3611501.0387942.326837J5119.4530.0010390.36115051.39251.39253.51943.20259.2008.051.2001.2001.0146.017.01.9201556446264490NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNA01>A02>A03>A04A01>A02>A03>A0400000normal
45EVT-20260616-0000052026-06-16T10:00:122PRESSPRESS_STATION_04EQ_PRESS_004HYDRAULIC_PRESSRUNNING1.7249101.8761351.5736850.0010000.3215751.0387942.326837J6110.7460.0010390.32157551.12151.12153.92742.55144.4946.039.4944.4941.3489.020.07.1911556446305511140.04.494NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN00000normal
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe" + } + }, + "metadata": {} + } + ], + "source": [ + "PROCESS_ORDER = [\"PRESS\", \"BODY\", \"PAINT\", \"ASSEMBLY\"]\n", + "TRANSFER_FLOW_ORDER = [(\"PRESS\", \"BODY\"), (\"BODY\", \"PAINT\"), (\"PAINT\", \"ASSEMBLY\")]\n", + "\n", + "\n", + "def get_nested(obj: dict, path: str, default=np.nan):\n", + " cur = obj\n", + " for key in path.split(\".\"):\n", + " if not isinstance(cur, dict) or key not in cur:\n", + " return default\n", + " cur = cur[key]\n", + " return cur\n", + "\n", + "\n", + "def to_float(value, default=np.nan):\n", + " try:\n", + " if value is None or value == \"\":\n", + " return default\n", + " return float(value)\n", + " except Exception:\n", + " return default\n", + "\n", + "\n", + "def to_int(value, default=0):\n", + " try:\n", + " if value is None or value == \"\":\n", + " return default\n", + " return int(float(value))\n", + " except Exception:\n", + " return default\n", + "\n", + "\n", + "def sequence_mismatch(expected, actual):\n", + " if pd.isna(expected) or pd.isna(actual):\n", + " return 0\n", + " return int(str(expected).strip() != str(actual).strip())\n", + "\n", + "\n", + "def flatten_event_row(row: pd.Series) -> dict:\n", + " payload = json.loads(row[\"event_json\"])\n", + " sensor = payload.get(\"sensor\", {}) or {}\n", + " current = sensor.get(\"current\", {}) or {}\n", + " vibration = sensor.get(\"vibration\", {}) or {}\n", + " robot = sensor.get(\"robotArmVibration\", {}) or {}\n", + " thermal = sensor.get(\"thermal\", {}) or {}\n", + " metrics = payload.get(\"processMetrics\", {}) or {}\n", + " equipment = payload.get(\"equipment\", {}) or {}\n", + " status = payload.get(\"equipmentStatus\", {}) or {}\n", + " product = payload.get(\"product\", {}) or {}\n", + " trace = payload.get(\"sourceTrace\", {}) or {}\n", + " process_data = payload.get(\"processData\", {}) or {}\n", + " press = process_data.get(\"press\", {}) or {}\n", + " body = process_data.get(\"body\", {}) or {}\n", + " paint = process_data.get(\"paint\", {}) or {}\n", + " assembly = process_data.get(\"assembly\", {}) or {}\n", + " bands = body.get(\"frequencyBands\", {}) or {}\n", + " band_values = [to_float(v) for v in bands.values()]\n", + " expected_sequence = assembly.get(\"expectedSequence\", np.nan)\n", + " actual_sequence = assembly.get(\"actualSequence\", np.nan)\n", + " return {\n", + " \"raw_event_id\": row.get(\"raw_event_id\"),\n", + " \"event_id\": row.get(\"event_id\"),\n", + " \"event_time\": row.get(\"event_time\"),\n", + " \"car_master_id\": product.get(\"carMasterId\", row.get(\"car_master_id_raw\")),\n", + " \"process_code\": row.get(\"process_code_raw\"),\n", + " \"station_code\": row.get(\"station_code_raw\"),\n", + " \"equipment_code\": equipment.get(\"equipmentCode\", row.get(\"equipment_code_raw\")),\n", + " \"equipment_type\": equipment.get(\"equipmentType\", row.get(\"equipment_type_raw\")),\n", + " \"operation_status\": status.get(\"operationStatus\", row.get(\"operation_status_raw\")),\n", + " \"current_rms_ampere\": to_float(current.get(\"rmsAmpere\")),\n", + " \"current_max_ampere\": to_float(current.get(\"maxAmpere\")),\n", + " \"current_min_ampere\": to_float(current.get(\"minAmpere\")),\n", + " \"vibration_acceleration_g\": to_float(vibration.get(\"accelerationG\")),\n", + " \"vibration_score\": to_float(vibration.get(\"vibrationScore\")),\n", + " \"vibration_rms\": to_float(vibration.get(\"vibrationRms\")),\n", + " \"vibration_peak\": to_float(vibration.get(\"vibrationPeak\")),\n", + " \"robot_axis\": robot.get(\"axis\", np.nan),\n", + " \"robot_frequency_hz\": to_float(robot.get(\"frequencyHz\")),\n", + " \"robot_amplitude\": to_float(robot.get(\"amplitude\")),\n", + " \"robot_vibration_score\": to_float(robot.get(\"vibrationScore\")),\n", + " \"thermal_score\": to_float(thermal.get(\"thermalScore\")),\n", + " \"avg_temperature\": to_float(thermal.get(\"avgTemperature\")),\n", + " \"max_temperature\": to_float(thermal.get(\"maxTemperature\")),\n", + " \"min_temperature\": to_float(thermal.get(\"minTemperature\")),\n", + " \"cycle_time_sec\": to_float(metrics.get(\"cycleTimeSec\")),\n", + " \"waiting_time_sec\": to_float(metrics.get(\"waitingTimeSec\")),\n", + " \"processing_time_sec\": to_float(metrics.get(\"processingTimeSec\")),\n", + " \"station_delay_sec\": to_float(metrics.get(\"stationDelaySec\")),\n", + " \"throughput_per_min\": to_float(metrics.get(\"throughputPerMin\")),\n", + " \"queue_length\": to_float(metrics.get(\"queueLength\")),\n", + " \"wip_count\": to_float(metrics.get(\"wipCount\")),\n", + " \"equipment_idle_time_sec\": to_float(metrics.get(\"equipmentIdleTimeSec\")),\n", + " \"ford_row_id\": to_int(trace.get(\"fordRowId\")),\n", + " \"forming_row_id\": to_int(trace.get(\"formingRowId\")),\n", + " \"robot_arm_vibration_row_id\": to_int(trace.get(\"robotArmVibrationRowId\")),\n", + " \"machine_vision_row_id\": to_int(trace.get(\"machineVisionRowId\")),\n", + " \"bosch_id\": to_int(trace.get(\"boschId\")),\n", + " \"press_count_increase_yn\": int(bool(press.get(\"countIncreaseYn\", False))),\n", + " \"press_target_cycle_time_sec\": to_float(press.get(\"targetCycleTimeSec\")),\n", + " \"press_timestamp_delay_sec\": to_float(press.get(\"timestampDelaySec\")),\n", + " \"body_robot_motion_status\": body.get(\"robotMotionStatus\", np.nan),\n", + " \"body_robot_operation_mode\": body.get(\"robotOperationMode\", np.nan),\n", + " \"body_frequency_peak_band\": body.get(\"frequencyPeakBand\", np.nan),\n", + " \"body_frequency_band_max\": float(np.nanmax(band_values)) if band_values else np.nan,\n", + " \"body_frequency_band_mean\": float(np.nanmean(band_values)) if band_values else np.nan,\n", + " \"paint_image_position\": paint.get(\"imagePosition\", np.nan),\n", + " \"paint_thermal_std_temp\": to_float(paint.get(\"thermalStdTemp\")),\n", + " \"paint_thickness_value\": to_float(paint.get(\"thicknessValue\")),\n", + " \"paint_defect_score\": to_float(paint.get(\"defectScore\")),\n", + " \"paint_vision_label\": paint.get(\"visionLabel\", np.nan),\n", + " \"paint_surface_quality_score\": to_float(paint.get(\"surfaceQualityScore\")),\n", + " \"assembly_expected_sequence\": expected_sequence,\n", + " \"assembly_actual_sequence\": actual_sequence,\n", + " \"assembly_missing_part_count\": to_int(assembly.get(\"missingPartCount\")),\n", + " \"assembly_fastening_error_count\": to_int(assembly.get(\"fasteningErrorCount\")),\n", + " \"assembly_sequence_error_count\": to_int(assembly.get(\"sequenceErrorCount\")),\n", + " \"assembly_sequence_mismatch_yn\": sequence_mismatch(expected_sequence, actual_sequence),\n", + " \"defect_yn\": int(row[\"defect_yn\"]),\n", + " \"defect_reason\": row.get(\"defect_reason\", \"\"),\n", + " }\n", + "\n", + "\n", + "def flatten_event_df(raw_df: pd.DataFrame) -> pd.DataFrame:\n", + " return pd.DataFrame([flatten_event_row(row) for _, row in raw_df.iterrows()])\n", + "\n", + "defect_train = flatten_event_df(defect_train_raw)\n", + "defect_test = flatten_event_df(defect_test_raw)\n", + "print(defect_train.shape, defect_test.shape)\n", + "display(pd.crosstab(defect_train[\"process_code\"], defect_train[\"defect_yn\"], normalize=\"index\"))\n", + "display(defect_train.head())" + ] + }, + { + "cell_type": "markdown", + "id": "56fa8462", + "metadata": { + "id": "56fa8462" + }, + "source": [ + "## 3. 모델 학습/평가 helper 함수" + ] + }, + { + "cell_type": "markdown", + "id": "e7c30ce8", + "metadata": { + "id": "e7c30ce8" + }, + "source": [ + "**셀 설명**\n", + "\n", + "전처리, class imbalance 보정, threshold 탐색, 혼동행렬, PR/ROC 곡선, feature leakage 점검, 피처 중요도와 데이터 분포 시각화 함수를 정의합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e29b0711", + "metadata": { + "id": "e29b0711" + }, + "outputs": [], + "source": [ + "CONFUSION_INDEX = [\"실제 정상(0)\", \"실제 불량(1)\"]\n", + "CONFUSION_COLUMNS = [\"예측 정상(0)\", \"예측 불량(1)\"]\n", + "CLASS_NAMES = [\"정상\", \"불량\"]\n", + "METRIC_LABELS = {\n", + " \"accuracy\": \"정확도\",\n", + " \"precision\": \"정밀도\",\n", + " \"recall\": \"재현율\",\n", + " \"f1\": \"F1 Score\",\n", + " \"pr_auc\": \"PR-AUC\",\n", + " \"roc_auc\": \"ROC-AUC\",\n", + "}\n", + "\n", + "\n", + "def make_one_hot_encoder():\n", + " try:\n", + " return OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False, min_frequency=10)\n", + " except TypeError:\n", + " return OneHotEncoder(handle_unknown=\"ignore\", sparse=False)\n", + "\n", + "\n", + "def split_feature_types(df: pd.DataFrame, feature_cols: list[str]):\n", + " numeric_cols = [c for c in feature_cols if pd.api.types.is_numeric_dtype(df[c])]\n", + " categorical_cols = [c for c in feature_cols if c not in numeric_cols]\n", + " return numeric_cols, categorical_cols\n", + "\n", + "\n", + "def make_preprocessor(df: pd.DataFrame, feature_cols: list[str], scale_numeric: bool = False):\n", + " numeric_cols, categorical_cols = split_feature_types(df, feature_cols)\n", + " transformers = []\n", + " numeric_steps = [(\"imputer\", SimpleImputer(strategy=\"median\"))]\n", + " if scale_numeric:\n", + " numeric_steps.append((\"scaler\", StandardScaler()))\n", + " if numeric_cols:\n", + " transformers.append((\"num\", Pipeline(numeric_steps), numeric_cols))\n", + " if categorical_cols:\n", + " transformers.append((\"cat\", Pipeline([(\"imputer\", SimpleImputer(strategy=\"most_frequent\")), (\"onehot\", make_one_hot_encoder())]), categorical_cols))\n", + " return ColumnTransformer(transformers=transformers, remainder=\"drop\", verbose_feature_names_out=False)\n", + "\n", + "\n", + "def scale_pos_weight_for(y):\n", + " y = pd.Series(y).astype(int)\n", + " return float((y == 0).sum() / max((y == 1).sum(), 1))\n", + "\n", + "\n", + "def predict_positive_proba(estimator, X):\n", + " return estimator.predict_proba(X)[:, 1]\n", + "\n", + "\n", + "def find_recall_priority_threshold(y_true, proba, min_recall=0.70, min_precision=0.20, beta=2.0):\n", + " precision, recall, thresholds = precision_recall_curve(y_true, proba)\n", + " if len(thresholds) == 0:\n", + " return 0.5\n", + " precision = precision[:-1]\n", + " recall = recall[:-1]\n", + " beta_sq = beta ** 2\n", + " f_beta = (1 + beta_sq) * precision * recall / np.maximum(beta_sq * precision + recall, 1e-12)\n", + " valid = (recall >= min_recall) & (precision >= min_precision)\n", + " if valid.any():\n", + " valid_idx = np.where(valid)[0]\n", + " best_idx = valid_idx[int(np.nanargmax(f_beta[valid_idx]))]\n", + " return float(thresholds[best_idx])\n", + " return float(thresholds[int(np.nanargmax(f_beta))])\n", + "\n", + "def compute_metrics(y_true, proba, threshold):\n", + " pred = (proba >= threshold).astype(int)\n", + " tn, fp, fn, tp = confusion_matrix(y_true, pred, labels=[0, 1]).ravel()\n", + " return {\n", + " \"threshold\": float(threshold),\n", + " \"pr_auc\": float(average_precision_score(y_true, proba)),\n", + " \"roc_auc\": float(roc_auc_score(y_true, proba)),\n", + " \"accuracy\": float(accuracy_score(y_true, pred)),\n", + " \"precision\": float(precision_score(y_true, pred, zero_division=0)),\n", + " \"recall\": float(recall_score(y_true, pred, zero_division=0)),\n", + " \"f1\": float(f1_score(y_true, pred, zero_division=0)),\n", + " \"false_positive_rate\": float(fp / max(fp + tn, 1)),\n", + " \"tn\": int(tn), \"fp\": int(fp), \"fn\": int(fn), \"tp\": int(tp),\n", + " }\n", + "\n", + "\n", + "def metric_summary_table(metrics: dict) -> pd.DataFrame:\n", + " return pd.DataFrame([\n", + " (\"정확도(Accuracy)\", metrics[\"accuracy\"]),\n", + " (\"정밀도(Precision)\", metrics[\"precision\"]),\n", + " (\"재현율(Recall)\", metrics[\"recall\"]),\n", + " (\"F1 Score\", metrics[\"f1\"]),\n", + " (\"ROC-AUC\", metrics[\"roc_auc\"]),\n", + " (\"PR-AUC\", metrics[\"pr_auc\"]),\n", + " (\"오탐률(False Positive Rate)\", metrics[\"false_positive_rate\"]),\n", + " (\"임계값(Threshold)\", metrics[\"threshold\"]),\n", + " ], columns=[\"지표\", \"값\"])\n", + "\n", + "\n", + "def confusion_matrix_table(metrics: dict) -> pd.DataFrame:\n", + " return pd.DataFrame(\n", + " [[metrics[\"tn\"], metrics[\"fp\"]], [metrics[\"fn\"], metrics[\"tp\"]]],\n", + " index=CONFUSION_INDEX,\n", + " columns=CONFUSION_COLUMNS,\n", + " )\n", + "\n", + "\n", + "def display_confusion_matrix_report(y_true, proba, threshold, title):\n", + " metrics = compute_metrics(y_true, proba, threshold)\n", + " cm_table = confusion_matrix_table(metrics)\n", + " metric_table = metric_summary_table(metrics)\n", + " print(f\"재현율(Recall): {metrics['recall']:.4f}\")\n", + " print(f\"정밀도(Precision): {metrics['precision']:.4f}\")\n", + " print(f\"F1 Score: {metrics['f1']:.4f}\")\n", + " print(f\"PR-AUC: {metrics['pr_auc']:.4f}\")\n", + " print(f\"임계값(Threshold): {metrics['threshold']:.4f}\")\n", + " display(metric_table)\n", + " display(cm_table)\n", + " plt.figure(figsize=(4.8, 4.0))\n", + " ax = sns.heatmap(cm_table, annot=True, fmt=\"d\", cmap=\"Blues\", cbar=False, annot_kws={\"size\": 11})\n", + " ax.set_title(title)\n", + " ax.set_xlabel(\"예측값\")\n", + " ax.set_ylabel(\"실제값\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + " return metric_table, cm_table\n", + "\n", + "\n", + "def plot_train_test_confusion(y_train, train_proba, y_test, test_proba, threshold, title_prefix):\n", + " train_metrics = compute_metrics(y_train, train_proba, threshold)\n", + " test_metrics = compute_metrics(y_test, test_proba, threshold)\n", + " tables = {\n", + " \"Train\": confusion_matrix_table(train_metrics),\n", + " \"Test\": confusion_matrix_table(test_metrics),\n", + " }\n", + " fig, axes = plt.subplots(1, 2, figsize=(10, 4.2))\n", + " for ax, (split_name, cm_table) in zip(axes, tables.items()):\n", + " sns.heatmap(cm_table, annot=True, fmt=\"d\", cmap=\"Blues\", cbar=False, ax=ax, annot_kws={\"size\": 11})\n", + " ax.set_title(f\"{title_prefix} {split_name} 혼동행렬\")\n", + " ax.set_xlabel(\"예측값\")\n", + " ax.set_ylabel(\"실제값\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + " return train_metrics, test_metrics\n", + "\n", + "\n", + "def plot_train_test_metric_comparison(train_metrics: dict, test_metrics: dict, title: str):\n", + " rows = []\n", + " for metric_key in [\"accuracy\", \"precision\", \"recall\", \"f1\", \"pr_auc\", \"roc_auc\"]:\n", + " rows.append({\"split\": \"Train\", \"metric\": METRIC_LABELS[metric_key], \"value\": train_metrics[metric_key]})\n", + " rows.append({\"split\": \"Test\", \"metric\": METRIC_LABELS[metric_key], \"value\": test_metrics[metric_key]})\n", + " plot_df = pd.DataFrame(rows)\n", + " plt.figure(figsize=(10, 4.5))\n", + " ax = sns.barplot(data=plot_df, x=\"metric\", y=\"value\", hue=\"split\", palette=[\"#4C78A8\", \"#F28E2B\"])\n", + " ax.set_title(title)\n", + " ax.set_xlabel(\"평가 지표\")\n", + " ax.set_ylabel(\"값\")\n", + " ax.set_ylim(0, 1.05)\n", + " ax.legend(title=\"데이터\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + " display(plot_df.pivot(index=\"metric\", columns=\"split\", values=\"value\").reset_index())\n", + "\n", + "\n", + "def plot_pr_roc_curves(y_true, proba_by_model: dict[str, np.ndarray], title_prefix: str):\n", + " fig, axes = plt.subplots(1, 2, figsize=(12, 4.5))\n", + " for model_name, proba in proba_by_model.items():\n", + " precision, recall, _ = precision_recall_curve(y_true, proba)\n", + " fpr, tpr, _ = roc_curve(y_true, proba)\n", + " axes[0].plot(recall, precision, label=f\"{model_name} (AP={average_precision_score(y_true, proba):.3f})\")\n", + " axes[1].plot(fpr, tpr, label=f\"{model_name} (AUC={roc_auc_score(y_true, proba):.3f})\")\n", + " axes[0].set_title(f\"{title_prefix} PR 곡선\")\n", + " axes[0].set_xlabel(\"재현율\")\n", + " axes[0].set_ylabel(\"정밀도\")\n", + " axes[0].legend()\n", + " axes[1].plot([0, 1], [0, 1], linestyle=\"--\", color=\"gray\", linewidth=1)\n", + " axes[1].set_title(f\"{title_prefix} ROC 곡선\")\n", + " axes[1].set_xlabel(\"False Positive Rate\")\n", + " axes[1].set_ylabel(\"True Positive Rate\")\n", + " axes[1].legend()\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "def plot_probability_distribution(y_true, proba, threshold, title):\n", + " plot_df = pd.DataFrame({\"actual\": pd.Series(y_true).map({0: \"정상\", 1: \"불량\"}), \"probability\": proba})\n", + " plt.figure(figsize=(9, 4.5))\n", + " ax = sns.histplot(data=plot_df, x=\"probability\", hue=\"actual\", bins=30, kde=True, stat=\"density\", common_norm=False)\n", + " ax.axvline(threshold, color=\"#D62728\", linestyle=\"--\", linewidth=1.5, label=f\"Threshold={threshold:.3f}\")\n", + " ax.set_title(title)\n", + " ax.set_xlabel(\"불량 예측 확률\")\n", + " ax.set_ylabel(\"밀도\")\n", + " ax.legend()\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "def plot_class_distribution(train_df, test_df, target_col, title_prefix):\n", + " label_map = {0: \"정상\", 1: \"불량\"}\n", + " rows = []\n", + " for split_name, df in [(\"Train\", train_df), (\"Test\", test_df)]:\n", + " counts = df[target_col].astype(int).value_counts().sort_index()\n", + " total = counts.sum()\n", + " for label, count in counts.items():\n", + " rows.append({\"split\": split_name, \"label\": label_map.get(int(label), str(label)), \"count\": int(count), \"ratio\": float(count / total)})\n", + " summary = pd.DataFrame(rows)\n", + " fig, axes = plt.subplots(1, 2, figsize=(11, 4))\n", + " sns.barplot(data=summary, x=\"split\", y=\"count\", hue=\"label\", ax=axes[0], palette=[\"#4C78A8\", \"#F28E2B\"])\n", + " axes[0].set_title(f\"{title_prefix} 클래스 건수\")\n", + " axes[0].set_xlabel(\"데이터\")\n", + " axes[0].set_ylabel(\"건수\")\n", + " sns.barplot(data=summary, x=\"split\", y=\"ratio\", hue=\"label\", ax=axes[1], palette=[\"#4C78A8\", \"#F28E2B\"])\n", + " axes[1].set_title(f\"{title_prefix} 클래스 비율\")\n", + " axes[1].set_xlabel(\"데이터\")\n", + " axes[1].set_ylabel(\"비율\")\n", + " axes[1].set_ylim(0, 1)\n", + " plt.tight_layout()\n", + " plt.show()\n", + " display(summary)\n", + "\n", + "\n", + "def plot_feature_distribution_grid(df: pd.DataFrame, feature_cols: list[str], target_col: str, title: str, max_features: int = 24):\n", + " numeric_cols = [c for c in feature_cols if c in df.columns and pd.api.types.is_numeric_dtype(df[c])]\n", + " if not numeric_cols:\n", + " print(f\"{title}: 시각화할 수치형 feature가 없습니다.\")\n", + " return\n", + " scored = []\n", + " for col in numeric_cols:\n", + " auc = single_feature_auc(df, col, target_col)\n", + " if not np.isnan(auc):\n", + " scored.append((col, auc))\n", + " selected_cols = [col for col, _ in sorted(scored, key=lambda item: item[1], reverse=True)[:max_features]]\n", + " if not selected_cols:\n", + " selected_cols = numeric_cols[:max_features]\n", + " ncols = 4\n", + " nrows = int(np.ceil(len(selected_cols) / ncols))\n", + " fig, axes = plt.subplots(nrows, ncols, figsize=(16, max(3, nrows * 2.4)))\n", + " axes = np.array(axes).reshape(-1)\n", + " plot_df = df.copy()\n", + " plot_df[\"_label\"] = plot_df[target_col].astype(int).map({0: \"정상\", 1: \"불량\"})\n", + " for ax, col in zip(axes, selected_cols):\n", + " sns.histplot(data=plot_df, x=col, hue=\"_label\", bins=25, stat=\"density\", common_norm=False, element=\"step\", ax=ax)\n", + " ax.set_title(col, fontsize=9)\n", + " ax.set_xlabel(\"\")\n", + " ax.set_ylabel(\"\")\n", + " for ax in axes[len(selected_cols):]:\n", + " ax.axis(\"off\")\n", + " fig.suptitle(title, fontsize=14, y=1.01)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "def plot_numeric_correlation_heatmap(df: pd.DataFrame, feature_cols: list[str], title: str, max_features: int = 18):\n", + " numeric_cols = [c for c in feature_cols if c in df.columns and pd.api.types.is_numeric_dtype(df[c])]\n", + " if len(numeric_cols) < 2:\n", + " print(f\"{title}: 상관관계를 계산할 수치형 feature가 부족합니다.\")\n", + " return\n", + " selected_cols = numeric_cols[:max_features]\n", + " corr = df[selected_cols].corr(numeric_only=True)\n", + " plt.figure(figsize=(11, 8))\n", + " sns.heatmap(corr, cmap=\"coolwarm\", center=0, linewidths=0.3, cbar_kws={\"shrink\": 0.8})\n", + " plt.title(title)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "def transformed_feature_names(pipeline):\n", + " return pipeline.named_steps[\"preprocess\"].get_feature_names_out().tolist()\n", + "\n", + "\n", + "def model_feature_importance(pipeline) -> pd.DataFrame:\n", + " feature_names = transformed_feature_names(pipeline)\n", + " model = pipeline.named_steps[\"model\"]\n", + " if hasattr(model, \"feature_importances_\"):\n", + " values = np.asarray(model.feature_importances_, dtype=float)\n", + " elif hasattr(model, \"coef_\"):\n", + " values = np.abs(np.asarray(model.coef_).reshape(-1))\n", + " else:\n", + " return pd.DataFrame(columns=[\"feature\", \"importance\"])\n", + " if len(values) != len(feature_names):\n", + " return pd.DataFrame(columns=[\"feature\", \"importance\"])\n", + " importance = pd.DataFrame({\"feature\": feature_names, \"importance\": values})\n", + " importance = importance.groupby(\"feature\", as_index=False)[\"importance\"].sum()\n", + " importance = importance.sort_values(\"importance\", ascending=False).reset_index(drop=True)\n", + " total = importance[\"importance\"].sum()\n", + " if total > 0:\n", + " importance[\"importance_ratio\"] = importance[\"importance\"] / total\n", + " else:\n", + " importance[\"importance_ratio\"] = 0.0\n", + " return importance\n", + "\n", + "\n", + "def plot_model_feature_importance(importance_df: pd.DataFrame, title: str, top_n: int = 25):\n", + " if importance_df.empty:\n", + " print(f\"{title}: 표시할 feature importance가 없습니다.\")\n", + " return\n", + " plot_df = importance_df.head(top_n).sort_values(\"importance\", ascending=True)\n", + " plt.figure(figsize=(10, max(5, top_n * 0.28)))\n", + " ax = sns.barplot(data=plot_df, x=\"importance\", y=\"feature\", palette=\"viridis\")\n", + " ax.set_title(title)\n", + " ax.set_xlabel(\"중요도\")\n", + " ax.set_ylabel(\"Feature\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + " display(importance_df.head(top_n))\n", + "\n", + "\n", + "def single_feature_auc(df: pd.DataFrame, feature_col: str, target_col: str) -> float:\n", + " y = df[target_col].astype(int)\n", + " x = df[feature_col]\n", + " if y.nunique() < 2 or x.nunique(dropna=True) < 2:\n", + " return np.nan\n", + " if pd.api.types.is_numeric_dtype(x):\n", + " encoded = pd.to_numeric(x, errors=\"coerce\")\n", + " encoded = encoded.fillna(encoded.median())\n", + " else:\n", + " filled = x.astype(\"string\").fillna(\"__MISSING__\")\n", + " encoded = filled.map(y.groupby(filled).mean()).astype(float)\n", + " try:\n", + " auc = roc_auc_score(y, encoded)\n", + " return float(max(auc, 1.0 - auc))\n", + " except Exception:\n", + " return np.nan\n", + "\n", + "\n", + "def drop_suspicious_features(df: pd.DataFrame, target_col: str, feature_cols: list[str], *, context: str, max_single_feature_auc: float = 0.985) -> list[str]:\n", + " rows = []\n", + " for col in feature_cols:\n", + " auc = single_feature_auc(df, col, target_col)\n", + " if not np.isnan(auc):\n", + " rows.append({\"feature\": col, \"single_feature_auc\": auc})\n", + " audit = pd.DataFrame(rows).sort_values(\"single_feature_auc\", ascending=False)\n", + " suspicious = audit[audit[\"single_feature_auc\"] >= max_single_feature_auc][\"feature\"].tolist() if not audit.empty else []\n", + " if not audit.empty:\n", + " print(f\"{context} 단일 feature 예측력 상위 10개\")\n", + " display(audit.head(10))\n", + " if suspicious:\n", + " print(f\"{context}에서 과도하게 정답을 설명하는 feature를 제외합니다:\", suspicious)\n", + " kept = [col for col in feature_cols if col not in suspicious]\n", + " if not kept:\n", + " raise ValueError(f\"{context}: suspicious feature 제거 후 남은 feature가 없습니다.\")\n", + " return kept\n", + "\n", + "\n", + "def select_model_features(df: pd.DataFrame, target_col: str, exclude_cols: list[str], leakage_cols: list[str] | None = None, *, context: str) -> list[str]:\n", + " leakage_cols = leakage_cols or []\n", + " excluded = set(exclude_cols) | set(leakage_cols) | {target_col}\n", + " feature_cols = [c for c in df.columns if c not in excluded]\n", + " if target_col in feature_cols:\n", + " raise ValueError(f\"{context}: target column leaked into features: {target_col}\")\n", + " leaked = sorted(set(feature_cols) & set(leakage_cols))\n", + " if leaked:\n", + " raise ValueError(f\"{context}: leakage columns leaked into features: {leaked}\")\n", + " if not feature_cols:\n", + " raise ValueError(f\"{context}: 학습에 사용할 feature가 없습니다.\")\n", + " present_excluded = sorted((set(df.columns) & set(leakage_cols)) - {target_col})\n", + " if present_excluded:\n", + " print(f\"{context} 정답 유출 방지 제외 컬럼: {present_excluded}\")\n", + " return feature_cols\n", + "\n", + "\n", + "def ensure_feature_columns_exist(df: pd.DataFrame, feature_cols: list[str], *, context: str) -> None:\n", + " missing_cols = [c for c in feature_cols if c not in df.columns]\n", + " if missing_cols:\n", + " raise ValueError(f\"{context}: test 데이터에 없는 feature 컬럼이 있습니다: {missing_cols}\")\n", + "\n", + "\n", + "def risk_grade(proba):\n", + " if proba >= 0.75:\n", + " return \"HIGH\"\n", + " if proba >= 0.45:\n", + " return \"MEDIUM\"\n", + " return \"LOW\"" + ] + }, + { + "cell_type": "markdown", + "id": "9065dfd2", + "metadata": { + "id": "9065dfd2" + }, + "source": [ + "## 4. 불량 탐지 모델 학습" + ] + }, + { + "cell_type": "markdown", + "id": "41ceb1ad", + "metadata": { + "id": "41ceb1ad" + }, + "source": [ + "**셀 설명**\n", + "\n", + "불량 탐지 모델 4종을 바로 고정 파라미터로 학습하지 않고, 먼저 Stratified K-Fold 교차검증으로 하이퍼파라미터 후보를 비교합니다. CV는 train 데이터 일부를 층화 샘플링해 수행하므로 Colab 런타임 부담을 줄이면서도 class imbalance 상황에서 PR-AUC, Recall 재현율, F1을 기준으로 모델별 최적 파라미터를 고릅니다.\n", + "\n", + "선택된 파라미터로 전체 train 데이터를 다시 학습한 뒤 test 데이터에서 최종 성능을 계산합니다. 결과는 모델별 표와 시각화로 확인합니다.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "01df8624", + "metadata": { + "id": "01df8624", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "460ddb84-96d7-419c-8232-9f6801e60ece" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "불량 탐지 정답 유출 방지 제외 컬럼: ['assembly_actual_sequence', 'assembly_expected_sequence', 'assembly_fastening_error_count', 'assembly_missing_part_count', 'assembly_sequence_error_count', 'assembly_sequence_mismatch_yn', 'body_robot_motion_status', 'bosch_id', 'defect_reason', 'ford_row_id', 'forming_row_id', 'machine_vision_row_id', 'operation_status', 'paint_defect_score', 'paint_surface_quality_score', 'paint_vision_label', 'press_count_increase_yn', 'press_timestamp_delay_sec', 'robot_arm_vibration_row_id']\n", + "불량 탐지 단일 feature 예측력 상위 10개\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " feature single_feature_auc\n", + "22 station_delay_sec 0.598710\n", + "26 equipment_idle_time_sec 0.598709\n", + "12 robot_frequency_hz 0.587136\n", + "14 robot_vibration_score 0.587136\n", + "8 vibration_score 0.587136\n", + "21 processing_time_sec 0.571561\n", + "10 vibration_peak 0.567340\n", + "4 current_rms_ampere 0.563096\n", + "5 current_max_ampere 0.562935\n", + "28 paint_thermal_std_temp 0.561908" + ], + "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", + "
featuresingle_feature_auc
22station_delay_sec0.598710
26equipment_idle_time_sec0.598709
12robot_frequency_hz0.587136
14robot_vibration_score0.587136
8vibration_score0.587136
21processing_time_sec0.571561
10vibration_peak0.567340
4current_rms_ampere0.563096
5current_max_ampere0.562935
28paint_thermal_std_temp0.561908
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"display(event_model_result_table)\",\n \"rows\": 10,\n \"fields\": [\n {\n \"column\": \"feature\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 10,\n \"samples\": [\n \"current_max_ampere\",\n \"equipment_idle_time_sec\",\n \"processing_time_sec\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"single_feature_auc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.014787816104544944,\n \"min\": 0.5619084321068056,\n \"max\": 0.5987104531222494,\n \"num_unique_values\": 9,\n \"samples\": [\n 0.562934865948325,\n 0.5987092717698705,\n 0.567339779321555\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "불량 탐지 feature 수: 35\n", + "불량 탐지 feature: ['process_code', 'station_code', 'equipment_code', 'equipment_type', 'current_rms_ampere', 'current_max_ampere', 'current_min_ampere', 'vibration_acceleration_g', 'vibration_score', 'vibration_rms', 'vibration_peak', 'robot_axis', 'robot_frequency_hz', 'robot_amplitude', 'robot_vibration_score', 'thermal_score', 'avg_temperature', 'max_temperature', 'min_temperature', 'cycle_time_sec', 'waiting_time_sec', 'processing_time_sec', 'station_delay_sec', 'throughput_per_min', 'queue_length', 'wip_count', 'equipment_idle_time_sec', 'press_target_cycle_time_sec', 'body_robot_operation_mode', 'body_frequency_peak_band', 'body_frequency_band_max', 'body_frequency_band_mean', 'paint_image_position', 'paint_thermal_std_temp', 'paint_thickness_value']\n", + "불량 탐지 scale_pos_weight: 3.841\n", + "튜닝 설정: enabled=True, folds=3, trials=3, max_rows=12000\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABDsAAAGACAYAAACjhmkzAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZYlJREFUeJzt3XlcVdX+//H3OXCYFJzBCQXNMi1nU9HCHCoLs3K8VmpfTTIszUpzqmuldtVK00xNUatbomY2WLcuDlj2K8VrVjdzCBwLyJgF4QDn94dfztfjYZ4OHF7Px8PHjbXXWvuzz+3Ip89ee22DxWKxCAAAAAAAwEkYHR0AAAAAAABARaLYAQAAAAAAnArFDgAAAAAA4FQodgAAAAAAAKdCsQMAAAAAADgVih0AAAAAAMCpUOwAAAAAAABOhWIHAAAAAABwKhQ7AAAAAACAU6HYATiJv/76S+3bt1dmZmahfSIiIjR58mS79qVLl+qGG26w+9OvXz9dvHjR2m/ixInauXNnsbH89NNP6t69e4Fzvv/++9Z+69at05w5c+zGWywW5eTk2P25VnR0tAYNGlRsPJK0du3aAuO5+k+nTp1KdH3X6ty5s5KSkiRJ9957r44cOVLsmDFjxmjPnj2lPpckTZ48ucD4+/btqwsXLlj7rV69Ws8//3yx81ksFt1222369ddfyxQPAKBmI4comjPlEHfccYcOHz5s1z5v3jytXr3a+vPOnTs1ceLEAueIj4/XihUr9OCDDyooKEg33XSTunXrpjvvvFOzZ8/W//t//69MsQEVzdXRAQCoGHl5ebJYLOrSpUuR/fr162fX9swzz+ipp56ymy84OFinT59W48aNJUnZ2dkym83FxnLq1Cm1atVK27Ztszvm6vp/f+1kZWUpOzvbrs+6dev02muv2bW7ublp3bp16tOnjzWegsYXZPLkyYX+0s73yiuv6D//+Y/uu+8+a1tUVJRdcmcymfTss89q/PjxkqTLly9bE6mSxJSWlqaff/65RHEXZM2aNcrLy7Npu3jxooKDg20SusI+32v9+9//Vnx8vOLi4tS+ffsyxwUAqJnIIYrmTDlEYcWfnJwc5ebmWn82m80FxvL777/r/vvvV+/evTVlyhS1adNG3t7eysrK0vnz5/X1118rLCxMzz33nEaNGlXmOIGKQLEDcDLR0dHy9PQs8FhERESBdwIMBoNNApHPZDLZ/OKTpH/961+KiYlR3bp1FRYWVuB5LBaLTCZTgXOWRGhoqEJDQ23akpKS1Lt3b9WrV69McxZ2jdKVeLOysmQ2m+Xm5mZz7LbbbtOPP/5o0/bGG2/o6NGjZYpDknbt2qWcnBxt3LhRAwYMKPV4o9Eoo9F2Yd5///tfNWvWTK1bty7VXBcuXNCLL76o0aNH68UXX9SNN94oPz+/UscEAKj5yCEK5kw5RHkdOHBAfn5+WrFihU27t7e3GjdurC5dushkMunzzz+n2AGHo9gBOAmDwSDpSiXe29u7wD5F3VGxWCw2SUleXp6ys7Pl4uJi0+/8+fPKzs4uNmFIT0/X999/bzNXVlaWbrvtNnl4eJTomq72+eef64YbblCHDh1KPVaSIiMjNXfuXOvPeXl5MpvNysnJUV5entzc3JSTk6NHH33UZpzBYJC7u7tNm4eHhywWS5niyMjI0Lp16/TCCy9ow4YN2r59u0aMGFGmua4WHh5e6nkOHTqkZ555RiEhIXruuee0bt06jRo1Sm+++aZuuummcscEAKgZyCGK5uw5RGl06dJFr7zyij7++GPdc889dkWgH3/8UV988YXuuOOOKo0LKAjFDsBJ+Pj4qGnTptblmQUxGo3WZZNXe/vtt/X666/b3YHx8/NTYGCgTdukSZM0cuTIYuP5448/tGzZMpnNZhmNRnl4eKhOnTrq0aOHTaLy6aef6tNPP5V0JRlp27at3Vy5ubnasmWLHnrooWLPW5jbb79d//73v60/GwwGGY1Gubu7W39RP/LII/L19S3zOYqTl5en+fPny9fXV2PGjFG7du0UGhoqX19f3XbbbWWed/PmzTp79qzWrl2r3NzcYpOo33//XRs3btSOHTv01FNPWT/XyZMnq0GDBnr44Yd13333adKkSWrRokWZ4wIA1AzkEEVz5hyitNq1a6fNmzdr3bp1ev311+Xt7W19jCUhIUH+/v566KGHSvT/M1DZKHYATsLNzU1RUVFlGnvixAk9+uijds/cFuTnn3+Wt7e3PDw81L9//0L7tWvXTlu3bi12vpCQEC1atEgGg8Fu+We+zZs3Kzc3V8OHDy92vmtd/QzqtXdXpCtJUP7xs2fPqnnz5srKypLRaJTJZNKlS5e0bds2paWlWcccOHBAAQEBpYojNzdXs2fP1qFDh7R9+3YZDAb16NFDr732mmbMmKEpU6bof/7nf6x310pq586dev3117V+/Xqlpqaqe/fuNsfvv/9+m58///xzzZkzR0OGDNEnn3xiV8wYOXKkevfurWXLlunOO+9USEiIXnnllVLFBACoWcghCuasOcS4ceMKbJ86dWqJxt9000164403JEmpqanKyMiQm5ubfHx8yvz4EVAZ+LcRqOHyl1KW1rWJQV5ennWu9PR0JScn68KFCzp//rzOnz+vsWPHSpISExN19uzZQp/pla7c/bl686u8vDylpaXp4sWLOnv2rEwmk3WTs4KWeF7tt99+0xtvvKHg4OAy/QINDQ3VN998U+L++RuJBQQE6Msvv9TevXv19ttv2ywT7devn+6++26bcQVt2pYvNjZWL7zwguLj47Vp0yabOz/BwcH64IMP9Mwzz2jnzp0aN25cie6GXLp0ScuXL9eHH36oFStWqEePHpKk48ePW/u8/vrrio+Ptxl322236auvviry7pO/v79WrFihxMREJSQkFBsLAKBmIocomrPmEO+884569epl0/bcc88VOeb5559XREREsXNfy83NTT/99FOpxwEVgWIHUMO9/fbbBe46XhJff/21fH191bFjRy1btkybNm2Sh4eH3N3d5enpqcaNG6tZs2YKDAyUyWSSdOU/lov7Rdq+fXudOnVKN998s6Qrz/l6eXmpSZMmatmypQYMGFDkL/Z8CQkJCg0N1aRJk7Rjxw7985//1IMPPliqa9ywYUOp+l8rOztbrVq1KvaO1Z49e9S4cWPde++9Nu3ff/+9Hn30UT3wwANatWqVfHx87Ma2a9dOO3bs0FdffVXg6+Culpubqw8++ECrV69Wy5YttW3btgKX7Rambt26qlu3bon6NmzYUA0bNizx3ACAmoUcomjOlkOUx4IFC2xeZ79mzRqdOnVKy5Yts7bt3LlTH374od59911rW2lXrAIViWIHUMMVtOt4vlGjRunBBx/UsGHDipxjwoQJmjBhQoXF1L59e0VHR+vSpUtydXWVl5eX3SZlxTl//rwmTpyoe+65R1OnTtXgwYM1btw4NWrUSHfddVeFxVpR3Nzc5O7ubvdLvVu3bvrXv/6l5s2bFznexcVFQ4YM0ZAhQ4rsl52drS+//FKzZ89WSEhIqZII7soAAK5GDlE9VFUOUR7XvpHGaDQW2CaJR1lQbfBvIuAkjh07ptGjR9tsTmk2m/XLL79o3rx5kq788hk3blyJnquVriwdvfoVp7169VLLli1LNNbNza3Q52fzDR48WMnJyXbt0dHRmjZtmkaMGGGN9YYbbtDatWv12GOP6eLFi6XeaOzdd9/VkiVLiu334osv2uxzYTAYlJWVpUuXLikrK0sZGRm6cOGCjh8/rlOnThW77NNkMhWbpJSGp6enzR2T0rj2rszV+vbtq9WrV6tz5852x7grAwDOjRyiaM6SQ+TLzs62a8vKyirR7/tPP/1Uc+bMsT66FBkZaT2Wl5en3NxcdevWTU8++WSFFsGAsqDYATiJG2+80e5d7tfauXOntmzZUujxrKwsbd68WV9++aXOnz+vlJQUubm5qUmTJurbt69Gjx6tjh07ljimJ598Ul999VWhbwdxcXHRtGnT1Lt3b2vb6dOnNWXKFL3wwgsKCQmx6d+lSxf985//VHR0dIljyPfwww/r4YcfLrLPvHnz9Ntvv9m0tW/fXnFxcerTp488PT3l7u6upk2bql27drrhhhtKfbepIs2ZM0cDBgzQoEGDStT/2jsw13JxceFuDADUQuQQRXOmHKJ9+/Z69NFH7T5XNze3Eq0MGTp0qIYOHVpknw0bNuj777+n2AGHI6sFapFrXwt3rSeffFIpKSmaNm2aOnbsKB8fH2VlZen8+fPas2ePxo0bp7feeku33HJLic73888/a9WqVYXuuP7qq6/q1KlTNm35m3oVtldE27ZtS7VHRb7o6GhNnTpVly5dKrSPwWDQiy++aNN244036ttvvy31+STJYrEU+5kXFkdJEqBz584pKSmp0OMPPPCALl++XOrzAwBwLXII58ghVq9eXaZ4SuPqFT2AI1HsAJxEYmKihg4dqpSUlEKXIbq6uup//ud/CjxmsVi0f/9+ffjhh+rQoYO13WQyqX379mrfvr1iY2O1d+/eEicqkuTl5VXoagEvL68C79hUxqaYv/zyi2666SatX7++wucuzNtvv61XX3211OMMBoP2799f5BtTSqJ169blGg8AqB3IIYpWG3OIwvz444965JFHCnwUJp+rq6umTZtWKecHSoNiB+AkEhISlJGRoZ9++qlMeywYDAbdfvvtevnll/XEE0+offv28vb2ltls1u+//67du3dr3759WrNmTanmTU9PV1ZWVoHHMjIyqnQ/iKq+0zB58mTra+gqg8FgUGZmZqGfb36f4p57BgDUbuQQxXO2HKKsTp8+rbZt22rr1q2ODgUoFsUOwEn4+vrKy8tLHTp0KPKXv8Fg0JdfflngJmGvv/66Nm/erGXLluncuXNKTU2VyWSyPm+7efNmmzs2xbnhhhv05JNPFvq8raurq5555pkSz3etkmxglu/GG2/U66+/Xmz8/v7++vLLL0sdR/6SUXd39yorLnTu3FmvvPKKFi5cWGS/ffv2qVmzZkX2MZlM7NcBALUUOUTRnDGHKI7JZCowloCAAJ06darYz8JoNOrgwYPy8vKqrBCBYhkshf0NAqDWu3YndQAAgJIghwDgaPwNBKBQJCkAICUlJWns2LGaNGlSifpHR0dr1KhR6tmzpwYPHqyIiIhKjhCofsghADgaa5YBAAAKcfbsWT322GNq0qSJcnJyStQ/LCxMS5YsUXBwsGJiYhQaGqo6derYvQoTAABUHkquAAAAhdiyZYueffZZDRs2rET933vvPY0ePVrBwcGSpDZt2mjevHkKDw+vzDABAMA1KHYAAAAUYubMmbr99ttL3H/v3r0aOHCgTVtQUJBiYmKUkJBQ0eEBAIBC8BhLFTly5IgsFotMJpOjQwEAwOHMZrMMBoO6du3q6FAqTG5urs6dO6c2bdrYtJtMJrVs2VInT56Ur69vmeYmjwAA4IqS5hAUO6qIxWIp9NVZAADUNs74OzE5OVmS5O3tbXfM29tbKSkpZZ47P4/Izs4u8xwAANQmFDuqSP6dmJtvvtnBkQAA4Hg//fSTo0OocDk5OdaihMFgsDlW3uKOyWSSxWLRddddV655AACo6U6dOmX3e7YgFDsAAAAqQP6KjrS0NPn4+NgcK6ittAwGg7y8vMo1BwAANV1JCh0SG5QCAABUCC8vL/n6+io2Ntam3Ww26/z582rdurWDIgMAoPah2AEAAFBBgoKCFBkZadN24MAB+fr6yt/f30FRAQBQ+1DsAAAAKKOnnnpKBw8etP48ceJERUREKCoqSpIUExOjRYsWKTQ01FEhAgBQK7FnBwAAQDHc3Nzk5uZm1x4TE6OkpCTrz9dff72WL1+upUuXasaMGapXr57Gjx+vESNGVGW4AADUegaLM777rRrK33Wet7EAQPWXm5srs9ns6DBqLJPJJBcXlyL78HuxdPi8AKDmII8ou4rMIVjZAQDA/7JYLIqLi1NycrKjQ6nx6tevr6ZNm5Z4x3QAAGo68oiKUVE5BMUOAAD+V36C4uvrKy8vL/5DvQwsFosyMjKUkJAgSWrWrJmDIwIAoGqQR5RPRecQFDsAANCVJaf5CUqjRo0cHU6N5unpKUlKSEiQr69vsctRAQCo6cgjKkZF5hC8jQUAAMn6bK2Xl5eDI3EO+Z8jzywDAGoD8oiKU1E5BMUOAACuwpLTisHnCACojfj9V34V9RlS7AAAAAAAAE6l2hQ79u3bpzFjxqhXr17q0aOHhg4dqvfee09Xvxk3Pj5ejz/+uHr16qW+fftq4cKFys7OtpknOztbixcvVr9+/dSrVy899thjio+Ptzvf1q1bdccdd6hnz54aOXKkoqOj7fpER0dr1KhR6tmzpwYPHqyIiIiKv/AKkpeX5+gQag0+awDlsXr1aoWGhpa4/8cff6yJEydWyLnj4uLUvn17JSYmVsh8AACgapFHlFy12aC0YcOGeu6559SxY0cZjUYdPnxYs2bNUnJysqZOnSqz2axJkybp7rvv1ooVK5SRkaFZs2bp5Zdf1osvvmid5+WXX9Zff/2lXbt2ycvLS2vXrtWkSZO0Y8cOmUwmSdJnn32mDRs2aO3atQoMDNS+ffv0+OOPa/v27WrVqpUk6ezZswoLC9OSJUsUHBysmJgYhYaGqk6dOgoJCXHIZ1QUo9GoVRH7dOHPZEeH4tRaNKmvqaP7OzoMADVYbm6ucnJyStX/2sJ+WeXk5MhisSg3N7dC5gMAAFWLPKLkqk2xo1OnTjY/33LLLXr66af19ttva+rUqYqKilKdOnU0ZcoUSVK9evW0ePFiDRgwQE8//bTq1aunpKQk7dq1S3v27FG9evUkSVOnTtW+ffv09ddfa8CAAZKk9evXa/78+QoMDJQk9e/fXyNGjND777+v5557TpL03nvvafTo0QoODpYktWnTRvPmzdOKFSuqZbFDki78mazTv//l6DAAAAAAAHCoavMYS0HS0tLk5+cnSdq7d6+1WJGvQYMG6tKli7755htJ0v79+9W1a1droSPfwIEDtW/fPklXlt6cOXNGffr0KbRP/vkGDhxo0ycoKEgxMTHW9/4CAAAAAIDqp9qs7MiXl5en+Ph4RUVFKTw8XKtWrZIknTlzRrfffrtd/8DAQJ04cUL33HOPzpw5ozZt2hTYJyoqSpJ0+vRptW7d2u59vYGBgTp9+rSys7Pl4uKic+fO2c1lMpnUsmVLnTx5Ur6+vqW+NovFooyMjFKPK47BYLC+jxhVIzMz02Y/GQA1X1ZWlvLy8pSbm1upyzPz9/3Jzc1VSkqKli9frqioKCUmJqpJkyYaMmSIpk6dKjc3N2t/i8WigwcPatmyZfr1119Vv3593XvvvXriiSfk6vp/v8ovXryof/zjH9q3b5+MRqNuu+02zZ49Ww0bNrQ7d2UvQc3NzVVeXp4yMzML3OvIYrGwYz0AAOWQkpKi1157TVFRUfrrr7/UpEkT3XPPPXriiSeseUS+6OhoLV26VMeOHVP9+vV133336cknn7TLIxYvXqy9e/fKaDQqODhYc+fOteYRNU21KnZs27ZNCxYskNlsVqNGjfTGG2/ohhtukCQlJibKx8fHboy3t7eSk5OtfRo3bmzXx8fHRykpKdY+3t7eBfaxWCxKTU21Jl8F9fP29rbOVVpms1nHjh0r09iieHp6qkOHDhU+LwoXGxurzMxMR4cBoIK5uroqKyurUs+Rk5Oj3NxcXb58WT/88IM8PDy0ZMkS+fn5KSYmRvPnz1fdunU1btw4SVd+d5w7d05z5szRrFmzdP311+vQoUNasGCBMjMzNWPGDElXijUTJkxQ27ZttWHDBrm4uOitt97S1KlTFR4ebu2T/7+XL1+u1OvMyspSTk6OYmJiCu1zbSIGAABK7pdfflHdunX1xhtvqGnTpjp16pRmzpyp+vXr22xKev78ec2ZM0fz589X+/bt9d1332nOnDnKzs62buOQlZWl8ePHq127dnr//ffl4uKiN954Q2FhYfrggw8cdYnlUq2KHSNHjtTIkSOVnJysqKgoTZ8+XatWrVKXLl2sm6EUJL84UVifq+8eFbaZS/44g8Fgnaegu07luZtvMpl03XXXlXl8YbgzVvUCAwNZ2QE4maysLP3+++9yd3eXh4dHpZ3H1dVVLi4u8vDwUHBwsHVvKEny9/fX3/72N33zzTeaPHmypCu/O+Li4vTmm29aVzi2bNlS6enpWr58uaZPny4vLy9t27ZNLi4uWr58ufX3wquvvqoBAwbop59+Us+ePeXu7i5JlX6NV19rq1atrOe92qlTpyr9/AAAOLM+ffrYbM/g6+urv/3tb9q7d69NseP333/XW2+9pVtvvVWSNHToUCUlJem1117Tk08+KS8vL0VERMhoNOr111+35hHLli1TcHCwDh48qFtuuaVqL64CVKtiR7769etr2LBhSk1N1Zo1a7RmzRp5e3srLS3Nrm9qaqp1xYe3t7dSU1OL7OPj41Ngn7S0NBkMBtWtW9e6tDctLc1uNUlBbSVlMBjk5eVVprGoXnhsCHA+RqNRRqNRLi4udo86VvR5JBV6jlatWmnnzp3W40ajUfXr19eAAQOsYyXp/vvv1+LFi3Xy5El169ZNX3/9tYYOHWqzHNXLy0tdunTRjz/+qN69e9ucuzKvMf8cRqNRnp6eBRZWKNQDAFDx/P399dFHH9m01a9fX/3797dpGzZsmBYuXKhff/1V3bp1U1RUlEJCQmx+P7u7u6tLly764YcfKHZUtFatWun999+XJAUEBBS4FDY2NlZDhw6VdOVu+1dffVVgn9atW1vnOXv2rHJzc20SvZiYGDVr1sx698nX11exsbHq3LmztY/ZbNb58+etcwEAUB4Wi0X/+te/tGvXLsXExCg5OVmZmZlq0KCBTb8WLVrYFDqkK28lq1+/vv7668pbuM6fP6/Dhw/r7bfftul3+fJltWzZsnIvBAAAVDnyiKJV62LHd999Z90kNCgoSFu3brUu65WkpKQk/fDDD1q0aJGkK8t4Fi9erJSUFJs3suzevdv67HNAQIAaNGigb7/91rqMJ79PUFCQ9eegoCBFRkbaFDsOHDggX19f+fv7V84FAwBqleXLl+vdd9/Vgw8+qFGjRsnX11ffffed3nnnHZt+hT2CKcnmEZHHH39cd999t12fa99SBgAAaj7yiKJVi1fP5uXl6V//+pf18ZL09HStW7dOW7du1dSpUyVJISEhSkxM1Jo1a5STk6OUlBTNnj1bd9xxh5o3by7pypKdgQMHas6cOUpNTZXZbNabb76ptLQ0DRkyxHq+KVOm6OWXX1ZsbKwkKSoqStu3b9cjjzxi7TNx4kRFRERY3+ISExOjRYsWKTQ0tEo+EwCAc8vOztbGjRu1ZMkSPf3007rtttvUvn17ZWdn2/U9d+6c3capqampSk5Otv4O9PPzU3p6ulq2bGn3p6ANtwEAQM1FHlG8alHsMJvN2rp1qwYPHqxu3bpp4MCBOn78uHbs2KEbb7xR0pWKU3h4uP7zn/+oT58+uvPOO9W0aVMtWLDAZq4XX3xRvr6+uvPOO9WnTx/98MMP2rBhg82O7yNHjtTYsWM1ceJEde/eXa+//rpWrFhhs3no9ddfr+XLl2v58uXq3r27Jk2apAcffFAjRoyomg8FAODU0tLSlJWVpXbt2tm07969265vRkaGPvzwQ5u2Tz/9VI0bN7augOzVq5d27txZ6W9ZAQAAjkceUbxq8RhLfiGjOP7+/lq3bl2Rfby8vPTCCy/ohRdeKLLf+PHjNX78+CL7BAUF2W3uAgBARWjYsKECAgK0cuVKTZs2TZcvX9aGDRuUl5dn17dt27ZavXq1fHx81KtXLx06dEhLlizR7Nmzrc/gjh07Vh988IEmTJigOXPmqEWLFoqLi9M333zDqkQAAJwMeUTxqsXKDgAAagt3d3e5u7vLYDDo7bffVlJSkh544AFNmDBBDRs21Pz5820SFXd3d/n6+mr16tV65513NGDAAC1btkzPPvusxowZY+3XoEEDffDBB/Lz89Ojjz6q4OBgTZ061brxmHTlNbaurq42b2wBAAA1B3lEyRksFovF0UHUBj/99JMk6eabb660c8xetVOnf/+r+I4os4DmjbR46n2ODgNAJbh8+bJiY2MVGBhY4KtSUTrFfZ5V8XvRmfB5AUD1Rh5RcSoqh2BlBwAAAAAAcCoUOwAAAAAAgFOh2AEAAAAAAJwKxQ4AAAAAAOBUKHYAAAAAAACnQrEDAAAAAAA4FYodAAAAAADAqVDsAAAAAAAAToViBwAAAAAAcCoUOwAAqKX+9re/6dChQ3btiYmJ6tq1a4Fjbr/9dv3++++VHRoAAKjmqnse4VolZwEAoAbLy8uT0eiY+wNlOfe5c+c0ZswYm7bLly+rSZMm+te//mVty83NldlsthsfFxenBg0aFDh3dnZ2gWMAAEDBHJVHlPW8zpJHUOwAAKAYRqNRqyL26cKfyVV63hZN6mvq6P6lHufv768DBw7YtP3zn//Up59+WqLxp06dko+PT6nPCwAA7DkijyhrDiE5Tx5BsQMAgBK48GeyTv/+l6PDKJOkpCS98cYbeuWVV0rU/5NPPtGJEyeUkJAgX1/fSo4OAADnRx5R9dizAwAAJ3b58mWFhYWpX79+uv322xUWFqa+ffuqb9+++uWXX+z6Hz16VN9995169eqlFStWFDjn6NGj1bdvX33wwQeVHT4AAHCgmpxHsLIDAAAnlZCQoBkzZsjLy0tHjhzR119/rTfffNN6fNSoUTb909LS9Oyzz+rhhx/W448/rjFjxmjTpk2aMGGCTb+IiAi1bt26Ki4BAAA4SE3PI1jZAQCAk7FYLPrkk080YsQIDRw4UOvXr9fKlSu1cOFCTZw4UadPn7Ybc/r0aY0aNUqdO3fWM888I29vb4WHh+uTTz7R1KlTlZ6eXvUXAgAAqpyz5BGs7AAAwMmEhoYqNzdX69atU/v27SVJHTt21CeffKJt27bJZDLZjXnnnXc0fPhwTZw4UQaDQZLk5+enLVu2aMeOHfLw8KjSawAAAI7hLHkExQ4AAJzM4sWL1ahRI7t2Nzc3Pfjgg9afZ8+ereuuu06S9Pzzzxc4l5ubm83r51566SU1bdq0giMGAADVhbPkERQ7AABwMlcnKL/++qvee+89HTx4UFlZWbJYLKpXr54GDBighx56SN7e3nbjixvj7u5elZcDAACqkLPkEezZAQCAk/rll180fvx4denSRTt27FBUVJT279+vtWvXSpJGjBihlJSUco8BAADOp6bnEazsAACgBFo0qV/jzvnNN9/o9ttv14gRI2zamzdvrqeeekr79+/XDz/8oODg4HKNAQAARavqPKIizlfT8wiKHQAAFCMvL09TR/d32LmNxrItxOzXr582btyoTz/9VIMGDZKnp6ck6c8//9TWrVuVnJysrl27lnsMAAAonKPyiPLkEFLNzyModgAAUIzyJAqOPHeHDh20YcMGvfvuu1q5cqWys7MlSd7e3rr99tu1bds2+fj4lHsMAAAonKPyiPKet6bnERQ7AABwYh06dNDixYsrfQwAAHA+NTmPYINSAAAAAADgVCh2AAAAFCE6OlqjRo1Sz549NXjwYEVERBQ7ZsuWLbr33nvVs2dPDRgwQP/4xz+UkZFRBdECAACJYgcAAEChzp49q7CwMIWFhenQoUNau3at1q9fr88++6zQMevWrdN7772npUuX6tChQ9q8ebOOHDmi+fPnV2HkAADUbhQ7AAAACvHee+9p9OjR1lfktWnTRvPmzVN4eHihYz7++GNNnz5dN9xwgyTJ399fc+bM0d69e6skZgAAQLEDAACgUHv37tXAgQNt2oKCghQTE6OEhIQCxzRt2lTnzp2zaYuJiVFAQEBlhQkAAK7B21gAAAAKkJubq3PnzqlNmzY27SaTSS1bttTJkyfl6+trN27atGkKDQ2Vn5+f7r77bkVGRmrZsmVauXJlueKxWCzs+wE4MYPB4OgQahWLxVKh82VlZSkvL0+5ubnKzc2t0Llrm9zcXOXl5SkzM1N5eXl2xy0WS4m+L9Wm2HH06FFt3LhR0dHRMpvNatu2rZ5++ml1795dkhQXF6f+/furbt26NuO6du2qt99+2/pzdna2Xn31Ve3atUtms1ldu3bVggUL5OfnZzNu69atWr9+vZKSkhQQEKBZs2apR48eNn2io6O1ZMkSxcbGqn79+po0aZJGjx5dSZ8AAACoTpKTkyVJ3t7edse8vb2VkpJS4LhOnTpp48aNmjJlil577TVdvnxZGzZssD7WUlZms1nHjh0r1xwAqieTyaQOHTrK1dXF0aHUCjk5ufrll//KbDZX6Lyurq7Kysqq0Dlro6ysLOXk5CgmJqbQPm5ubsXOU22KHefOndOQIUO0cOFCeXh4aNu2bQoNDdWuXbvk5+ennJwcGY1GRUdHFznPyy+/rL/++ku7du2Sl5eX1q5dq0mTJmnHjh0ymUySpM8++0wbNmzQ2rVrFRgYqH379unxxx/X9u3b1apVK0n/tyHZkiVLFBwcrJiYGIWGhqpOnToKCQmp9M8DAIDyioyM1I4dO7R69eoCj3/88cfau3evli9fXqp5b731Vm3btk1NmzatgCirr5ycHFkslgLvIBV1R/Ds2bP6+9//rnbt2mno0KHatWuXZs+erUWLFql9+/ZljsdkMum6664r8/jCcDe5alX03WQ4B4PBIFdXF62K2KcLfyY7Ohyn1qJJfU0d3V/t2rWr0O9jVlaWfv/9d7m7u8vDw6PC5nWU3bt366OPPtKqVasKPP7JJ59o3759eu2110o1b//+/bVly5ZicwhXV1e1atVK7u7udsdOnTpVonNVm2LHtQWEMWPG6LPPPtOBAwf0wAMPlGiOpKQk7dq1S3v27FG9evUkSVOnTtW+ffv09ddfa8CAAZKk9evXa/78+QoMDJR05QMfMWKE3n//fT333HOSCt+QbMWKFRQ7AAA1Qk5OTpFLafOXiV5tyJAhunTpkk1bVlaWduzYoRYtWki6sooyJyen4gOuZvJXdKSlpcnHx8fmWEFt0pXVF6Ghofrb3/6mcePGSZKGDh2q7du3a9KkSfr8888LHFcSBoNBXl5eZRpblLy8PBmNbONWFfisUZwLfybr9O9/OTqMWsHT07NC5zMajTIajXJxcZGLS81foZOXl6e8vLxCryX/ZsDVx0uaQ1w77louLi4yGo3y9PQssHBU0iJ9tSl2FKRu3bpKT08vcf/9+/era9eu1kJHvoEDB2rfvn0aMGCA4uLidObMGfXp08euz9y5c63Fjr1792rZsmU2fYKCgjRt2jQlJCQU+IwuAMA5WfJyZTA6JnEp77m/++47a7H/WpcuXVKvXr1s2r744gu7fg888IAuXLhgTVQkKTU1VYmJiapbt26JlpLWRF5eXvL19VVsbKw6d+5sbTebzTp//rxat25tN+a3337Tn3/+qYcfftimfcSIEdq0aZOOHDlivZFSXRiNRu4mV4H8u8kAah9H5RG1PYeotsWO1NRURUdHa+bMmSUec+bMGbtNxCQpMDBQUVFRkqTTp0+rdevWdpWkwMBAnT59WtnZ2XJxcSnThmTFqayNxQwGQ4VXJlG0zMxMlqECTqaojcVcXFz0xxeLlZ14tkpjcmvYSs2GzC7zRmcWi0W33HKL1qxZU+DxHTt2aP/+/cXOn5OTY/1s8j311FNydXXVo48+qqFDh9qNqajNxRwtKChIkZGRNsWOAwcOyNfXV/7+/nb93d3ddfnyZV26dMlmn7G8vDwlJydbH6mtbribDACVx2Cs+jwiP4coK4PBoF69emndunUFHv/www+t/41dlIJWgj711FMymUyaPHmy7r333jLHWJxqW+x46623FBwcbC04GAwG5eXl6f7779eFCxfk4+Ojvn37atq0aWrYsKEkKTExUY0bN7aby8fHx7qJWGJiYoEbjfn4+MhisSg1NdWafJV2Q7LiVNbGYp6enurQoUOFz4vCxcbGKjMz09FhAKhgBW0slr+MMjvxrLISSvaMaEXLzs4usGBQnMaNG+vw4cPq379/gcczMzM1ZswYXb582do2fPhwJSUl2dwU8PHxUdOmTW36rVq1Ss2bN5ckm/Z8FbW5mKNNnDhRDz30kHr06GHdw2vRokUKDQ2VdKWoM3HiRD3//PNq06aNAgMD1a9fPz322GNasGCB2rZtqz///FPLli2Tj4+P3WboAIDawZF5RFk0b95c0dHRuu222wo8npmZqYceesim7e6771ZiYqJNDlGvXj27lZAbNmxQy5YtKz7oa1TLYsfBgwf16aefaseOHda2pk2b6qOPPlLbtm3l6uqqc+fO6fXXX9fkyZO1ZcsWubq6WjcSu9bVd48Ke8Y4f5zBYCjzhmTFYWMx5xEYGMjKDsDJVOeNxcpaFOjWrZsOHTpU4v7Z2dmKjY3V0aNHi12BsGfPHtWvX19dunQp9HdbRWwu5mjXX3+9li9frqVLl2rGjBmqV6+exo8frxEjRkiStaBz9WO3K1asUHh4uMLCwnTx4kX5+PgoODhY77zzTo0o8AAAcPPNN+s///lPiftnZ2frt99+088//1xsDvH555+rQYMG6tq1a6X893G+alfsuHDhgmbMmKFly5bZPCri4uKiG2+80fpz69attWTJEt166636+eef1aVLF3l7eys1NdVuztTUVOtmYD4+PgX2SUtLk8FgUN26da3LdEuzIVlJVNbGYqh6PDYEOJ/qvLFYaeNZt26dNm/eXKoxrVu31qZNmyT936Zkly9fVnJysuLj43X+/HlduHBBEyZMkHRlNUf+I30FxVdRm4tVB0FBQfroo48KPObu7q79+/fbtU2ZMkVTpkypivAAAKgw5c0h8l/nW1QOkZmZKTc3t0rf7LxaFTvS0tIUGhqqKVOmqHfv3sX2d3NzU4sWLRQXFyfpyt32r776yq5fbGysdelMQECAzp49q9zcXJvkLCYmRs2aNbPefSrthmQAAFQXkydP1uTJk+3ad+zYoX379umNN94odGxwcLCGDRsmd3d36yqXBg0aqGnTpja//4YPH14lS1ABAEDVcaYcotoUO8xms6ZOnao+ffrowQcfLNGYtLQ0xcbGqm3btpKkPn36aPHixUpJSbF5I8vu3butr38LCAhQgwYN9O233+rWW2+16RMUFGT9ubQbkgEA4AwK24jsag8//LDq169f+cEAAIAao7rlENWm2DF37lx5enpq9uyCd4w9f/68EhMTddNNN0mSjh8/rpdfflm33nqr2rVrJ0ny9/fXwIEDNWfOHC1evFienp5at26d0tLSNGTIEOtcU6ZM0csvv6w1a9ZY39Syfft2ffDBB9Y+xW1IBgBAdbdz584C38Ry1113SZLS09N19913a86cOXZ9Tp48qe3bt+vo0aNKTEyUm5ub/Pz81L9/f02YMMHmTSMAAMC5OEMOUS2KHWlpafr444/l5eWlW265xeZYr1699Oabb+rSpUt64YUXdObMGZlMJjVt2lT333+/xo4da9P/xRdf1NKlS3XnnXfKbDara9eu2rBhg82GYCNHjlRGRoYmTpyolJQU+fv7a8WKFTaboxS3IRkAANXdfffdp/vuu6/Q41988YW2bt1q1x4dHa0nnnhCM2bM0IQJE9SoUSOZzWadPn1a27dv1wMPPKCPPvpIderUqcToAQCAozhDDlEtih3e3t46fvx4kX1uuOGGQjcHu5qXl5deeOEFvfDCC0X2Gz9+vMaPH19kn6I2JAMA1C5uDVvVuHN+++23mjFjRoGvUpeubMo6atQou/bdu3frrrvu0siRI/8vFjc3dezYUR07dtTdd9+tH374QX379i1XfAAA1BZVnUeQQ1STYgcAANWZJS9XzYYU/JhlVZzbYCzb22FiY2M1YMAALVq0qFTjevfureeff14DBgxQ7969ra+Q++uvv/Thhx8qPT1dHTt2LFNMAADUNo7KI2p7DkGxAwCAYpQ1UXD0uQMDA7V8+XJ99913hfYxGo367LPPbF4PGxwcrFdeeUUffPCBFixYoJycHOvr2W+77TZt27aNDUoBACghR+URtT2HoNgBAICTCgoK0qFDh8o0tk+fPurTp08FRwQAAGoCZ8ghjI4OAAAAAAAAoCJR7AAAAAAAAE6FYgcAAAAAAHAqFDsAALiKxWJxdAhOgc8RAFAb8fuv/CrqM6TYAQCAZH01WkZGhoMjcQ75n2P+5woAgDMjj6g4FZVD8DYWAAAkubi4qH79+kpISJAkeXl5yWAwODiqmsdisSgjI0MJCQmqX7++XFwc99peAACqCnlE+VV0DkGxAwCA/9W0aVNJsiYqKLv69etbP08AAGoD8oiKUVE5BMUOAAD+l8FgULNmzeTr6yuz2ezocGosk8nEig4AQK1DHlF+FZlDUOwAAOAaLi4u/Mc6AAAoE/KI6oENSgEAAAAAgFOh2AEAAAAAAJwKxQ4AAAAAAOBUKHYAAAAAAACnQrEDAAAAAAA4FYodAAAAAADAqVDsAAAAAAAAToViBwAAAAAAcCoUOwAAAAAAgFOh2AEAAAAAAJwKxQ4AAAAAAOBUKHYAAAAAAACnQrEDAAAAAAA4FYodAAAAAADAqVDsAAAAAAAAToViBwAAAAAAcCoUOwAAAAAAgFOh2AEAAAAAAJwKxQ4AAAAAAOBUKHYAAAAAAACnQrEDAAAAAAA4lWpT7Dh69KimT5+ufv36qVevXho7dqwOHz5s0+fUqVMaP368brnlFgUHB2v16tWyWCw2fdLT0/Xcc8+pT58+6tWrl2bOnKm0tDSbPhaLRWvWrFH//v3Vs2dPjRs3TidPnrSLKTIyUkOHDlXPnj01dOhQRUZGVvyFAwAAAACAClVtih3nzp3TkCFD9OWXX+rbb7/Vvffeq9DQUMXHx0uSUlJSNGHCBA0bNkzff/+9tm7dqr1792rdunU280ybNk0eHh7as2eP9u3bJw8PD02fPt2mz7p167Rv3z5FRETo+++/19ChQ/XII48oJSXF2ufw4cP6+9//roULF+rQoUN66aWX9Pzzz9sVYAAAAAAAQPVSbYodISEhuvPOO1WnTh25uLhozJgxat++vQ4cOCBJ2rlzp3r16qUHHnhABoNBfn5+WrRokTZt2qS8vDxJ0q+//qrffvtN8+bNk6enpzw9PTV//nydOHFCx48flyTl5uZq48aNWrRokfz8/GQ0GjVy5Eh1795dn3zyiTWe8PBwPfHEE+rUqZMkqUuXLgoLC9OmTZuq9oMBAAAAAAClUm2KHQWpW7eu0tPTJUl79+7VwIEDbY63a9dO3t7e+vHHHyVJe/bsUXBwsFxdXa19TCaTgoODFRUVJUk6cuSIGjRooDZt2tjMNXDgQO3bt0+SlJ2drQMHDtidb9CgQTpw4IDMZnOFXicAAAAAAKg4rsV3cYzU1FRFR0dr5syZkqQzZ87YFSgkKTAwUCdOnFCXLl105swZdejQocA+v/zyS4nmkaT4+HiZTCY1btzYpo+fn58sFosuXLiggICAUl+TxWJRRkZGqccVx2AwyNPTs8LnReEyMzPt9osBAJScxWKRwWBwdBgAAMBJVdtix1tvvaXg4GBrYSIxMVHe3t52/by9vZWcnGzt4+PjY9fHx8fHuh9HSfokJSUVeK788129t0dpmM1mHTt2rExji+Lp6VlgkQeVJzY2VpmZmY4OAwBqNDc3N0eHAAAAnFS1LHYcPHhQn376qXbs2GFty8nJKfBO+tV3hiqqT1GPqZTnTpTJZNJ1111XprFF4c5Y1QsMDGRlBwCUw6lTpxwdAgAAcGLVrthx4cIFzZgxQ8uWLZOvr6+13dvb2+4VspKUlpZmXanh7e2t1NRUuz6pqanWPj4+PoX2yV/NUVgf6cqrbQtb9VEcg8EgLy+vMo1F9cJjQwBQPhTqAQBAZapWG5SmpaUpNDRUU6ZMUe/evW2OBQQEKDY21m5MbGysWrduLenK3fbi+hQ1T/4+HP7+/srIyNDFixdt+sTFxclsNqtFixZluj4AAFDzREdHa9SoUerZs6cGDx6siIiIYsfk5eXp/fff1/Dhw9WrVy91795dM2bMqIJoAQCAVI2KHWazWVOnTlWfPn304IMP2h0PCgpSZGSkTdvJkyd18eJFdenSRZLUp08fRUVFKScnx2be/fv3KygoSJLUtWtXxcXF6bfffrOZa/fu3dY+Hh4e6tatm935du/erR49evCMMQAAtcTZs2cVFhamsLAwHTp0SGvXrtX69ev12WefFTrGYrFoxowZ2r9/v/7xj3/o+++/18GDB/XMM89UYeQAANRu1abYMXfuXHl6emr27NkFHh87dqy+/fZbffTRR7JYLIqPj9fcuXM1YcIEeXh4SJJ69+6t5s2ba+HChbp8+bIyMzP10ksvqVWrVurRo4ckycvLS+PGjdPcuXOVkJAgi8Wi7du36+DBgxo9erT1fI899phWrlxpfa3t0aNHtWrVKk2ePLmSPwkAAFBdvPfeexo9erSCg4MlSW3atNG8efMUHh5e6JjPP/9c586d06pVq6x7dbm4uKh58+ZVEjMAAKgme3akpaXp448/lpeXl2655RabY7169dKbb76pxo0ba8OGDVq4cKEWLlwoDw8PDR8+XFOnTrXpv2rVKi1cuFDBwcGyWCzq16+fVq5cadPnySef1MqVKzV8+HBlZmaqXbt2Cg8PV6NGjax9+vXrp9mzZ2vWrFlKSEhQkyZNNHfuXOvqDwAA4Pz27t2rZcuW2bQFBQVp2rRpSkhIsNlfLN+2bds0ceJEubpWizQLAIBaqVr8Fvb29tbx48eL7dexY0e9//77RfZp2LChXn311SL7uLi4aPr06Zo+fXqR/UJCQhQSElJsXAAAwPnk5ubq3LlzatOmjU27yWRSy5YtdfLkSbtih8Vi0Q8//GDNM77//nv5+Pjovvvu06RJk2Qymcocj8ViUUZGRpnHF8RgMLDpdhXLzMzkjW6ww3ex6vFdrLlK+obUalHsAAAAqG6Sk5MlqcC3sHl7eyslJcWuPSkpSZmZmXrllVc0efJk/eMf/9Aff/yhWbNmKS4uTgsWLChzPGazWceOHSvz+IJ4enqqQ4cOFTonihYbG6vMzExHh4Fqhu9i1eO7WLOVZB9Nih0AAAAFyMnJkcViKfAOUmF3A7OysiRJw4cP14ABAyRdeRPcK6+8onvuuUdPP/20fHx8yhSPyWSy7gFSUXgFcNULDAzkbjLs8F2senwXa65Tp06VqB/FDgAAgALkr+hIS0uzK1AU1CbJZtP0qwUGBsrb21uxsbHq3LlzmeIxGAzy8vIq01hUHzyqAFQPfBdrrpIWB6vN21gAAACqEy8vL/n6+io2Ntam3Ww26/z582rdurXdmAYNGsjLy8u6wuNqeXl5qlu3bqXFCwAA/g/FDgAAgEIEBQUpMjLSpu3AgQPy9fWVv79/gWNuueUW7dmzx6bt559/liS1atWqcgIFAAA2KHYAAAAUYuLEiYqIiFBUVJQkKSYmRosWLVJoaKikK29smTBhgmJiYqxjJk2apLffflvfffedJOnEiRN67rnnFBYWVq63sQAAgJJjzw4AAIBCXH/99Vq+fLmWLl2qGTNmqF69eho/frxGjBgh6compjExMUpPT7eO6dmzp1588UW9+OKL+uOPP9SgQQM99NBDmjBhgoOuAgCA2odiBwAAQBGCgoL00UcfFXjM3d1d+/fvt2sfMmSIhgwZUtmhAQCAQvAYCwAAAAAAcCoUOwAAAAAAgFOh2AEAAAAAAJwKxQ4AAAAAAOBUKHYAAAAAAACnQrEDAAAAAAA4FYodAAAAAADAqVDsAAAAAAAATqVCix2PPvpoRU4HAABQLuQmAADUTuUudmzdulXx8fGSpG+++UZ5eXnlDgoAAKAikJsAAFA7lavYkZ6erkWLFuny5cuSJIvFUiFBAQAAlNbx48e1Zs0aRUdHW9uuzk2OHDmizZs3a/PmzTpy5IgkaezYsVUeJwAAqHzlKnZs375d7du3V+vWrSVJBoOhQoICAAAojdOnT+tvf/ubDh06pKlTp9oUPPLzk6lTp+r//b//p++++05PPPGEJOno0aMOiRcAAFQu17IOTExM1FtvvaU333yzIuMBAAAotQ8++EB33nmnFi9erK+++krh4eHq0aOHJGnFihWSpJSUFK1Zs0aS1LlzZ4fFCgAAKl+ZVnbk5ORo+vTpGjJkiDWRAAAAcJTo6Gjdd999kqRBgwbpl19+sR6Lj49XfHw8j9sCAFCLlHplR2Jiop577jl5eXnp+eeftzvOoywAAKCqnT9/XgEBAZIko9GoBg0aKDU1VZK0cOFCGY1G7dq1y4ERAgCAqlSqYsdtt92mtLQ06zLRawsbFotFXbp0sT+Jq6sOHz5crkABAAAKc+nSJdWpU8f6c506dZSZmWnThxsyAADUHqUqdqxfv15bt27Vzp07NWjQIA0aNMiuT0REhFxcXGxP4lrmrUEAAACKVadOHWVlZalu3bqSpMuXL8vd3V0SRQ4AAGqjUlUhrr/+es2bN0+33nqrnnnmGdWvX99mzw6DwaDrr79eRmO5XvICAABQKs2aNdO5c+fUqFEjSdLFixfl4+Mj6cqNGEnKzc11WHwAAKBqlakqERwcrKeeekozZ87U5cuXKzomAACAUunevbv27NkjSTp8+LACAwOtN1++/PJLffnll2xQCgBALVLm50vGjh2r/fv3Kzw8XI8//nhFxgQAAFAqDzzwgB566CFdvnxZUVFReuqpp6zHNmzYIKPRqE6dOlnbLBaLXnvtNbtHbwEAgHMo1/MmU6ZM0bvvvqusrKyKigcAAKDUOnbsqGXLlikpKUmTJk3SXXfdJcl2v47777/f+s8zZ85UUlKSZs6cWeWxAgCAyleunUM7d+6se+65R8nJyfLz86uomAAAAEpt4MCBGjhwYKHHFyxYYP3nhx56qCpCAgAADlLu16TMmzfP+s8BAQFsTgoAAKoNchMAAGqnCv3t/8UXX1TkdAAAAOVCbgIAQO1UqpUdn3/+ubKzs0vU99Zbb1WjRo2Uk5Oju+++W1999VWZAgQAACjOunXrSpyjXM3NzU2TJ0+uhIgAAIAjlarYsW3bNrvNSI8cOaKuXbvatBkMBgUGBqpRo0bKy8vT2bNnSzR/UlKSwsLC5OXlpfXr19scu+OOO/Tnn3/a7Jru5uamPXv2yMPDw9q2detWrV+/XklJSQoICNCsWbPUo0cPm7mio6O1ZMkSxcbGqn79+po0aZJGjx5t0yc+Pl4LFizQ4cOH5erqqrvvvlvPPvus3NzcSnQtAACg6pw5c6ZMxQ53d/dKiAYAADhaqYodGzdutPk5JydHN910k95///0ix129E3phzp49q8cee0xNmjRRTk6O3fGcnBy9/fbbdoWLq3322WfasGGD1q5dq8DAQO3bt0+PP/64tm/frlatWlnPExYWpiVLlig4OFgxMTEKDQ1VnTp1FBISIkkym82aNGmS7r77bq1YsUIZGRmaNWuWXn75Zb344ovFXgsAAKhaCxcudHQIAACgGinXnh0Gg6FEhYyS2LJli5599lkNGzaszHOsX79e8+fPV2BgoCSpf//+GjFihE0x5r333tPo0aMVHBwsSWrTpo3mzZun8PBwa5+oqCjVqVNHU6ZMkclkUr169bR48WJ9+umnSklJKXN8AAAAAACg8pX7bSwWi6Ui4rC+537Hjh1lGh8XF6czZ86oT58+Nu0DBw7U3Llz9dxzz0mS9u7dq2XLltn0CQoK0rRp05SQkCBfX1/t3btXAwYMsOnToEEDdenSRd98843uueeeMsUIAAAqx3/+8x/l5uYW2cdgMMjf319+fn5VFBUAAHCUUhU7xowZo7i4OPXu3VsjR45U9+7d9Y9//KOyYiuV06dPq3Xr1jZ7ekhSYGCgTp8+rezsbLm4uOjcuXNq06aNTR+TyaSWLVvq5MmT8vX11ZkzZ3T77bfbnSMwMFAnTpwoc7HDYrEoIyOjTGOLYjAY5OnpWeHzonCZmZkVVugDgNrIYrFU2OpQSZo9e7bMZrNN2x9//KFmzZpZfzabzcrNzdW3335bYecFAADVU6mKHUePHtWSJUv03//+V1OmTFHPnj318ssvV1ZsdhYsWKCLFy/KxcVFN910k6ZPn6727dtLkhITE+Xt7W03xsfHRxaLRampqdakqqB+3t7e1kdUEhMT5ePjU2Cf5OTkMsdvNpt17NixMo8vjKenpzp06FDh86JwsbGxyszMdHQYAFCjVeSm319++aVdW/v27bVnzx7rz3l5efy+BACglij1Yyz33HOPhg4dqtDQUM2fP1/Dhw/Xu+++qxYtWlRGfFZr165Vs2bNVLduXf3111/aunWrHn74Ye3cuVMtWrQocFNT6f8eszEYDMrJyZHFYinwbtLVd+nz+xWkPHehTCaTrrvuujKPL0xF3hlDyQQGBrKyAwDK4dSpU5V+jmt/PxqNRn5nAgBQS5R5z44GDRpo1apVev755/U///M/+vDDD1W3bl1J0sWLF613vS9dulQhgbZr1876z40aNdKUKVN09OhR7dq1S5MnT5aPj49SU1PtxqWlpclgMKhu3brWZ3nT0tLsVm5c3ebt7a20tDS7uVJTUwtc8VFSBoNBXl5eZR6P6oPHhgCgfCg6AACAylSut7FIVx4tad68uc3jLI888ogGDx6swYMH6/7771e3bt3Ke5oCBQYGKi4uTpIUEBCgs2fP2m1OFhMTo2bNmsnd3V1eXl7y9fVVbGysTR+z2azz58+rdevW1rliYmLszhcbG2vtAwAAAAAAqqdyFzsMBoNeeuklff755zp69Kgk6dNPP9Wvv/6qX3/9VceOHdM///nPcgdakB9//FFt27aVdKVA0aBBA7tNx3bv3q2goCDrz0FBQYqMjLTpc+DAAfn6+srf39/aZ/fu3TZ9kpKS9MMPP9i97QUAANQM2dnZjg4BAABUkVIVOzw8PApcdtqyZUuNGTNGb731VoUFdjWz2ay9e/cqKytL0pXXzD7//POKi4vTsGHDrP2mTJmil19+2bpyIyoqStu3b9cjjzxi7TNx4kRFREQoKipK0pWVH4sWLVJoaKi1T0hIiBITE7VmzRrl5OQoJSVFs2fP1h133KHmzZtXyjUCAICyu+mmm3TjjTfa/LFYLDY/d+7cWb6+vo4OFQAAVIFS7dlx5MiRQo9NnTpVp0+fLm88cnNzs9ud3WKx6J133tHMmTNlsVjUqFEj3Xrrrdq2bZt1nxBJGjlypDIyMjRx4kSlpKTI399fK1assNkU9Prrr9fy5cu1dOlSzZgxQ/Xq1dP48eM1YsQIax93d3eFh4frpZdeUp8+feTi4qK77rpLs2bNKvf1AQCAird79+5CNyvPZzAY1KhRoyqKCAAAOFKZNyi9lo+Pjzp16lTueUJCQhQSEmLT5ubmpo0bN5Zo/Pjx4zV+/Pgi+wQFBemjjz4qso+/v7/WrVtXonMCAADH8vPzc3QIAACgGin3nh0AAAAAAADVCcUOAAAAAADgVCh2AAAAAAAAp0KxAwAAAAAAOBWKHQAAAAAAwKlQ7AAAAAAAAE6FYgcAAAAAAHAqFDsAAACKEB0drVGjRqlnz54aPHiwIiIiSjw2NzdXw4cPV6dOnSoxQgAAcC2KHQAAAIU4e/aswsLCFBYWpkOHDmnt2rVav369PvvssxKN37Bhg5o1a6acnJxKjhQAAFyNYgcAAEAh3nvvPY0ePVrBwcGSpDZt2mjevHkKDw8vdmxsbKx27typadOmVXaYAADgGhQ7AAAACrF3714NHDjQpi0oKEgxMTFKSEgodJzFYtG8efM0Z84ceXp6VnaYAADgGq6ODgAAAKA6ys3N1blz59SmTRubdpPJpJYtW+rkyZPy9fUtcOz777+vFi1aqF+/fjp//nyFxGOxWJSRkVEhc+UzGAwUY6pYZmamLBaLo8NANcN3serxXay5LBaLDAZDsf0odgAAABQgOTlZkuTt7W13zNvbWykpKQWOu3DhgjZu3Kht27ZVaDxms1nHjh2r0Dk9PT3VoUOHCp0TRYuNjVVmZqajw0A1w3ex6vFdrNnc3NyK7UOxAwAAoAA5OTmyWCwF3kEq6m7g888/r2nTpqlBgwYVGo/JZNJ1111XoXOW5M4YKlZgYCB3k2GH72LV47tYc506dapE/Sh2AAAAFCB/RUdaWpp8fHxsjhXUJkmffPKJjEajhg4dWuHxGAwGeXl5Vfi8qFo8qgBUD3wXa66SFgcpdgAAABTAy8tLvr6+io2NVefOna3tZrNZ58+fV+vWre3GHDt2TNHR0erRo4e1LS8vT7m5uerRo4cGDRqkV155pUriBwCgNqPYAQAAUIigoCBFRkbaFDsOHDggX19f+fv72/WfNWuWZs2aZdN2/vx53XHHHYqOjq70eAEAwBW8ehYAAKAQEydOVEREhKKioiRJMTExWrRokUJDQyVdeWPLhAkTFBMT48gwAQDANVjZAQAAUIjrr79ey5cv19KlSzVjxgzVq1dP48eP14gRIyRd2cQ0JiZG6enphc5hMpnk7u5eVSEDAABR7AAAAChSUFCQPvroowKPubu7a//+/UWO9/Pz05EjRyojNAAAUAgeYwEAAAAAAE6FYgcAAAAAAHAqFDsAAAAAAIBTodgBAAAAAACcCsUOAAAAAADgVCh2AAAAAAAAp0KxAwAAAAAAOBWKHQAAAAAAwKlQ7AAAAAAAAE6FYgcAAAAAAHAqFDsAAAAAAIBTodgBAAAAAACcCsUOAAAAAADgVKpVsSMpKUljx47VpEmT7I6lp6frueeeU58+fdSrVy/NnDlTaWlpNn0sFovWrFmj/v37q2fPnho3bpxOnjxpN1dkZKSGDh2qnj17aujQoYqMjLTrc+rUKY0fP1633HKLgoODtXr1alksloq7WAAAAAAAUCmqTbHj7NmzevDBB2UymZSTk2N3fNq0afLw8NCePXu0b98+eXh4aPr06TZ91q1bp3379ikiIkLff/+9hg4dqkceeUQpKSnWPocPH9bf//53LVy4UIcOHdJLL72k559/XocPH7b2SUlJ0YQJEzRs2DB9//332rp1q/bu3at169ZV2vUDAAAAAICKUW2KHVu2bNGzzz6rYcOG2R379ddf9dtvv2nevHny9PSUp6en5s+frxMnTuj48eOSpNzcXG3cuFGLFi2Sn5+fjEajRo4cqe7du+uTTz6xzhUeHq4nnnhCnTp1kiR16dJFYWFh2rRpk7XPzp071atXLz3wwAMyGAzy8/PTokWLtGnTJuXl5VXuBwEAAAAAAMql2hQ7Zs6cqdtvv73AY3v27FFwcLBcXV2tbSaTScHBwYqKipIkHTlyRA0aNFCbNm1sxg4cOFD79u2TJGVnZ+vAgQMaOHCgTZ9BgwbpwIEDMpvNkqS9e/fa9WnXrp28vb31448/lus6AQAAAABA5XItvovjnTlzRh06dLBrDwwM1C+//GLtc22hI7/PiRMnJEnx8fEymUxq3LixTR8/Pz9ZLBZduHBBAQEBxc7VpUuXMl2HxWJRRkZGmcYWxWAwyNPTs8LnReEyMzPZwwUAysFischgMDg6DAAA4KRqRLEjMTFRPj4+du0+Pj7W/ThK0icpKUne3t4FnsPb29tmroL6eXt7Kzk5uayXIbPZrGPHjpV5fGE8PT0LLAah8sTGxiozM9PRYQBAjebm5uboEAAAgJOqEcWOnJycAu+iX31XqCR98h9TKUhp5yoLk8mk6667rszjC8OdsaoXGBjIyg4AKIdTp045OgQAAODEakSxw9vbW6mpqXbtqamp1tUcPj4+hfbJX6VRWB/pyqtt8/t5e3vbvdZWktLS0gpcPVJSBoNBXl5eZR6P6oPHhgCgfCjUAwCAylRtNigtSmBgoGJjY+3aY2Nj1bp1a0lSQEBAoX0CAgIkSf7+/srIyNDFixdt+sTFxclsNqtFixbFzpV/PgAAAAAAUD3ViGJHnz59FBUVpZycHGub2WzW/v37FRQUJEnq2rWr4uLi9Ntvv9mM3b17t7WPh4eHunXrpsjISLs+PXr0sD47HBQUZNfn5MmTunjxYpk3JwUAAAAAAFWjRhQ7evfurebNm2vhwoW6fPmyMjMz9dJLL6lVq1bq0aOHJMnLy0vjxo3T3LlzlZCQIIvFou3bt+vgwYMaPXq0da7HHntMK1eutL5C9ujRo1q1apUmT55s7TN27Fh9++23+uijj2SxWBQfH6+5c+dqwoQJ8vDwqNqLBwAAAAAApVLt9uxwc3MrcHf2VatWaeHChQoODpbFYlG/fv20cuVKmz5PPvmkVq5cqeHDhyszM1Pt2rVTeHi4GjVqZO3Tr18/zZ49W7NmzVJCQoKaNGmiuXPnWld/SFLjxo21YcMGLVy4UAsXLpSHh4eGDx+uqVOnVt6FAwAAAACAClHtih0hISEKCQmxa2/YsKFeffXVIse6uLho+vTpmj59epnOcbWOHTvq/fffLzZeAAAAAABQvdSIx1gAAAAAAABKimIHAAAAAABwKhQ7AAAAAACAU6HYAQAAAAAAnArFDgAAAAAA4FQodgAAAAAAAKdCsQMAAAAAADgVih0AAAAAAMCpUOwAAAAAAABOhWIHAAAAAABwKhQ7AAAAAACAU6HYAZRCvbqesuTlOjqMWoHPGQAAAEBZuTo6AKAmqePpJoPRRX98sVjZiWcdHY7TcmvYSs2GzHZ0GAAAAABqKIodQBlkJ55VVsIpR4eBaigvL09GI4vmKhufMwAAAIpCsQMAKpDRaNSqiH268Geyo0NxWi2a1NfU0f0dHQYAAACqMYodAFDBLvyZrNO//+XoMAAAAIBaizXAAAAAAADAqVDsAAAAAAAAToViBwAAAAAAcCoUOwAAAAAAgFOh2AEAAFCE6OhojRo1Sj179tTgwYMVERFRZP+vv/5aoaGhCgoKUu/evTVx4kSdOsXrygEAqEoUOwAAAApx9uxZhYWFKSwsTIcOHdLatWu1fv16ffbZZ4WOOXfunMaNG6c9e/Zo//79uvnmmzV58mRlZGRUYeQAANRuFDsAAAAK8d5772n06NEKDg6WJLVp00bz5s1TeHh4oWPGjh2rvn37ysPDQ25ubpo2bZok6aeffqqSmAEAAMUOAACAQu3du1cDBw60aQsKClJMTIwSEhJKNIfBYFCdOnWUnp5eGSGihqhX11OWvFxHh1Fr8FkDcHV0AAAAANVRbm6uzp07pzZt2ti0m0wmtWzZUidPnpSvr2+x85w+fVq///67evbsWa54LBZLhT8KYzAY5OnpWaFzomB1PN1kMLrojy8WKzvxrKPDcWpuDVup2ZDZyszMlMVicXQ4JcJ3serkFx4NRhdHh+L0LHm5upyVXeHfQ4vFIoPBUGw/ih0AAAAFSE5OliR5e3vbHfP29lZKSkqJ5nnttdf04IMPysfHp1zxmM1mHTt2rFxzXMvT01MdOnSo0DlRtOzEs8pKYMPaqhAbG6vMzExHh1EifBerDoXHqpFfdKys76Gbm1uxfSh2AAAAFCAnJ0cWi6XAO0glvUu1c+dOnThxQq+88kq54zGZTLruuuvKPc/VSnJnDKipAgMDa9TKDlQtCo9VozK+hyV9wxnFDgAAgALkr+hIS0uzW5VRUNu1fv75Zy1dulSbN2+Wl5dXueMxGAwVMg9QW/BYCOB4lfE9LGlxkA1KAQAACuDl5SVfX1/FxsbatJvNZp0/f16tW7cudOwff/yhsLAwvfTSSxW+GgMAABSPYgcAAEAhgoKCFBkZadN24MAB+fr6yt/fv8AxaWlpevTRR/XII49owIABVREmAAC4BsUOAACAQkycOFERERGKioqSJMXExGjRokUKDQ2VdOWNLRMmTFBMTIykK/t8TJ06VT179tSECRMcFTYAALUee3YAAAAU4vrrr9fy5cu1dOlSzZgxQ/Xq1dP48eM1YsQISVeKGzExMUpPT5d0ZdO07777Tj/99JM+/fRTm7nuu+8+zZs3r8qvAQCA2qjGFDuio6P18MMPq06dOjbtd999t1588UVJUnp6ul5++WVFRUUpLy9PwcHBmj9/vs0r4ywWi9auXastW7bo0qVLuvHGGzV//ny1a9fOZt7IyEitWLFCcXFxatq0qaZNm6ZBgwZV/oUCAIBqJSgoSB999FGBx9zd3bV//37rz+3bt9fx48erKjQAAFCIGlPsyM3NVcuWLfXvf/+70D7Tpk2Tv7+/9uzZI0lavHixpk+frg0bNlj7rFu3Tvv27VNERISaNGmiDz/8UI888oh27dqlevXqSZIOHz6sv//971q9erU6deqkH374QY8//rgaNGig7t27V+6FAgAAAACAcnGaPTt+/fVX/fbbb5o3b548PT3l6emp+fPn68SJE9Y7LLm5udq4caMWLVokPz8/GY1GjRw5Ut27d9cnn3xinSs8PFxPPPGEOnXqJEnq0qWLwsLCtGnTJkdcGgAAAAAAKAWnKXbs2bNHwcHBcnX9v8UqJpNJwcHB1k3Fjhw5ogYNGqhNmzY2YwcOHKh9+/ZJkrKzs3XgwAENHDjQps+gQYN04MABmc3myr0QAAAAAABQLjXmMZbinDlzRh06dLBrDwwM1C+//GLtc22hI7/PiRMnJEnx8fEymUxq3LixTR8/Pz9ZLBZduHBBAQEBZYrRYrEoIyOjTGOLYjAY5OnpWeHzAo6WmZkpi8Xi6DBKjO9i1app/37AlsVikcFgcHQYAADASdWYYofBYNDFixcVEhKi+Ph4NWrUSIMGDdKUKVNUp04dJSYmysfHx26cj4+PUlJSJKlEfZKSkmw2NL2at7e3tV9ZmM1mHTt2rMzjC+Pp6VlgoQeo6WJjY5WZmenoMEqM72LVqmn/fsCem5ubo0MAAABOqsYUO26++WZt3bpVgYGBkq682m3RokWaOXOm3nzzTeXk5BR4h+/qO0cl6VPUYyrlvQtlMpl03XXXlXl8YbgzBmcVGBhYo+7c812sWjXt3w/YOnXqlKNDAAAATqzGFDs8PT1tXg/bvn17LV++XEFBQfrzzz/l7e2t1NRUu3GpqanW1Rw+Pj6F9slfzVFYH+nKq20LW/VREgaDQV5eXmUeD9Q2PBKCovDvR81GcRAAAFSmGr1BacOGDVWvXj3FxcUpMDBQsbGxdn1iY2PVunVrSVJAQEChffL34fD391dGRoYuXrxo0ycuLk5ms1ktWrSo+AsBAAAAAAAVpkYXO86ePav09HQFBASoT58+ioqKUk5OjvW42WzW/v37FRQUJEnq2rWr4uLi9Ntvv9nMs3v3bmsfDw8PdevWTZGRkXZ9evTowfPFAAAAAABUczWm2HHixAmdOHFCFotFOTk5io6O1uOPP65x48bJ29tbvXv3VvPmzbVw4UJdvnxZmZmZeumll9SqVSv16NFDkuTl5aVx48Zp7ty5SkhIkMVi0fbt23Xw4EGNHj3aeq7HHntMK1eu1I8//ihJOnr0qFatWqXJkyc75NoBAAAAAEDJ1Zg9O/766y+99NJLiouLk5ubm1q2bKmJEydq2LBh1j6rVq3SwoULFRwcLIvFon79+mnlypU28zz55JNauXKlhg8frszMTLVr107h4eFq1KiRtU+/fv00e/ZszZo1SwkJCWrSpInmzp1rXf0BAAAAAACqrxpT7OjTp48+//zzIvs0bNhQr776apF9XFxcNH36dE2fPr3IfiEhIQoJCSltmAAAAAAAwMFqzGMsAAAAAAAAJUGxAwAAAAAAOBWKHQAAAAAAwKlQ7AAAAAAAAE6FYgcAAAAAAHAqFDsAAAAAAIBTodgBAAAAAACcCsUOAAAAAADgVCh2AAAAAAAAp0KxAwAAAAAAOBWKHQAAAAAAwKlQ7AAAAAAAAE6FYgcAAAAAAHAqFDsAAAAAAIBTodgBAAAAAACcCsUOAAAAAADgVCh2AAAAAAAAp0KxAwAAAAAAOBWKHQAAAAAAwKlQ7AAAAAAAAE6FYgcAAAAAAHAqFDsAADVKvbqesuTlOjqMWoPPGgAA1ESujg4AAIDSqOPpJoPRRX98sVjZiWcdHY5Tc2vYSs2GzHZ0GAAAAKVGsQMAUCNlJ55VVsIpR4cBAACAaojHWAAAAAAAgFOh2AEAAAAAAJwKxQ4AAAAAAOBUKHYAAAAAAACnQrEDAAAAAAA4FYodAAAAAADAqVDsAAAAAAAAToViBwAAAAAAcCoUOwAAAAAAgFOh2FGM6OhojRo1Sj179tTgwYMVERHh6JAAAEAVKksuEBkZqaFDh6pnz54aOnSoIiMjqyBSAACQz9XRAVRnZ8+eVVhYmJYsWaLg4GDFxMQoNDRUderUUUhIiKPDAwAAlawsucDhw4f197//XatXr1anTp30ww8/6PHHH1eDBg3UvXv3Kr4CAABqJ1Z2FOG9997T6NGjFRwcLElq06aN5s2bp/DwcAdHBgAAqkJZcoHw8HA98cQT6tSpkySpS5cuCgsL06ZNm6oiZAAAIIodRdq7d68GDhxo0xYUFKSYmBglJCQ4KCoAAFBVSpsLZGdn68CBA3ZjBg0apAMHDshsNldqvAAA4AoeYylEbm6uzp07pzZt2ti0m0wmtWzZUidPnpSvr2+J5zObzbJYLPrxxx8rOlRJksFgUEiPFsrJbVYp8+MKd5OLfvrpJ+W2GytLmxxHh+O0MlxclfrTT7JYLI4OpdT4LlY+vodVpzK/i2azWQaDocLnrUhlyQXi4+NlMpnUuHFjm3Y/Pz9ZLBZduHBBAQEBpY6lMvMI/t6qGvzdVXVqah7Bd7Fq8F2sGtUhh6DYUYjk5GRJkre3t90xb29vpaSklGq+/P8zKjOx86njUWlzw5aLZ31Hh1ArVPf/ECoM38Wqwfew6lTGd9FgMFT773hZcoGkpKQC+xc1piQqO4/g762qw99dVae6/x1TEL6LVYfvYtVwZA5BsaMQOTk5slgsslgsdh9kWapTXbt2rajQAABAFShLLlDUYyoFzVNS5BEAAJQOe3YUIv+uTFpamt2xtLQ0+fj4VHVIAACgCpUlF/Dx8VFqamqB86Wnpxe66gMAAFQsih2F8PLykq+vr2JjY23azWazzp8/r9atWzsoMgAAUBXKkgv4+/srIyNDFy9etGmPi4uT2WxWixYtKjVmAABwBcWOIgQFBSkyMtKm7cCBA/L19ZW/v7+DogIAAFWltLmAh4eHunXrZjdm9+7d6tGjh9zc3Co1XgAAcAXFjiJMnDhRERERioqKkiTFxMRo0aJFCg0NdXBkAACgKhSXC+Tm5mrChAmKiYmxjnnssce0cuVK65tTjh49qlWrVmny5MlVfwEAANRSBktNeydTFfv222+1dOlSnT17VvXq1dP48eM1fvx4R4cFAACqSFG5QFZWlgYPHqxVq1apU6dO1jGfffaZ3nzzTSUkJKhJkyaaOnWqQkJCHHUJAADUOhQ7AAAAAACAU+ExFgAAAAAA4FQodgAAAAAAAKdCsQMAAAAAADgVih0AAAAAAMCpUOwAAAAAAABOhWIHUA7Z2dkaMWKEjh8/7uhQAABADUIOAQCVi1fPolZ55plntG/fPkmS2WxWTk6OPD09JUkuLi764osv1LBhQwdGCNQ+fC8B1AT8XQVUP3wvURSKHai1duzYoU8++USbNm1ydCgA/ldFfi8/+eQTHTx4UC+//HL5AwOAq5BDANUPOQSuxWMsAACnlJOTo5ycHEeHAQAAahhyCOdAsQP4X3fddZd++OEHjR8/Xj169ND333+vrKwszZ49W7fddpt69OihwYMHKyIiwmZc165dFR8fL0n67rvvNGHCBG3evFn9+/dX9+7dNWLECP3444+OuCSgxsvNzdXrr7+uvn37qlu3bpoyZYoSEhKsxw8ePKj77rtPPXr0UFBQkDZt2qS8vDz169dPCxYs0GeffaYePXooPDzcgVcBwNmRQwDVDzkEXB0dAFBdZGdn69VXX9Wzzz6rTp06yWKxKD09XX379tXcuXNVt25dxcbG6uGHH1anTp104403SpKysrJkNpslSQaDQUePHpWrq6siIiLUpEkTbdmyRY8//rgiIyPl4eHhyEsEapw33nhDX3/9tbZs2aImTZpo1apVmj59ut5//33l5eVp+vTpeu2119S7d29lZ2crPT1dRqNR33zzjXbs2KGDBw/qlVdecfRlAHBy5BBA9UMOAVZ2AFe54YYb1KlTJ0lXkg5vb2+FhISobt26kqTAwED17t1bhw8fLnSOzMxMvfLKK/Lz85PRaNTYsWPl4uKin376qUquAXAWKSkpeuedd7R06VL5+/vLw8NDM2bM0O+//67//ve/Sk5OVlZWlnr06CFJcnNzYxMyAA5DDgFUH+QQkCh2ADZ69uxp17Znzx5NnjxZAwYMULdu3fSvf/1LycnJhc7h6+urxo0b27Q1a9bMukwVQMkcP35cvr6+atu2rbXNaDTqpptu0q+//qqGDRuqd+/eeuyxx3Tq1CkHRgoA5BBAdUIOAYliB2CjQYMGNj/v2rVLs2bNUv/+/fXuu+/q4MGDGjp0qIp6iZG7u7tdm8lkUm5uboXHCziz+Ph4nT9/Xj169LD588033ygtLU2StHLlSt11112aPHmynn76aSUmJjo4agC1FTkEUH2QQ0Bizw7AhtFoW//75z//qaefflpjxoyxtsXFxal58+ZVHRpQ69SpU0ft2rXTzp07C+1jNBo1YsQI3XvvvXrmmWc0c+ZMrV+/vuqCBID/RQ4BVB/kEJBY2QEUKSkpSS1atLD+nJaWpqNHjzowIqD26Nixo06fPq0///yz2L5ubm6aNm2avv/+e2ubq6trkXdQAaAykUMAjkMOAYliB1Ckzp0768MPP1RWVpYSExM1e/Zsm8QFQOXx8/PTwIEDNX36dMXExEiSLl26pKioKElSenq6fvnlF1ksFmVnZ2vLli3q2LGjdXyTJk30yy+/KDs7W6mpqQ65BgC1FzkE4DjkEJAodqAWc3Nzk5ubm83P1z4rO3v2bFksFvXv31/333+/unfvrqFDh9o8O+vu7i6TyWT956vnLOxcAAp27Xdl0aJFuvnmmzV+/Hh17dpVd955p77++mtJV+6ahoWF6eabb1a/fv107tw5vfbaa9ax3bt3V8uWLdWnTx898cQTVX4tAJwXOQRQ/ZBD4FoGC+tzAAAAAACAE2FlBwAAAAAAcCoUOwAAAAAAgFOh2AEAAAAAAJwKxQ4AAAAAAOBUKHYAAAAAAACnQrEDAAAAAAA4FYodAAAAAADAqVDsAFBjxcfHq2fPnnb/nC87O1sLFy5Unz591K1bN02dOlXx8fE2fX7//XfddNNNys3NtZs/NzdXOTk5Nn8sFotNn3Xr1mnOnDkVfGUAAKAykUMAzo9iB4Bq67333tNNN92kG264webPa6+9Jkkym826fPmy3T/ne+655/Trr7/qgw8+UGRkpHx9fTVu3DhlZGRY+5jNZpnNZrsEZOjQoerQoYM6duxo8+f555+36ZeVlaXs7OzKuHwAAFBG5BAAXB0dAAAU5r///a8efPBBPfvsszbtLi4uxY49duyYIiMjtWfPHjVu3FiSNH/+fI0YMULvv/++Jk2aVOjY3NxcnThxQl9++aUCAgLKdQ0AAKDqkUMAYGUHgGrLYrHIZDLJ1dXV5o/BYCh2bGRkpHr27GlNUiTJYDBo6NCh+uKLL4o9ryS5ulIPBgCgJiKHAECxA4BTiomJUZcuXezae/bsqd9++63qAwIAADUCOQTgHCg5AqhRRo4cqR9//NH6s5ubW4H9Ll68qG7dutm1+/r6KjMzUykpKapXr16pzm02m2UymXT58mWlpaVJks2zuwAAoPoihwBqF4odAGqUiIgI5eXlSbqyC/o999xTqvH5y0uv3UysIPfee6+MRqPy8vKUnZ0tg8GgiIgIff311woPD5ckXb58WYMHDy7lVQAAgKpGDgHULhQ7ANQoRqNRRqPR+s+Fady4sZKSkuza4+Pj5enpqfr16xd7rq1bt6pp06aSJHd3d5lMJklShw4dFBoaKklauXKlzpw5U9rLAAAAVYwcAqhdKHYAcEpt27bVkSNH7NoPHjyo66+/vkRzeHh4qG7duhUdGgAAqMbIIQDnQLEDQLVlNBqVnp6u9PR05eTkKCcnR3FxcTp9+rSMRqM6depU6NjBgwfr7bff1sWLF627qVssFu3atUvDhg0r9rySlJmZqczMTJnNZmVmZuqPP/7QmTNnlJCQoEcffbTiLhQAAFQocggAFDsAVFu9e/fW/Pnz9cEHH8jV1VV169ZVkyZN1LJlS/Xt27fIsTfccIPuuOMOPfXUU1q0aJF8fHy0fPlyZWVlacyYMUWONRqN6tq1q0JCQiRJLi4u8vb2lq+vr1q0aKEbbrhBubm5cnFxqbBrBQAAFYccAgDFDgDV1r333qt777230OPnz58vcvzChQu1dOlSjRo1SllZWerXr582bdokd3f3Ys+9ZcsWZWZmymAwyN3dXQaDodTxAwAAxyCHAECxA4DTcnNz09y5czV37twyjff09KzgiAAAQE1ADgHUfIVvQwwAAAAAAFADUewAUGO5urpal5OaTKYSLS29lslkkslkKvMSUzc3N7m5uZVpLAAAcAxyCMD5GSwWi8XRQQAAAAAAAFQUVnYAAAAAAACnQrEDAAAAAAA4FYodAAAAAADAqVDsAAAAAAAAToViBwAAAAAAcCoUOwAAAAAAgFOh2AEAAAAAAJwKxQ4AAAAAAOBUKHYAAAAAAACnQrEDAAAAAAA4lf8PGdIoCimF18YAAAAASUVORK5CYII=\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " split label count ratio\n", + "0 Train 정상 30468 0.793438\n", + "1 Train 불량 7932 0.206563\n", + "2 Test 정상 7672 0.799167\n", + "3 Test 불량 1928 0.200833" + ], + "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", + "
splitlabelcountratio
0Train정상304680.793438
1Train불량79320.206563
2Test정상76720.799167
3Test불량19280.200833
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"display(event_model_result_table)\",\n \"rows\": 4,\n \"fields\": [\n {\n \"column\": \"split\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 2,\n \"samples\": [\n \"Test\",\n \"Train\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"label\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 2,\n \"samples\": [\n \"\\ubd88\\ub7c9\",\n \"\\uc815\\uc0c1\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"count\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 12619,\n \"min\": 1928,\n \"max\": 30468,\n \"num_unique_values\": 4,\n \"samples\": [\n 7932,\n 1928\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"ratio\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.34215616400574994,\n \"min\": 0.20083333333333334,\n \"max\": 0.7991666666666667,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.2065625,\n 0.20083333333333334\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "defect_yn 정상 비율 불량 비율\n", + "process_code \n", + "ASSEMBLY 0.793438 0.206563\n", + "BODY 0.784479 0.215521\n", + "PAINT 0.779792 0.220208\n", + "PRESS 0.816042 0.183958" + ], + "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", + "
defect_yn정상 비율불량 비율
process_code
ASSEMBLY0.7934380.206563
BODY0.7844790.215521
PAINT0.7797920.220208
PRESS0.8160420.183958
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"display(event_model_result_table)\",\n \"rows\": 4,\n \"fields\": [\n {\n \"column\": \"process_code\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 4,\n \"samples\": [\n \"BODY\",\n \"PRESS\",\n \"ASSEMBLY\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uc815\\uc0c1 \\ube44\\uc728\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.016097710542876044,\n \"min\": 0.7797916666666667,\n \"max\": 0.8160416666666667,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.7844791666666666,\n 0.8160416666666667,\n 0.7934375\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\ubd88\\ub7c9 \\ube44\\uc728\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.016097710542876034,\n \"min\": 0.18395833333333333,\n \"max\": 0.22020833333333334,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.21552083333333333,\n 0.18395833333333333,\n 0.2065625\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "CV tuning rows: 12000 positive_ratio: 0.2066\n", + "\n", + "[LightGBM] lightweight CV tuning: 3 trials x 3 folds\n", + " trial 1: CV PR-AUC=0.9276, Recall=0.9371, F1=0.8022, elapsed=2.7s\n", + " trial 2: CV PR-AUC=0.9345, Recall=0.9484, F1=0.8028, elapsed=3.1s\n", + " trial 3: CV PR-AUC=0.9319, Recall=0.9383, F1=0.8065, elapsed=3.1s\n", + "\n", + "[XGBoost] lightweight CV tuning: 3 trials x 3 folds\n", + " trial 1: CV PR-AUC=0.8659, Recall=0.9480, F1=0.7192, elapsed=6.2s\n", + " trial 2: CV PR-AUC=0.8457, Recall=0.9226, F1=0.7017, elapsed=2.1s\n", + " trial 3: CV PR-AUC=0.8834, Recall=0.9544, F1=0.7215, elapsed=2.4s\n", + "\n", + "[CatBoost] lightweight CV tuning: 3 trials x 3 folds\n", + " trial 1: CV PR-AUC=0.8831, Recall=0.9584, F1=0.7240, elapsed=3.8s\n", + " trial 2: CV PR-AUC=0.8565, Recall=0.9242, F1=0.7293, elapsed=5.2s\n", + " trial 3: CV PR-AUC=0.9065, Recall=0.9318, F1=0.7725, elapsed=5.3s\n", + "\n", + "[LogisticRegression] lightweight CV tuning: 3 trials x 3 folds\n", + " trial 1: CV PR-AUC=0.5971, Recall=0.8596, F1=0.4502, elapsed=1.7s\n", + " trial 2: CV PR-AUC=0.6095, Recall=0.8540, F1=0.4572, elapsed=1.8s\n", + " trial 3: CV PR-AUC=0.6157, Recall=0.8580, F1=0.4593, elapsed=2.3s\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " model_name trial_no cv_pr_auc cv_recall cv_precision \\\n", + "0 LightGBM 2 0.934463 0.948366 0.697822 \n", + "1 LightGBM 3 0.931911 0.938282 0.707198 \n", + "2 LightGBM 1 0.927581 0.937072 0.701304 \n", + "3 CatBoost 3 0.906456 0.931821 0.660354 \n", + "4 XGBoost 3 0.883359 0.954416 0.580354 \n", + "5 CatBoost 1 0.883073 0.958445 0.581853 \n", + "6 XGBoost 1 0.865852 0.947958 0.579387 \n", + "7 CatBoost 2 0.856514 0.924153 0.602729 \n", + "8 XGBoost 2 0.845673 0.922552 0.567136 \n", + "9 LogisticRegression 3 0.615725 0.858009 0.315055 \n", + "10 LogisticRegression 2 0.609526 0.853974 0.313730 \n", + "11 LogisticRegression 1 0.597149 0.859624 0.306069 \n", + "\n", + " cv_f1 cv_accuracy cv_threshold elapsed_sec \\\n", + "0 0.802814 0.903000 0.336858 3.108951 \n", + "1 0.806456 0.906917 0.388233 3.069297 \n", + "2 0.802172 0.904500 0.448503 2.653610 \n", + "3 0.772539 0.886417 0.518421 5.318331 \n", + "4 0.721533 0.847583 0.443721 2.388007 \n", + "5 0.724020 0.849000 0.450893 3.753630 \n", + "6 0.719196 0.847083 0.462588 6.186436 \n", + "7 0.729256 0.858167 0.493912 5.158900 \n", + "8 0.701664 0.837250 0.478727 2.087466 \n", + "9 0.459327 0.578833 0.377523 2.252431 \n", + "10 0.457195 0.576833 0.380491 1.819699 \n", + "11 0.450235 0.563167 0.380118 1.678352 \n", + "\n", + " params \n", + "0 {'model__subsample': 0.85, 'model__reg_lambda'... \n", + "1 {'model__subsample': 0.95, 'model__reg_lambda'... \n", + "2 {'model__subsample': 0.95, 'model__reg_lambda'... \n", + "3 {'model__learning_rate': 0.045, 'model__l2_lea... \n", + "4 {'model__subsample': 0.95, 'model__reg_lambda'... \n", + "5 {'model__learning_rate': 0.035, 'model__l2_lea... \n", + "6 {'model__subsample': 0.95, 'model__reg_lambda'... \n", + "7 {'model__learning_rate': 0.035, 'model__l2_lea... \n", + "8 {'model__subsample': 0.85, 'model__reg_lambda'... \n", + "9 {'model__C': 0.7} \n", + "10 {'model__C': 0.3} \n", + "11 {'model__C': 0.1} " + ], + "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", + " \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", + "
model_nametrial_nocv_pr_auccv_recallcv_precisioncv_f1cv_accuracycv_thresholdelapsed_secparams
0LightGBM20.9344630.9483660.6978220.8028140.9030000.3368583.108951{'model__subsample': 0.85, 'model__reg_lambda'...
1LightGBM30.9319110.9382820.7071980.8064560.9069170.3882333.069297{'model__subsample': 0.95, 'model__reg_lambda'...
2LightGBM10.9275810.9370720.7013040.8021720.9045000.4485032.653610{'model__subsample': 0.95, 'model__reg_lambda'...
3CatBoost30.9064560.9318210.6603540.7725390.8864170.5184215.318331{'model__learning_rate': 0.045, 'model__l2_lea...
4XGBoost30.8833590.9544160.5803540.7215330.8475830.4437212.388007{'model__subsample': 0.95, 'model__reg_lambda'...
5CatBoost10.8830730.9584450.5818530.7240200.8490000.4508933.753630{'model__learning_rate': 0.035, 'model__l2_lea...
6XGBoost10.8658520.9479580.5793870.7191960.8470830.4625886.186436{'model__subsample': 0.95, 'model__reg_lambda'...
7CatBoost20.8565140.9241530.6027290.7292560.8581670.4939125.158900{'model__learning_rate': 0.035, 'model__l2_lea...
8XGBoost20.8456730.9225520.5671360.7016640.8372500.4787272.087466{'model__subsample': 0.85, 'model__reg_lambda'...
9LogisticRegression30.6157250.8580090.3150550.4593270.5788330.3775232.252431{'model__C': 0.7}
10LogisticRegression20.6095260.8539740.3137300.4571950.5768330.3804911.819699{'model__C': 0.3}
11LogisticRegression10.5971490.8596240.3060690.4502350.5631670.3801181.678352{'model__C': 0.1}
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"display(event_model_result_table)\",\n \"rows\": 12,\n \"fields\": [\n {\n \"column\": \"model_name\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 4,\n \"samples\": [\n \"CatBoost\",\n \"LogisticRegression\",\n \"LightGBM\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"trial_no\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 1,\n \"max\": 3,\n \"num_unique_values\": 3,\n \"samples\": [\n 2,\n 3,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cv_pr_auc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.13226232449899528,\n \"min\": 0.5971489045737713,\n \"max\": 0.9344633999731989,\n \"num_unique_values\": 12,\n \"samples\": [\n 0.6095263334230935,\n 0.6157252452507588,\n 0.9344633999731989\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cv_recall\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.03917687154212582,\n \"min\": 0.85397446745386,\n \"max\": 0.9584454444577822,\n \"num_unique_values\": 12,\n \"samples\": [\n 0.85397446745386,\n 0.858009491993875,\n 0.948365934613962\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cv_precision\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.15315411240822374,\n \"min\": 0.3060685954000458,\n \"max\": 0.7071975967851619,\n \"num_unique_values\": 12,\n \"samples\": [\n 0.31372964522405455,\n 0.3150552253879512,\n 0.6978217778588197\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cv_f1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.13940567080711017,\n \"min\": 0.4502352124810967,\n \"max\": 0.8064557839434242,\n \"num_unique_values\": 12,\n \"samples\": [\n 0.45719534111727445,\n 0.459326792178925,\n 0.8028137009473023\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cv_accuracy\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.1370956825284053,\n \"min\": 0.5631666666666667,\n \"max\": 0.9069166666666666,\n \"num_unique_values\": 12,\n \"samples\": [\n 0.5768333333333333,\n 0.5788333333333333,\n 0.903\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cv_threshold\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.05593780199857902,\n \"min\": 0.3368583159806368,\n \"max\": 0.5184207367921806,\n \"num_unique_values\": 12,\n \"samples\": [\n 0.3804908163843998,\n 0.37752315491309973,\n 0.3368583159806368\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"elapsed_sec\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.5013057134849703,\n \"min\": 1.6783518340002956,\n \"max\": 6.18643563500018,\n \"num_unique_values\": 12,\n \"samples\": [\n 1.819699066999874,\n 2.252431180000258,\n 3.1089514619998226\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"params\",\n \"properties\": {\n \"dtype\": \"object\",\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "모델별 선택 파라미터\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " model_name best_params\n", + "0 LightGBM {'model__subsample': 0.85, 'model__reg_lambda'...\n", + "1 XGBoost {'model__subsample': 0.95, 'model__reg_lambda'...\n", + "2 CatBoost {'model__learning_rate': 0.045, 'model__l2_lea...\n", + "3 LogisticRegression {'model__C': 0.7}" + ], + "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", + "
model_namebest_params
0LightGBM{'model__subsample': 0.85, 'model__reg_lambda'...
1XGBoost{'model__subsample': 0.95, 'model__reg_lambda'...
2CatBoost{'model__learning_rate': 0.045, 'model__l2_lea...
3LogisticRegression{'model__C': 0.7}
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"display(event_model_result_table)\",\n \"rows\": 4,\n \"fields\": [\n {\n \"column\": \"model_name\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 4,\n \"samples\": [\n \"XGBoost\",\n \"LogisticRegression\",\n \"LightGBM\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"best_params\",\n \"properties\": {\n \"dtype\": \"object\",\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "[LightGBM] final fit start\n", + "[LightGBM] Train F1=0.8789, Test F1=0.8426, Test PR-AUC=0.9560, Test Recall=0.9341\n", + "\n", + "[XGBoost] final fit start\n", + "[XGBoost] Train F1=0.7436, Test F1=0.7425, Test PR-AUC=0.9029, Test Recall=0.9528\n", + "\n", + "[CatBoost] final fit start\n", + "[CatBoost] Train F1=0.7799, Test F1=0.7698, Test PR-AUC=0.9181, Test Recall=0.9305\n", + "\n", + "[LogisticRegression] final fit start\n", + "[LogisticRegression] Train F1=0.4686, Test F1=0.4597, Test PR-AUC=0.6526, Test Recall=0.8677\n", + "selected_event_model_name: LightGBM\n", + "불량 탐지 모델 학습 결과\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 모델 Train F1 Test F1 Train 재현율 Test 재현율 Train 정밀도 \\\n", + "0 LightGBM 0.878897 0.842573 0.972138 0.934129 0.801976 \n", + "1 CatBoost 0.779898 0.769792 0.943016 0.930498 0.664889 \n", + "2 XGBoost 0.743551 0.742522 0.953858 0.952801 0.609228 \n", + "3 LogisticRegression 0.468559 0.459742 0.861447 0.867739 0.321795 \n", + "\n", + " Test 정밀도 Train 정확도 Test 정확도 Test PR-AUC Test ROC-AUC 임계값(Train 기준) \\\n", + "0 0.767363 0.944661 0.929896 0.955974 0.986500 0.502521 \n", + "1 0.656422 0.890052 0.888229 0.918066 0.974119 0.525871 \n", + "2 0.608278 0.864089 0.867292 0.902932 0.968021 0.489376 \n", + "3 0.312710 0.596354 0.590417 0.652634 0.815697 0.377797 \n", + "\n", + " 선택 파라미터 \n", + "0 {'model__subsample': 0.85, 'model__reg_lambda'... \n", + "1 {'model__learning_rate': 0.045, 'model__l2_lea... \n", + "2 {'model__subsample': 0.95, 'model__reg_lambda'... \n", + "3 {'model__C': 0.7} " + ], + "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", + "
모델Train F1Test F1Train 재현율Test 재현율Train 정밀도Test 정밀도Train 정확도Test 정확도Test PR-AUCTest ROC-AUC임계값(Train 기준)선택 파라미터
0LightGBM0.8788970.8425730.9721380.9341290.8019760.7673630.9446610.9298960.9559740.9865000.502521{'model__subsample': 0.85, 'model__reg_lambda'...
1CatBoost0.7798980.7697920.9430160.9304980.6648890.6564220.8900520.8882290.9180660.9741190.525871{'model__learning_rate': 0.045, 'model__l2_lea...
2XGBoost0.7435510.7425220.9538580.9528010.6092280.6082780.8640890.8672920.9029320.9680210.489376{'model__subsample': 0.95, 'model__reg_lambda'...
3LogisticRegression0.4685590.4597420.8614470.8677390.3217950.3127100.5963540.5904170.6526340.8156970.377797{'model__C': 0.7}
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "variable_name": "event_model_result_table", + "summary": "{\n \"name\": \"event_model_result_table\",\n \"rows\": 4,\n \"fields\": [\n {\n \"column\": \"\\ubaa8\\ub378\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 4,\n \"samples\": [\n \"CatBoost\",\n \"LogisticRegression\",\n \"LightGBM\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Train F1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.17568180578795617,\n \"min\": 0.4685592813550024,\n \"max\": 0.8788966774947284,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.7798978208737358,\n 0.4685592813550024,\n 0.8788966774947284\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test F1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.16800465504410292,\n \"min\": 0.4597416872767244,\n \"max\": 0.8425730994152046,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.7697918901523279,\n 0.4597416872767244,\n 0.8425730994152046\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Train \\uc7ac\\ud604\\uc728\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.04894334102906186,\n \"min\": 0.8614473020675744,\n \"max\": 0.9721381744831064,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.9430156328794755,\n 0.8614473020675744,\n 0.9721381744831064\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test \\uc7ac\\ud604\\uc728\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.03701487230321801,\n \"min\": 0.8677385892116183,\n \"max\": 0.9528008298755186,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.9304979253112033,\n 0.8677385892116183,\n 0.9341286307053942\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Train \\uc815\\ubc00\\ub3c4\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.20206173419907764,\n \"min\": 0.3217952340585853,\n \"max\": 0.8019760790431617,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.6648888888888889,\n 0.3217952340585853,\n 0.8019760790431617\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test \\uc815\\ubc00\\ub3c4\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.19410908996828016,\n \"min\": 0.31271028037383175,\n \"max\": 0.7673625905411163,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.6564215148188803,\n 0.31271028037383175,\n 0.7673625905411163\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Train \\uc815\\ud655\\ub3c4\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.15529713870327488,\n \"min\": 0.5963541666666666,\n \"max\": 0.9446614583333334,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.8900520833333333,\n 0.5963541666666666,\n 0.9446614583333334\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test \\uc815\\ud655\\ub3c4\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.15456711786020697,\n \"min\": 0.5904166666666667,\n \"max\": 0.9298958333333334,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.8882291666666666,\n 0.5904166666666667,\n 0.9298958333333334\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test PR-AUC\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.13832268833744524,\n \"min\": 0.6526339505198415,\n \"max\": 0.9559739814794836,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.9180660018798659,\n 0.6526339505198415,\n 0.9559739814794836\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test ROC-AUC\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.08062568262928234,\n \"min\": 0.8156968109502032,\n \"max\": 0.9865001903781169,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.9741186155724973,\n 0.8156968109502032,\n 0.9865001903781169\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uc784\\uacc4\\uac12(Train \\uae30\\uc900)\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.06581648846522219,\n \"min\": 0.377796850305734,\n \"max\": 0.5258707595986962,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.5258707595986962,\n 0.377796850305734,\n 0.5025206934115897\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uc120\\ud0dd \\ud30c\\ub77c\\ubbf8\\ud130\",\n \"properties\": {\n \"dtype\": \"object\",\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + } + ], + "source": [ + "EVENT_TARGET = \"defect_yn\"\n", + "EVENT_LEAKAGE_COLS = [\n", + " \"defect_yn\",\n", + " \"target_defect_yn\",\n", + " \"defect_reason\",\n", + " \"operation_status\",\n", + " \"operation_status_raw\",\n", + " \"quality_status\",\n", + " \"paint_vision_label\",\n", + " \"paint_defect_score\",\n", + " \"paint_surface_quality_score\",\n", + " \"assembly_missing_part_count\",\n", + " \"assembly_fastening_error_count\",\n", + " \"assembly_sequence_error_count\",\n", + " \"assembly_sequence_mismatch_yn\",\n", + " \"press_count_increase_yn\",\n", + " \"press_timestamp_delay_sec\",\n", + " \"body_robot_motion_status\",\n", + " \"assembly_expected_sequence\",\n", + " \"assembly_actual_sequence\",\n", + " \"ford_row_id\",\n", + " \"forming_row_id\",\n", + " \"robot_arm_vibration_row_id\",\n", + " \"machine_vision_row_id\",\n", + " \"bosch_id\",\n", + "]\n", + "EVENT_EXCLUDE_COLS = [\n", + " \"raw_event_id\",\n", + " \"event_id\",\n", + " \"event_time\",\n", + " \"car_master_id\",\n", + " \"defect_reason\",\n", + " EVENT_TARGET,\n", + "] + EVENT_LEAKAGE_COLS\n", + "\n", + "event_feature_cols = select_model_features(defect_train, EVENT_TARGET, EVENT_EXCLUDE_COLS, EVENT_LEAKAGE_COLS, context=\"불량 탐지\")\n", + "event_feature_cols = drop_suspicious_features(defect_train, EVENT_TARGET, event_feature_cols, context=\"불량 탐지\")\n", + "ensure_feature_columns_exist(defect_test, event_feature_cols, context=\"불량 탐지\")\n", + "\n", + "X_event_train = defect_train[event_feature_cols]\n", + "y_event_train = defect_train[EVENT_TARGET].astype(int)\n", + "X_event_test = defect_test[event_feature_cols]\n", + "y_event_test = defect_test[EVENT_TARGET].astype(int)\n", + "event_scale_pos_weight = scale_pos_weight_for(y_event_train)\n", + "\n", + "ENABLE_HYPERPARAMETER_TUNING = True\n", + "CV_FOLDS = 3\n", + "TUNING_TRIALS_PER_MODEL = 3\n", + "MAX_TUNING_ROWS = 12_000\n", + "\n", + "print(\"불량 탐지 feature 수:\", len(event_feature_cols))\n", + "print(\"불량 탐지 feature:\", event_feature_cols)\n", + "print(\"불량 탐지 scale_pos_weight:\", round(event_scale_pos_weight, 3))\n", + "print(f\"튜닝 설정: enabled={ENABLE_HYPERPARAMETER_TUNING}, folds={CV_FOLDS}, trials={TUNING_TRIALS_PER_MODEL}, max_rows={MAX_TUNING_ROWS}\")\n", + "\n", + "plot_class_distribution(defect_train, defect_test, EVENT_TARGET, \"불량 탐지\")\n", + "display(pd.crosstab(defect_train[\"process_code\"], defect_train[EVENT_TARGET], normalize=\"index\").rename(columns={0: \"정상 비율\", 1: \"불량 비율\"}))\n", + "plot_feature_distribution_grid(defect_train, event_feature_cols, EVENT_TARGET, \"불량 탐지 주요 수치형 feature 분포\", max_features=24)\n", + "plot_numeric_correlation_heatmap(defect_train, event_feature_cols, \"불량 탐지 수치형 feature 상관관계\", max_features=18)\n", + "\n", + "\n", + "def make_event_model_configs(scale_pos_weight: float):\n", + " return {\n", + " \"LightGBM\": {\n", + " \"estimator\": lgb.LGBMClassifier(\n", + " objective=\"binary\",\n", + " n_estimators=220,\n", + " learning_rate=0.045,\n", + " num_leaves=15,\n", + " min_child_samples=80,\n", + " subsample=0.85,\n", + " colsample_bytree=0.75,\n", + " reg_lambda=8.0,\n", + " scale_pos_weight=scale_pos_weight,\n", + " random_state=RANDOM_STATE,\n", + " n_jobs=-1,\n", + " verbosity=-1,\n", + " ),\n", + " \"scale_numeric\": False,\n", + " \"param_distributions\": {\n", + " \"model__n_estimators\": [160, 220, 280],\n", + " \"model__learning_rate\": [0.035, 0.045, 0.06],\n", + " \"model__num_leaves\": [11, 15, 23],\n", + " \"model__min_child_samples\": [60, 80, 120],\n", + " \"model__subsample\": [0.75, 0.85, 0.95],\n", + " \"model__colsample_bytree\": [0.70, 0.80, 0.90],\n", + " \"model__reg_lambda\": [4.0, 8.0, 12.0],\n", + " },\n", + " },\n", + " \"XGBoost\": {\n", + " \"estimator\": xgb.XGBClassifier(\n", + " objective=\"binary:logistic\",\n", + " eval_metric=\"aucpr\",\n", + " tree_method=\"hist\",\n", + " n_estimators=220,\n", + " learning_rate=0.045,\n", + " max_depth=3,\n", + " min_child_weight=8,\n", + " subsample=0.85,\n", + " colsample_bytree=0.75,\n", + " reg_lambda=8.0,\n", + " scale_pos_weight=scale_pos_weight,\n", + " random_state=RANDOM_STATE,\n", + " n_jobs=-1,\n", + " ),\n", + " \"scale_numeric\": False,\n", + " \"param_distributions\": {\n", + " \"model__n_estimators\": [160, 220, 280],\n", + " \"model__learning_rate\": [0.035, 0.045, 0.06],\n", + " \"model__max_depth\": [2, 3, 4],\n", + " \"model__min_child_weight\": [5, 8, 12],\n", + " \"model__subsample\": [0.75, 0.85, 0.95],\n", + " \"model__colsample_bytree\": [0.70, 0.80, 0.90],\n", + " \"model__reg_lambda\": [4.0, 8.0, 12.0],\n", + " },\n", + " },\n", + " \"CatBoost\": {\n", + " \"estimator\": CatBoostClassifier(\n", + " loss_function=\"Logloss\",\n", + " eval_metric=\"PRAUC\",\n", + " iterations=220,\n", + " learning_rate=0.045,\n", + " depth=4,\n", + " l2_leaf_reg=10.0,\n", + " scale_pos_weight=scale_pos_weight,\n", + " random_seed=RANDOM_STATE,\n", + " thread_count=2,\n", + " verbose=False,\n", + " allow_writing_files=False,\n", + " ),\n", + " \"scale_numeric\": False,\n", + " \"param_distributions\": {\n", + " \"model__iterations\": [160, 220, 280],\n", + " \"model__learning_rate\": [0.035, 0.045, 0.06],\n", + " \"model__depth\": [3, 4, 5],\n", + " \"model__l2_leaf_reg\": [6.0, 10.0, 14.0],\n", + " },\n", + " },\n", + " \"LogisticRegression\": {\n", + " \"estimator\": LogisticRegression(class_weight=\"balanced\", max_iter=1000, C=0.3, random_state=RANDOM_STATE),\n", + " \"scale_numeric\": True,\n", + " \"param_distributions\": {\n", + " \"model__C\": [0.1, 0.3, 0.7],\n", + " },\n", + " },\n", + " }\n", + "\n", + "\n", + "def make_model_pipeline(config, train_df, feature_cols):\n", + " return Pipeline([\n", + " (\"preprocess\", make_preprocessor(train_df, feature_cols, scale_numeric=config.get(\"scale_numeric\", False))),\n", + " (\"model\", clone(config[\"estimator\"])),\n", + " ])\n", + "\n", + "\n", + "def sample_param_candidates(param_distributions: dict, n_iter: int, random_state: int):\n", + " if not param_distributions:\n", + " return [{}]\n", + " return list(ParameterSampler(param_distributions, n_iter=n_iter, random_state=random_state))\n", + "\n", + "\n", + "def make_tuning_sample(X: pd.DataFrame, y: pd.Series, max_rows: int):\n", + " if len(X) <= max_rows:\n", + " return X, y\n", + " sampled_parts = []\n", + " for label, label_index in y.groupby(y).groups.items():\n", + " label_index = pd.Index(label_index)\n", + " n_rows = max(1, int(round(len(label_index) / len(y) * max_rows)))\n", + " sampled_parts.append(label_index.to_series().sample(n=min(n_rows, len(label_index)), random_state=RANDOM_STATE))\n", + " sampled_index = pd.Index(pd.concat(sampled_parts).tolist())\n", + " if len(sampled_index) > max_rows:\n", + " sampled_index = sampled_index.to_series().sample(max_rows, random_state=RANDOM_STATE).index\n", + " sampled_index = sampled_index.sort_values()\n", + " return X.loc[sampled_index], y.loc[sampled_index]\n", + "\n", + "\n", + "def tune_event_model_cv(model_name: str, config: dict, X: pd.DataFrame, y: pd.Series, feature_cols: list[str]):\n", + " candidates = sample_param_candidates(config.get(\"param_distributions\", {}), TUNING_TRIALS_PER_MODEL, RANDOM_STATE)\n", + " cv = StratifiedKFold(n_splits=CV_FOLDS, shuffle=True, random_state=RANDOM_STATE)\n", + " rows = []\n", + " best_row = None\n", + " best_score = (-np.inf, -np.inf, -np.inf)\n", + " print(f\"\\n[{model_name}] lightweight CV tuning: {len(candidates)} trials x {CV_FOLDS} folds\")\n", + " for trial_no, params in enumerate(candidates, start=1):\n", + " fold_metrics = []\n", + " started_at = time.perf_counter()\n", + " for train_idx, valid_idx in cv.split(X, y):\n", + " X_fold_train = X.iloc[train_idx]\n", + " y_fold_train = y.iloc[train_idx]\n", + " X_fold_valid = X.iloc[valid_idx]\n", + " y_fold_valid = y.iloc[valid_idx]\n", + " estimator = make_model_pipeline(config, X_fold_train, feature_cols)\n", + " estimator.set_params(**params)\n", + " estimator.fit(X_fold_train, y_fold_train)\n", + " valid_proba = predict_positive_proba(estimator, X_fold_valid)\n", + " threshold = find_recall_priority_threshold(y_fold_valid, valid_proba, min_recall=0.65, min_precision=0.20)\n", + " fold_metrics.append(compute_metrics(y_fold_valid, valid_proba, threshold))\n", + " elapsed_sec = time.perf_counter() - started_at\n", + " row = {\n", + " \"model_name\": model_name,\n", + " \"trial_no\": trial_no,\n", + " \"params\": params,\n", + " \"cv_pr_auc\": float(np.mean([m[\"pr_auc\"] for m in fold_metrics])),\n", + " \"cv_recall\": float(np.mean([m[\"recall\"] for m in fold_metrics])),\n", + " \"cv_precision\": float(np.mean([m[\"precision\"] for m in fold_metrics])),\n", + " \"cv_f1\": float(np.mean([m[\"f1\"] for m in fold_metrics])),\n", + " \"cv_accuracy\": float(np.mean([m[\"accuracy\"] for m in fold_metrics])),\n", + " \"cv_threshold\": float(np.mean([m[\"threshold\"] for m in fold_metrics])),\n", + " \"elapsed_sec\": elapsed_sec,\n", + " }\n", + " rows.append(row)\n", + " score = (row[\"cv_pr_auc\"], row[\"cv_recall\"], row[\"cv_f1\"])\n", + " if score > best_score:\n", + " best_score = score\n", + " best_row = row\n", + " print(f\" trial {trial_no}: CV PR-AUC={row['cv_pr_auc']:.4f}, Recall={row['cv_recall']:.4f}, F1={row['cv_f1']:.4f}, elapsed={elapsed_sec:.1f}s\")\n", + " return best_row, rows\n", + "\n", + "\n", + "event_model_configs = make_event_model_configs(event_scale_pos_weight)\n", + "event_best_params = {model_name: {} for model_name in event_model_configs}\n", + "event_cv_rows = []\n", + "X_event_tune, y_event_tune = make_tuning_sample(X_event_train, y_event_train, MAX_TUNING_ROWS)\n", + "print(\"CV tuning rows:\", len(X_event_tune), \"positive_ratio:\", round(float(y_event_tune.mean()), 4))\n", + "\n", + "if ENABLE_HYPERPARAMETER_TUNING:\n", + " for model_name, config in event_model_configs.items():\n", + " best_row, rows = tune_event_model_cv(model_name, config, X_event_tune, y_event_tune, event_feature_cols)\n", + " event_cv_rows.extend(rows)\n", + " event_best_params[model_name] = best_row[\"params\"] if best_row else {}\n", + "\n", + "event_cv_results = pd.DataFrame(event_cv_rows)\n", + "if not event_cv_results.empty:\n", + " display(\n", + " event_cv_results.sort_values([\"cv_pr_auc\", \"cv_recall\", \"cv_f1\"], ascending=False)\n", + " [[\"model_name\", \"trial_no\", \"cv_pr_auc\", \"cv_recall\", \"cv_precision\", \"cv_f1\", \"cv_accuracy\", \"cv_threshold\", \"elapsed_sec\", \"params\"]]\n", + " .reset_index(drop=True)\n", + " )\n", + "print(\"모델별 선택 파라미터\")\n", + "display(pd.DataFrame([{\"model_name\": model_name, \"best_params\": params} for model_name, params in event_best_params.items()]))\n", + "\n", + "event_candidate_models = {}\n", + "event_eval_rows = []\n", + "event_train_proba_by_model = {}\n", + "event_test_proba_by_model = {}\n", + "\n", + "for model_name, config in event_model_configs.items():\n", + " print(f\"\\n[{model_name}] final fit start\")\n", + " estimator = make_model_pipeline(config, defect_train, event_feature_cols)\n", + " estimator.set_params(**event_best_params.get(model_name, {}))\n", + " estimator.fit(X_event_train, y_event_train)\n", + " train_proba = predict_positive_proba(estimator, X_event_train)\n", + " test_proba = predict_positive_proba(estimator, X_event_test)\n", + " threshold = find_recall_priority_threshold(y_event_train, train_proba, min_recall=0.65, min_precision=0.20)\n", + " train_metrics = compute_metrics(y_event_train, train_proba, threshold)\n", + " test_metrics = compute_metrics(y_event_test, test_proba, threshold)\n", + " event_candidate_models[model_name] = estimator\n", + " event_train_proba_by_model[model_name] = train_proba\n", + " event_test_proba_by_model[model_name] = test_proba\n", + " event_eval_rows.append({\n", + " \"model_name\": model_name,\n", + " \"threshold\": threshold,\n", + " \"best_params\": event_best_params.get(model_name, {}),\n", + " **{f\"train_{k}\": v for k, v in train_metrics.items()},\n", + " **{f\"test_{k}\": v for k, v in test_metrics.items()},\n", + " })\n", + " print(f\"[{model_name}] Train F1={train_metrics['f1']:.4f}, Test F1={test_metrics['f1']:.4f}, Test PR-AUC={test_metrics['pr_auc']:.4f}, Test Recall={test_metrics['recall']:.4f}\")\n", + "\n", + "event_model_comparison = pd.DataFrame(event_eval_rows).sort_values([\"test_pr_auc\", \"test_recall\", \"test_f1\"], ascending=False).reset_index(drop=True)\n", + "selected_event_model_name = str(event_model_comparison.iloc[0][\"model_name\"])\n", + "selected_event_threshold = float(event_model_comparison.iloc[0][\"threshold\"])\n", + "selected_event_model = event_candidate_models[selected_event_model_name]\n", + "print(\"selected_event_model_name:\", selected_event_model_name)\n", + "\n", + "event_model_result_table = event_model_comparison[[\n", + " \"model_name\",\n", + " \"train_f1\", \"test_f1\",\n", + " \"train_recall\", \"test_recall\",\n", + " \"train_precision\", \"test_precision\",\n", + " \"train_accuracy\", \"test_accuracy\",\n", + " \"test_pr_auc\", \"test_roc_auc\",\n", + " \"threshold\",\n", + " \"best_params\",\n", + "]].rename(columns={\n", + " \"model_name\": \"모델\",\n", + " \"train_f1\": \"Train F1\",\n", + " \"test_f1\": \"Test F1\",\n", + " \"train_recall\": \"Train 재현율\",\n", + " \"test_recall\": \"Test 재현율\",\n", + " \"train_precision\": \"Train 정밀도\",\n", + " \"test_precision\": \"Test 정밀도\",\n", + " \"train_accuracy\": \"Train 정확도\",\n", + " \"test_accuracy\": \"Test 정확도\",\n", + " \"test_pr_auc\": \"Test PR-AUC\",\n", + " \"test_roc_auc\": \"Test ROC-AUC\",\n", + " \"threshold\": \"임계값(Train 기준)\",\n", + " \"best_params\": \"선택 파라미터\",\n", + "})\n", + "print(\"불량 탐지 모델 학습 결과\")\n", + "display(event_model_result_table)" + ] + }, + { + "cell_type": "markdown", + "id": "fd86b6b8", + "metadata": { + "id": "fd86b6b8" + }, + "source": [ + "**셀 설명**\n", + "\n", + "후보 모델별 평가 지표와 혼동행렬을 출력하고, 선택된 모델의 classification report, PR 곡선, ROC 곡선을 시각화합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "22e5c22b", + "metadata": { + "id": "22e5c22b", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "19590d47-25b7-487d-e6f8-44cba0981b54" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "불량 탐지 모델별 평가 지표\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 모델 Train F1 Test F1 Train 재현율 Test 재현율 Train 정밀도 \\\n", + "0 LightGBM 0.878897 0.842573 0.972138 0.934129 0.801976 \n", + "1 CatBoost 0.779898 0.769792 0.943016 0.930498 0.664889 \n", + "2 XGBoost 0.743551 0.742522 0.953858 0.952801 0.609228 \n", + "3 LogisticRegression 0.468559 0.459742 0.861447 0.867739 0.321795 \n", + "\n", + " Test 정밀도 Train 정확도 Test 정확도 Test PR-AUC Test ROC-AUC 임계값(Train 기준) \\\n", + "0 0.767363 0.944661 0.929896 0.955974 0.986500 0.502521 \n", + "1 0.656422 0.890052 0.888229 0.918066 0.974119 0.525871 \n", + "2 0.608278 0.864089 0.867292 0.902932 0.968021 0.489376 \n", + "3 0.312710 0.596354 0.590417 0.652634 0.815697 0.377797 \n", + "\n", + " 선택 파라미터 \n", + "0 {'model__subsample': 0.85, 'model__reg_lambda'... \n", + "1 {'model__learning_rate': 0.045, 'model__l2_lea... \n", + "2 {'model__subsample': 0.95, 'model__reg_lambda'... \n", + "3 {'model__C': 0.7} " + ], + "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", + "
모델Train F1Test F1Train 재현율Test 재현율Train 정밀도Test 정밀도Train 정확도Test 정확도Test PR-AUCTest ROC-AUC임계값(Train 기준)선택 파라미터
0LightGBM0.8788970.8425730.9721380.9341290.8019760.7673630.9446610.9298960.9559740.9865000.502521{'model__subsample': 0.85, 'model__reg_lambda'...
1CatBoost0.7798980.7697920.9430160.9304980.6648890.6564220.8900520.8882290.9180660.9741190.525871{'model__learning_rate': 0.045, 'model__l2_lea...
2XGBoost0.7435510.7425220.9538580.9528010.6092280.6082780.8640890.8672920.9029320.9680210.489376{'model__subsample': 0.95, 'model__reg_lambda'...
3LogisticRegression0.4685590.4597420.8614470.8677390.3217950.3127100.5963540.5904170.6526340.8156970.377797{'model__C': 0.7}
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "variable_name": "event_model_result_table", + "summary": "{\n \"name\": \"event_model_result_table\",\n \"rows\": 4,\n \"fields\": [\n {\n \"column\": \"\\ubaa8\\ub378\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 4,\n \"samples\": [\n \"CatBoost\",\n \"LogisticRegression\",\n \"LightGBM\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Train F1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.17568180578795617,\n \"min\": 0.4685592813550024,\n \"max\": 0.8788966774947284,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.7798978208737358,\n 0.4685592813550024,\n 0.8788966774947284\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test F1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.16800465504410292,\n \"min\": 0.4597416872767244,\n \"max\": 0.8425730994152046,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.7697918901523279,\n 0.4597416872767244,\n 0.8425730994152046\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Train \\uc7ac\\ud604\\uc728\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.04894334102906186,\n \"min\": 0.8614473020675744,\n \"max\": 0.9721381744831064,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.9430156328794755,\n 0.8614473020675744,\n 0.9721381744831064\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test \\uc7ac\\ud604\\uc728\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.03701487230321801,\n \"min\": 0.8677385892116183,\n \"max\": 0.9528008298755186,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.9304979253112033,\n 0.8677385892116183,\n 0.9341286307053942\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Train \\uc815\\ubc00\\ub3c4\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.20206173419907764,\n \"min\": 0.3217952340585853,\n \"max\": 0.8019760790431617,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.6648888888888889,\n 0.3217952340585853,\n 0.8019760790431617\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test \\uc815\\ubc00\\ub3c4\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.19410908996828016,\n \"min\": 0.31271028037383175,\n \"max\": 0.7673625905411163,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.6564215148188803,\n 0.31271028037383175,\n 0.7673625905411163\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Train \\uc815\\ud655\\ub3c4\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.15529713870327488,\n \"min\": 0.5963541666666666,\n \"max\": 0.9446614583333334,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.8900520833333333,\n 0.5963541666666666,\n 0.9446614583333334\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test \\uc815\\ud655\\ub3c4\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.15456711786020697,\n \"min\": 0.5904166666666667,\n \"max\": 0.9298958333333334,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.8882291666666666,\n 0.5904166666666667,\n 0.9298958333333334\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test PR-AUC\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.13832268833744524,\n \"min\": 0.6526339505198415,\n \"max\": 0.9559739814794836,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.9180660018798659,\n 0.6526339505198415,\n 0.9559739814794836\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test ROC-AUC\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.08062568262928234,\n \"min\": 0.8156968109502032,\n \"max\": 0.9865001903781169,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.9741186155724973,\n 0.8156968109502032,\n 0.9865001903781169\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uc784\\uacc4\\uac12(Train \\uae30\\uc900)\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.06581648846522219,\n \"min\": 0.377796850305734,\n \"max\": 0.5258707595986962,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.5258707595986962,\n 0.377796850305734,\n 0.5025206934115897\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uc120\\ud0dd \\ud30c\\ub77c\\ubbf8\\ud130\",\n \"properties\": {\n \"dtype\": \"object\",\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "[LightGBM] Train/Test 혼동행렬\n", + "Train FP=1904 FN=221 | Test FP=546 FN=127\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " split threshold pr_auc roc_auc accuracy precision recall \\\n", + "0 Train 0.502521 0.974105 0.992645 0.944661 0.801976 0.972138 \n", + "1 Test 0.502521 0.955974 0.986500 0.929896 0.767363 0.934129 \n", + "\n", + " f1 false_positive_rate tn fp fn tp \n", + "0 0.878897 0.062492 28564 1904 221 7711 \n", + "1 0.842573 0.071168 7126 546 127 1801 " + ], + "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", + "
splitthresholdpr_aucroc_aucaccuracyprecisionrecallf1false_positive_ratetnfpfntp
0Train0.5025210.9741050.9926450.9446610.8019760.9721380.8788970.0624922856419042217711
1Test0.5025210.9559740.9865000.9298960.7673630.9341290.8425730.07116871265461271801
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"plot_model_feature_importance(event_model_importance, f\\\"\\ubd88\\ub7c9 \\ud0d0\\uc9c0 \\ud53c\\ucc98 \\uc911\\uc694\\ub3c4 - {selected_event_model_name}\\\", top_n=25)\",\n \"rows\": 2,\n \"fields\": [\n {\n \"column\": \"split\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 2,\n \"samples\": [\n \"Test\",\n \"Train\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"threshold\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0,\n \"min\": 0.5025206934115897,\n \"max\": 0.5025206934115897,\n \"num_unique_values\": 1,\n \"samples\": [\n 0.5025206934115897\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"pr_auc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.012820383592897139,\n \"min\": 0.9559739814794836,\n \"max\": 0.9741047418313843,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.9559739814794836\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"roc_auc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.004345085867128677,\n \"min\": 0.9865001903781169,\n \"max\": 0.9926450697410859,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.9865001903781169\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"accuracy\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.010440873565957619,\n \"min\": 0.9298958333333334,\n \"max\": 0.9446614583333334,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.9298958333333334\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"precision\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.024475432440318877,\n \"min\": 0.7673625905411163,\n \"max\": 0.8019760790431617,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.7673625905411163\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"recall\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.026876806155027206,\n \"min\": 0.9341286307053942,\n \"max\": 0.9721381744831064,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.9341286307053942\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"f1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.02568464837699031,\n \"min\": 0.8425730994152046,\n \"max\": 0.8788966774947284,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.8425730994152046\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"false_positive_rate\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.006134921042125044,\n \"min\": 0.06249179466981751,\n \"max\": 0.07116788321167883,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.07116788321167883\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"tn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 15158,\n \"min\": 7126,\n \"max\": 28564,\n \"num_unique_values\": 2,\n \"samples\": [\n 7126\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"fp\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 960,\n \"min\": 546,\n \"max\": 1904,\n \"num_unique_values\": 2,\n \"samples\": [\n 546\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"fn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 66,\n \"min\": 127,\n \"max\": 221,\n \"num_unique_values\": 2,\n \"samples\": [\n 127\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"tp\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4179,\n \"min\": 1801,\n \"max\": 7711,\n \"num_unique_values\": 2,\n \"samples\": [\n 1801\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "[CatBoost] Train/Test 혼동행렬\n", + "Train FP=3770 FN=452 | Test FP=939 FN=134\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " split threshold pr_auc roc_auc accuracy precision recall \\\n", + "0 Train 0.525871 0.923610 0.975237 0.890052 0.664889 0.943016 \n", + "1 Test 0.525871 0.918066 0.974119 0.888229 0.656422 0.930498 \n", + "\n", + " f1 false_positive_rate tn fp fn tp \n", + "0 0.779898 0.123736 26698 3770 452 7480 \n", + "1 0.769792 0.122393 6733 939 134 1794 " + ], + "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", + "
splitthresholdpr_aucroc_aucaccuracyprecisionrecallf1false_positive_ratetnfpfntp
0Train0.5258710.9236100.9752370.8900520.6648890.9430160.7798980.1237362669837704527480
1Test0.5258710.9180660.9741190.8882290.6564220.9304980.7697920.12239367339391341794
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"plot_model_feature_importance(event_model_importance, f\\\"\\ubd88\\ub7c9 \\ud0d0\\uc9c0 \\ud53c\\ucc98 \\uc911\\uc694\\ub3c4 - {selected_event_model_name}\\\", top_n=25)\",\n \"rows\": 2,\n \"fields\": [\n {\n \"column\": \"split\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 2,\n \"samples\": [\n \"Test\",\n \"Train\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"threshold\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0,\n \"min\": 0.5258707595986962,\n \"max\": 0.5258707595986962,\n \"num_unique_values\": 1,\n \"samples\": [\n 0.5258707595986962\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"pr_auc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0039202864500118345,\n \"min\": 0.9180660018798659,\n \"max\": 0.9236101241458601,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.9180660018798659\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"roc_auc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.000790725322926813,\n \"min\": 0.9741186155724973,\n \"max\": 0.9752368700482923,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.9741186155724973\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"accuracy\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0012889967365379824,\n \"min\": 0.8882291666666666,\n \"max\": 0.8900520833333333,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.8882291666666666\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"precision\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0059873376237461655,\n \"min\": 0.6564215148188803,\n \"max\": 0.6648888888888889,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.6564215148188803\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"recall\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.008851355906435439,\n \"min\": 0.9304979253112033,\n \"max\": 0.9430156328794755,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.9304979253112033\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"f1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.007145972143309037,\n \"min\": 0.7697918901523279,\n \"max\": 0.7798978208737358,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.7697918901523279\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"false_positive_rate\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0009498291888595653,\n \"min\": 0.12239311783107404,\n \"max\": 0.12373637915189707,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.12239311783107404\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"tn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 14117,\n \"min\": 6733,\n \"max\": 26698,\n \"num_unique_values\": 2,\n \"samples\": [\n 6733\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"fp\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2001,\n \"min\": 939,\n \"max\": 3770,\n \"num_unique_values\": 2,\n \"samples\": [\n 939\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"fn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 224,\n \"min\": 134,\n \"max\": 452,\n \"num_unique_values\": 2,\n \"samples\": [\n 134\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"tp\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4020,\n \"min\": 1794,\n \"max\": 7480,\n \"num_unique_values\": 2,\n \"samples\": [\n 1794\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "[XGBoost] Train/Test 혼동행렬\n", + "Train FP=4853 FN=366 | Test FP=1183 FN=91\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " split threshold pr_auc roc_auc accuracy precision recall \\\n", + "0 Train 0.489376 0.904375 0.967881 0.864089 0.609228 0.953858 \n", + "1 Test 0.489376 0.902932 0.968021 0.867292 0.608278 0.952801 \n", + "\n", + " f1 false_positive_rate tn fp fn tp \n", + "0 0.743551 0.159282 25615 4853 366 7566 \n", + "1 0.742522 0.154197 6489 1183 91 1837 " + ], + "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", + "
splitthresholdpr_aucroc_aucaccuracyprecisionrecallf1false_positive_ratetnfpfntp
0Train0.4893760.9043750.9678810.8640890.6092280.9538580.7435510.1592822561548533667566
1Test0.4893760.9029320.9680210.8672920.6082780.9528010.7425220.15419764891183911837
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"plot_model_feature_importance(event_model_importance, f\\\"\\ubd88\\ub7c9 \\ud0d0\\uc9c0 \\ud53c\\ucc98 \\uc911\\uc694\\ub3c4 - {selected_event_model_name}\\\", top_n=25)\",\n \"rows\": 2,\n \"fields\": [\n {\n \"column\": \"split\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 2,\n \"samples\": [\n \"Test\",\n \"Train\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"threshold\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0,\n \"min\": 0.48937615752220154,\n \"max\": 0.48937615752220154,\n \"num_unique_values\": 1,\n \"samples\": [\n 0.48937615752220154\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"pr_auc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0010206428198474779,\n \"min\": 0.9029320733900803,\n \"max\": 0.9043754803082473,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.9029320733900803\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"roc_auc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 9.962748950470732e-05,\n \"min\": 0.9678805846478579,\n \"max\": 0.9680214791947006,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.9680214791947006\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"accuracy\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.002264951408488141,\n \"min\": 0.8640885416666667,\n \"max\": 0.8672916666666667,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.8672916666666667\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"precision\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0006715042542035827,\n \"min\": 0.6082781456953642,\n \"max\": 0.6092277961188501,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.6082781456953642\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"recall\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0007473845379645471,\n \"min\": 0.9528008298755186,\n \"max\": 0.953857791225416,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.9528008298755186\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"f1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0007272269852571615,\n \"min\": 0.7425222312045271,\n \"max\": 0.7435506854700015,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.7425222312045271\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"false_positive_rate\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.003595488931619036,\n \"min\": 0.1541970802919708,\n \"max\": 0.15928186950242879,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.1541970802919708\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"tn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 13524,\n \"min\": 6489,\n \"max\": 25615,\n \"num_unique_values\": 2,\n \"samples\": [\n 6489\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"fp\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2595,\n \"min\": 1183,\n \"max\": 4853,\n \"num_unique_values\": 2,\n \"samples\": [\n 1183\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"fn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 194,\n \"min\": 91,\n \"max\": 366,\n \"num_unique_values\": 2,\n \"samples\": [\n 91\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"tp\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4051,\n \"min\": 1837,\n \"max\": 7566,\n \"num_unique_values\": 2,\n \"samples\": [\n 1837\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "[LogisticRegression] Train/Test 혼동행렬\n", + "Train FP=14401 FN=1099 | Test FP=3677 FN=255\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " split threshold pr_auc roc_auc accuracy precision recall \\\n", + "0 Train 0.377797 0.655090 0.815531 0.596354 0.321795 0.861447 \n", + "1 Test 0.377797 0.652634 0.815697 0.590417 0.312710 0.867739 \n", + "\n", + " f1 false_positive_rate tn fp fn tp \n", + "0 0.468559 0.472660 16067 14401 1099 6833 \n", + "1 0.459742 0.479275 3995 3677 255 1673 " + ], + "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", + "
splitthresholdpr_aucroc_aucaccuracyprecisionrecallf1false_positive_ratetnfpfntp
0Train0.3777970.6550900.8155310.5963540.3217950.8614470.4685590.472660160671440110996833
1Test0.3777970.6526340.8156970.5904170.3127100.8677390.4597420.479275399536772551673
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"plot_model_feature_importance(event_model_importance, f\\\"\\ubd88\\ub7c9 \\ud0d0\\uc9c0 \\ud53c\\ucc98 \\uc911\\uc694\\ub3c4 - {selected_event_model_name}\\\", top_n=25)\",\n \"rows\": 2,\n \"fields\": [\n {\n \"column\": \"split\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 2,\n \"samples\": [\n \"Test\",\n \"Train\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"threshold\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0,\n \"min\": 0.377796850305734,\n \"max\": 0.377796850305734,\n \"num_unique_values\": 1,\n \"samples\": [\n 0.377796850305734\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"pr_auc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.001736991324000949,\n \"min\": 0.6526339505198415,\n \"max\": 0.6550904272079681,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.6526339505198415\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"roc_auc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.00011698963803798295,\n \"min\": 0.8155313626174328,\n \"max\": 0.8156968109502032,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.8156968109502032\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"accuracy\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0041984465132950755,\n \"min\": 0.5904166666666667,\n \"max\": 0.5963541666666666,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.5904166666666667\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"precision\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.006424032357254939,\n \"min\": 0.31271028037383175,\n \"max\": 0.3217952340585853,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.31271028037383175\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"recall\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0044486118019452054,\n \"min\": 0.8614473020675744,\n \"max\": 0.8677385892116183,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.8677385892116183\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"f1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.006234980566500743,\n \"min\": 0.4597416872767244,\n \"max\": 0.4685592813550024,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.4597416872767244\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"false_positive_rate\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0046778273813063796,\n \"min\": 0.47265983983195486,\n \"max\": 0.47927528675703857,\n \"num_unique_values\": 2,\n \"samples\": [\n 0.47927528675703857\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"tn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 8536,\n \"min\": 3995,\n \"max\": 16067,\n \"num_unique_values\": 2,\n \"samples\": [\n 3995\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"fp\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 7583,\n \"min\": 3677,\n \"max\": 14401,\n \"num_unique_values\": 2,\n \"samples\": [\n 3677\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"fn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 596,\n \"min\": 255,\n \"max\": 1099,\n \"num_unique_values\": 2,\n \"samples\": [\n 255\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"tp\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 3648,\n \"min\": 1673,\n \"max\": 6833,\n \"num_unique_values\": 2,\n \"samples\": [\n 1673\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9gAAATvCAYAAAD98ljqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XdUE9nbB/BvAoReRBAbxY6KBVERf9i7a1dkXeuuXVkVu6yiuLq6VuwVy9ob2F0LVlRU7L0XREQsdCkp7x+8ZI1JMGgkCN/POZ5j7tyZeYKGJ8/M3HsFMplMBiIiIiIiIiL6JkJdB0BERERERESUH7DAJiIiIiIiItICFthEREREREREWsACm4iIiIiIiEgLWGATERERERERaQELbCIiIiIiIiItYIFNREREREREpAUssImIiIiIiIi0gAU2ERERERERkRawwKYC4++//8aQIUNyvN+ePXvQt2/f7xBRwdO5c2esW7dO68eNiIhAhQoVFP586Tzp6elo1qyZ0n6f/+nWrZvK/adMmaLQb+fOnfJtffv2xdGjRwEAS5Yswd9//62wr5eXl9J56tati9evXyv0W7lyJf7444+v+IkQEeUPzN0/tujoaKV8N23atC/u161bNzg7O2ebn+vXr69y31WrVin0W7BggXybv7+//PvB7t27MWzYMIV9R4wYoXSemjVr4saNGwr9Dhw4gD59+uTsh0EFhr6uAyDSlqVLl+L69etYsWKFyu12dnaQSCQ5Pq5EIkF6erpGfU+cOAFzc3PUrFlT5fYbN25g48aNuHTpEmJjY2FgYIDChQujevXqmD17NgQCAQDg9evXaNiwIWQyGQDA2toaZcuWxcCBA+Hp6alwzMqVK0Mmk+Hw4cOwt7dXG9uuXbvg5+eHRo0aYfny5Sr7LF++HPPnz8/2PZ4+fRp2dnbZ9lHHyckJ1tbWX7Xv527duoXY2Fj56yVLlihs19PTw4kTJwAAQqEQ9erVg1D43zXFt2/f4sWLFzh37hwsLS3VnufTfbKIxWL4+flhzJgx8jaRSASJRAI9PT2kp6fL/8+kp6cjLS1NYf9t27ZBKpXKX0ulUjRs2BAvXrxA0aJF5e1paWlK+xIR5SfM3Xk/d2fZuHEjmjZtqpCnVHn06BEiIyPlrz/Pz0KhUJ6fBQIBateuDRMTE4U+V69exfbt21GpUiW151GXn3v37o1ffvlF3mZgYKAyP2dkZCjl2Hnz5mHOnDkKbd7e3nj8+DGqVq0qb2N+puywwKZ8QyKRQCwWq92eG1caDx8+jBIlSqhM0oGBgVi3bh26deuGwMBAlChRAmKxGFFRUbh8+bI8QQOZCUImk2HPnj0oXrw43r17h8OHD2PgwIHYsGEDatSoodDX0dERO3fuhK+vr9rYtm/fDkdHR2RkZKjt07dvX4Wk5OXlhV69eqFt27YAMhOhubl5jn4mn5o7d+5X7/u5u3fv4smTJxr1FQgE8PDwgEgkkrdlFbhmZmbQ19f8V+G///6LCRMmqD3P6dOnv3gMoVCo9MUgK4aAgABs3rxZ3p71syciyo+Yu/N+7s6yZs0alCtX7osF9pMnT3D16lWNj+vi4qJUYMtkMpiamuYoP9+4cQO9e/dWu33btm1fPIaq/Jz13WH16tWYPXu2vP3Tf0+iT7HAJsoFGzZswNatW7F161Y4OzsrbCtatCjc3NxU7mdmZgYLCwtYWFhg0KBBuHfvHnbv3q30S71Lly7YsGEDhg0bBj09PaXjPHnyBI8ePYK3tzfu37+vNk4DAwMYGBjIXwsEAhgbG8PCwiInbzdXeHl5AQCSk5OxceNGnDhxAtHR0UhPT0eRIkVQp04ddOvWDU5OTlo9b8uWLdGyZUsAwMOHDxEdHY0yZcqgRIkSGh9j3759OH/+vPyLg0wmg5mZGZycnDB58mRMnjwZALBo0SI8f/5cq/ETEZFmmLu/TvPmzdG8eXOIxWJs3boVhw8fRlRUFJKTk2FrawtXV1f8/PPPqFy5slbPW7VqVXlh//z5czx//hz29vYoVaqUxsc4c+YMDh06pFDYJyYmwtnZGRUrVkS/fv0AAMHBwdixY4dW46f8gwU2FRiqHkM7c+YM5s+fj4cPH8LS0hJdu3aFg4MD9u3bh6CgIHk/mUyG5cuXY8eOHYiJiYGNjQ369++P7t27A8gsmEaPHi3vv3jxYnTt2hV//vknkpKSsGDBAkyfPl0pQeeUk5MTbt++rdReu3Zt7Ny5E6dPn0ajRo2UtgcHB6N169YwNjb+pvMDQLNmzRAYGIg1a9YgNDQUvXv3hq+vLyIiIrBkyRLcuXMH6enpKFWqFEaMGKEwRqpPnz6oV6+efFxcjx490KVLF0RERODo0aMQi8WoXr06AgICULJkyS/GIhaL0aNHD9jb22PixIlwcnKCSCRCdHQ09u3bh44dO2Lnzp0oU6aM0r5ZV6iTkpJUfrH5tN/nV7MTExMxePBgpKSkwMHBAbdu3UK9evXkhTEAjBw5EiNHjgQA+f+TLIGBgZg2bRo8PDyUzsc72ERE/2Hu1k7uBjLHpS9fvhyRkZFwcHDAkCFD0KZNG/n2a9euYebMmbh79y5EIhHc3NywfPlyTJo0Cdu3bwcA9OrVCwAwZ86cL+YnHx8fJCcnY8SIEShfvjwMDQ3x9u1bhIaGonv37li+fDnq1Kmjcl+BQIDk5ORsn24QCARK+VssFmPkyJF4+PAhKlSogEePHsHR0RHz58+X34meO3eu/Im6hg0bKuy/atUqtG3bVn4R/1O8g02a4iRnVGB8/hjanTt3MHjwYDRo0ACHDx/GunXrcPv2bSxYsEBp3Nbly5dx8uRJzJgxA6GhoRg5ciT+/vtvXLx4EQDQunVrXLp0CW3atEH//v1x6dIlTJo0CQBw8uRJmJqaonnz5t/8Hu7cuaP2TmmXLl1UXk2VSCTYs2cPOnfu/M3nzzre4sWLUaVKFRw9elT+ONbp06fRrl07bN68GQcPHkTTpk3h4+OjMHGXRCJRGEsnEAgwd+5cpKWlYf369di9ezeKFCmCwYMHy8ewZSc6Ohp37tzBiBEj4OLiAjMzM4hEIjg6OsLHxwcmJia4cOGCyn1tbGzg4OCAunXronLlymr/fJ58AWDZsmVwcHBAcHAwAgMDcfDgQdy4cUM+sRmQ+eXj9u3bGDRokNL+GRkZKseOAcDkyZNx//593L9/Hz4+Pl/8GRAR5WfM3drJ3SEhIZg+fTqGDh2KI0eOwMfHB5MnT0ZYWBgAIDU1FQMHDkTz5s1x5MgR7Nu3D7/++isAYNKkSbh06RKKFSuG5cuX49KlS2jdunW255NIJDh58iQGDBgANzc3mJubQyQSoXjx4ujZsyfKly+PM2fOqN3f1dUVXl5e2ebnatWq4ePHjwr7bdu2DUlJSThw4AACAwOxd+9eyGQyhQvXvr6+uH37NqZOnap03oyMDLUX3fv16yfPzzNmzMj2/VPBxjvYVGCtX78e9evXx/Dhw+VtgYGBaNCggVJfIyMjLF26VD5BV7t27XDp0iX8+++/qF27NvT09GBhYQEDAwMYGhoqPJZ1+/ZtVK1aVWGcVk7FxcVhw4YNuHz5MsaOHauyT6dOnbBkyRLExsbC1tZW3h4WFgYzMzNUr14922SWExKJRGlcXNbd2ixDhgxBcHAwzp49m+0XhEKFCmHWrFnyn8+kSZPg6emJmzdvKkwookrJkiVRv359+Pn54bfffoODgwP09fXx5s0b7N27F4aGhmjSpInKfUUikUJBDABdu3ZF9+7d0b59+2zP++DBA4Ur9yKRCLVq1cKdO3fQrFkzAJl3vtWNHRMKhUhNTQWQmcwTEhIQGxuLZ8+eoXDhwqhVq1a25yciKqiYu3MuIyMDs2fPRkBAAFq1agUAKF68OF6/fo0VK1bA09MTDx8+BAD89ttv8v2yxlqLRCKIRCIIhUKYmJho9Oi5np4evL298ddff2Hw4MEoV64cRCIR3r9/j9DQUDx//hx//vmn2v23bNmi8NrX1xflypX74ozyDx48QM2aNeUXsYVCITw8PHDz5k15n6z8rOpCt1AolBftYrEYiYmJiI2NxYsXL2BgYKDy/xnR51hgU4F1+fJlDB48WKHN2NgYrVq1Upo8q0yZMkqzXzs7O8tnwcxOYmKiUjJ6/Pgxfv75Z4W7tN7e3gqzUgOZXwZkMhlSUlJgZWWFFStWoGzZsirPY2NjA09PT4SEhGDAgAHy9pCQEHTq1OmLceaEqru6qtjb2ystPfW5unXrKnyBMTExgYODA16+fPnFAlsgEGDp0qX4999/cfToUdy4cQNv376Fh4cHatSogQkTJijNEC6TybKdkVYmk6l8JO3TR9GqV6+OPXv2oEWLFjAyMkJsbCyOHj2KgICAbOPN4ubmhkGDBsn//U1MTGBrawtHR0c+Ek5ElA3m7py7desWUlJSlO7Gu7u7y5ewcnBwgFgsxs6dO9GlSxetnHfKlCk4efIkjhw5gqCgIDx+/Bienp6oUqUK9u7dq3JWc3WPhMtkMkilUrXbsy5ou7q6IigoCL/88gusrKyQlJSEffv2afwkgJubG6ZPn45p06ZBKpXCxMQEhQsXhoODg8bffYhYYFOB9ebNG5XjfB0cHJSStKrxT8bGxhot0WBubo6oqCiFttKlS2P37t3yJD1r1iwkJiYq7btu3TpYWlri3bt3OHv2LIYOHYq///5b7S95Ly8vzJgxQ56k4+PjcerUKa2vpVy8eHGltvj4eGzYsAHh4eF49eoVkpOTkZSU9MUxSqqW7TI3N5ff4f0SAwMDtG3bFm3btsWOHTuwd+9eLF68WG3/VatWZTub+fXr1zFu3Dil9qwZwosUKYL+/ftj7NixqF+/PooWLYqoqCj8+uuvCsuwZHfXY+7cuZg1axYkEonaq+hAZiGf3fItREQFDXN3zkVFRSEtLQ3u7u4K7VKpFKmpqYiPj4elpSWCgoIwceJEbNu2Db6+vqhbt+43nVcgEKBRo0Zo1KgRzp07h4kTJ6pdagzIXFv686fhPrdo0SKV7du2bUP16tXRvn173Lx5E02aNEGJEiXw6tUrtG7dWuWYalVGjhyJESNGQCwWQ09PT+3j4uXKlUOLFi00OiYVPCywqcD6dB3iTxkZGWn1PBUqVMC///6r0CYQCBTGY32+PEWWYsWKye9s1qhRA0WKFIGfnx/Onj2rsoDLmmjr4sWLqF27Nvbv3w93d3eFx8604fMvLSkpKejatSuMjIzQtWtXODs7w8rKSj6WTZtiYmIUJk5TpUKFCirbR44ciYEDByrcJfjUx48fYWBg8MVlQQwNDbFgwQLExsbi9evXcHJyUlgCZdKkSfIr80KhUGWC1tPTQ/PmzREdHZ3tecaPH59tLEREBQlz99extrZWuUyVQCCQP+mV9XRWSEgIfH190aJFC5XjlLPj4uKS7ZJi6vKzt7c3pk6dip9++knl9rS0NAiFQoXZ0lURCASYNGkSfv/9d0RGRqJEiRIKF/IHDx4s/w6japI0IDNv9+vXDxEREWrPo6+vr/A4PdGnWGBTgWVnZ4eXL18qXdF9+vTpVx9TVeKsX78+AgICcPz4cTRu3Pirjw1kPs717t07vHv3DjY2Nkrb9fT00KlTJ+zYsQO1a9dGcHCw0qN038ORI0eQnJyMPXv2KHzJ+fDhg9bPZWdnh5s3b2o0CdrnPk/MMTEx2LBhA86dO4cHDx7IvxRYWVmhSpUqaN68Obp06aL2DrOtrS2kUik2bdqEs2fPIjo6GgkJCbCwsECxYsXwv//9Dx07dlS7ZmhoaGi28c6ZMweXL1+Gt7d3jt8rEVF+xNydc3Z2dnj//j1sbW1haGiYbV89PT106dIFLi4u6NSpE7p164aKFStqfK4rV658VX7+/MJ2QkICNmzYgLCwMNy5c0f+VJuZmRkqV66MBg0aoGfPnvKZwT9nZWUFgUCAkJAQnDlzBi9fvkRcXBxMTU3lS3m2bt1a7bCsf/75J9t4t2zZgv379+f4fVLBwFnEqcBq0KABQkJCFNqyxuqo+4X9JSKRSGl8kLW1NQYPHgx/f/9v+gIAADdv3oSJiYnSuOJPde7cGceOHcPly5fx6tWrXJmQIzY2Fvb29grF9cOHD7/bGs4ikQiGhobw8/PDnTt3YGhoqNGfTwvlmJgYdOjQAVFRURg9ejROnjyJmzdv4sqVK9i8eTOaNGmCFStWwN/fX20cjx49Qrt27RAXF4fRo0cjODgY586dQ3BwMEaNGoWEhAR4eXmpXJ6FiIhyjrk751xcXGBkZKTyDrY6zs7OMDExUXhM3tDQMNtls4D/8nNgYCBOnjypcX7+9E5ySkoKvLy8cOXKFfTv3x+HDx/GjRs3cO3aNQQHB6Nz587Yu3cvBg4cqDaOt2/fol27drh//z4GDhyIrVu34uzZs9i7dy/8/f1haGiInj174tSpUxr/TIg0xTvYlK9IJBIkJCQotGX98v7cwIED0a5dO/j7+2PQoEFISEiAv78/jIyM1N5x/JLixYvj0KFD8PLywocPH+Di4gKBQID+/fvjzZs36NKlC3r37o3GjRujePHikEqliIyMxOPHj1G5cmWl42Wt0fzu3TuEhYVh8eLF6Nu3b7aPSJUsWRKurq4YNWoU2rVr98XHqbTBzc0NCxYswL59++Du7o779+9j+vTpObrq/TXu37+Pd+/efdW+Fy9ehIGBAebPn6/QLhKJUKZMGZQpUwY2NjaYOHEipk2bpvIYoaGhqFKlitJj3BYWFqhevTqqV6+OhIQE7N+/H66urkr7DxkyBCdPnlQbo0gkgp+fX87fHBHRD4S5+/vmbmNjYwwcOBCzZ8+GVCpFq1atkJGRgevXr6Nw4cKoU6cOnj17hnv37qFq1aqQSqVYv349hEIhqlevrvBzOnjwIMqWLYv4+HiUL19e7TmfPHmichIzTdy7dw8vXrxQedHE0dERjo6OKFeuHDp27Ijk5GSYmpoqHSM8PBwmJiZKy2mZmZmhUqVKqFSpEoDMtcZVLcU2bdo0bNmyRe3deH19ffTt2/er3h/lfyywKd/Q09PD+fPnlZY4at68ORYtWgQ9PT2FR5Ds7OywadMm/PXXX2jVqhUsLCzw888/48KFCwqTVRkaGqq8Kq6q3cvLC6dPn0br1q3h6OiIXbt2QSQSQSAQYOLEiWjZsiU2b94MHx8fvH37Vv6FoFatWvjll1/kx8mKs2XLlhAKhbCwsECFChUwefJktGvXTuGcWctnfMrb2xu+vr5KM4Gq+8Kijqr+qib9qFGjBqZPn47ly5dj4sSJcHJywtixYxEeHq4wY/fn+6qbQCTrCviXCAQCpKSkfHHCGn19faXz1KpVC+np6ZgwYQI6d+6MMmXKwMLCAhKJBDExMbh8+TKWLVuGRo0aqT1uw4YNsWbNGixbtgwtW7aEo6MjhEIhpFIpnj17hmPHjiE0NFTtpGv37t3DsmXLuOwHERVYzN3/+Z65e9CgQbCwsMDmzZsxZ84cGBoaokKFCvILxO/fv8esWbPw6tUrGBsbw8XFBUFBQQqPtPv4+GD8+PFo1qwZfvrpp2zXghYIBEhNTf1ifv783xfIHKdtb2+PYcOGoWfPnnB2doalpSVkMhnevn2LGzduYOXKlahdu7bK4hrIfCx/5syZ+Pvvv9G+fXuULVsW+vr6kMlkiIqKwqlTp7Bp0yZMnDhR5f7379+Hn58funfvnm38RKoIZF8zUIIoH3j27BlOnjwJT09PWFlZISYmBhs3bsTz58+xYcMGtTNHUt4REBCAbdu2ZbvsFgB06NABf//9t1L7y5cvERQUhLCwMERFRcmPY2JigqpVq6JFixbw9vbO9v9CZGSk/NGz169fIz09HSKRCEWLFoWnpye8vLzg6Oioct8hQ4bg+PHj2Y5XMzExwdWrV7N9f0REBQVz949h5cqVWLhwYbYTngGZF7s3btyo1P7+/XusWbMGJ06cwPPnz+XHEYlEqFy5Mho3boxevXplO7nd27dvsXXrVpw+fRpRUVFITU2Fvr4+bGxs4OHhgU6dOsnvZH9u2rRp2LRpk9pJ9YDMiwjnzp1TuRoKFWwssKnAiomJgb+/P27cuIGEhATY2NigRYsWGDZsGMzMzHQdHuUyiUSC5ORkGBgYqFzahYiIdI+5u+CRSqVITk6GUChUe8eaKC9hgU1ERERERESkBZxFnIiIiIiIiEgLWGATERERERERaQELbCIiIiIiIiItKHDLdBm7+ug6BKJ8IfJMoK5DIMo3bMwKXDrO1hRn7a0BTFSQTTl/X9chEOUfhUpr1I13sImIiIiIiIi0gAU2ERERERERkRawwCYiIiIiIiLSAhbYRERERERERFrAApuIiIiIiIhIC1hgExEREREREWkBC2wiIiIiIiIiLWCBTURERERERKQFLLCJiIiIiIiItIAFNhEREREREZEWsMAmIiIiIiIi0gIW2ERERERERERawAKbiIiIiIiISAtYYBMRERERERFpAQtsIiIiIiIiIi1ggU1ERERERESkBSywiYiIiIiIiLSABTYRERERERGRFujrOoBPJScnIyIiAtHR0UhISICFhQWKFSuGmjVrwtTUVNfhERERFXjM1UREROrliQI7PDwcq1evxt27d1GlShUUL14c5ubmiI6OxokTJzBu3Di4uLigb9++8PDw0HW4REREBQ5zNRER0ZfptMCOiYnBlClTYG5ujkGDBsHNzQ0CgUCpn1QqxaVLl7B9+3asX78eAQEBsLOz00HEREREBQtzNRERkeZ0WmAvWbIEfn5+sLe3z7afUCiEu7s73N3d8fTpUyxevBh//vlnLkVJRERUcDFXExERaU4gk8lkug4iNxm7+ug6BKJ8IfJMoK5DIMo3bMzyxIitPGOKs4GuQyDKF6acv6/rEIjyj0KlNeqWZzJ6YmIizpw5gwcPHiA+Ph4CgQDm5uZwcnKCh4cHihYtqusQiYiICjTmaiIiouzpfJmujIwM+Pv7o2HDhti1axcSExNhaWkJc3NzJCYmYu/evWjVqhUmTJiAtLQ0XYdLRERU4DBXExERaUbnd7DnzJmD2NhYhIaGwsrKSmWfDx8+wM/PD7NmzcKkSZNyN0AiIqICjrmaiIhIMzq/g33gwAHMmjVLbcIGgEKFCmHmzJk4dOhQ7gVGREREAJiriYiINKXzAlssFsPExOSL/czMzCAWi3MhIiIiIvoUczUREZFmdF5gu7m5ISgo6Iv9goKC4OrqmgsRERER0aeYq4mIiDSj8zHY/v7+6NevH06cOIEmTZqgdOnSsLCwgEwmQ0JCAp4+fYpjx47hw4cPGiV3IiIi0i7maiIiIs3kiXWwxWIxTp06hRMnTuD58+d4//49xGKxfOmPunXrok2bNhCJRN98Lq6DTaQdXAebSHt+hHWwczNXcx1sIu3gOthEWvQjrYOtr6+PJk2aoEmTJroOhYiIiFRgriYiIvoynY7BnjRpEl68eJGjfZ49e4aJEyd+p4iIiIjoU8zVREREmtPpHezff/8dAQEBMDY2hre3N2rVqqW278WLF7FlyxakpaVh8uTJuRglERFRwcVcTUREpLk8MQY7PDwcQUFBuH37NqpWrYqSJUvCzMwMiYmJiIqKwvXr11G5cmX07dsXHh4e33QujsEm0g6OwSbSnh9hDHZu5mqOwSbSDo7BJtIiDcdg54kCO0tSUhIuX76MqKgoJCYmwtzcHCVKlICbmxvMzMy0cg4W2ETawQKbSHt+hAI7S27kahbYRNrBAptIi36kSc6ymJmZoUGDBroOg4iIiNRgriYiIlJPp5OcfW7btm26DoGIiIiywVxNRESkXp4qsBctWqTrEIiIiCgbzNVERETq6fQR8devXyMjI0P+WiqVIjIyUv7azs4OIpEIiYmJuHbtGlxdXbU2vouIiIi+jLmaiIhIczotsH/55Rekp6fLXwuFQnTr1k3+etq0aXBxcUGXLl1gbW2NuLg47Ny5E9bW1roIl4iIqMBhriYiItJcnppFXJXAwEDIZDL4+vpiyZIlSE9Ph6+v71cfj7OIE2kHZxEn0p4faRZxVbSdqzmLOJF2cBZxIi3ScBbxPDUGO0tycjKkUikA4MSJE/Ir5d7e3jh58qQOIyMiIiKAuZqIiEiVPFlgT5gwATt37gQAxMXFoWjRogAAGxsbJCYm6jI0IiIiAnM1ERGRKnmuwF63bh1evnyJjh07Asgc60VERER5B3M1ERGRanlm0Nfbt28RGBiI69evIygoCAYGmeOvRCIRkpOTYWpqitTUVHk7ERER5S7maiIiouzptMB2dXWFtbU1LC0t8eDBA7i7u2PLli0Ky3vUrl0bR44cQceOHREaGgo3NzcdRkxERFSwMFcTERFpTqcFdmhoKGJiYvDo0SPs2bMH4eHhWL58OUaNGgWBQAAA6N69O/r06YOLFy/i9OnTCAoK0mXIREREBQpzNRERkeby1DJd169fx9ixY+Hq6oqZM2fK2+/evYuwsDB4enqiYsWK33QOLtNFpB1cpotIe36kZbpyI1dzmS4i7eAyXURapOEyXXmqwAaAxMREeHt7w8vLC7/++qvWj88Cm0g7WGATac+PVGAD3z9Xs8Am0g4W2ERapGGBnecyurm5OZYuXYoNGzboOhTKgRaelTC8RxPYFDKDUCjAuWtPMG7uLnxMzQAA/Ny6FgZ714dIpA99PT3sOX4N01ccQtb1naX+v6BpHWe8T0iRH/PizWcYNn2rwnm6t3VH3051YWQogqFIH1sOXMSctUeV4unZrg5WBvRAs36BCLv86Du+c6Lcs39PMObMmIotwQdQrHgJefuViItYuXQBUpJTIBaL0a1nH7Tt0Fm+XSaTYX3QChw9fBACgQBlypbDWL8pMP1kDG2W9PR09PLuABvbIli8cl1uvC36ATFX5w8CoRB9t5yBvshQob2QfSns8P0Fj84c/v/XpdF9xR7cOrgdJxf/qdDXo88IuLTuCj2RIYRCIS7vWIMLGxYpnce95++o8pM3hPoG0Dc0xJkVf+PG3k3f9w0S6dCeQ8cxff4yFLMrIm8TGRhg66q50NPTU+g7buoc7Dt8ArfO7FNYlSE1NQ0rN2zHybCLkMqkSEvLgP+YIfCoWT233gZ9hTxXYAOAk5MTJk2apOswKAeSUtLQb9I/eBUbDz09IVZP7Qn/wW0wYX4IvFq4YbB3fXQavhzv4pJhZmKI9TN+hW+vJpi3/hgAQF9PiL9WHcK6kPNqzzF5SBtULlccXUeuwtsPSZn76SsvDWNpZozfuzfClTsvYKCvp7Sd6Ee0culC3L97G+YWFpBIxPL2xw8fYNpkP8xZuByly5RFYmICxg4fgmLFS6Bm7ToAgD3BO3D75g2s3bQTIpEIm9YHYeaf/vjz73lK59myYS1K2DsgJSkp194b/ZiYq398MqkUq73/p9CmLzLEsKP38fJaOACgZDV3tJu2Au9fPIFQT/lr47vnD7G+TzOkpyTDxKow+mwIxYfIx3hw8qC8T8eZa5GRmoL1vzZHenLm7xahfp78CkqkNRKJBPU9amFOwNhs+12+fhsf4hIgkUghlcqQVV+LxRL0950Ed7dq2LpqLkQiEWQyGSQSaS5ET9+CC1eSVpy98hivYuMBABKJFPPXH0OTOs4AgIa1y2P7v5fxLi4ZQGYxvnFfODxcy2h8/DIOtujVvg56jlsjL64BQCxW/iUzeWgbLN58Akkpad/ylojyDKlUChsbW8wKXArRZ3eadu/aBu/uvVC6TFkAgLm5BYb6jkHIzv+e/tizazuGjhgFkUgEAOjW81fcvnUD8XFxCsd6Hf0Kx48dRtduPb/vGyKiPKty6654ev4EUhMzc7pp4SLYPKgDXt2KUNn/wYkDSE/JzO8pce9wZccalPlfM/l2J/cGsC1bCfv8B8uLawCQisVKxyIqaCQSCWYsWInxwwcobdvzbyjMzEzh06+7PH8LBALo8+ZRnqfTy4cRERHIyMhQu71KlSowMzNDYmIirl27BldXV4VlQSjvKmRpirT0zH/bCzeeYugvDbFx3wXEJ32EhZkRhvdsgpBjVzU+Xsemrth68BLS0rNPyFXKl4BbJQeM/HsHurdx/6b3QJRXCIVCdOraTeW2qJeRqFO3nkJbqdJlcff2LQBAfFwcYmPfwKnUfxe0hEIhqlSrjsuXLqBxsxby9kXzZ6HfIB+uYUwKmKsLlpre/XF0zgT56/vH9+Vof2PLQhCnpcpfu7T2xpUdnFWeSJUtwQfgVrUySjuWVNp28Ogp9PJur4Oo6FvptMCeN28eJBKJ/PWdO3dQqVIlAJlXaCZMmIASJUqgS5cusLa2RlxcHHbu3Alra2tdhUwa6t/FE5v2XwQAbNh7AW6VHRGxww//7A1Hj7buOHL2DhZuPKHx8aqWL4Ezlx9izpjO8HQrh4wMMbYcvISlW04p9Js3zgvj54Vo9b0Q5WVWhazxKuqlQltU5At8eP8OAPDubSyKFLFT2q+IXVG8ioqUv7504TySk5JRr0FjXIm4+H2Dph8Kc3XBUaS8C4wsrPDi8tmv2l/PQIRqHXpiy+CO8raiFariyblj6DAjCMUquSI9JQkXNy3Dzf1btBU20Q/pfVw8NuzYi51rFqjcfu/hUxgaGuL38dPwLDIKhaws0a9HF9T3qJnLkVJO6bTA3rx5s8JrT09PbNu2TaEtMDAQ7du3h6+vL5YsWYL169fD19c3N8OkHGrqURFVK5TEbxP/AZA5wdK6kHNoULMc/Aa0wrOot9hy4CI+ncBeJgMG/9wA/Tp7wsjQAJduPcP05QfxMiYOAGBtaYrhPZrA9+/tGD17FwpbmWLTrL6wMDPGzFX/AsicSO3Vmzicv/4k198zka781K4jZv7pj5rudVCqdFnEvonByqULIRBkjgBKTEyAyFCktJ9IZIjU1My7TOKMDCyaNwtT/pqdq7HTj4G5uuCo6T0AV3au+er9G/pMwrNLpxHz4Ka8zdjKGvUGjMf+AB9E3bgIy+IO+GX5HgiEQk5yRvmaQABEXLuFbgNGIS4+EY4li2Fgn5/hWiVzGcO5S9bi126dYG5mqnL/uPgELFu7Bf6jh6KMkz3uPXyKQaMn42//0XB3q5qbb4VyKE+OwX7x4gWio6MBACdOnEC3bpmPRnp7e+PkyZM6jIy+pKSdFZZM6oY+fuuQnpH5OHdLz8rYt9QHq3eGoUTDcQj85zi2zx+IXzvWle83YX4IPLvPhmeP2fhf91l4EvkWe5cOhZ5e5n9RqVSG4GNXcfTcXQDAu7hkjJsbjN/+/xhmJoaYOLA1/gjcnbtvmEjH3Gq5Y9T4iZg/6y/08u6IqZPGo1vPPjD9/4QtEomQnpautF9aWhoMDTPHc2/bsgHV3WrKx3ETaYK5On8xMDZB5ZadcT3k62aGL1uvBSo274hD00YotMtkUkRsX4WoG5lPxsS/eoETC6fAzavvN0ZMlLe1aFwP+zcvw5aVc3Fw6wr83OknDB4zBc9eROHG7fu4c/8RurZvqXZ/gVCAfj28UMbJHgDgXK4U+vzcEbv2H8mtt0BfKU8V2NWrVwcA/Pnnn/LkHBcXh6JFiwIAbGxskJiYqKPo6EtMjETYNm8ApizZhyt3Xsjbx/zWHOPnBWPx5pN4H5+MFdtPo9vo1Zg0+Cd5n/fxycgQZz6CmJYuxuw1RyDS10fF0pn/9rHvE/Hw+RuF8z2OjIVNocxxfuP6tcDmAxfld7yJCpI6deth4fI1+GdbCBatWAsTExOULlMOAGBbpChiXkcr7fMm5jWK2BXFhw/vEbJjK/oNHJrbYdMPirk6f3Jp7Y2n4SeQEvcux/valHZG24Cl2ObjhbSkBIVtye9i8e7ZA4W29y8ew8Ta5pviJcrrTIyNYGaaebFbIBCg4f9qo0k9D5w+H4Fp85ZhwogBCktyfa5wISs4OZRQaHMoWQzvP8R/17jp2+l8jYTWrVvDysoKAwcOxOLFixEWFoaXL1+iS5cuAJDtfzzKO4RCAf6Z+SuOnL2DLQcuKWwzNzXCvSevFdpuP3oFSzPjbI+ppyeA+P+XIrh85zlcyhVX2F7WwRaPI98CAIrbWqGac0m0a1xNvr2MvS0W+f2MCzeeou+kf776vRH9aPbt3oWGjTNn8bWxtYWxiQmePnmEUqUz71BLpVLcuHYFA4cOx9vYN5DJZPh90G/y/T+mpOD9u7fo3a0TRo2biKrVa+jkfVDewVyd/9X8eQCOzfXL8X6mhYug29Jg7PMfjNjHd5W2v7oVAbvyVfDswn9zphR2LIv3Lx5/U7xEPyKpVAo9PT18iE/A9PkrlLZ3/nUYOrVpht7eHVClYnk8ePQM9sWLyrc/j3wFx5LFcjNk+go6L7DfvHmD7t27Y9y4cahXrx6uXr2KhQsXymexFYlESE5OhqmpKVJTUzm7bR41d0wXpKZlIGDpfqVta4LPYurv7dB7wlrEfkiCoUgfU3zaYuP+C/I+DsUK4UX0BwCAyEAfE/q3RMy7RHlhvu1QBMK3jEfw0au4cOMpLMyMMHNkJyzadBwAVBbQh1cNx8zV/+LEhfvf4y0T5QlZcxkIBAJkZKRj17bNuH/vDnzH/vdFucvP3bF0wTz8NScQBgYibNmwFmXLVUCJkpmPne3af1ThmFciLmLV0oVYtmZj7r0RytOYq/O3YpVcYWxZCE/DNZ98FAD0DY3wy7LdCP9nER6FqX5s9fL2IPRYtQ+Pwo7g3dMHMC9SHI1+n4xD0zlGn/K3mDdvUdi6kHxZrcPHw3AmPAK+g/uge5c2Sv0r1GmFXWsXyvv/0rkN/gpcgaqVy8O2sDUeP32BDdv3YFXgtFx9H5RzOi+wjYyM0L17d7Ru3Ro+Pj4oXbq0fHZSAKhduzaOHDmCjh07IjQ0FG5ubjqMllSxMjfGoJ8b4P7T1wjfOl7eLpPJ0H7oUizfdhpp6WKELB4CfT0hBALgyNk7mLr0gLzv6N9aoL5bWaSmiyEUCHD8wj10/H2ZfPu7uGT0HL8Gc8d5wcxYBIFAgDXBZ/HPnnC1cWWIJfLHzonyCwMDA+jr/1e8PH38CH/6Zy6pI5FI4FbbHYFLV8PA4L+Jzbx/6YWE+Dj0/rkzBEIBnEqVxsSAv9SeQ19fH3r6Ok8PlIcwV+dvNbr8hoitynfTPiXJSIdMKlVoK1uvBYpVcoWegUhhTHV89AtsGdIJAPD2yT0cmuYL7wXbINDTg0wiQdjqOXh64aTW3wdRXnI6/DKCNu2E6P8vOJZyLIn1i2eiiI3qFRZEIgMIBP+9rlvbFb29O6DHoLEQCAUwMTLClHG/y8dkU94lkH06lbMOeHp6IiwsDACQmpqK/v37o2nTpujduzcA4N69e+jTpw8aNWqE06dPIygoCM7Ozl99PmNXH63ETVTQRZ4J1HUIRPmGjVnevqCR27l6ijPvgBNpw5TzfIqPSGsKldaoW54aNGVkZIS5c+dizZo1ePjwIQDA2dkZa9euRenSpbF69epvSthERET0bZiriYiI1MtTBTYAFClSBKNGjcKsWbPkbRUrVkT//v1RsWJFHUZGREREAHM1ERGROjovsLds2aLU1q5dOwiFQrx//14HEREREdGnmKuJiIg0o/NBX/b2qgfqr1iR/WQbRERElDuYq4mIiDSj8zvYRERERERERPkBC2wiIiIiIiIiLWCBTURERERERKQFLLCJiIiIiIiItIAFNhEREREREZEW6HQW8evXryM9PT1H+xgYGKB69erfJyAiIiJSwFxNRESkOZ0W2AsXLsxx0haJRAgKCvpOEREREdGnmKuJiIg0p9MCm8mXiIgob2OuJiIi0pxOC+yVK1d+1VXxAQMGfKeIiIiI6FPM1URERJrT6SRnMplMqW3NmjU6iISIiIhUYa4mIiLSnECmKnPqkKenJ8LCwgAAUqkU27dvh7e3NwQCgVaOb+zqo5XjEBV0kWcCdR0CUb5hY6bTB8py7Hvn6inOBlo5DlFBN+X8fV2HQJR/FCqtUTedL9MVExODuLg4+Wtra2sAgFgsxpgxY3D16lWtJWwiIiLKOeZqIiIizej8knmvXr3w8uVLuLq6on379ti1axeePHmCcePGoVq1avjjjz90HSIREVGBxlxNRESkGZ0X2MnJyThx4gROnjyJAwcOYP78+UhJScG0adPQpk0bXYdHRERU4DFXExERaUbnj4gDQJEiRdC1a1esW7cOCxcuRLly5XDkyBGkpqbqOjQiIiICczUREZEm8kSB/amaNWti69atKFKkCLy8vBTGfBEREZHuMVcTERGplucKbADQ09PDxIkT0b59ewwaNAhpaWm6DomIiIg+wVxNRESkTOcF9qxZs9Ru69evH1xdXREcHJyLEREREdGnmKuJiIg0k+fWwf7euA42kXZwHWwi7fnR1sH+3rgONpF2cB1sIi36UdbBJiIiIiIiIsoPdHrJ/OLFi0hPT1e5zc3NDcnJyXj48CFkMhnKlSsHW1tbLFu2DIMHD87lSImIiAom5moiIiLN6bTAXrJkCTIyMpTaBQIBAgIC4OfnB5lMBoFAAKlUip07d2L37t1M2kRERLmEuZqIiEhzOi2w169fn+32uLg4HDlyBADQpEkTAEABGzJORESkU8zVREREmsvTY7AFAoGuQyAiIqJsMFcTERH9J88V2CtXrsSVK1cA8Ao4ERFRXsRcTUREpFqeKrAfP36Mf/75B05OTroOhYiIiFRgriYiIlLvqwvsGTNmaNRP3cyjn3v+/DmGDBkCf39/WFtbf21YRERE9P+Yq4mIiHLXVxXYEokE//zzzxf7Xbt2DY0bN1abuP/66y8sW7YMS5YsQffu3TFkyBA0b95cvl3VuC6O9SIiIvoy5moiIqLc991mEX/x4gWGDx8OX19fiEQilX2sra0RFRWFsLAwmJqaokKFCgrbPx3XlZSUhAkTJiAuLu57hUxERFSgMFcTERFpl8YFtouLCyQSify1TCZDxYoV5a/Hjh2Ljh074uLFi4iMjMTatWsxePBgdO7cWe0xBw0aBACQSqXYt28f+vXrh9mzZ8PDwwMAMGTIEHnfuXPn4vnz5/jpp580f3dEREQFCHM1ERGRbglkGk7/+fz582zHaBUrVgwvX77E6NGj8eLFC9SqVQtz586FlZWVxsFcv34dQ4cOxZYtW2Bvb6/xfjlh7OrzXY5LVNBEngnUdQhE+YaNmXYeKMsvuXqKs8F3OS5RQTPl/H1dh0CUfxQqrVE3jQvsnIiLi8Py5cuxf/9+rF69Gs7Ozhrvu337dty5cwdTpkzRdlgAWGATaQsLbCLt0VaBnRN5OVezwCbSDhbYRFqkywI7y9atW7Fo0SKEhISgSJEiGu8nkUigp6f3XWJigU2kHSywibRHFwV2lryYq1lgE2kHC2wiLdKwwNY4o0+ePBnv3r1D3bp10a5dO5iZmSn1EYvFOH36tHzCE1tbW7i5uSEmJiZHSft7JWwiIqL8jLmaiIhItzRepmvnzp0oWbIkQkJC0LRpUxw8eFCpT1JSEtauXQsfHx+sWbMG69atw8uXL9GvXz+tBk1ERETKmKuJiIh0S+M72BKJBCNHjoRIJMLx48fxxx9/4NWrVwoJ2crKChs2bICzszNWr14NY2NjpKWloVq1at8leCIiIvoPczUREZFuaXwHWyAQyP/euHFjbNy4EatWrcKxY8ey7SsQCBReExER0ffBXE1ERKRbXz2rSpkyZTBz5kxMmDABtWrVgqWlJdLT03Ht2jUAwOXLl2FoaIj4+HgmbSIiIh1griYiIspd3zRtaaNGjVC7dm0sXrwYf/zxB2JiYvDXX3+hQoUKmDNnDoDMq+Jt27bVSrBERESUM8zVREREuUfjAlvdal7Dhw9H586dMWjQINjb22P37t3aio2IiIhygLmaiIhItzQeg33o0CGIRCKl9jJlymDMmDGQSCRaDYyIiIhyhrmaiIhItzS+g12qVCm127p3766VYIiIiOjrMVcTERHplsZ3sImIiIiIiIhIPY3vYE+fPh0ZGRk5PoFIJIKfn1+O9yMiIqKcYa4mIiLSLY0LbFtbW6Snp+f4BKrGghEREZH2MVcTERHplsYF9oABA75nHERERPSNmKuJiIh0S+MCe8qUKUhLS8vxCQwNDTFlypQc70dEREQ5w1xNRESkWxoX2E5OTkqPnc2fPx8jRoyAQCBQfwJ9jU+RKz5cWqzrEIjyhUtPPug6BKJ8o175Qlo5Tn7J1VOuROs6BKJ8Qfr4qK5DIMo3hIVKa9RPIJPJZF97kooVK+L27dsQCjMnI7969SrMzMxQrly5rz3kd5cq1nUERPkDC2wi7dFWga3Kj5irkfJW1xEQ5QsssIm0R1ilm2b9cnJQVbV41hXxixcvYvDgwYiO5lVnIiIiXWGuJiIi0p0cPRPWpEkT6OnpoVWrVvDy8sLZs2chEAiwZs0arFq1CnPmzIGnp+f3ipWIiIi+gLmaiIhId3JUYL969QpTp07FmTNn0K5dOzRq1AiPHj2CkZERtm7dCkdHx+8VJxEREWmAuZqIiEh3cvSIuEAgQIcOHbBo0SKcPHkSdnZ2ePbsGVq2bMmETURElAcwVxMREelOjgrsT1laWmLcuHHYv38/9u/fj+HDhyMlJUWbsREREdE3YK4mIiLKXV9dYGdxcHDA5s2bIZPJMHDgQKXlQYiIiEi3mKuJiIhyR44KbENDQ/kyH58yMjJCYGAgzM3N4evrq3IGUyIiIvr+mKuJiIh0J0cF9tWrV6Gvr3peNKFQiMDAQBQrVgzJyclaCY6IiIhyhrmaiIhIdwSyAnYJO1Ws6wiI8odLTz7oOgSifKNe+UK6DiFvSXmr6wiI8gXp46O6DoEo3xBW6aZRP42X6Tp48GC2Y7aaNGmCqKgo3L9/HwDg7OyMChUqwMfHB4sXL9b0NERERPSVmKuJiIh0S+MCe8eOHUhLS1O5TSgUolq1aujVqxecnJwglUoRHR2Ns2fP4tixY1oLloiIiNRjriYiItItjQvstWvXfrFPcnIytm/fDgBwcXH5+qiIiIgox5iriYiIdOubl+n6lEAg0ObhiIiISMuYq4mIiL6fby6wN2/ejA8fMic7KmDzpREREf0QmKuJiIhyxzcV2JcuXcL8+fOZrImIiPIo5moiIqLc89UF9suXLzFy5EhMmDAB1tbW2oyJiIiItIC5moiIKHdpPMlZfHw8zM3NIRQKcerUKUyYMAG//PILOnXqJO/zreO6njx5gvDwcERHRyM+Ph6WlpYoVqwY3N3dUaZMmW86NhERUX7HXE1ERKRbGhXYEokEderUgb6+PooUKYJXr15h6tSp8PLyyna/7Nbi/PTYISEhWLt2LQwMDODm5obixYvDwcEB8fHxePToEbZs2QKpVIo+ffqgY8eO0NfX+LoAERFRgcBcTUREpHsaZT89PT2cPXsWr169wvXr17Fjxw4sW7YMFSpUQNWqVVXuY2Njg2rVqqFYsWJqj3vnzh3MnDkTbm5uWLlyJUqUKKG2b2RkJHbs2IE+ffrgjz/+QMWKFTUJnYiIqEBgriYiItI9gewrZz3ZvHkz5s6dixUrVqBmzZoAMsd6lSxZEgCQkpKCDx8+oFChQjAxMVF5jAULFuC3336Dubm5xueNi4vD2rVr4evr+zVhI1X8VbsR0WcuPfmg6xCI8o165Qt9l+P+qLkaKW+/bj8iUiB9fFTXIRDlG8Iq3TTq99UFNgDs27cP06ZNw+7du7O9+p2XsMAm0g4W2ETa870KbODHzNUssIm0gwU2kfZoWmB/0zJdbdu2Rbt27XDo0KFvOQwRERF9J8zVREREueeb7mD/iHgHm0g7eAebSHu+5x3sHxLvYBNpBe9gE2lPrtzBJiIiIiIiIqJMOl9Do1q1apBIJF/sJ5PJYGhoiCtXruRCVERERJSFuZqIiEgzOi+wO3fujBcvXiAgIOCLfQ0MDHIhIiIiIvoUczUREZFmdD4GWyqVYujQoXBxccHQoUO/+/k4BptIOzgGm0h78voY7NzO1RyDTaQdHINNpD0/zBhsoVCI+fPno3Tp0roOhYiIiFRgriYiItKMzgtsADAyMkKrVq10HQYRERGpwVxNRET0ZXmiwCYiIiIiIiL60em0wJ40aRJevHiRo32ePXuGiRMnfqeIiIiI6FPM1URERJrT6Sziv//+OwICAmBsbAxvb2/UqlVLbd+LFy9iy5YtSEtLw+TJk3MxSiIiooKLuZqIiEhzOp9FHADCw8MRFBSE27dvo2rVqihZsiTMzMyQmJiIqKgoXL9+HZUrV0bfvn3h4eHxTefiLOJE2sFZxIm0J6/PIg7kbq7mLOJE2sFZxIm0R9NZxPNEgZ0lKSkJly9fRlRUFBITE2Fubo4SJUrAzc0NZmZmWjkHC2wi7WCBTaQ9P0KBnSU3cjULbCLtYIFNpD2aFtg6fUT8c2ZmZmjQoIGuwyAiIiI1mKuJiIjUyxOziGdkZGD//v0AgMePH+P+/fs6joiIiIg+xVxNRET0ZXmiwE5KSsKKFSsAAFeuXMGFCxd0HBERERF9irmaiIjoy3RaYMfExODVq1eIiYmBWCxGdHQ04uPjER8fj1evXiE5ORkA8PHjR5w/fx4JCQm6DJeIiKjAYa4mIiLSnE4nOatfvz4yMjKgKgSBQICePXuid+/e6NSpE/T19ZGcnIzt27ejSJEiX31OTnJGpB2c5IxIe/LyJGe6yNWc5IxIOzjJGZH2/JCziGdJSUkBAJiYmGDjxo148uQJ/P39sXLlSiQmJmLUqFFffWwW2ETawQKbSHvycoGtzvfM1SywibSDBTaR9mhaYOeJMdifW79+PUJCQgAAJ0+ehJeXFwCgS5cuOHXqlC5DIyIiIjBXExERqaLzZbqio6MRFRUFAHB0dIStrS2KFSuG27dvA8gc++Xk5AQAsLa2RlJSkq5CJSIiKpCYq4mIiDSj8wK7Q4cOKFmyJMRiMaRSKfbt24eSJUvi+PHjAID09HQYGBjoOEoiIqKCi7maiIhIMzovsI2MjLBr1y4AgKenJwCgaNGi+PAhc3xnoUKF8O7dO9jZ2UEsFkNPT09nsRIRERVEzNVERESa0fkYbIFAoNRmZWWF1NRUAED16tURFhYGALhw4QIqVaqUq/EREREVdMzVREREmtH5HWxVjIyM5Em7c+fO6N27N+7cuYPjx49j5syZOo6OiIiImKuJiIiU6fwO9qekUimkUikyMjKQnp4OAChXrhwWLlwIQ0NDBAQEwN3dXcdREhERFVzM1UREROrp/A62iYmJ/O9WVlaoXLkyAKBBgwby9po1a6JmzZq5HhsRERExVxMREWlKIJPJZLoO4lNZV8NFItF3OX6q+LsclqjAufTkg65DIMo36pUvpOsQcuR752qkvP0+xyUqYKSPj+o6BKJ8Q1ilm0b9dH4H+3PfLVmTzp05fQr/rFuDDx/eQyqVwbVGDYweOwHGxsaIjX2DhYHzcffOLQgggLmFBcaMm4CKlSorHEMsFmPG9Kk4FxaGQ0eP6+idEOUeqUSCGWP7Q5yRodAe+zoKA8dOw7OHd3Hl/EmFbSnJiShVvjIGjZsub5NIxNi8fC5uXTmPv4N2qzzXzYhzWDFrInwmzYZzFTdtvxXKR5ir87+du/djyl9z8O/uLShZvBgA4E3sW8xfvAK37t6HAAJYmJthwuhhqFyxAgDg7v0HGO8/XelYDx49wZWwozA2NsrV90CkC7tCryBg1QEcWuiDEkX+u3i69/R1bDp0ERkZEoilUjRzr4ihXg0gFGaO2M0QSzD7nyM4d+MJAKBOlVIY26s5RAaK5drpKw8xcv4OLB3XDbVdSuXeGyON5bkCGwB69OiBjRs36joM0jITExNMmzFLvozLJL9xWLp4IUaNGQepVIYOHTvhz+kzAACnT53EiN+HYu/BwzA0NAQApCQnY8yoEbC2LgyxhI8iUMEg1NPDH3PXKLRlpKdhQv8uKONcBVVq1kXbbn0Vtm9Y+jccSpWXv079mILlf/8BC8tCkEokKs9z6lAIzobuR+EixdT2IfoUc3X+FbhkJW7duQ9LC3NIxP/9PpDJZOjU7ifMCPgDAHDyzDkMHTkBh3dvgaGhISpWKI8929YrHOv6zdv4a/YCFtdUICzYchy3H7+CpZkRxBKpvP1A2E1sOnQRyyf8gkIWpkj+mIZR83dizd5z6Nchc+nDRdtOID1DjL3zBgMApq85hAVbj2NMz+by42w7EoHgE1dR3NYKYqkUlDflqUnOsjx79kzttqzH0ujH41azFuzs7AAA+vr66P1rP5w/l7msi52dHdxq1pL3rd+gISwtLfHk8SN5W1JyEtp16IhBQ31yN3CiPObimWOoWK0mTMzMlbalfkzBtfDTcG/wX0JOTUnG/5r8hHa/9FN/UIEAo6Ytgam5xfcImfIh5ur8SSqVwtbWBisWzoLhZ08q2BWxRS236vLXDevVhaWFOR49eab2eFt37oZXp3bfKVqivEMqlcK2kBmWTfhF6a5z+M2n+MmzCgpZmAIATI0N0bFRdVy590K+795T1zGyR1MIhUIIhUL4/tIE+8/chOSTQl0gANZN6Q0rM+Pce2OUYzq9g+3r6wvpJ1dfypUrBx8fxeJp5syZePjwIerVq4c+ffqgTZs2OHLkSG6HSt9BfHwcRCJDtdsTEhIUthcpYocWLVsjKuplboRHlGed/nc3OvcZqnLbhVNHUKVmXRiZmMrbrArbola9pngb80rtMRu07KDtMCmfYK4uWIRCIbp37aRx/4SERKVCXL4tMRGnz4Zj0viR2gqPKM8SCoX4pWVtlduqly+JDQcvoEPDarAwNUZicirW7juPFnUqAQDuPnuNItbmsDD9r3A2MzFCMRtL3HkajSplSwAAujbjRJI/Ap3ewW7UqBEaNmyIixcvokGDBtiwYYNSn4MHD8LLywvbtm0DkDkGl/KHndu3om27Diq3nTl9CtbW1ihTtmzuBkWUx7189gjJSQkoX7m6yu2n/g1BvebtczcoyteYq0mdU2fOwdq6EMqWUT0OdM/+f9GkYT2YGPNuGxVsHRtVR/UK9mg/chkWbj2O9qOWoYKjHXq3qQMAePM+EUULWyrtV6ywBSJjOKnsj0anBXa7du3QsWNHmJiYoFOnTjBW8QvYzMwMLVu2VLh6Tj++s2FncO/ePXT26qq07ePHj5g1YzqGjxytg8iI8rZTh0JQr7nqxy2fPrgDiViMMs4uuRwV5WfM1aTKx4+pmD57AUYPG6y2z7Zde9CVj4cTQSgUwqtJDRgbGmDZztMQCgVoV7+qfIKzxJRUGBooP1gsMtBHalqGUjvlbXlyDDblb6+jo/HnFH/MnDVH5Uy0Af4T0bBxE7jX8dBBdER5V1rqR0ScPY66jX9Suf3UvyGo34J3r4no+5s4dSaaNKwHD3fVj6xGXL0OkUgEl0rOuRwZUd5z8vID9P1zA7yb18S5tWPxa9u6GPr3Vmw/ehkAINLXR1qG8pM/aeliGIry5JzUlI08+y82fPhw5LElukkLUlJSMGLYUAwdNhyVXaoobQ9atQJxcXGYPnOWDqIjytsunj4K56puMLe0Utr2MSUZ18JPw+u333M/MCqwmKsLphVB/yAuPh6zpk1S22fbrj3w6tg2F6MiyrtWhZzBuN7N0bGRKwCge6vaKGdvi9ELdqFrMzfYFbZA9Nt4pf2i38WjaGFOPvqjybMFdqNGjSCVSvHo0aMvd6YfgkQiwbjRI+HpWU/l2OtDBw/g4IH9WLdhM/T09HI/QKI87tShEHTuM0TltvMnDsHFzQOmZkzElHuYqwueA/8ew/5/j2LzmmVqc/WHuHicPhuOyeNH5XJ0RHlTUkoaypS0VWgr52iHxORUAEBFp6J4Hv0OCckf5ROdJaWk4mnUW1QqXSzX46Vvk2cfEe/QoQM6ddJ8FkvK+/6eMR1GRoYYOmyE0rarVy4jcO5sLFyyDObmyksPERV0zx/dQ3JSApyrqn4ck4+Hky4wVxcsl6/dwOwFS7FswSyYm5up7bd73yE0buAJMzNTtX2ICpKuzdwwf1Mo3sUnAQDS0jOwYHMo2jesDgAwMjRAh4bVMW/jMUilUshkMszfHIo29arC2FD1LP2Ud+XZO9jqCAQCXYdAXyEhPh7btmyCU6lS8O7c4b8NAgGWrViNdWtWIy09Db6/Ky499PMvPdCpi5dCm76+gcqx20T52Zkje9GwVSeVvwOfPLgNyIDyLq7ZHkNPXx/6Btl/dvT1DaCvb/BNsRIxV+cPBgYG0Nf/76vi6nWbkJaWhqG+4xX69fDurLDW9a49+zF98oRci5MorzHQ14O+/n9PeHRv5Q4DfX0MnL4JEqkUMhlQz7UsfvduJO8zqkdTzFj7L9r6LgUA1HB2wB+/tVJ7fAN9Pu2ZVwlkOhw8NXToUEgkEoSHh6NOnTqIiIhAREQEPD09ERYWBgBo1aoVDh06BA8PDzRp0gRHjx7FhQsXvvqcqVw5hEgrLj3hshFE2lKvfCFdh6CWLnI1Ut5qKXqigk36+KiuQyDKN4RVumnUT6d3sDt16gSxWIyOHTtCIBDAx8dHqc+gQYMAAPPmzcOTJ0/w00+qZ88lIiIi7WOuJiIi0pxO72Cr8+lVcW3jHWwi7eAdbCLtyct3sNX5nrmad7CJtIN3sIm0R9M72HlykrPevXvrOgQiIiLKBnM1ERGRsjx5B/t74h1sIu3gHWwi7fkR72B/V7yDTaQVvINNpD0/9B1sIiIiIiIioh8NC2wiIiIiIiIiLWCBTURERERERKQFLLCJiIiIiIiItECn62Bfv34d6enpOdrHwMAA1atX/z4BERERkQLmaiIiIs3ptMBeuHBhjpO2SCRCUFDQd4qIiIiIPsVcTUREpDku00VEX4XLdBFpD5fp+gyX6SLSCi7TRaQ9mi7TpdM72CtXrvyqq+IDBgz4ThERERHRp5iriYiINKfTSc5U3Txfs2aNDiIhIiIiVZiriYiINJfnHhH39PREWFgYAEAqlWL79u3w9vaGQCDQyvH5iDiRdvARcSLt+dEeEf/euZqPiBNpBx8RJ9IeTR8R1/kyXTExMYiLi5O/tra2BgCIxWKMGTMGV69e1V7CJiIiohxjriYiItKMTsdgA0CvXr3w8uVLuLq6on379ti1axeePHmCcePGoVq1avjjjz90HSIREVGBxlxNRESkGZ0X2MnJyThx4gROnjyJAwcOYP78+UhJScG0adPQpk0bXYdHRERU4DFXExERaUbnj4gDQJEiRdC1a1esW7cOCxcuRLly5XDkyBGkpqbqOjQiIiICczUREZEm8kSB/amaNWti69atKFKkCLy8vBTGfBEREZHuMVcTERGplucKbADQ09PDxIkT0b59ewwaNAhpaWm6DomIiIg+wVxNRESkTOcF9qxZs9Ru69evH1xdXREcHJyLEREREdGnmKuJiIg0k+fWwf7euA42kXZwHWwi7fnR1sH+7rgONpFWcB1sIu35YdbBJiIiIiIiIsoPdLpM18WLF5Genq5ym5ubG5KTk/Hw4UPIZDKUK1cOtra2WLZsGQYPHpzLkRIRERVMzNVERESa02mBvWTJEmRkZCi1CwQCBAQEwM/PDzKZDAKBAFKpFDt37sTu3buZtImIiHIJczUREZHmdFpgr1+/PtvtcXFxOHLkCACgSZMmAIACNmSciIhIp5iriYiINJenx2ALBAJdh0BERETZYK4mIiL6T54rsFeuXIkrV64A4BVwIiKivIi5moiISLU8VWA/fvwY//zzD5ycnHQdChEREanAXE1ERKRenimwnz9/jiFDhsDf3x/W1ta6DoeIiIg+w1xNRESUPZ1OcvbXX3+hUKFCkEql2LJlC8aMGYPmzZvLt6sa18WxXkRERLmHuZqIiEhzOi2wra2tERUVhbCwMJiamqJChQoK2z8d15WUlIQJEyYgLi4ul6MkIiIquJiriYiINKfTAnvQoEEAAKlUin379qFfv36YPXs2PDw8AABDhgyR9507dy6eP3+On376SSexEhERFUTM1URERJoTyPLQ9J/Xr1/H0KFDsWXLFtjb23+Xc6SKv8thiQqcS08+6DoEonyjXvlCug5BY7mRq5Hy9vscl6iAkT4+qusQiPINYZVumvX7znHkSLVq1TBs2DAEBQXpOhQiIiJSgbmaiIhIPZ0+Iq5K165dIZFIdB0GERERqcFcTUREpFqeuoOdRU9PT9chEBERUTaYq4mIiJTlyQKbiIiIiIiI6EfDApuIiIiIiIhIC1hgExEREREREWkBC2wiIiIiIiIiLWCBTURERERERKQFLLCJiIiIiIiItIAFNhEREREREZEWsMAmIiIiIiIi0gIW2ERERERERERawAKbiIiIiIiISAtYYBMRERERERFpAQtsIiIiIiIiIi1ggU1ERERERESkBQKZTCbTdRBEREREREREPzrewSYiIiIiIiLSAhbYRERERERERFrAApuIiIiIiIhIC1hgExEREREREWkBC2wiIiIiIiIiLWCBTURERERERKQFLLCJiIiIiIiItIAFNhEREREREZEWsMAmIiIiIiIi0gIW2ERERERERERawAKbiIiIiIiISAtYYBMRERERERFpAQtsIiIiIiIiIi1ggU0qtWjRAjExMbh69Sp+++03tf2GDx8Od3d3+Z+AgACtx9KtWzdcunRJ5bb379/D1dVV5bZGjRrh1atXKrfFxMRg4sSJGsfg7++P169fa9yfKEtufZaOHTuGIUOGqN2+Z88ejBgxIkfHzFKvXj21//9z+lkKDAzE7du3vyoOIlLEXK2IuZq+FnO1Iubqb6Ov6wBId1auXInNmzdDIpHA09MTEydOhKmpKQAgIyMDGRkZSE9PR0ZGhtpjLFiw4KvPHxkZiZ9//lmhLTU1Fba2tvj333/lbRKJRG0Mr1+/RqFChVRuyy72gIAAjB07Vv46JiYGAQEBuHz5MvT19dG6dWuMGTMGIpEIANCvXz9MmTIFy5cvz9F7pIJB158lABCLxZBIJGq3SyQSSKVSpfZWrVohOTlZoS0tLQ3BwcEoUaIEgMzPklgsVnnczz9LWeeaPn06du7ciRs3bihs++233zB06FCsWbMGBgYGGr03ooJM179fmKspv9D1Zwlgri4oWGAXUHv27MGuXbsQEhICY2NjDBgwAOPGjcPixYs12n/YsGG4fPmyym1mZmbw8/NDgwYNsj2Gvb09zp49q9C2adMm7Nu3T7M3AeDRo0ewsLDQuD8AnD9/HsbGxnBycgKQ+Uu1X79+aN26NRYsWICUlBSMGzcO06ZNw9SpUwEADg4OMDMzw/nz5+Hh4ZGj81H+lhc+S1nCw8PRuHFjlduSk5Ph7u6u1H7o0CGltk6dOiEqKkqetAEgISEB79+/h5mZmfzL7OefJQD4+PEjfH19kZGRoTLRW1hYoEaNGti9eze8vLw0el9EBVVe+P3CXE35QV74LGVhrs7/WGAXUOvXr4evr6/8inJAQABatmwp/8B/6RGrhQsXKrWdO3cOy5Ytg6WlJapVq5bjmD58+ICFCxdi5syZGu+zd+9ePHjwAG/evEGRIkU02icoKAj9+/eXvz516hRMTU0xePBgAIClpSVmzJiBxo0bY9SoUbC0tAQAeHt7Y/ny5UzapCCvfJYEAgHc3d2xcuVKldt37dqFU6dOaXQsVcnW19cXBgYGGDBgANq1awdA+bMEACdOnICLiws6dOiA5s2bqzy+l5cXBgwYwKRN9AV55ffLp5ir6UeUVz5LzNUFAwvsAig9PR13795FnTp15G2lSpWCk5MTxowZg6ZNm6q9svb5ca5du4aTJ0/i33//RXR0NAYMGID+/fvDzMwsRzGlpqZi6NCh8PT0RKNGjTB06FBcu3YNABAfH69yn+vXryM8PBzu7u5YsGABpk+frtTH29sbenp68PHxQbdu3ZCUlIRbt26hVq1a8j4nTpxQer+FChVC9erVERYWhp9++gkA4Obmhjt37iApKSnH74/yp7z0WSpevDgiIiJQv359lds/fvyIHj16KLW3bt0a79+/h56enrzN0tISjo6OCv2CgoJQsmRJ+WtVn6Ws4wHAy5cv1cZasmRJ6Ovr4/HjxyhTpsyX3xxRAZSXfr9kYa6mH1Fe+iwxVxcMLLALoA8fPkBfXx9WVlYK7SVKlMDHjx+/uP/27dsREhKCN2/eoGrVqmjYsCG6deuGmzdvIjw8HD169EBqaipatGgBX1/fLx7vzZs3GDlyJExMTHD16lWcOXMGS5YskW/v2rWr0j6JiYkYM2YMevbsiSFDhuDnn3/GunXr0KdPH4V+27ZtU/jlExERgWrVqkEo/G9+v+fPn6NRo0ZK5yhVqhQePHggT9pCoRBVq1ZFREQEGjZs+MX3RflfXvosValSBVeuXMlR/Onp6Xj8+DFu3br1xTFWBw8eRKFCheDq6oqyZcuq/CzlRM2aNREeHs6kTaRGXvr9AjBX048rL32WmKsLBhbYBZBAIIBUKoVMJoNAIJC3i8Vi2NrafnF/d3d3eHh4wN7eXqHd3t5efkUsNTUVSUlJ2R5HJpNh3759mDNnDn799Vf8+uuvuH37NkaNGoUSJUpg0qRJCuNFsjx79gyDBw9GtWrVMHr0aOjp6WHNmjUYPHgwIiIiMHPmTLVXEj8fqwJkzm6qamyYubk54uLiFNqKFy+udrZTKnjywmdp5cqVWL9+fY7idnR0xObNm+WvsyZ0SU1NRVxcHGJiYvDy5UtERUXJvwh//PgRIpFI/kiaqs9STvCzRJS9vPD7BWCuph9fXvgsMVcXLCywCyBra2sIBAK8fv0axYoVk7dHRkZi9OjREIlEKseiREZGolu3bpDJZDk638qVK1G5cmWl9oEDB0IikWDlypVwdnYGAFSuXBl79+7Fjh071F6l++eff9C5c2f07dtX/ovSzs4OW7duRXBwMIyMjNTGkpiYCHNzc4U2sVis9j19+osYyJz0ISEhQf2bpQIlL3yWBgwYgAEDBij1DQ4OxsmTJ1WOG8siEonQoEEDtG/fHoaGhjA0NISRkREKFSqEokWLKtxR6ty5s8JjZ6o+SzlhYWGB58+ff/X+RPldXvj9AjBX048vL3yWmKsLFhbYBZC+vj6qV6+OkydPolu3bgCAGzduoEKFCvKlLVSNRbG3t0dYWJjW4pgxYwYKFy6s1C4SidC9e3f56wkTJqBs2bLy1/7+/iqPJxKJFJYS+fPPP1G0aFGFPubm5oiJiVFqS0xMVDpeQkKC0tXy+Ph42NnZZfOuqCDJK5+lb6FuopVP9ezZU+nROlWfpZyIj4/P8azCRAVJXvn9wlxNP7q88ln6FszVPxYW2AVU//79MWHCBNSsWRMWFhYICAjApEmTcjWGTxP2vXv3sHHjRly8eBFpaWmQyWSwtLRE48aN0aNHD7VX3760n6GhoUL/EiVKKM3O6OTkhCdPnigd++nTp2jbtq1C26tXrzimixTkhc8SAOzevVvl2q8tW7YEkDnRSevWreHn56dy/4cPH2Lnzp24fv063r9/D5FIBDs7OzRs2BB9+vRRepRT1WcpJ169eqXwZZyIlOWF3y/M1ZQf5IXPEsBcXVCwwC6gGjRoAD8/P4wbNw4AMGTIEFSvXl2jfY8dOyZfc1IVqVQKAwMDHDp0KNtHwLLcuXMHv/76K8aMGYPx48fLfzm8evUK27ZtQ5cuXbB37175Ehzfsp+bmxvGjRsHqVQqn/Chbt262L59u8KjOx8+fMC1a9fw119/ydskEgmuX7+OefPmafBTooIir3yWOnTogA4dOqjdfujQIWzfvl3ltoiICPz+++8YOXIk+vTpg8KFCyMjIwPPnj3Dzp070alTJ4SEhMDU1FS+j6rPUk5cunRJ4e4XESnLK79fAOZq+rHllc8Sc3XBwAK7AGvTpg3atGmT4/2aNm2Kpk2bZtvHzc0N796902hihbCwMDRq1AhdunRRaC9evDh8fX1x+vRpXLt2DQ0aNPjm/czNzeHi4oKLFy/Kl2to06YNli9fjuXLl6Nfv35ITk7GhAkT0Lx5cxQvXly+76VLl+Di4sJlP0hJXvgsnTt3DiNHjlR7B0koFKqc5RcAQkND0bJlS4W1LkUiESpXrozKlSujdevWuHbtGv73v//Jt6v6LGkqMjISEomEV8WJNJAXfr8AzNX048sLnyXm6oKBBTZ9FwKBQONJITw9PbF27Vrs27cPTZs2hbGxMQAgNjYW27dvR1xcHFxdXbW2X9++fbF161b5LxpDQ0OsWbMGf/75Jzw8PKCnp4eWLVvKr3Jm2b59O3777bcc/RyIvpWmn6WnT5+icePGCndyNFWnTh34+/ujcePGqFOnjnzSonfv3mHXrl1ISkpSOfnR55+lTxkYGCg99pll+/bt+PXXX3McJxFpF3M1kXYwV9OnWGCTSvr6+jAwMJD/+Z4qVaqEoKAgbNiwAYsWLUJ6ejqAzKtujRo1wo4dO1ROsPC1+9WtWxf//PMPnjx5gtKlSwPInMgiuwkknj59iuTkZIWrgkSayK3PUqlSpRAYGIjw8HC1fYRCIfbv36/0CFuDBg0wc+ZMbNmyBQEBARCLxRAIBDAzM0P9+vWxY8cOpYlTANWfpSx2dna4evWq0j5xcXG4fPkyfv/99697o0Qkx1ytiLmavhZztSLm6m8jkOV07nkiDezbtw/NmzdXe1VM12JiYrBgwQKNryD+8ccf8PHxUVjegSg35LfP0rx589CiRQuVV9mJKHflt98vzNWkK/nts8Rc/W1YYBMRERERERFpQc6nkyMiIiIiIiIiJSywiYiIiIiIiLSABTYRERERERGRFrDAJiIiIiIiItICFthEBUR4eDjatm2L6tWro3fv3njy5Il82/v371GtWjUAmTNN1qpVS+UxPnz4AGdnZ1SoUEH+p3v37mrP+eTJE4W+WX8qVaoEf39/eb9nz55xpkoiIirwmKuJfnxcB5uoAHjx4gWGDBkCf39/NGnSBNu2bUO/fv2wZ88emJubQyKRIDU1FQCQkZEh//unxGIxzM3NERERAalUKm/X19eHTCaDQCBQ2qd06dK4ceOGUvu8efMQGRkpf52eng6xWKyNt0pERPRDYq4myh9YYBMVAOvXr0eTJk3QoUMHAEC/fv1w+vRpBAcHo3fv3l/cPyIiItur3/r6+ujevTv8/PyUtqlaE/Ly5cvo2LGj5m+AiIgon2OuJsofWGATFQBnz57FsGHDFNpatmyJgIAA/PXXX1/cv2bNmrh//75S+8uXLxEYGIhLly6hVatWGsVy/PhxREZGol27dkrbsq6M6+npqbzKTkRElF8xVxPlDxyDTVQAvHz5Ek5OTgpt5cuXh4mJCe7fv4+wsDCNjyUWi3Hq1CkMHz4cLVu2hK2tLQ4cOABXV9cv7vv48WP4+flh4sSJMDc3V9peuXJlVK5cWaMvEkRERPkJczVR/sA72ET5XEZGBjIyMmBqaqrQbmVlhZSUlC+Op5LJZHj48CGuXr2KCxcuICwsDI6OjqhSpQpKlSqFXbt2ISoqClWrVkWFChVQp04dGBgYKB3nxIkTGD9+PPr27Yu2bduqPJeqK+9ERET5HXM1Uf7BApsonzMwMICBgQESEhIU2uPi4mBkZAR9/ex/DTx48AC///47qlatitq1a2PMmDEoVqyYfPu7d+9w6dIlXLt2DeHh4ahRo4ZC0n78+DEWLFiACxcuYOrUqWjRooV23yAREdEPjrmaKP9ggU1UANjb2+Px48eoUqWKvO3+/fsoXLhwtvtlZGTAyckJ+/btU2hPS0uT/93MzAyNGjVCo0aN5G1isRj6+vrYuHEjZs+ejS5duuDff/9FoUKFtPSOiIiI8hfmaqL8gQU2UQHwv//9D8ePH5fPTAoAhw4dQlRUFCpUqKB2vzZt2uDZs2c5Pp+npyeCgoLQrFkztGjRAra2ttn2L168OMaOHZvj8xAREeUXzNVE+QMLbKICoFevXmjfvj12796NFi1a4J9//sGVK1ewY8cOVK1aFbGxsfD09FTa7/Dhw990Xjs7OwBAZGQkihQpIl8G5MOHDzAzM5M/nhYZGcmlQIiIqEBjribKHziLOFEB4ODggKVLl2LVqlWoWbMmDh48iBUrVqBq1aoa7Z+RkYG0tLRs/0ilUrX7+/j44Nq1a/LXw4YNw6lTp+SvR48ejYsXL371+yMiIvrRMVcT5Q+8g01UQHh4eODAgQNftW/jxo3x5s2bbPuIRCKsXbsWNWvWVLm9V69eCq979+4NIPMK+YsXLxAZGflVsREREeUXzNVEPz4W2ET0RWfOnPlin169euH+/ftqk/bKlSvl2/r37y9vX7FiBWrVqoW1a9eiefPmcHR01E7QREREBQhzNVHewEfEiUgrDAwMIJPJ1G43MjKCqakpTE1NoaenBwDYunUr9u3bhzlz5mDIkCHo2bMnrl69mlshExERFSjM1UTfH+9gExH09PQgEokAZCbfrAlOtEUgECAxMVG+ZEhycjL27NmDiIgIrF69GtbW1ujRoweMjIzg4+OD0NBQGBkZaTUGIiKiHxlzNdGPQSDL7jIWEZGGhg0bhgYNGqBz585K28aOHYu9e/fKr5qbm5tjzZo1sLOzk89emiUtLU3rXxqIiIiIuZooN7DAJiIiIiIiItICjsEmIiIiIiIi0gIW2ERERERERERawAKbiIiIiIiISAtYYBMRERERERFpAQtsIiIiIiIiIi1ggU1ERERERESkBSywiYiIiIiIiLSABTYRERERERGRFrDAJiIiIiIiItICFthEREREREREWsACm4iIiIiIiEgLWGATERERERERaQELbCIiIiIiIiItYIFNREREREREpAUssImIiIiIiIi0gAU2ERERERERkRawwCYiIiIiIiLSAhbYRERERERERFrAApuIvpvOnTtj3bp1Wj9uREQEKlSooPDnS+dJT09Hs2bNlPb7/E+3bt1U7j9lyhSFfjt37pRv69u3L44ePQoAWLJkCf7++2+Ffb28vJTOU7duXbx+/Vqh38qVK/HHH398xU+EiIhI96Kjo5Xy3bRp0764X7du3eDs7Jxtfq5fv77KfVetWqXQb8GCBfJt/v7+8u8Hu3fvxrBhwxT2HTFihNJ5atasiRs3bij0O3DgAPr06ZOzHwYVWPq6DoDoe5NIJNi7dy92796Ne/fuIT4+HoaGhnB0dMSKFStQrFgxjY8VERGBxMRENGrUSN52+fJl/PLLLwAAgUAAGxsbVKpUCT4+PqhatarW34+mXr9+jWPHjqFHjx5q+yxfvhzz58/P9jinT5+GnZ3dV8Xg5OQEa2vrr9r3c7du3UJsbKz89ZIlSxS26+np4cSJEwAAoVCIevXqQSj87xri27dv8eLFC5w7dw6WlpZqz/PpPlnEYjH8/PwwZswYeZtIJIJEIoGenh7S09ORnp4OILOQT0tLU9h/27ZtkEql8tdSqRQNGzbEixcvULRoUXl7Wlqa0r5ERAURc7fucneWjRs3omnTpgp5SpVHjx4hMjJS/vrz/CwUCuX5WSAQoHbt2jAxMVHoc/XqVWzfvh2VKlVSex51+bl3797yf0sAMDAwUJmfMzIylHLsvHnzMGfOHIU2b29vPH78WOH/AfMz5QQLbMrXEhISMHToUMTGxqJv374ICAiAhYUFkpKScPv2bRgZGeXoeOfPn0dUVJRCkhaLxQCAS5cuQSaTITY2Flu3bkXv3r2xZ88eODg4aPU9aer58+dYs2ZNtkm6b9++CknJy8sLvXr1Qtu2bQFkJkJzc/OvjmHu3Llfve/n7t69iydPnmjUVyAQwMPDAyKRSN6WVeCamZlBX1/zX33//vsvJkyYoPY8p0+f/uIxhEKh0heDrBgCAgKwefNmeXvWz56IqKBi7tZt7s6yZs0alCtX7osF9pMnT3D16lWNj+vi4qJUYMtkMpiamuYoP9+4cQO9e/dWu33btm1fPIaq/Jz13WH16tWYPXu2vL1GjRoax0YFGwtsytfGjh0LAwMDhISEwNjYWN5ubW2t9eRpYWEBALC0tMTEiRNx/fp1HDp0CAMHDtTqebTJwMAABgYG8tcCgQDGxsby95KXeHl5AQCSk5OxceNGnDhxAtHR0UhPT0eRIkVQp04ddOvWDU5OTlo9b8uWLdGyZUsAwMOHDxEdHY0yZcqgRIkSGh9j3759OH/+vPyLg0wmg5mZGZycnDB58mRMnjwZALBo0SI8f/5cq/ETEf1omLuzl9dyd/PmzdG8eXOIxWJs3boVhw8fRlRUFJKTk2FrawtXV1f8/PPPqFy5slbPW7VqVXlh//z5czx//hz29vYoVaqUxsc4c+YMDh06pFDYJyYmwtnZGRUrVkS/fv0AAMHBwdixY4dW46f8iwU25Vvnzp3DhQsXEBoaqpCgVcnIyEBgYCAOHz6MN2/ewMrKCg0bNsTYsWNhZmaGK1euKIzNDQkJwf/+9z+sWbNG7TGdnJwQHR2t0JaUlIQFCxbg8OHDeP/+PUqWLIlu3bqhV69eEAgE8n7p6elYsWIFdu/ejZiYGBQpUgQdOnTAoEGDFO7Krlq1Cps3b0ZsbCxsbGwwdOhQeHl5wcXFBRkZGQCAChUqwMDAALdu3crRzy9Ls2bNEBgYiDVr1iA0NBS9e/eGr68vIiIisGTJEty5cwfp6ekoVaoURowYoTBGqk+fPqhXrx769u0LAOjRowe6dOmCiIgIHD16FGKxGNWrV0dAQABKliz5xVjEYjF69OgBe3t7TJw4EU5OThCJRIiOjsa+ffvQsWNH7Ny5E2XKlFHaN+sKdVJSEvT09NSeQ9XV7MTERAwePBgpKSlwcHDArVu3UK9ePXlhDAAjR47EyJEjAQDdu3dX2D8wMBDTpk2Dh4eH0vl4B5uI6D/M3drJ3QCwZ88eLF++HJGRkXBwcMCQIUPQpk0b+fZr165h5syZuHv3LkQiEdzc3LB8+XJMmjQJ27dvBwD06tULADBnzpwv5icfHx8kJydjxIgRKF++PAwNDfH27VuEhoaie/fuWL58OerUqaNyX4FAgOTkZPmTBer6fJ6/xWIxRo4ciYcPH6JChQp49OgRHB0dMX/+fPnPfO7cufIn6ho2bKiw/6pVq9C2bVv5RfxP8Q42fS0W2JRvHThwAC1atNBoDPCLFy+QmJiImTNnwt7eHtHR0Rg/fjzmzZsHf39/uLq64tKlS1i5ciWio6MxefJkhWT5OZlMhnv37qFdu3byNrFYjH79+iE5ORnz58+Ho6Mjrl27hoCAALx9+xajRo2S9x09ejRu3LiBqVOnolKlSnj48CH+/PNPPHv2DPPmzQMAHDx4EBs3bsTcuXNRunRpvH//Xr5/eHg4Ll26hICAAOzdu1fluCVNSSQSLF68GO7u7hg/frw8uZ0+fRrt2rXDxIkTYWJigpCQEPj4+ODIkSPyx8kkEgkkEon8WAKBAHPnzkWdOnWwfv16mJqaYunSpRg8eDD27t2r8EVFlejoaNy5c0f+nrM4OjrCx8cHW7ZswYULF1QW2DY2NnBwcEDdunWzPYednZ3SY9/Lli2Dg4MD/vrrLwCZX6K6deuGo0ePolmzZgAyv3y0atUKixYtQmJiosL+GRkZav8NeAebiOg/zN3ayd0hISGYMWMG/P39UaNGDVy7dg2TJk2ClZUVPD09kZqaioEDB2LgwIFYsGABZDKZPP9MmjQJY8aMQbt27TB58mS4ubnB1NQ02/NJJBKcPHkSq1atgpubm7y9ePHi6NmzJ/bt24czZ86oLbBdXV1VFrmfMjAwwKVLlxQuvGzbtg1JSUk4cOAAhEIhpFIpfHx8sHnzZvmkZL6+vujXrx927dqF48ePKxwzIyND7UX3fv368Q42fRUW2JRv3b17F507d9aob5kyZTB16lT5azs7OwwaNAgLFiyAv78/BAIBLCwsYGhoCAMDg2wfw3rz5g0WL16M+Ph4dOrUSd4eHByMx48fIzQ0VL5/06ZNYWVlhV69esHLywsODg44e/Ysjh07hn///Vf+KJyNjQ1WrlyJFi1a4MKFC3B3d0dERARat26NmjVrAoDClxEzMzOYmJhAKBRq5ZExiUSiNHtm1t3aLEOGDEFwcDDOnj2b7c+9UKFCmDVrlryYnjRpEjw9PXHz5s0vTixTsmRJ1K9fH35+fvjtt9/g4OAAfX19vHnzBnv37oWhoSGaNGmicl+RSCSf6TtL165d0b17d7Rv3z7b8z548EDhyr1IJEKtWrVw584deYEtFArVjh0TCoVITU0FkJnMExISEBsbi2fPnqFw4cKoVatWtucnIioomLu/PXdnZGRg9uzZCAgIQKtWrQBkFrqvX7/GihUr4OnpiYcPHwIAfvvtN/l+WRfHRSIRRCIRhEIhTExMNIpFT08P3t7e+OuvvzB48GCUK1cOIpEI79+/R2hoKJ4/f44///xT7f5btmxReO3r64ty5cphyJAh2Z73wYMHqFmzpvxihFAohIeHB27evCnvk5WfVV2wEAqF+PjxI4DMiymJiYmIjY3FixcvYGBggAYNGnzxvRN9jst0Ub6VlJQEMzOzr97f3t5eaRml7NSsWRPVqlVDvXr1EBYWhrVr16Jw4cLy7UePHkX79u2VElXNmjVRpkwZefF39OhR1K9fX2mcWcmSJVGvXj0cPnwYAFCxYkWEhobi6dOnX/sWNfb5I1XqaPIzq1u3rsKdahMTEzg4OODly5dfPL5AIMDSpUvRvXt3HD16FMOHD4e3tzc2b96M8uXLIyQkRGnWVJlMBrFYrPJPdts/vfNevXp17NmzR14kx8bG4ujRowpX6bPj5uaGQYMGwdnZGVWqVEGzZs0wfPhwBAcH5+j/GBFRfsfc/e1u3bqFlJQUNG/eXKHd3d1dvvyUg4MDxGKxwpKT32rKlCkYO3Yszp8/j/Hjx6N9+/YICgqCubk59u7diwoVKijtoy4/y2QySKXSbPM3kHnn+9ChQ4iLiwOQ+f9n3759OcrP06dPR8WKFVG5cmU0btwYQ4YMwebNm/lEGX013sGmfMvMzAxJSUka9z979ix27dqFhw8f4sOHD0hJSVFYWik7BgYG2L17N8RiMWJiYhAaGooePXpgxYoV8ruykZGRaNy4scr9y5QpgxcvXsj7VaxYUW2/+/fvAwC6dOmCDx8+wNvbGy1btsTQoUO/eUkOdYoXL67UFh8fjw0bNiA8PByvXr1CcnIykpKSvjhGSdVjf+bm5vLi9UsMDAzQtm1btG3bFjt27MDevXuxePFitf1XrVqV7Wzm169fx7hx45Tas2YIL1KkCPr374+xY8eifv36KFq0KKKiovDrr7/C09NTob86c+fOxaxZsyCRSNReRQcyC3l7e3u1xyEiyu+Yu79dVFQU0tLS4O7urtAulUqRmpqK+Ph4WFpaIigoCBMnTsS2bdvg6+v7xSFUXyIQCNCoUSM0atQI586dw8SJE7F8+XK1/Q8cOKD0NNznFi1apLJ927ZtqF69Otq3b4+bN2+iSZMmKFGiBF69eoXWrVt/8XHzLCNHjsSIESMgFouhp6en9nHxcuXKoUWLFhodk4gFNuVb5cqV03hykO3bt2Pq1Kn4+eefMWLECBQvXhzPnj3DiBEjNNpfIBDIJ+lycnKCu7s7jIyMMHXqVPnV4S+NL87anpN+AwYMQMeOHbFgwQK0aNECy5YtUzmR1rf6fKKZlJQUdO3aFUZGRujatSucnZ1hZWWFSZMmaf3cMTExChOnqaLqqjiQmTgHDhyIAQMGqNz+8eNHGBgYfHFZEENDQyxYsACxsbF4/fo1nJycFJZAmTRpkvwLklAoVJmg9fT00Lx5c6XJcz4/z/jx47ONhYgoP2Pu1g5ra2uVy1QJBAJYWloC+O/prJCQEPj6+qJFixYKj9xr4tOJ2VRRl5+9vb0xdepU/PTTTyq3p6WlQSgUKsyWropAIMCkSZPw+++/IzIyEiVKlFC4kD948GD5dxhVk6QBmXm7X79+iIiIUHsefX19hcfpibLDApvyrRYtWmD06NEYN24crKyssu27YsUKjBkzRmE9RVWPb30pgX7K3d0d69atk792dHTE48ePVfZ9/PixfMyZo6MjHj16pLbf58tQ2draYtq0abCwsMDMmTOxZ8+eHMeaU0eOHEFycjL27NmjsB7phw8ftH4uOzs73Lx5EzKZLMf7fp6YY2JisGHDBpw7dw4PHjyQfymwsrJClSpV0Lx5c3Tp0kXtHWZbW1tIpVJs2rQJZ8+eRXR0NBISEmBhYYFixYrhf//7Hzp27Kh2zdDQ0NBs450zZw4uX74Mb2/vHL9XIqL8gLn723O3nZ0d3r9/D1tbWxgaGmbbV09PD126dIGLiws6deqEbt26qb0Tr8qVK1e+Kj9/fmE7ISEBGzZsQFhYGO7cuSN/qs3MzAyVK1dGgwYN0LNnT7WT1FlZWUEgECAkJARnzpzBy5cvERcXB1NTU/lSnq1bt1Y7E/o///yTbbxbtmzB/v37c/w+qWDiGGzKtxo1agQXFxeMGTMGaWlp2fZ9+/YtypUrp9D2+YRYQObEH9ldqf3UzZs3UaxYMfnrDh06YM+ePUhISFDod+nSJbx48UJ+FbdDhw44c+aM/LGzLJGRkQgLC1OYfOVTNWrUQFRUlPy1oaGhxrHmVGxsLOzt7RWK64cPH3638UoikQiGhobw8/PDnTt3YGhoqNGfTwvlmJgYdOjQAVFRURg9ejROnjyJmzdv4sqVK9i8eTOaNGmCFStWwN/fX20cjx49Qrt27RAXF4fRo0cjODgY586dQ3BwMEaNGoWEhAR4eXnh9u3b3+XnQESU3zF3f3vudnFxgZGRkco72Oo4OzvDxMREKZbsls0C/svPgYGBOHnypMb5+dM7ySkpKfDy8sKVK1fQv39/HD58GDdu3MC1a9cQHByMzp07Y+/evdmuTf727Vu0a9cO9+/fx8CBA7F161acPXsWe/fuhb+/PwwNDdGzZ0+cOnVK458J0dfiHWzKtwQCAQIDAzF48GB07twZffv2hZubG8zNzZGUlITbt2+jTp06sLKygpubG1avXg07Ozvo6elhx44dCkkmS/HixbFx40Y8fvwYGRkZClekExISkJGRgTdv3uDYsWNYsWKFwqNWLVq0wIYNG9C3b19MmDABDg4OuHjxIqZMmYL+/fvD1tYWAFClShW0atUK/fv3x6RJk+Ds7Ix79+5h4sSJaNu2rfzK8rFjx1C4cGHY29sjKioKixYtUpjtslixYoiNjcWpU6fg5OQEY2NjFClSRCs/Wzc3NyxYsAD79u2Du7s77t+/L58k5Hu6f/8+3r1791X7Xrx4EQYGBpg/f75Cu0gkQpkyZVCmTBnY2Nhg4sSJmDZtmspjhIaGokqVKkqPcVtYWKB69eqoXr06EhISsH//fri6uirtP2TIEJw8eVJtjCKRCH5+fjl/c0RE+QRz97fnbmNjYwwcOBCzZ8+GVCpFq1atkJGRgevXr6Nw4cKoU6cOnj17hnv37qFq1aqQSqVYv349hEIhqlevrvBzO3jwIMqWLYv4+HiUL19e7TmfPHny1WPJ7927hxcvXmDfvn1Kd6gdHR3h6OiIcuXKoWPHjkhOTla5ZFh4eDhMTEwwY8YMhXYzMzNUqlQJlSpVApA5K/znk78BwLRp07Blyxa1d+P19fXRt2/fr3p/VPCwwKZ8zdraGhs3bkRISAiCg4MxY8YMJCYmwsjICJUrV5YXQVnLWXTv3h1SqRTNmjXDvHnz0Lx5c2RkZMgfNW7SpAkOHDiAzp07w8bGBhs3boSenh7S09NRq1Yt6OnpwcrKCi4uLliyZIlC0hQIBFi5ciUWLlyI4cOH48OHD3B0dISvry+6deumEPeMGTOwcuVKTJ48GTExMShatCi8vb3Rv39/eZ/r169j06ZNSE5Ohq2tLZo1a4YxY8bItxcpUgQDBw7E2LFjIRQKMX36dLUTtWTJurL8KVWTftSoUQPTp0/H8uXLMXHiRDg5OWHs2LEIDw9XmH37833VTSCSdQX8SwQCAVJSUr54V0NfX1/pPLVq1UJ6ejomTJiAzp07o0yZMrCwsIBEIkFMTAwuX76MZcuWoVGjRmqP27BhQ6xZswbLli1Dy5Yt4ejoKF9389mzZzh27BhCQ0PVTrp27949LFu2jMt+EBFlg7n723P3oEGDYGFhgc2bN2POnDkwNDREhQoV5BeI379/j1mzZuHVq1cwNjaGi4sLgoKCYGNjIz+Gj48Pxo8fj2bNmuGnn35SKl4/JRAIkJqa+sX8rKenp/R4eIUKFWBvb49hw4ahZ8+ecHZ2hqWlJWQyGd6+fYsbN25g5cqVqF27ttr1uN3d3TFz5kz8/fffaN++PcqWLQt9fX3IZDJERUXh1KlT2LRpEyZOnKhy//v378PPzw/du3fPNn4iTQhkXzNwgohIBwICArBt2zaFIl6VDh064O+//1Zqf/nyJYKCghAWFoaoqCj5cUxMTFC1alW0aNEC3t7eamcRBTIf98t69Oz169dIT0+HSCRC0aJF4enpCS8vLzg6Oqrcd8iQITh+/Hi249VMTExw9erVbN8fERFRXpJ1EeJLj7fXqlULGzduVGp///491qxZgxMnTuD58+fy44hEIvnyWb169VIYmva5t2/fYuvWrTh9+jSioqKQmpoKfX192NjYwMPDA506dZLfyf7ctGnTsGnTpmxnoBcIBDh37pzK1VCIPsUCm4gKJIlEguTkZBgYGCjNkk5ERES6IZVKkZycDKFQqPaONVFexgKbiIiIiIiISAs4izgRERERERGRFrDAJiIiIiIiItICFthEREREREREWlDglukydvXRdQhE+cKdo3N0HQJRvlHKRv3MuAXRFGcDXYdAlC9MPnFJ1yEQ5RuCYtU16sc72ERERERERERawAKbiIiIiIiISAtYYBMRERERERFpAQtsIiIiIiIiIi1ggU1ERERERESkBSywiYiIiIiIiLSABTYRERERERGRFrDAJiIiIiIiItICFthEREREREREWsACm4iIiIiIiEgLWGATERERERERaQELbCIiIiIiIiItYIFNREREREREpAUssImIiIiIiIi0gAU2ERERERERkRawwCYiIiIiIiLSAhbYRERERERERFqgr+sAPpWcnIyIiAhER0cjISEBFhYWKFasGGrWrAlTU1Ndh0dERFTgMVcTERGplycK7PDwcKxevRp3795FlSpVULx4cZibmyM6OhonTpzAuHHj4OLigr59+8LDw0PX4RIRERU4zNVERERfptMCOyYmBlOmTIG5uTkGDRoENzc3CAQCpX5SqRSXLl3C9u3bsX79egQEBMDOzk4HERMRERUszNVERESa02mBvWTJEvj5+cHe3j7bfkKhEO7u7nB3d8fTp0+xePFi/Pnnn7kUJRERUcHFXE1ERKQ5gUwmk+k6iNxk7Oqj6xCI8oU7R+foOgSifKOUjZGuQ8hTpjgb6DoEonxh8olLug6BKN8QFKuuUb88MQYbABITE3HmzBk8ePAA8fHxEAgEMDc3h5OTEzw8PFC0aFFdh0hERFSgMVcTERFlT+fLdGVkZMDf3x8NGzbErl27kJiYCEtLS5ibmyMxMRF79+5Fq1atMGHCBKSlpek6XCIiogKHuZqIiEgzOr+DPWfOHMTGxiI0NBRWVlYq+3z48AF+fn6YNWsWJk2alLsBEhERFXDM1URERJrR+R3sAwcOYNasWWoTNgAUKlQIM2fOxKFDh3IvMCIiIgLAXE1ERKQpnRfYYrEYJiYmX+xnZmYGsVicCxERERHRp5iriYiINKPzAtvNzQ1BQUFf7BcUFARXV9dciIiIiIg+xVxNRESkGZ2Pwfb390e/fv1w4sQJNGnSBKVLl4aFhQVkMhkSEhLw9OlTHDt2DB8+fNAouRMREZF2MVcTERFpJk+sgy0Wi3Hq1CmcOHECz58/x/v37yEWi+VLf9StWxdt2rSBSCT65nNxHWwi7eA62ETa8yOsg52buZrrYBNpB9fBJtKeH2odbH19fTRp0gRNmjTRdShERESkAnM1ERHRl+l0DPakSZPw4sWLHO3z7NkzTJw48TtFRERERJ9iriYiItKcTu9g//777wgICICxsTG8vb1Rq1YttX0vXryILVu2IC0tDZMnT87FKImIiAou5moiIiLN5Ykx2OHh4QgKCsLt27dRtWpVlCxZEmZmZkhMTERUVBSuX7+OypUro2/fvvDw8Pimc3EMNpF2cAw2kfb8CGOwczNXcww2kXZwDDaR9mg6BjtPFNhZkpKScPnyZURFRSExMRHm5uYoUaIE3NzcYGZmppVzsMAm0g4W2ETa8yMU2FlyI1ezwCbSDhbYRNrzQ01ylsXMzAwNGjTQdRhERESkBnM1ERGRejqd5Oxz27Zt03UIRERElA3maiIiIvXyVIG9aNEiXYdARERE2WCuJiIiUk+nj4i/fv0aGRkZ8tdSqRSRkZHy13Z2dhCJREhMTMS1a9fg6uqqtfFdRERE9GXM1URERJrTaYH9yy+/ID09Xf5aKBSiW7du8tfTpk2Di4sLunTpAmtra8TFxWHnzp2wtrbWRbhEREQFDnM1ERGR5vLULOKqBAYGQiaTwdfXF0uWLEF6ejp8fX2/+nicRZxIOziLOJH2/EiziKui7VzNWcSJtIOziBNpj6aziOepMdhZkpOTIZVKAQAnTpyQXyn39vbGyZMndRgZERERAczVREREquTJAnvChAnYuXMnACAuLg5FixYFANjY2CAxMVGXoRERERGYq4mIiFTJcwX2unXr8PLlS3Ts2BFA5lgvIiIiyjuYq4mIiFTT6SRnn3r79i0CAwNx/fp1BAUFwcAgc/yVSCRCcnIyTE1NkZqaKm8nIiKi3MVcTURElD2dFtiurq6wtraGpaUlHjx4AHd3d2zZskVheY/atWvjyJEj6NixI0JDQ+Hm5qbDiImIiAoW5moiIiLN6bTADg0NRUxMDB49eoQ9e/YgPDwcy5cvx6hRoyAQCAAA3bt3R58+fXDx4kWcPn0aQUFBugyZiIioQGGuJiIi0lyeWqbr+vXrGDt2LFxdXTFz5kx5+927dxEWFgZPT09UrFjxm87BZbqItIPLdBFpz4+0TFdu5Gou00WkHVymi0h7NF2mK08V2ACQmJgIb29veHl54ddff9X68VlgE2kHC2wi7fmRCmzg++dqFthE2sECm0h7fth1sM3NzbF06VK8fPlS16EQERGRCszVREREquWZWcQ/5eTkhEmTJuk6DMqBFp6VMLxHE9gUMoNQKMC5a08wbu4ufEzNkPdpVc8Fw3s2hrmpEYwMDXD60gP4/r1Dvt3K3Bh/DGyNejXLAQAMDfTRdeRKPHz+BgBQz60cAnzawMzECAb6egjcEIr1u8/L9y9ma4mpv7dDlfIlIBAAse+TMHHBbly7xy+A9GPbvWMT/t0XAoFAgIz0dJSvWBm/DR4OG1s7bFqzHGdPHVfon5SUCOdKLvD7czYeP7iHudP9lY757MlDBB89ByMjYwDA+TMnsDFoGWQywMTUFD6j/4BT6bK58v7ox8RcnT/oGxrBc8BYlG/4EwQCIfQNDXFw6jA8vXASNbr8htrdhyj0NzA2xsf4OKz2/h8AoInvn6jQqA1kMhn0RCI8OReK0PmTkJaUAABwcm+ApiP/goGRMYR6ekiMfY3jCybj5bXwXH+vRLkpQyzGio0hOHrmIsRiCQoXssSUkf1R2qE4Yt/FYez0RYh9HweBQAADfT306tIaHVo0kO+f8jEV81ZtwcVrd5CekYHSDiUwZWQ/FClcSIfvijSR5x4R/974iPj38b8aZfA08i1excZDT0+I1VN74vXbBEyYHwIA6NPRA73be6D3hHV4Ef0eAKCvL4RYLAUAmJsaIXSNL5ZvO411u89BKpVBKBRAJgNkMhkqly2O4IWD0MFnKe4+eQ1LM2MELxyEP5cfwMmLDyAQCBCxww+z1xzB1oOZj0M19aiIlQE9ULndFIVCn7SDj4jnntevXsK6sC1EhoaQiMXYuGY5Lp47jSXrtqvsv2j2NJQuVwE/dfBSuf3e7RtYvmA2AlduAAA8e/IIUyf4YvbiIBS2LYJb169g3l+TseyfHTA0/LEeXf5R/WiPiH9vfEQ8dwj19NBr7WE8vXASYStnQZKRLm+XSiQq9/lfv9EwsrBC6LyJAABrx7KIe/kUUokEBkbGaD1pIYwtC2GrTxcAgEkhG8hkUnyMy8z9FRq1QYeZa7C0bTUkvonOhXdZsPERcd2Zs2ITXr2OxYzxQ2BoKMKl63cwdX4Qglf/DZkMiIl9B/vidgCAp5Gv0Hf0dPj59EHTerUAAL4BgShiY41xg3tAKBTi0Inz2LT7MDYumKLDd1WwafqIuE7vYEdERCAjQ33hU6VKFZiZmSExMRHXrl2Dq6urwrIglHecvfJY/neJRIr5649h9Z+9AAAWZkaY+ns71PL6CzHvEuX9soprABjeszFORzzAmuCz8jap9L9rP/26eGLRxuO4++Q1ACA+6SMmzA/BiF5NcPLiAxSzsUAxW0t5cQ0Ax87fxfv4ZFRwsuNdbPqhFS1eUv53PX199Ow3BHt2bsG72DcobFtEoe/HlBScO3MCfYf4qj3egd070KpdJ/nrw/tD0OnnnvJjuVSrgfIVK+PyhXOoW7+xlt8N/WiYq/Ovqu17IDUxHqeWTFNoV1dcA0CNLr9hY/828tfvnz+S/z0j9SOOzh6Pkaefy9tSPrxV2P/+if2IvHoOTrUb4Ob+rd/6FojyJJlMhi17jiJ062IYGooAALWqVUKNKs4Iu3gdjeq6yYtrAChlXxzdO7bEqQtX0bReLbz7EI/wK7dwZtcKCIWZI3pbNfLAroMn8ODJC5Qv7aCT90Wa0WmBPW/ePEg++SV+584dVKpUCQAgEAgwYcIElChRAl26dIG1tTXi4uKwc+dOWFtb6ypk0lAhS1OkpWd+IWvpWRmnLz1UKK4/59XCDd6jVqndXrqkDY6cvaPQdudxNNwqOwIAot8mID4xBb3a18E/e8Llx7S2NMWDZ2++9e0Q5SlpqakQCAQwt7RS2nbi6EHU8vCEiampyn2TEhMQEX4WQ0dOkLddjbiAlm07KfSrUt0NVy6Fs8Am5up8zKV1V1z4Z5HG/cv8rynioyPxIfKJ2j5GloWQ+OZVtscxsiiEhJgojc9L9KN5+z4eBvr6sLJQvNhYtlRJ3Lz/GI3quintk5CUDDubzMe/I1/FoLidLfT19VTuzwI7b9Npgb1582aF156enti2bZtCW2BgINq3bw9fX18sWbIE69f/H3v3HR1F9f5x/L3pkARCgIRelN4jTRRBivReBaT3LigiRYoCItIF6d0vvUpTpBfpTQVFegkYaiAJpO7+/siPlTUJbGCTDcnndQ7nsHfuzDyDbp48M3PvXUS/fnE/mZGkoXOT8vxv0xEAiubLyrkrAQzuUpO6lYphNJrYsvcPvp2/jfCISNxcncmVNT3ubi5smNaDzBnTciPgAWNmbeXYmei74HcfBJM7W3qLc7yZPSM+3p5A9J3ClgPmsXpyV6qWK0hoWARV3i5Ak49n8Tg0PHEvXiQBXbl0gXnfT6ZV+664uLjE2L5lw2p69h8c5/47ftpEufcq4ZYqtbnt/t07ZPTJZNEvo08mDu7bZbvA5bWlXJ18ZcpfjIiwJzSbuoL0OfPy+MFdDswdz4X922LtX7J5Z06sin2Nc4PBQJYipag+aDy/fPt5rH08fTJT5qOePL5/h6tH99nsOkSSGk+P1Dx+EsqjoBDSeP57w/uafwDh4ZZvBAU/fsIve4+w69fjLJoUPWeKt1cabt2+S1SUEUdHB4v9vdOmSZyLkJeW5GYRB7h27Rq3bkWPy9m1axctWrQAoHnz5uzevduOkYk1qpYrSLH82Zi/9lcAvNO6065BOS7duMu7rcbxQcfJ5M/ty5TBzaK3p0lNZKSRQV1q0n3k/yjT/GsmLtrOmqndyJMj+pXVRRsO0qtlJQq8EV0EZMmYluE961i8Rn7mwi2W/HiYptVL0rre26zZdoJzl/9J5KsXSRhzpk2kRd3KdGvdmPQZMtKgWasYfc79+QeREREULFIszuNs2bCamvUaW7QFBwfh4mpZrLu4uhAWGmqb4CVZUq5+/aXySk+FboPZOWkYM+q/xU9jPqHulzPIVaZCjL4eGTORvUQ5/vxlfYxtjScsYcDBW3RasZ+LB37h7M9rLbYXrtGEvtv/pt+uy+Qu8z4/ftEtoS5JJElwc3WhdpV3GDNtEU9CwzCZTOw7fIpf9h7B+P/TX12/GUDN1v0oV78TE2cvZdSArqRLG/3gKEfWTOTJlY2pC1YSERlJVJSR9T/v4eQf58z7S9KVpArsEiVKAPDVV1+Zk3NgYCCZMkUXVRkyZCAoKO7XjMX+svl6Mf2LFrQbvJDwiEggeiz1/hMXWL7lKEajiceh4fQds4IPa5bG1cUJo8lE6lQuDJq0jpt3HgKw//gFVv10jBa1oyd62HvsPH2/XsHEz5pyZMUg5o1qw+TFO3gUEl0AODgY2DKzFyUL56Bci7GUajqGPDl92PfDADxSu9rnH0PEhjr36s+yjTtZuWUPLi4uTIxlZvAt62MWz8/64/QJnF1cyFugkEW7s7Mz4WGWb3qEhYXh4qrvjsSkXJ18mExGDswbz93L5wAI+Pt3Di6ail+jmGubv9W4Pb9vXm6eCO1Zaz5pzbi3MzGp0hv45CnE+70tfz6d+Wk1U6rmY3SJNJxYPZ+2i37ByUU/XyR5G9m/M1kzZaRVn+HU6zCAHQeO0aphdbw8o18bz57Fl61LJvHbth+YMKwvn341lfOXr5v3n/bVp4SGhtGs2xAadh7Ixav+1PvgPfP+knTZfZmuWrVq4eXlRdeuXZk2bRr79+/nxo0bNGkSPfvk04H9kvSldnNhxcQujJi+kRNnr5nb7zwIIuDeI4u+Dx49JuRJOGk9UnEvMISIiCguXr9j0efi9bvmJ9YAv/z6J7/8+qf5c8lCOTh7MXqcV8XS+fDNkAa/xqPMk6c16jOTrbN606xGKYvJ00ReZ2nSetHt44E0qV6ekOAg3D2i73aHhARzcN8uOvXsH+e+WzaspuZ/xloDZMjoy+2AWxbLct0N+IcMGX1j9JWUSbk6eQq5d5t7l89btN2/doE3361q0WYwGHiraQd+6Fz3ucd7FODP5i/70HvrGXZ/92WM7VER4ZxYPZ8CVevz5rsfcG7Xple/CJEkysXFmd7tm9K7/b8renw5eR4lCuWz6GcwGChTohDN61Vl9ZZdDOr5/5MEe7ozqFdbi75dPx9LtQplEz54eSV2z4i3b9+mdu3aDBw4kAEDBjBixAgmTJiAs3P0Eh0uLi6EhIQAEBoaam6XpMXBwcDise3ZduAsyzZbLglx/Mw1iuTJYtHmndYdR0cDt+8HEREZxR8XblLozcwWffLkyMil/xTdz2rX8B3W7zgFQBp3Ny5cu2MxMznAn5f+IV2aVK9wZSJJT0REOBGRERiN//7/vuOnTZR6+10808Q+NuvRw0COHTrA+9VqxdhWqGhxfj913KLtt1PHKVS0uG0Dl9eWcnXydPP3Y/jmK2LRlj5nXu5fu2jRlqdCDR7eusHdS3+98JhunmkxvOCGizV9RJKb4MdP2HngOBXe9ot1e1DwY0xGY6zbAG7dvsv5y9cpUThfnH0kabD7Tzc3NzdatWrF1q1buXnzJm+88YZ5dlKAMmXKsG1b9GQbO3bsoGTJmLPuif1NGNCE0LAIRn4f8270tgNnKZQnC3Xfjx4X6uLsxORBzfh+2R5zn1kr9zLhs6bm17nfLp6buu8X44eNh2Mcz9nJkT4fVcavYHYWrjsIwK4j58idNT3Navz7/8dbhXJQ873CrPv/IlzkdRQREcGd2wHmz8FBjxg/6gvKv18VzzRpze2xja1+1i9bf+Tt8hVxd4/5alndRh+ydtli7t2JnnH/zG8nOfv7KSpUrm7DK5HXmXJ18nR02Uyq9PsKjwzRb6tkeKMAZVv35Oj/Zlj0KxXH5GYu7h6kTpfB/NnTJzP1Rs3iyP++N7d5Zc1l/ruDoyPvdvwE9/QZ45xITSS5iIr6t1gOuHOfPl9MoG3TWnil8eDW7btEREaat+87coqVm3bQuHblWPe/dO0mPYeO57PurS0mPZOkye6viD+VLl065s2bR+fOnVm0aBFt20a/EtGqVSvatWvHkSNH2Lt3L/PmxT57pdiPl2cqun1YkXOX/+HQ8n9nDjWZTNTv+T237wfR5ONZTBv6IaM/boCDwcC6HScZM3urue+i9QfJlCENh5d/TmSUkTv3g2jx6VzuBUY/ESn0ZmbzutpOjg7sPnKO2t2mEREZvXTMo+BQ6vX8nlF96/NJ+w8wGk08ePiYjkMXc+m65RqcIq+Th4H3Gfl5X0KfPMHFxRWDg4FKH9SiQbOW5j7nzv4OJhNFS8Rd1GzbtJ5+g0bEui1fwcK069qbIZ/0wGAw4OrqxvCxk0mVOnWs/SXlUq5OXi4d3Mmhxd/R/oedmIxGwp88ZtPwnuYx2RBdNGcpUopV/VrG2N87Rx4ajp2Pg6MjkeHhREWEc3zFHE6uXWjuU2PQeDLmKURE6BMwmbh24gDzW75PZJgmUZTkbdb/1rHzwDEiI6NwdXWhVYPq1Kv2HgAbtu1j3dbduLg44+ToSBbfDMwfP4T8zyy/NWrqfH7/6yIRkZGk8fCgX8cPea9sCTtdjcSHwWSy71R05cuXZ//+/ebPt2/fpmnTpsydO5e8efMC8Oeff7J//37Kly9PwYIFX+l8qfx6vdL+IhLt7C/j7R2CSLKRO4ObvUN4rsTO1SMK6BVzEVsYvuvoizuJiFUMmUtY1S/JvWPg4+PDJ598wrhx48xtBQsWpHPnzq+csEVEROTVKVeLiIjEzu4F9rJly2K01atXDwcHB+7fv2+HiERERORZytUiIiLWsfsY7OzZs8faPmvWrESORERERGKjXC0iImIduz/BFhEREREREUkOVGCLiIiIiIiI2IAKbBEREREREREbUIEtIiIiIiIiYgMqsEVERERERERswK6ziJ8+fZrw8PB47ePs7EyJEiUSJiARERGxoFwtIiJiPbsW2FOnTo130nZxcWHevHkJFJGIiIg8S7laRETEenYtsJV8RUREkjblahEREevZtcCePXv2S90V79KlSwJFJCIiIs9SrhYREbGeXSc5M5lMMdrmz59vh0hEREQkNsrVIiIi1jOYYsucdlS+fHn2798PgNFoZOXKlTRv3hyDwWCT46fy62WT44ikdGd/GW/vEESSjdwZ3OwdQrwkdK4eUcDZJscRSemG7zpq7xBEkg1D5hJW9bP7Ml0BAQEEBgaaP3t7ewMQGRnJgAEDOHnypM0StoiIiMSfcrWIiIh17DoGG6BNmzbcuHEDPz8/6tevz5o1a7h06RIDBw6kePHiDBkyxN4hioiIpGjK1SIiItaxe4EdEhLCrl272L17N5s3b2bSpEk8fvyYUaNGUadOHXuHJyIikuIpV4uIiFjH7q+IA/j4+NCsWTMWLlzI1KlTyZs3L9u2bSM0NNTeoYmIiAjK1SIiItZIEgX2s0qVKsXy5cvx8fGhadOmFmO+RERExP6Uq0VERGKX5ApsAEdHR4YOHUr9+vXp1q0bYWFh9g5JREREnqFcLSIiEpPdC+xx48bFua1Tp074+fmxdu3aRIxIREREnqVcLSIiYp0ktw52QtM62CK2oXWwRWzndVsHO6FpHWwR29A62CK289qsgy0iIiIiIiKSHNh1ma4jR44QHh4e67aSJUsSEhLC+fPnMZlM5M2bl4wZMzJjxgy6d++eyJGKiIikTMrVIiIi1rNrgT19+nQiIiJitBsMBkaOHMngwYMxmUwYDAaMRiOrV69m/fr1StoiIiKJRLlaRETEenYtsBctWvTc7YGBgWzbtg2AKlWqAJDChoyLiIjYlXK1iIiI9ZL0GGyDwWDvEEREROQ5lKtFRET+leQK7NmzZ3PixAlAd8BFRESSIuVqERGR2CWpAvvixYssXryYXLly2TsUERERiYVytYiISNxeusD++uuvreoX18yj/3X16lV69OjBsGHD8Pb2ftmwRERE5P8pV4uIiCSulyqwo6KiWLx48Qv7nTp1isqVK8eZuMeMGcOMGTOYPn06rVq1okePHlSrVs28PbZxXRrrJSIi8mLK1SIiIokvwWYRv3btGn379qVfv364uLjE2sfb2xt/f3/279+Pu7s7+fPnt9j+7Liu4OBgBg0aRGBgYEKFLCIikqIoV4uIiNiW1QV2kSJFiIqKMn82mUwULFjQ/Pmzzz6jYcOGHDlyhOvXr7NgwQK6d+9O48aN4zxmt27dADAajWzcuJFOnTrx7bffUq5cOQB69Ohh7jthwgSuXr1K7dq1rb86ERGRFES5WkRExL4MJiun/7x69epzx2hlzpyZGzdu8Omnn3Lt2jVKly7NhAkT8PLysjqY06dP07NnT5YtW0b27Nmt3i8+Uvn1SpDjiqQ0Z38Zb+8QRJKN3BncbHKc5JKrRxRwTpDjiqQ0w3cdtXcIIsmGIXMJ6/pZW2DHR2BgIDNnzmTTpk3MnTuXAgUKWL3vypUrOXv2LCNGjLB1WIAKbBFbUYEtYju2KrDjIynnahXYIrahAlvEdqwtsBNkDLaXlxeff/45uXLlomPHjqxbtw4fHx+r9m3WrJnF620iIiJie8rVIiIitmd1gT18+HDu3bvHO++8Q7169fDw8IjRJzIykr1795onPMmYMSMlS5YkICDA6qQN4OjoaHVfERERiaZcLSIiYl9WL9O1evVqsmXLxrp166hatSpbtmyJ0Sc4OJgFCxbQq1cv5s+fz8KFC7lx4wadOnWyadAiIiISk3K1iIiIfVn9BDsqKor+/fvj4uLCzp07GTJkCDdv3rRIyF5eXixZsoQCBQowd+5cUqVKRVhYGMWLF0+Q4EVERORfytUiIiL2ZfUTbIPBYP575cqV+eGHH5gzZw7bt29/bl+DwWDxWURERBKGcrWIiIh9vfQkZ2+++SZjx45l0KBBlC5dmrRp0xIeHs6pU6cAOH78OK6urjx8+FBJW0RExA6Uq0VERBLXK80iXqlSJcqUKcO0adMYMmQIAQEBjBkzhvz58zN+fPQSPgaDgbp169okWBEREYkf5WoREZHEY3WBHddy2X379qVx48Z069aN7Nmzs379elvFJiIiIvGgXC0iImJfVo/B3rp1Ky4uLjHa33zzTQYMGKD1MEVEROxMuVpERMS+rH6CnTt37ji3tWrVyibBiIiIyMtTrhYREbEvq59gi4iIiIiIiEjcrH6CPXr0aCIiIuJ9AhcXFwYPHhzv/URERCR+lKtFRETsy+oCO2PGjISHh8f7BLGNBRMRERHbU64WERGxL6sL7C5duiRkHCIiIvKKlKtFRETsy+oCe8SIEYSFhcX7BK6urowYMSLe+4mIiEj8KFeLiIjYl9UFdq5cuWK8djZp0iQ+/vhjDAZD3CdwsvoUieLB0Wn2DkEkWThy6b69QxBJNnJncLPJcZJLrh5x4pa9QxBJFoznt9o7BJFkw5C5hHX9TCaT6WVPUrBgQc6cOYODQ/Rk5CdPnsTDw4O8efO+7CETXGikvSMQSR5UYIvYToV83gl27NcxV/P4rr0jEEkWVGCL2I5D8dbW9YvPQWOrxZ/eET9y5Ajdu3fn1i3ddRYREbEX5WoRERH7idc7YVWqVMHR0ZGaNWvStGlTDhw4gMFgYP78+cyZM4fx48dTvnz5hIpVREREXkC5WkRExH7iVWDfvHmTL7/8kn379lGvXj0qVarEhQsXcHNzY/ny5eTMmTOh4hQRERErKFeLiIjYT7xeETcYDDRo0IDvvvuO3bt34+vry5UrV6hRo4YStoiISBKgXC0iImI/8Sqwn5U2bVoGDhzIpk2b2LRpE3379uXx48e2jE1ERERegXK1iIhI4nrpAvupHDlysHTpUkwmE127do2xPIiIiIjYl3K1iIhI4ohXge3q6mpe5uNZbm5uTJ48GU9PT/r16xfrDKYiIiKS8JSrRURE7CdeBfbJkydxcop9XjQHBwcmT55M5syZCQkJsUlwIiIiEj/K1SIiIvZjMKWwW9ihkfaOQCR5OHLpvr1DEEk2KuTztncIScvju/aOQCRZMJ7fau8QRJINh+Ktrepn9TJdW7Zsee6YrSpVquDv78+5c+cAKFCgAPnz56dXr15MmzbN2tOIiIjIS1KuFhERsS+rC+xVq1YRFhYW6zYHBweKFy9OmzZtyJUrF0ajkVu3bnHgwAG2b99us2BFREQkbsrVIiIi9mV1gb1gwYIX9gkJCWHlypUAFClS5OWjEhERkXhTrhYREbGvV16m61kGg8GWhxMREREbU64WERFJOK9cYC9dupQHDx4AaMkPERGRJEi5WkREJHG8UoF99OhRJk2apGQtIiKSRClXi4iIJJ6XLrBv3LhB//79GTRoEN7eWl5EREQkqVGuFhERSVxWF9gPHz7EaDQCsGfPHpo1a0bz5s1p1KiRuY/GdYmIiNiPcrWIiIh9WTWLeFRUFG+//TZOTk74+Phw8+ZNvvzyS5o2bfrc/Z63FmdsLl26xKFDh7h16xYPHz4kbdq0ZM6cmbJly/Lmm2/G61giIiIpiXK1iIiI/VlVYDs6OnLgwAFu3rzJ6dOnWbVqFTNmzCB//vwUK1Ys1n0yZMhA8eLFyZw583OPHRUVxbp161iwYAHOzs6ULFmSLFmykCNHDh4+fMiFCxdYtmwZRqORdu3a0bBhQ5ycrF5dTEREJEVQrhYREbE/g+klZz1ZunQpEyZMYNasWZQqVQqIHuuVLVs2AB4/fsyDBw9Ily4dqVOnjvUYZ8+eZezYsZQsWZImTZqQNWvWOM93/fp1Vq1axYkTJxgyZAgFCxZ8mbAJjXyp3UTkP45cum/vEESSjQr5EmZ89Ouaq3l89+X2ExELxvNb7R2CSLLhULy1Vf1eusAG2LhxI6NGjWL9+vUvvPsdmylTptChQwc8PT2t3icwMJAFCxbQr1+/eJ8PVGCL2IoKbBHbSagCG17PXK0CW8Q2VGCL2E6iFNgAo0ePJnPmzHTo0OFVDpNoVGCL2IYKbBHbScgCG16/XK0CW8Q2VGCL2E6iFdivGxXYIrahAlvEdhK6wH7tqMAWsQkV2CK2Y22B/dLrYIuIiIiIiIjIv1Rgi4iIiIiIiNiA3dfQKF68OFFRUS/sZzKZcHV15cSJE4kQlYiIiDylXC0iImIduxfYjRs35tq1a4wcOfKFfZ2dnRMhIhEREXmWcrWIiIh17D7JmdFopGfPnhQpUoSePXsm+Pk0yZmIbWiSMxHbSeqTnCV2rtYkZyK2oUnORGzntZnkzMHBgUmTJvHGG2/YOxQRERGJhXK1iIiIdexeYAO4ublRs2ZNe4chIiIicVCuFhERebEkUWCLiIiIiIiIvO7sWmB/8cUXXLt2LV77XLlyhaFDhyZQRCIiIvIs5WoRERHr2XUW8d69ezNy5EhSpUpF8+bNKV26dJx9jxw5wrJlywgLC2P48OGJGKWIiEjKpVwtIiJiPbvPIg5w6NAh5s2bx5kzZyhWrBjZsmXDw8ODoKAg/P39OX36NIULF6Zjx46UK1fulc6lWcRFbEOziIvYTlKfRRwSN1drFnER29As4iK2Y+0s4kmiwH4qODiY48eP4+/vT1BQEJ6enmTNmpWSJUvi4eFhk3OowBaxDRXYIrbzOhTYTyVGrlaBLWIbKrBFbMfaAtuur4j/l4eHBxUrVrR3GCIiIhIH5WoREZG4JYlZxCMiIti0aRMAFy9e5Ny5c3aOSERERJ6lXC0iIvJiSaLADg4OZtasWQCcOHGCw4cP2zkiEREReZZytYiIyIvZtcAOCAjg5s2bBAQEEBkZya1bt3j48CEPHz7k5s2bhISEAPDkyRMOHjzIo0eP7BmuiIhIiqNcLSIiYj27TnJWoUIFIiIiiC0Eg8FA69atadu2LY0aNcLJyYmQkBBWrlyJj4/PS59Tk5yJ2IYmOROxnaQ8yZk9crUmOROxDU1yJmI7r+Us4k89fvwYgNSpU/PDDz9w6dIlhg0bxuzZswkKCuKTTz556WOrwBaxDRXYIraTlAvsuCRkrlaBLWIbKrBFbMfaAjtJjMH+r0WLFrFu3ToAdu/eTdOmTQFo0qQJe/bssWdoIiIignK1iIhIbOy+TNetW7fw9/cHIGfOnGTMmJHMmTNz5swZIHrsV65cuQDw9vYmODjYXqGKiIikSMrVIiIi1rF7gd2gQQOyZctGZGQkRqORjRs3ki1bNnbu3AlAeHg4zs7Odo5SREQk5VKuFhERsY7dC2w3NzfWrFkDQPny5QHIlCkTDx48ACBdunTcu3cPX19fIiMjcXR0tFusIiIiKZFytYiIiHXsPgbbYDDEaPPy8iI0NBSAEiVKsH//fgAOHz5MoUKFEjU+ERGRlE65WkRExDp2f4IdGzc3N3PSbty4MW3btuXs2bPs3LmTsWPH2jk6ERERUa4WERGJye5PsJ9lNBoxGo1EREQQHh4OQN68eZk6dSqurq6MHDmSsmXL2jlKERGRlEu5WkREJG52f4KdOnVq89+9vLwoXLgwABUrVjS3lypVilKlSiV6bCIiIqJcLSIiYi2DyWQy2TuIZz29G+7i4pIgxw+NTJDDSjxcvnSRpo3q06lLN7r16AVAnRof4OzsbDEL7YctP6JRk+h1Vfft3cPihfN58OA+RqMJv7fe4tPPBpEqVSq7XIPAkUv37R1CimCMimLsZ12IiIiwaL/7jz9dPhtF0VLlLNq/HdSDe7f/Yey8tea2wHt3WLt4BtcvXwCTCU+vdDRu25OcefKb+1w4e5qV86YSERGBs7MzTTr0Jl/hEgl6bfKvCvm87R1CvCR0rubx3YQ5rlht9fpNjBgznp/WLyNblswA/H3hEiPGfEtQUDAmkwn31Knp0bkdFd97J9ZjrNmwmcEjxrBkzjTKlPJLzPDl/xnPb7V3CCnOmp2nGDl3K1sndyerjxcA01fvZfvhcxb9Hj0OpVierEzq1wiAB48eM3bxL/x1JYCwiEhK5M3KFx1r4J7KNcY5wiMiqffpbHy9PVk0vHWCX5NEcyhu3b+13Z9g/1eCJWtJMr75egxlyr5N5DMFQ1RUFN/PmkuOnDlj3Sd16tSM+nqceYbaLwYP5PtpU/lkwMDEClvELhwcHRk8YZ5FW0R4GIM7N+HNAkUs2g/t/hkXVzeiov69k2g0Gpn4RV9qNW1Dh37DAPjjxCG+++pTRs9ahaubG48C7zNn/Aj6jphIlhy5+efGVSYP/5hB4+eSNl36hL9Iee0oVydvk6fP5o+z50ibxpOoyChze5ZMvkwa+yW+PhkBOPXbH3TtM4D5MyZTuGB+i2M8Cgpi4f9WULhgfiIj9XRDUoYpy3dz5tIt0rq7EWk0mtt7NqlAzyYVLPqOmLOFgrl8ATCZTHT/ZgU13ynEN73qAzDvx4OMnLuVcb0bxDjP/I2HyJEpHSGPwxLuYuSlJakx2E999NFH9g5BEsj2bT+TPkN6ihYrHq/9SpYqja9v9A8hJycn2rbvxMFf9ydEiCJJ3tF92ylQvBSpPTzNbaGPQ9i6ajENPupi0ffhg7s8vH+XtyvVMLcVeett3D3S8M+Nq9HH27ud0hWqkiVHbgAyZctJmYrVOLr3l0S4GnldKVcnT0ajkYwZMzBr6jhc/3MjxcPD3VxcA5QoVoTaNaqy79dDMY4zZfoc2rZshvszwwtEkjOj0UTGdB7M+Lw5Li7Pf4YZEhrOjqN/U6d89I3yPy7eIiw8kra1/52/okPdt/nrSgCPQkIt9r159yE/H/yTtrXK2P4ixCaSZIF95cqVOLc9fS1NXj9Pnjxh+rSp9O33ySsf6+HDQFxcYr4yI5IS7P1pPe9Vr2/RtnHZPCpUr4+7Z1qL9rTpMpDK3YP9v2w0tx3Z+wshwY/IlC0HAH+ePkr+Ipavb+Yr4sfZU0cT6AokOVCuTp4cHBxo1ayR1WuZP3wUhG/GjBZtf507z+9n/6Rx/doJEaJIkuTgYKBl9VI4Ory4vNq8/w8q+L1pfv37WsADcmRKZ9HHYDCQK3N6/rz8j0X7N4t+oXfzijg7WfcdlcRn11fE+/Xrh/GZ1yfy5s1Lr169LPqMHTuW8+fP895779GuXTvq1KnDtm3bEjtUsYF5s2dSu05dfHx8X/lYq1cup269Bq8elMhr5saVC4QEB1mMj751/QpnTx9j6KT5PLh7x6K/g4MD3QeNYdpXAzh78ghOzi78eeoIvYaOw9Uteg6DwPt3SZfBx2I/7wy+3PnHP8GvR5I+5WqJzYPAh2zYtJUbN25Su+YHFtu++mYSA/v3jnX9dBGBFb+c4IuO/75Z5p0mNddvB8body3gPncfhpg///rbJYKfhFG5VD6OnLmSCJHKy7DrE+xKlSrx/vvvc+TIESpWrMiSJUti9NmyZQtNmzZlxYoVABrH85q6fu0a27dvo3Xb9rF3MMCwoYNo2rAeHzZtxPfTpprXV/2vA/v38ddff9G4abMEjFgkadqzdR3vVatn0bZs1gQat+uBo2Ps90yz5HyDd6rU5ui+7RzcuYVS5auQKdu/8x08DgnC+T9vhDi7uBAeprFdolwtlo6dPE21es0p/0Fdlq1ez7hRw3B5ZoLSDZt/xtcnIyVLFLNjlCJJ1+8XbhIRGUWJfNnMbaUK5uBJaDjLtx3HaDQRERnF7HUH+OdeEE/no46IjOKbxdv5vG01e4UuVrJrgV2vXj0aNmxI6tSpadSoUawzQnt4eFCjRg2Lu+fy+vlm7Gh69f4YV9fYX+v+YelKFiz+H6vW/cj0mXO4eOEC474eHaPfP7du8dWIYYwdN16T7EiKExb6hOMHdlGuci1z27H9O3B2caXIW2/Huo8xKoqJQ/tw5fyfDJ20kOHfLSHg5nXGfNKR0MfRd8WdnFyICLcspsPDwvQdE0C5WiyV8ivOth9X8NuhXQzo24OOPftx7/4DAIJDQpg2ax4DPu5h5yhFkq4V20/QrOpbFm3OTo4sHP4Rf1y6RaOBc2g2aD5Ojg6UK5qbtB7RP3MXbzlC6UI5yJs9Y2yHlSQkSY7BluTlwL69hD55QtVq1ePskz5DBvOrZOnTp+ezzwfzy7afLfo8fvyYj/v0pGefvhQuUjRBYxZJio7s/YUCxUrimdYLgMiICNYunkGzTn3j3Oev34/z6ME9eg+fQM48+cmWKw+9h40nTbr0HPn/SczSZfDh/p0Ai/0e3A2I8dq4iMhTjo6OVK1UgffeeZvNP20HYObcxdSvXYPMmV59KJhIchT8OIwdR89R970iMbb5eqdhVLc6rP+2C+u+7UyHeuU4f/02ebNn5P6jEJb9fIxezSraIWqJryS3TNdTffv2JYkt0S0vyd//BgEBATRr9O+kTHfvRq9xeuDAPuYv+l+MJyJRxigcn5m8ISoqioGf9qd8+fc09lpSrD1b19O4XXfz59Anj4mKiGTm2CHmtqjICIIePmBknzbUbtYWBwdHfLJkx8np3x/3BoOBLDlyExIcBMCbBYvy9x8nKVb6XXOfv/84yZsFdCNLnk+5WoKCgzGaot9cCLhzhz//+ptfdu4xb7923Z/hY76lRLEifDtqmL3CFEkSNuz9nfdKvGl+Kv08J/++gbubC5nSp+GvKwGYgPYjfzBvfxwazt3AYBoOmMMXHWvwVoHsCRi5xEeSLbArVaqE0WjkwoUL9g5FXlGzD1vS7MOWFm0zpn9HVGQkvfr2IyoqioB//sE3UyYA7t27x5ivRtKgYWNz/2++Ho2bmys9+3ycmKGLJBlXL5zjcfAjChQrZW7zSJOWbxast+h3N+AW3wzsyvCpiwF4HBLMusUzOLxnG2UrRo/bunL+T347coD+X00BoPwHdfn6k468U6W2eR3sg7t+4vNxsxLn4uS1pVydsty4eYssmXxxcHDAZDKxYfPPHDpynIH9oie9i62Abt2pF907teWdt0sndrgiSc7K7ScY2iH2NzqjjEbzDOSnz/sz5PuNjO5eB4ACuXzZMb23Rf8jZ64wZflu/vdVuwSNWeIvyRbYDRo0AGDu3Ln2DUQShJOTk/mV8MjISD7t35fg4GCcnZxwcHSkXoOGNP//ovzRw4esWPY/cuXOTfPGDf49iMHAjFlzSZ8hgx2uQCRx7d/2IxVrNnzhrLwOjo4Wk52ldveg78jJrF30PT+tXoLBwYC7Rxo69h+OT5bou93eGXzo0H848yaOxBgVhYODA+37DiW9T+YEvSZ5/SlXJ2/Ozs4Wb7/MW7SUAweP4OrmioPBQL68b7Js4UwyZkgf5zGcnBwtjiGSEjg7OeLkaDkS97cL/phMJkoXyhnrPn3HrybgQRBh4ZFkypCGsb3qUSxP1jjP4eToiJOW6kqSXrufeFryIXno3PXf11xdXV1ZsnRFnH3TpE3L6TPnEiMskSSrVY8BVvXzzuDD2HlrLdoy+Gamy2dfPXe/gsVL8cXkhS8bnogF5erk4ecNyy0+Dx/0SbyPsWDmFFuFI/La+GlKzIn+iuXJyo8Tusa5z7TP4rc6zlsFsrNoeOt4xyYJz64Fds+ePYmKiuLevXt069aN4ODgGH2eju169OgRQ4cOjbWPiIiIJAzlahEREevZtcBu1KgRkZGRNGwY/dpjr169YvTp1q0bABMnTuTSpUvUrl07scMUERFJsZSrRURErGcwJcHpP8uXL8/+/fsT5NihkQlyWJEU58il+/YOQSTZqJDP294hxFtC5moe302Y44qkMMbzW+0dgkiy4VDculfyk+Q62G3btrV3CCIiIvIcytUiIiIxJckn2AlJT7BFbENPsEVs53V8gp2g9ARbxCb0BFvEdl7rJ9giIiIiIiIirxsV2CIiIiIiIiI2oAJbRERERERExAZUYIuIiIiIiIjYgF3XwT59+jTh4eHx2sfZ2ZkSJUokTEAiIiJiQblaRETEenYtsKdOnRrvpO3i4sK8efMSKCIRERF5lnK1iIiI9bRMl4i8FC3TJWI7WqbrP7RMl4hNaJkuEduxdpkuuz7Bnj179kvdFe/SpUsCRSQiIiLPUq4WERGxnl0nOYvt4fn8+fPtEImIiIjERrlaRETEeknuFfHy5cuzf/9+AIxGIytXrqR58+YYDAabHF+viIvYhl4RF7Gd1+0V8YTO1XpFXMQ29Iq4iO1Y+4q43ZfpCggIIDAw0PzZ2zv6l4zIyEgGDBjAyZMnbZewRUREJN6Uq0VERKxj1zHYAG3atOHGjRv4+flRv3591qxZw6VLlxg4cCDFixdnyJAh9g5RREQkRVOuFhERsY7dC+yQkBB27drF7t272bx5M5MmTeLx48eMGjWKOnXq2Ds8ERGRFE+5WkRExDp2f0UcwMfHh2bNmrFw4UKmTp1K3rx52bZtG6GhofYOTURERFCuFhERsUaSKLCfVapUKZYvX46Pjw9Nmza1GPMlIiIi9qdcLSIiErskV2ADODo6MnToUOrXr0+3bt0ICwuzd0giIiLyDOVqERGRmOxeYI8bNy7ObZ06dcLPz4+1a9cmYkQiIiLyLOVqERER6yS5dbATmtbBFrENrYMtYjuv2zrYCU7rYIvYhNbBFrGd12YdbBEREREREZHkwK7LdB05coTw8PBYt5UsWZKQkBDOnz+PyWQib968ZMyYkRkzZtC9e/dEjlRERCRlUq4WERGxnl0L7OnTpxMRERGj3WAwMHLkSAYPHozJZMJgMGA0Glm9ejXr169X0hYREUkkytUiIiLWs2uBvWjRouduDwwMZNu2bQBUqVIFgBQ2ZFxERMSulKtFRESsl6THYBsMBnuHICIiIs+hXC0iIvKvJFdgz549mxMnTgC6Ay4iIpIUKVeLiIjELkkV2BcvXmTx4sXkypXL3qGIiIhILJSrRURE4pZkCuyrV6/So0cPhg0bhre31gMVERFJapSrRUREns+uk5yNGTOGdOnSYTQaWbZsGQMGDKBatWrm7bGN69JYLxERkcSjXC0iImI9uxbY3t7e+Pv7s3//ftzd3cmfP7/F9mfHdQUHBzNo0CACAwMTOUoREZGUS7laRETEenYtsLt16waA0Whk48aNdOrUiW+//ZZy5coB0KNHD3PfCRMmcPXqVWrXrm2XWEVERFIi5WoRERHrGUxJaPrP06dP07NnT5YtW0b27NkT5ByhkQlyWJEU58il+/YOQSTZqJDv9RnPnBi5msd3E+a4IimM8fxWe4cgkmw4FG9tXb8EjiNeihcvTp8+fZg3b569QxEREZFYKFeLiIjEza6viMemWbNmREVF2TsMERERiYNytYiISOyS1BPspxwdHe0dgoiIiDyHcrWIiEhMSbLAFhEREREREXndqMAWERERERERsQEV2CIiIiIiIiI2oAJbRERERERExAZUYIuIiIiIiIjYgApsERERERERERtQgS0iIiIiIiJiAyqwRURERERERGxABbaIiIiIiIiIDajAFhEREREREbEBFdgiIiIiIiIiNqACW0RERERERMQGDCaTyWTvIERERERERERed3qCLSIiIiIiImIDKrBFREREREREbEAFtoiIiIiIiIgNqMAWERERERERsQEV2CIiIiIiIiI2oAJbRERERERExAZUYIuIiIiIiIjYgApsERERERERERtQgS0iIiIiIiJiAyqwRURERERERGxABbaIiIiIiIiIDajAFhEREREREbEBFdgiIiIiIiIiNqACW2JVvXp1AgICOHnyJB06dIizX9++fSlbtqz5z8iRI20eS4sWLTh69Gis2+7fv4+fn1+s2ypVqsTNmzdj3RYQEMDQoUOtjmHYsGH8888/VvcXeSqxvkvbt2+nR48ecW7fsGEDH3/8cbyO+dR7770X5///8f0uTZ48mTNnzrxUHCJiSbnaknK1vCzlakvK1a/Gyd4BiP3Mnj2bpUuXEhUVRfny5Rk6dCju7u4AREREEBERQXh4OBEREXEeY8qUKS99/uvXr/Phhx9atIWGhpIxY0Z++uknc1tUVFScMfzzzz+kS5cu1m3Pi33kyJF89tln5s8BAQGMHDmS48eP4+TkRK1atRgwYAAuLi4AdOrUiREjRjBz5sx4XaOkDPb+LgFERkYSFRUV5/aoqCiMRmOM9po1axISEmLRFhYWxtq1a8maNSsQ/V2KjIyM9bj//S49Pdfo0aNZvXo1v/32m8W2Dh060LNnT+bPn4+zs7NV1yaSktn754tytSQX9v4ugXJ1SqECO4XasGEDa9asYd26daRKlYouXbowcOBApk2bZtX+ffr04fjx47Fu8/DwYPDgwVSsWPG5x8iePTsHDhywaPvf//7Hxo0brbsI4MKFC6RJk8bq/gAHDx4kVapU5MqVC4j+odqpUydq1arFlClTePz4MQMHDmTUqFF8+eWXAOTIkQMPDw8OHjxIuXLl4nU+Sd6SwnfpqUOHDlG5cuVYt4WEhFC2bNkY7Vu3bo3R1qhRI/z9/c1JG+DRo0fcv38fDw8P8y+z//0uATx58oR+/foRERERa6JPkyYNb731FuvXr6dp06ZWXZdISpUUfr4oV0tykBS+S08pVyd/KrBTqEWLFtGvXz/zHeWRI0dSo0YN8xf+Ra9YTZ06NUbbr7/+yowZM0ibNi3FixePd0wPHjxg6tSpjB071up9fvzxR/7++29u376Nj4+PVfvMmzePzp07mz/v2bMHd3d3unfvDkDatGn5+uuvqVy5Mp988glp06YFoHnz5sycOVNJWywkle+SwWCgbNmyzJ49O9bta9asYc+ePVYdK7Zk269fP5ydnenSpQv16tUDYn6XAHbt2kWRIkVo0KAB1apVi/X4TZs2pUuXLkraIi+QVH6+PEu5Wl5HSeW7pFydMqjAToHCw8P5888/efvtt81tuXPnJleuXAwYMICqVavGeWftv8c5deoUu3fv5qeffuLWrVt06dKFzp074+HhEa+YQkND6dmzJ+XLl6dSpUr07NmTU6dOAfDw4cNY9zl9+jSHDh2ibNmyTJkyhdGjR8fo07x5cxwdHenVqxctWrQgODiYP/74g9KlS5v77Nq1K8b1pkuXjhIlSrB//35q164NQMmSJTl79izBwcHxvj5JnpLSdylLliwcO3aMChUqxLr9yZMnfPTRRzHaa9Wqxf3793F0dDS3pU2blpw5c1r0mzdvHtmyZTN/ju279PR4ADdu3Igz1mzZsuHk5MTFixd58803X3xxIilQUvr58pRytbyOktJ3Sbk6ZVCBnQI9ePAAJycnvLy8LNqzZs3KkydPXrj/ypUrWbduHbdv36ZYsWK8//77tGjRgt9//51Dhw7x0UcfERoaSvXq1enXr98Lj3f79m369+9P6tSpOXnyJPv27WP69Onm7c2aNYuxT1BQEAMGDKB169b06NGDDz/8kIULF9KuXTuLfitWrLD44XPs2DGKFy+Og8O/8/tdvXqVSpUqxThH7ty5+fvvv81J28HBgWLFinHs2DHef//9F16XJH9J6btUtGhRTpw4Ea/4w8PDuXjxIn/88ccLx1ht2bKFdOnS4efnR548eWL9LsVHqVKlOHTokJK2SByS0s8XUK6W11dS+i4pV6cMKrBTIIPBgNFoxGQyYTAYzO2RkZFkzJjxhfuXLVuWcuXKkT17dov27Nmzm++IhYaGEhwc/NzjmEwmNm7cyPjx42nfvj3t27fnzJkzfPLJJ2TNmpUvvvjCYrzIU1euXKF79+4UL16cTz/9FEdHR+bPn0/37t05duwYY8eOjfNO4n/HqkD07KaxjQ3z9PQkMDDQoi1LlixxznYqKU9S+C7Nnj2bRYsWxSvunDlzsnTpUvPnpxO6hIaGEhgYSEBAADdu3MDf39/8i/CTJ09wcXExv5IW23cpPvRdEnm+pPDzBZSr5fWXFL5LytUpiwrsFMjb2xuDwcA///xD5syZze3Xr1/n008/xcXFJdaxKNevX6dFixaYTKZ4nW/27NkULlw4RnvXrl2Jiopi9uzZFChQAIDChQvz448/smrVqjjv0i1evJjGjRvTsWNH8w9KX19fli9fztq1a3Fzc4szlqCgIDw9PS3aIiMj47ymZ38QQ/SkD48ePYr7YiVFSQrfpS5dutClS5cYfdeuXcvu3btjHTf2lIuLCxUrVqR+/fq4urri6uqKm5sb6dKlI1OmTBZPlBo3bmzx2lls36X4SJMmDVevXn3p/UWSu6Tw8wWUq+X1lxS+S8rVKYsK7BTIycmJEiVKsHv3blq0aAHAb7/9Rv78+c1LW8Q2FiV79uzs37/fZnF8/fXXpE+fPka7i4sLrVq1Mn8eNGgQefLkMX8eNmxYrMdzcXGxWErkq6++IlOmTBZ9PD09CQgIiNEWFBQU43iPHj2Kcbf84cOH+Pr6PueqJCVJKt+lVxHXRCvPat26dYxX62L7LsXHw4cP4z2rsEhKklR+vihXy+suqXyXXoVy9etFBXYK1blzZwYNGkSpUqVIkyYNI0eO5IsvvkjUGJ5N2H/99Rc//PADR44cISwsDJPJRNq0aalcuTIfffRRnHffXrSfq6urRf+sWbPGmJ0xV65cXLp0KcaxL1++TN26dS3abt68qTFdYiEpfJcA1q9fH+varzVq1ACiJzqpVasWgwcPjnX/8+fPs3r1ak6fPs39+/dxcXHB19eX999/n3bt2sV4lTO271J83Lx50+KXcRGJKSn8fFGuluQgKXyXQLk6pVCBnUJVrFiRwYMHM3DgQAB69OhBiRIlrNp3+/bt5jUnY2M0GnF2dmbr1q3PfQXsqbNnz9K+fXsGDBjA559/bv7hcPPmTVasWEGTJk348ccfzUtwvMp+JUuWZODAgRiNRvOED++88w4rV660eHXnwYMHnDp1ijFjxpjboqKiOH36NBMnTrTiX0lSiqTyXWrQoAENGjSIc/vWrVtZuXJlrNuOHTtG79696d+/P+3atSN9+vRERERw5coVVq9eTaNGjVi3bh3u7u7mfWL7LsXH0aNHLZ5+iUhMSeXnCyhXy+stqXyXlKtTBhXYKVidOnWoU6dOvPerWrUqVatWfW6fkiVLcu/ePasmVti/fz+VKlWiSZMmFu1ZsmShX79+7N27l1OnTlGxYsVX3s/T05MiRYpw5MgR83INderUYebMmcycOZNOnToREhLCoEGDqFatGlmyZDHve/ToUYoUKaJlPySGpPBd+vXXX+nfv3+cT5AcHBxineUXYMeOHdSoUcNirUsXFxcKFy5M4cKFqVWrFqdOneLdd981b4/tu2St69evExUVpbviIlZICj9fQLlaXn9J4bukXJ0yqMCWBGEwGKyeFKJ8+fIsWLCAjRs3UrVqVVKlSgXAnTt3WLlyJYGBgfj5+dlsv44dO7J8+XLzDxpXV1fmz5/PV199Rbly5XB0dKRGjRrmu5xPrVy5kg4dOsTr30HkVVn7Xbp8+TKVK1e2eJJjrbfffpthw4ZRuXJl3n77bfOkRffu3WPNmjUEBwfHOvnRf79Lz3J2do7x2udTK1eupH379vGOU0RsS7laxDaUq+VZKrAlVk5OTjg7O5v/JKRChQoxb948lixZwnfffUd4eDgQfdetUqVKrFq1KtYJFl52v3feeYfFixdz6dIl3njjDSB6IovnTSBx+fJlQkJCLO4Kilgjsb5LuXPnZvLkyRw6dCjOPg4ODmzatCnGK2wVK1Zk7NixLFu2jJEjRxIZGYnBYMDDw4MKFSqwatWqGBOnQOzfpad8fX05efJkjH0CAwM5fvw4vXv3frkLFREz5WpLytXyspSrLSlXvxqDKb5zz4tYYePGjVSrVi3Ou2L2FhAQwJQpU6y+gzhkyBB69eplsbyDSGJIbt+liRMnUr169VjvsotI4kpuP1+Uq8Vektt3Sbn61ajAFhEREREREbGB+E8nJyIiIiIiIiIxqMAWERERERERsQEV2CIiIiIiIiI2oAJbRERERERExAZUYIuIiIiIiIjYgApskRTi0KFD1K1blxIlStC2bVsuXbpk3nb//n2KFy8ORC/lULp06ViP8eDBAwoUKED+/PnNf1q1ahXnOS9dumTR9+mfQoUKMWzYMHO/K1euaCkIERFJ8ZSrRV5/TvYOQEQS3rVr1+jRowfDhg2jSpUqrFixgk6dOrFhwwY8PT2JiooiNDQUgIiICPPfnxUZGYmnpyfHjh3DaDSa252cnDCZTBgMhhj7vPHGG/z2228x2idOnMj169fNn8PDw4mMjLTFpYqIiLyWlKtFkgcV2CIpwKJFi6hSpQoNGjQAoFOnTuzdu5e1a9fStm3bF+5/7Nix5979dnJyolWrVgwePDjGNldX1xhtx48fp2HDhtZfgIiISDKnXC2SPKjAFkkBDhw4QJ8+fSzaatSowciRIxkzZswL9y9VqhTnzp2L0X7jxg0mT57M0aNHqVmzplWx7Ny5k+vXr1OvXr0Y257eGXd0dIz1LruIiEhypVwtkjxoDLZICnDjxg1y5cpl0ZYvXz5Sp07NuXPn2L9/v9XHioyMZM+ePfTt25caNWqQMWNGNm/ejJ+f3wv3vXjxIoMHD2bo0KF4enrG2F64cGEKFy5s1S8SIiIiyYlytUjyoCfYIslcREQEERERuLu7W7R7eXnx+PHjF46nMplMnD9/npMnT3L48GH2799Pzpw5KVq0KLlz52bNmjX4+/tTrFgx8ufPz9tvv42zs3OM4+zatYvPP/+cjh07Urdu3VjPFduddxERkeROuVok+VCBLZLMOTs74+zszKNHjyzaAwMDcXNzw8np+T8G/v77b3r37k2xYsUoU6YMAwYMIHPmzObt9+7d4+jRo5w6dYpDhw7x1ltvWSTtixcvMmXKFA4fPsyXX35J9erVbXuBIiIirznlapHkQwW2SAqQPXt2Ll68SNGiRc1t586dI3369M/dLyIigly5crFx40aL9rCwMPPfPTw8qFSpEpUqVTK3RUZG4uTkxA8//MC3335LkyZN+Omnn0iXLp2NrkhERCR5Ua4WSR5UYIukAO+++y47d+40z0wKsHXrVvz9/cmfP3+c+9WpU4crV67E+3zly5dn3rx5fPDBB1SvXp2MGTM+t3+WLFn47LPP4n0eERGR5EK5WiR5UIEtkgK0adOG+vXrs379eqpXr87ixYs5ceIEq1atolixYty5c4fy5cvH2O/nn39+pfP6+voCcP36dXx8fMzLgDx48AAPDw/z62nXr1/XUiAiIpKiKVeLJA+aRVwkBciRIwfff/89c+bMoVSpUmzZsoVZs2ZRrFgxq/aPiIggLCzsuX+MRmOc+/fq1YtTp06ZP/fp04c9e/aYP3/66accOXLkpa9PRETkdadcLZI86Am2SApRrlw5Nm/e/FL7Vq5cmdu3bz+3j4uLCwsWLKBUqVKxbm/Tpo3F57Zt2wLRd8ivXbvG9evXXyo2ERGR5EK5WuT1pwJbRF5o3759L+zTpk0bzp07F2fSnj17tnlb586dze2zZs2idOnSLFiwgGrVqpEzZ07bBC0iIpKCKFeLJA16RVxEbMLZ2RmTyRTndjc3N9zd3XF3d8fR0RGA5cuXs3HjRsaPH0+PHj1o3bo1J0+eTKyQRUREUhTlapGEpyfYIoKjoyMuLi5AdPJ9OsGJrRgMBoKCgsxLhoSEhLBhwwaOHTvG3Llz8fb25qOPPsLNzY1evXqxY8cO3NzcbBqDiIjI60y5WuT1YDA97zaWiIiV+vTpQ8WKFWncuHGMbZ999hk//vij+a65p6cn8+fPx9fX1zx76VNhYWE2/6VBRERElKtFEoMKbBEREREREREb0BhsERERERERERtQgS0iIiIiIiJiAyqwRURERERERGxABbaIiIiIiIiIDajAFhEREREREbEBFdgiIiIiIiIiNqACW0RERERERMQGVGCLiIiIiIiI2IAKbBEREREREREbUIEtIiIiIiIiYgMqsEVERERERERsQAW2iIiIiIiIiA2owBYRERERERGxARXYIiIiIiIiIjagAltERERERETEBlRgi4iIiIiIiNiACmwRERERERERG1CBLSIJok+fPowePdrmx7116xb58+e3+DNq1KgX7teiRQsKFCgQY99n/1SoUCHWfefMmWPRb8qUKeZtw4YNY+HChQCsX7+ePn36WOz78ccfxzhPqVKl+O233yz6bd68mXbt2sXvH0NERCSJMBqNFClSxCLfde/e/YX7ffLJJxQsWPC5+blIkSI8efIkxr5btmyx6PfZZ5+Zt82ePdv8+8GxY8do1KiRxb7ffvttjPMUL16c7du3W/Q7deoUH3zwwcv8k0gK5WTvAEQSSmRkJLVr16Z+/fr06NEjxvaLFy/SrFkzlixZQqFChSy2/fbbb/zwww8cPXqUO3fu4OzsTPr06SlRogTffvstBoMBgH/++Yf3338fk8kEgLe3N3ny5KFr166UL18+4S8yDiEhISxatCjW635q48aNfPrpp889zrJly3jrrbdeKoasWbOSPn36l9r3vy5cuMD169fNn6dPn26x3cHBgV27dgFgMBgoU6YMqVOntuhz8uRJVq5cGeO/9X+P81+RkZG0bduWli1bmtucnZ2JiorC0dGR8PBwwsPDAYiIiCAsLMxi/4kTJzJ+/HiLtubNm3Px4kWKFStmbgsLC4uxr4hISqPcbd/c/dSGDRsoWLAg+fLle26/GzducP78efPnyZMnW2x/Nj8DFC9eHG9vb4s+p06dYuLEic8tYg0GA46OjhZtUVFRfPDBB5w4ccLc5uzsTGRkJE5OToSFhZnz87O5+qlPP/2Ufv36WbT179+fv/76i6pVq5rblJ8lvlRgS7Ll5OTEmDFjaN++PZUrV6ZAgQLmbVFRUXz++ee0bNkyRoKePHkyCxcupEWLFkyePJmsWbMSGRmJv78/x48fNydoiP5FwGQysWHDBrJkycK9e/f4+eef6dq1K0uWLHnlBPeyHjx4wJQpU56bpGvVqkXFihXNn/v06UORIkXo0qWLuc3T0/OlYxg4cOBL7/tfly5d4uTJk1b3L1KkSIwC22Qy4e7ujpOT9T/2fvvtN9q2bRvn9hUrVrzwGA4ODjEKdxcXFwDmzp3Lt99+a2631/8vIiJJhXK3fXP3U6tXr6Zhw4YvLLD9/f05cuSI1cfNkSNHjAL7ZfLznTt3qFatWpzb/1vox8ZgMMQ459P8vHXrVj7++GNzu6+vr9WxiajAlmStZMmStGzZkoEDB7J69WqcnZ2B6Fd+nzx5Qu/evS36L1myhOXLl7N8+XKLpA6QKVMmSpYsGet5PDw8SJMmDWnSpKFbt2789ddfrF+/PkkXTI6OjqRJk8bis6urq0VbUlGtWjWqVatGZGQky5cv5+eff8bf35+QkBAyZsyIn58fH374IYULF7bpeYsVK2Yu7K9evcrVq1fJnj07uXPntvoY+/btY+vWrRZJPCgoiAIFClCwYEE6deoEwNq1a1m1apVN4xcReR0pd8ctqeXusmXLUrZsWSB6mNSmTZu4cuUKQUFBeHt7U6hQIZo1a2buYysZM2Y05+dbt25x4cIFfHx8yJcvn/lmyn+HYv3X77//zrJlyyzy84ULF6hXrx4VKlSgZs2aABw+fJgBAwbYNH5J3lRgS7LXr18/du/ezffff0/fvn3566+/mDVrFkuWLDHfqQQIDg5mypQpjB49OkaCjq9cuXJx5swZi7bw8HBmzZrF+vXrCQgIwMfHhwYNGtCtWzeLOEwmE0uWLGHZsmVcv36ddOnSUb16dT7++GM8PDzM/dauXcusWbPw9/fHy8uLFi1a0LNnT6pXr86VK1cAyJ8/PwB79+59qbuv7dq1o02bNhw+fJhVq1ZRpUoVvv32W86dO8eUKVM4deoUwcHBZM+enc6dO9OgQQPzvkOGDMHV1ZVhw4YB0U+08+TJw8OHD1m/fj0hISEUKFCAYcOGUbBgQavi6dWrFyEhIXz88cfky5cPV1dX7t69y44dO2jVqhUzZ87k7bffjnVfg8FASEgIkZGRcR4/tlfQIiMj6d+/P+fPnyd//vxcuHCBnDlzMmnSJPN/twkTJjBhwgQA3n//fYv958yZQ926dWnatGmM8+kJtohI7JS7Xz53Q/TN3YkTJ5oLz9atW1vM83Hx4kVGjx7NyZMnMRgM5M2bl8WLF7NgwQImTZoEwJEjRxg0aBD9+vWjW7duzz3fqFGjOHz4MJ9//jmFCxfG3d2dBw8e8Ouvv9KrVy+GDBli8TvCs142Pz89786dOylatCj+/v64uLgwY8YM0qZNC0S/afb0bbO8efNa7Lt06VJ8fX0tnlQ/pSfY8ipUYEuy5+rqytixY2ndujXvv/8+w4cPp3379hQpUsSi3+7du3F3d3/uK0fWOnv2LFmzZrVo+/TTT/ntt9/48ssvKVSoEOfPn+err77iypUrTJw40dxv3LhxrF69mhEjRlC2bFn8/f35+uuv6dKlC0uWLMHR0ZHTp08zevRoJk6cSJEiRQgODiY4OBiAdevWce3aNerXr8/Ro0cxGAwv/bpYVFQUK1euJHfu3GzdutX8qvOvv/7KO++8Q9++ffHy8mLv3r0MHjyYN954wzyuOCoqyiJZGgwGFi9eTL58+fj+++/JkCEDy5cvp2PHjuzYsYNUqVK9MJbdu3czZ84ci6cRWbJkoXXr1mzcuJF9+/bFWWD7+fnFWuQ+y9nZmaNHj1rEsmLFCoKDg9m8eTMODg4YjUZ69erF0qVLzb+s9OvXj06dOrFmzRp27txpccyIiIhYfykA6NSpk55gi4jEQrn75XP3wYMH6dOnDwMGDKBixYpcvHiRwYMHkzp1apo1awZA7969ee+99xg9ejSOjo5cvHgRFxcXOnbsSMuWLenatSt16tShbt26L8zPANu3b6dbt268++675ranNyP27NnD7t274yywS5QoQb9+/cxj4uOybds2cubMaf68Z88eDh48yNatW3F1dQWiC+7vvvuOoUOHAtFzngwbNoxDhw4xduxYi+M9Lz/XrFlTT7DlpanAlhShRIkStGnThjZt2pA7d+5YZ7U8c+YMxYoVsxinFV+BgYEsWbKE48ePW8xkeeDAAbZv385PP/1Ejhw5AMiQIQOzZ8+mevXqHD58mLJly3Lp0iUWLlzIokWLKFOmjLnf3LlzqVy5Mhs2bKBRo0YcO3aMd9991zwO69nJxFKnTm2+W26LV8Zu3LjBjBkzLP5d2rdvb9GnadOmbNq0id27d1tM3PVfRqORadOmmZN1v379+Omnn9i9e7c5kcXF0dGR5s2bM2bMGLp3707evHlxcXHh/v377Nixg6tXr/LVV1/Fuf+yZcssPvfr14+8efM+d6wbwN9//02pUqXMNxccHBwoV64cv//+u7mPg4MDTk5OsU6S5uDgYJ75NDIykqCgIO7cucO1a9dwdna2GEsnIiL/Uu5+OePGjaNnz57myTmzZs3KF198wbhx42jatCkPHjzg4sWLrFq1Cnd3dyC6GIboG83Ozs44OTmRKlUqq2Np2bIl06dPx8HBgcKFC+Pm5sajR4/49ddf2bdvH1OnTo1z32ffAgMYP348Dx48eOFKJOfOnaNEiRLm4hrgnXfeYd68eRb9rMnPUVFRBAcHc/fuXW7cuEFISAi1atWy6tpF/ksFtqQYhQsXJjQ0lPz585vHcz0rKCgoRiK5ePEiH374ocVd1ebNm8e4k1mvXj1MJhOPHz/Gy8uLWbNmkSdPHvP2X375hQoVKpgT9FPZsmXjvffe4+eff6Zs2bLs2LGDPHnymBP0Ux4eHtStW5eff/6ZRo0aUahQIebMmcNvv/323ILWFipWrGjVLy7Zs2fnn3/+eW6ft956y+JO+NPX0m7cuGFVLCNGjGD37t1s27aNefPmcfHiRcqXL0/RokX58ccfY32FK65XzkwmE0ajMc7tT8dk+fn5MW/ePFq2bImXlxfBwcFs3LiRxo0bWxVzyZIlGT16NKNGjcJoNJI6dWrSp09Pjhw5YrxOLiIilpS74+f27ducPXuWWbNmWbSXLVuWGzducO/ePdKlS0fWrFlZsGAB3bt3j/Mpbnx06dIFPz8/Nm3axNq1azl58iTly5enUKFCrF69mly5csXY53n52WQyvTA/lyhRgsWLF3Pr1i0yZ85MeHg4a9asiXPM/X/5+fkxevRoFixYgNFoxM3NjfTp05M1a1ZKliypAltemgpsSRHu37/PV199xccff8zMmTOpX78+77zzjkUfT09P/P39LdreeOMN1q9fb07S48aNIygoKMbxFy5cSNq0abl37x4HDhygZ8+efPPNN+YC6vr163GOM37zzTc5d+6cud+zyf2//X799VcAypUrx2effUa3bt0oW7Ysffr0idfEW/GRJUuWGG1Pnjxh+fLl7N27l+vXr5tfc6tTp85zj5UuXboYbZ6enoSGhloVi8FgoFKlSlSqVIlff/2VoUOHMnPmzDj7b968mf79+z/3mN99912s7StWrKBEiRLUr1+f33//nSpVqpA1a1Zu3rxJrVq1Xvi6+VP9+/fn448/JjIyEkdHxzh/kcmbNy/Vq1e36pgiIimBcnf8Pf23iKs4vH37tvnp+pAhQ9i8eTN9+vShRo0ar/QWAEDp0qUpXbo0V69epVq1ajGeJD/r1KlTNG/e/LnHW7NmTaztEydOpHbt2pQpU4Y2bdpQp04dsmTJwu3btylVqpTFmw7Pu6YWLVrw4YcfEhERYX4TLTZZsmSJsYa2yPOowJYUYeTIkeYfuo6OjgwdOpRNmzZZLOWUP39+fvrpJ4v9DAaDxXis/y799FTmzJnJmDEjOXPm5K233sLHx4fBgwdz4MABDAbDC5PW0+3W9gNo1KgRH3zwAbNnz6Zu3bqMHj2a+vXrP3f/l/HfsVcmk4mOHTty+/ZtWrVqRZEiRUiXLh3ff/+9zc8N0UtuRURExLn96WQw/9W8eXO+/PJLateuHev2sLAwHBwcYn0i8iyDwcAXX3xB7969uX79OlmzZrVYYqR79+7mf6O4JmFxcHCgU6dOHDt2LM7zODk50aFDh+fGIiKSkih3vxyDwcDq1atjFIwGg4FMmTIB0Tchli1bxi+//MKYMWNYt24dM2bMiNfT7GcnZotNXPm5fPnyzJs3z3yD4r/Cw8MxmUwWr37HpUuXLrRs2ZLLly/j4+Nj8SZb06ZNzb8/xJWfDQYDw4cPZ8OGDXGew8HBIc7fJURiowJbkr0tW7Zw6NAhtmzZAkCHDh3YtGkTEydONE+CAVChQgVGjhzJzp07qVy58iuds2zZsty7d4979+6RIUMGcubMyYULF2Lte/HiRfOrUzlz5mTdunWx9rt06VKMV6w8PT355JNPyJQpE2PGjKFOnTo4Ojq+8l3o5zl27Bh//PEHO3bsIGPGjOb2R48ekSFDBpuf78SJEy+c+CQ2//3F4tGjRyxZsoT9+/dz9uxZ81NzDw8PChcuTMWKFWndurXFrLDP8vLywmAwsG7dOvbt28eNGzcIDAzE3d0dHx8f3n77bWrVqkXdunVj3X/x4sXPjXfZsmVs2rQp3tcpIpIcKXe/HF9fX/Mr1tmyZXth/w8++IBixYpRp04ddu3aRdWqVa0+16ZNmzAajfGO8b+FblhYGMuWLWP37t389ttvhISEANE3RvLnz8+7775L27Zt4xwP7uHhQd68eVm/fj179uzhypUr3L9/Hzc3NzJmzEipUqWoWbMmy5cvj3X/r7/+mq+//jrOePfu3WteEUXEGjFH/IskI/fu3ePLL7/kiy++ME8m4uTkxKhRo1i2bBnHjx839/X29qZ79+4MGzaMy5cvv9J5f//9d1KnTm1eJqJBgwbs27ePa9euWfS7fv06+/fvN796VLt2ba5cucLhw4ct+gUFBfHjjz/G+YrSW2+9RWBgoDkpPb3r+7wnvy/rzp07eHl5WRTX9+/f58SJEzY/F4CLiwuurq5MnjyZ3bt34+rqatWfZxP448ePadq0KSdOnKBz5878/PPP/Pbbb5w6dYq1a9fSuHFjfvzxR7p27RpnHHfv3qVevXqcO3eOrl27snz5cg4cOMCPP/7IsGHDcHV1pXXr1uzZsydB/h1ERFIK5e6Xz91ZsmQhe/bscRaTsfH19SVLliwW86G4uro+d9ksiJ4QzdXVlWXLlrFy5Uqr8/OzN8BNJhPt27dn8+bNNGvWjB9//JFTp05x+vRpNm/eTIcOHTh06BAtW7YkPDw81jjCwsJo1qwZu3fv5qOPPuKHH35g//79bNmyhbFjx5IlSxZ69uyplTok0egJtiRrw4cPp2TJkjHGBhcrVoxWrVoxZMgQNmzYYE5qnTt35vbt2zRp0oS2bdtSuXJlsmTJgtFo5Pr161y8eJHChQvHOE9wcDCOjo7cu3eP/fv3M23aNDp27Gh+/bho0aLUrFmTzp0788UXX1CgQAH++usvhg4dSt26dc1jvHx9fenQoQOffPIJQ4cOpVSpUly7do3hw4dToEABqlSpAkQvwQHRY7vu37/P2LFj8fPzM9/d9fLyIlWqVKxfv5533nnH6jvZ1ihevDj3799n4cKF1KxZkxs3bjB27FjefPNNmxw/LpcuXXrpdSj/+usvrl27xsaNG2M8oc6ZMyc5c+Ykb968NGzYkJCQEPOsqs86dOgQqVOnjnGX28PDg0KFClGoUCEgermt2JaLefqLYVxP452cnOjYseNLXZ+ISHKi3P1qubtPnz4MHDgQNzc3mjVrhoODA3/++SdRUVF88MEH3L9/n71791KyZElcXFzYsGEDly5doly5cuZjZMmShW3btlGhQgXu379vznGxuXbt2ktPlHb79m2OHz8eYwmupzFkyZKFsmXLUqZMGa5cuUK+fPliHOPs2bNcu3aN9evXW8wW7uzsTJ48eciTJw9eXl7MmTOHNm3axNh//vz5TJw4Mc6n8Q4ODi+cY0bkWSqwJdnaunUrx48fZ+PGjbFu//jjj9mzZw8zZ86kb9++QPRYnKFDh1KjRg2WLl1Kr169uHv3Lm5ubmTKlInSpUubl72Af19DrlGjBg4ODqRJk4b8+fMzfPhw6tWrZ3G+r7/+mtmzZzN8+HACAgLIlCkTzZs3p3Pnzhb9+vXrh4+PD1OnTuXatWt4e3tTu3ZtevfubX597OLFi3z33XcEBgbi5eXFe++9x+eff24R14ABA5g8eTLffPMNn376KR9++OFz/72e3ll+VmyTcmXNmpWZM2cyYcIEJk+ejK+vL507dyYkJIQ//vjDYt9n71L/9/NTT59Qv4jBYCA0NJSwsLDn9ovtPPnz5yd79uz06dOH1q1bU6BAAdKmTYvJZOLu3bv89ttvzJ49mzJlysRaXEP0q4Njx47lm2++oX79+uTJkwcnJydMJhP+/v7s2bOH//3vfxavLj7r3LlzDB48mFatWr3wWkVEUirl7lfP3fXq1cPZ2Zm5c+eyYMECHB0dyZ07N3369AGibyzMmDHDvFxkvnz5mDFjhsWY6Q4dOvDxxx9TrVo13nrrLRYuXBhnDA4ODoSFhb0wP8c274mPjw9+fn4MGjSIjh07UqRIEby9vTEYDNy/f58///yThQsXkjt37lhnIgcoWLAgmTNnZtCgQbRq1YoCBQqYb6YHBARw8OBBpk2bxkcffRTr/ufPn6dNmzYWS7SJvAqD6WUGN4qIJLLZs2czderUF746V7p0aX744YcY7ffv32f+/Pns2rWLq1evmo/j4uJC4cKFqVy5Mm3atMHNzS3OY9+9e9c8e7q/vz+hoaE4OTmRIUMGypUrZ16GJTajRo3if//733PHqxkMBn799VeLSdRERESSso0bNzJ48OA4X+F+KkuWLOzatStGe0hICIsXL2bbtm1cuHDBfBwnJyfy58/Pe++9R/v27fHy8orz2MHBwaxYsYJdu3Zx5coVnjx5gqOjI+nSpaNUqVLUr18/xjJqT82fP58JEya88JX41atXU7Ro0ef2EQEV2CKSAhmNRkJCQnBwcIjzibWIiIgkLpPJZB6T7u7unqCTtookFBXYIiIiIiIiIjagWcRFREREREREbEAFtoiIiIiIiIgNqMAWERERERERsYEUt0xXKr9e9g5BJFk4tukbe4cgkmwUzqrJ9p41ooDzizuJyAsN3/qLvUMQSTYMud+3qp+eYIuIiIiIiIjYgApsERERERERERtQgS0iIiIiIiJiAyqwRURERERERGxABbaIiIiIiIiIDajAFhEREREREbEBFdgiIiIiIiIiNqACW0RERERERMQGVGCLiIiIiIiI2IAKbBEREREREREbUIEtIiIiIiIiYgMqsEVERERERERsQAW2iIiIiIiIiA2owBYRERERERGxARXYIiIiIiIiIjagAltERERERETEBlRgi4iIiIiIiNiACmwRERERERERG3CydwDPCgkJ4dixY9y6dYtHjx6RJk0aMmfOTKlSpXB3d7d3eCIiIimecrWIiEjckkSBfejQIebOncuff/5J0aJFyZIlC56enty6dYtdu3YxcOBAihQpQseOHSlXrpy9wxUREUlxlKtFRERezK4FdkBAACNGjMDT05Nu3bpRsmRJDAZDjH5Go5GjR4+ycuVKFi1axMiRI/H19bVDxCIiIimLcrWIiIj17FpgT58+ncGDB5M9e/bn9nNwcKBs2bKULVuWy5cvM23aNL766qtEilJERCTlUq4WERGxnsFkMpnsHURiSuXXy94hiCQLxzZ9Y+8QRJKNwlk1dvlZIwo42zsEkWRh+NZf7B2CSLJhyP2+Vf2SxBhsgKCgIPbt28fff//Nw4cPMRgMeHp6kitXLsqVK0emTJnsHaKIiEiKplwtIiLyfHZfpisiIoJhw4bx/vvvs2bNGoKCgkibNi2enp4EBQXx448/UrNmTQYNGkRYWJi9wxUREUlxlKtFRESsY/cn2OPHj+fOnTvs2LEDLy+vWPs8ePCAwYMHM27cOL744ovEDVBERCSFU64WERGxjt2fYG/evJlx48bFmbAB0qVLx9ixY9m6dWviBSYiIiKAcrWIiIi17F5gR0ZGkjp16hf28/DwIDIyMhEiEhERkWcpV4uIiFjH7gV2yZIlmTdv3gv7zZs3Dz8/v0SISERERJ6lXC0iImIdu4/BHjZsGJ06dWLXrl1UqVKFN954gzRp0mAymXj06BGXL19m+/btPHjwwKrkLiIiIralXC0iImIduxfYvr6+rFu3jj179rBr1y727NnD/fv3iYyMNC/90axZM+rUqYOLi4u9wxUREUlxlKtFRESsY/cCG8DJyYkqVapQpUoVe4ciIiIisVCuFhEReTG7jsH+4osvuHbtWrz2uXLlCkOHDk2giERERORZytUiIiLWs+sT7N69ezNy5EhSpUpF8+bNKV26dJx9jxw5wrJlywgLC2P48OGJGKWIiEjKpVwtIiJiPYPJZDLZO4hDhw4xb948zpw5Q7FixciWLRseHh4EBQXh7+/P6dOnKVy4MB07dqRcuXKvdK5Ufr1sFLVIynZs0zf2DkEk2Sic1d3eIbxQYubqEQWcbRS1SMo2fOsv9g5BJNkw5H7fun5JocB+Kjg4mOPHj+Pv709QUBCenp5kzZqVkiVL4uHhYZNzqMAWsQ0V2CK28zoU2E8lRq5WgS1iGyqwRWzH2gI7SUxy9pSHhwcVK1a0dxgiIiISB+VqERGRuNl1krP/WrFihb1DEBERkedQrhYREYlbkiqwv/vuO3uHICIiIs+hXC0iIhI3u74i/s8//xAREWH+bDQauX79uvmzr68vLi4uBAUFcerUKfz8/Gw2vktEREReTLlaRETEenYtsFu2bEl4eLj5s4ODAy1atDB/HjVqFEWKFKFJkyZ4e3sTGBjI6tWr8fb2tke4IiIiKY5ytYiIiPWS1CzisZk8eTImk4l+/foxffp0wsPD6dev30sfT7OIi9iGZhEXsZ3XaRbx2Ng6V2sWcRHb0CziIrZj7SziSWoM9lMhISEYjUYAdu3aZb5T3rx5c3bv3m3HyERERASUq0VERGKTJAvsQYMGsXr1agACAwPJlCkTABkyZCAoKMieoYmIiAjK1SIiIrFJcgX2woULuXHjBg0bNgSix3qJiIhI0qFcLSIiEju7TnL2rLt37zJ58mROnz7NvHnzcHaOHn/l4uJCSEgI7u7uhIaGmttFREQkcSlXi4iIPJ9dC2w/Pz+8vb1JmzYtf//9N2XLlmXZsmUWy3uUKVOGbdu20bBhQ3bs2EHJkiXtGLGIiEjKolwtIiJiPbsW2Dt27CAgIIALFy6wYcMGDh06xMyZM/nkk08wGAwAtGrVinbt2nHkyBH27t3LvHnz7BmyiIhIiqJcLSIiYr0ktUzX6dOn+eyzz/Dz82Ps2LHm9j///JP9+/dTvnx5ChYs+Ern0DJdIrahZbpEbOd1WqYrMXK1lukSsQ0t0yViO9Yu05WkCmyAoKAgmjdvTtOmTWnfvr3Nj68CW8Q2VGCL2M7rVGBDwudqFdgitqECW8R2rC2wk8wkZ095enry/fffs2TJEnuHIvFQvXwh+n5UhQzpPHBwMPDrqUsMnLCGJ6ERAAQdncKZi7cs9hk+7Ud+3n/W/NnLMxVDutbivVJ5AXB1dqJZ/9mcv3rb3Cd3tgysm9qNVT+fYPSsLRbH+35YS6q+XYD7jx6b2478foU+o5fb/HpF7OXGtcv07/whjVt2oHnbrgCcOHyAtcsW8ORxCJERERTxK02brn1xdXUDYNWSuWxdvwIv7/Tm42TwycTg0ZMBuHr5ArMnjyEkOBiTyUSq1Klp+lFnSr5dPtGvT14PytXJh5OrG+W7fEa+92tjMDjg5OrKli/7cPnw7hh9G4ydT7E6LfiqaGqePp9xdfek8sdfkrN0BTCZCH8Swu7vRnLp4E7zfrnKVKDyx1/h6u6Jg5MTv86fxMk1CxLrEkUS1ZqfDzBi2lK2zhlJtkwZLLZdu3mHrsO+o1bF0vRuXddi26Xr/zBpwTpuBNwjMiqKnFl8GNi5CdkzZwRgy56jzF35M1FGExGRkeTO5kv/9g15M0fmRLs2sU6SK7ABcuXKxRdffGHvMCQegh+H0emLxdy88xBHRwfmftmaYd3rMGjSOgCcnBx5t9U4oqKMse7v6e7GtrkfM3PFXgZOXIvRaMLBwcCz71eUKZqLGcNbcenGXZwcYy4J4+TowJg5W1m47mCCXKNIUjB/2rcU9StNVGQkAH/9cZp5079l+Ljv8cmUhYjwcOZM/YaFMybR9eNBAERFRVK1VgNaduwZ6zEz+mSi/9CxpM/oA8C5s78xenBfho/7njfzvdqrvpJ8KVe//hwcHfloziYuH97NvA/fIyoi3Nz+X9n93iG1V3ocnJwwODhgiooCoOnkZVw5updZDUthMpnIXPgtWs5Yx9wP3+PhzWv45CtCg6/n87+u9bhz4SxunmlpOXMDgf5XuHxoV6Jer0hCm7JoA3+cv0paj9REGS1/5z315yWGTlpMjswZifr/789TwSFP6Dh4MmP6t6WcX3TeXbPtAN2GT2fz7BEAvFUoD4u/LYpHajdMJhMrtuyj3eeT+GXBKNxcXRLl+sQ6WrhSbOLAiYvcvPMQgKgoI5MWbafK2wWs3r9v68rsPfY389cewGiMrqqNRhPPjmDwSe9Joz4zOX7mmm2DF3lNHNy7g7Tp0pO3QBFz2x+njlKybHl8MmUBwNnFhWp1G/PXHyetPm5qdw9zcQ2Qv1Ax3qtUnZNHf7Vd8CKS5BSr/xGhQQ/ZM32UubgGMP7nl3+DgwM1Bo3n528GxDhG7rKVOLp0pjlf3zpzgltnT5Kl8FsAlGrehUOLpnLnQvQba6FBD9k2biClW3RNqMsSsQuj0UhG77TMHNkLl1iWKrwX+IiZX/aiSL5cMbb9fcUfrzQe5uIaoHG1d7l1+z6BQSEAZMqYDo/U0W+mGQwGPqxdAS9Pd85evJ4wFyQvza5PsI8dO0ZERESc24sWLYqHhwdBQUGcOnUKPz8/i2VBJOlKl9adsPC4/9v+V9PqJWn+yZzn9tm0+/dXDUvktRUW+oTlC2Yw/NsZbNu0xtyev1AxpowdRr2mH5HBJxMRERGs/mEehYq92jJJwcFB5ClQ+FXDlmRAuTr5KlKrGYcXf/fCfqVbdOPaiQPcu/x3jG03Th+mXPuP2f3dlwDkLFWe7CXKsWl49Bsz3jne4MK+nyz2uX3hDFmKlLLBFYgkHQ4ODrSs+36c26uUKxHntjdzZObm7fvsP36W8iULATB31c9ky5QBL8/Y5+gwGo0EP36Cj3faVwlbEoBdC+yJEydavCJx9uxZChWK/p/KYDAwaNAgsmbNSpMmTfD29iYwMJDVq1fj7e1tr5DFSp2blOd/m45Y1dfN1ZlcWdPj7ubChmk9yJwxLTcCHjBm1laOnbmawJGKvB7W/G8+71WtiXeGjBbtRd8qQ/W6Tfi0a0s+qNOIo7/uxSdTFtp07ftS5wl6GMjubZsIuHWD8pVr2CJ0ec0pVydfmfIXIyLsCc2mriB9zrw8fnCXA3PHc2H/NnOf1F7pKfNRD+Y0fSfWY6z7vAMfzdlItuJluXf5b4rW+ZC1n7XlUYA/ACH375Iu+xsW+3jnyINHBt+EuzCR10xaT3fGD+zAp9/Mpdq7b3Hn/kMu3whgzqjesfa/fusO3y/dTNV3/GKM8xb7s2uBvXTpUovP5cuXZ8WKFRZtkydPpn79+vTr14/p06ezaNEi+vXrl5hhSjxVLVeQYvmz0WHoYov2H6f3wMc7DU9Cw1n50zGmL9uDyWTCO01qIiONDOpSk+4j/8fNOw8pXzIPa6Z2o0r7SVy4djuOM1kymaD7hxXp1Lg8bq7OHP3jCqNnbuFGQGACXKVI4vnH/zoH9+1gwuxlsW5/t1I1Thzez5r/zcfDMw0tO/Q0T3AG0UXQgT2/cPrEYR6HBJPzjbw0b9OV7Ln+/aX3z99PMm3cCG7/cwvfzFkZ8vUUnGN5xU1SHuXq5CuVV3oqdBvMli/7cPfyOXzzFaXlzPWs+7w9V47sBaDqJ2M4uHAKYcGPYj3Gw5tXObJ0JjU+H0+e8tX4fdMy/H8/Zt5+cu0C6o+azaVfd3Dn4p94+mShct+RmIyxz8kiklKVKPgmVcuVYOXWfRgMBvq1a0CmjJY3Kheu3c7Ctdv55+4DKpYpyvBeLe0UrTxPkhyDfe3aNW7dip5xeteuXbRo0QKA5s2bs3v3bjtGJi+SzdeL6V+0oN3ghYRHRJrbc1UdRO1u0yjdbAwfDZxP/Sol+LT9BwAYTSZSp3Jh0KR15nHc+49fYNVPx2hRu7TV5x40aR3lW31L+Y++5d1W47h0/S4/ft8Tx1gmRBN5ncyb/i0tO/TExcU1xraLf//J5z3bULxUWeav2U6nPgOZM3UsS+dNN/ep07glE+cs55vpi5k8byVvlXmXkQO6E/TooblPwaJ+TF+ygeU/HaR1lz58+VkvAh/cT5Trk9eTcvXrz2QycmDeeO5ePgdAwN+/c3DRVPwaRS+9lrVoaTIX8uPEyrlxHqPRt4soXv8jFneozpSq+YiKjKT7hhOk8c0KwJXDe9g8sjc1h06m+4YTNBq3kF8XTIyzYBdJiYIfh9K0z9c8CQtn69wv+d+EAew8dJoOgyZbTBDcrlFVdv8wluPrpuBX8A26fPEdSWzFZSGJFdglSpQA4KuvvjIn58DAQDJlygRAhgwZCAoKslN08iKp3VxYMbELI6Zv5MRZy4nIAu79+9/t2q37DP/uRxpW9QPgXmAIERFRXLx+x2Kfi9fvkiGd9eP47j8MISIy+jXGsPBIvp2/DRcnJwq+kellL0nE7k4cOUBYaCjlKlSJdfvG1T9Qq+GHfNiuO17pvKlQpSZfTZzN+hWLCAsLBcDdw9P8RNvR0YnKNeqRLWdu/vz9VIzjOTo6UrZ8JfzKlOPArp8T7Lrk9aVcnXyE3LvNvcvnLdruX7tAau/oV05rDpnET2M/ifMXeO8cb5K3Qk0Wt6/OlSN7eXDjMus/78DFA79QumU3c78L+7exuH11ZtR/i0XtqhEeEsLt82cS7sJEXjNb9xwjo3daJnzeidzZfHmr0Jss/qY/dx885OCpv2L0d0/lRrcWtbgfGMTfl/3tELE8j92X6apVqxZeXl507dqVadOmsX//fm7cuEGTJk2A6AkDJOlzcDCweGx7th04y7LNR1/c39HBPKYvIjKKPy7cpNCbmfnj/E1znzw5MnLpP0V3fDk6GoiMY2kwkdfB7Vs3uXf3Nv07f2huC7x/D4CTR3/FwzMtpd+paLGPb5ZsuLi68SQkxOJV8WcZjUYcY1mK56nHIcEY9Qqn/D/l6uTp5u/H8M1XhED/K+a29Dnzcv/aRQBSp0tPzcGTYuzXZfVhTq5dxLXj+wm6fTPG0+iAv3/HO0eeOM/7VtMOnN22zjYXIZIMBD9+Qp6clutZu7g4kzOrD4+CQ56zXyhGPcFOcuxeYN++fZtWrVoxcOBA3nvvPU6ePMnUqVPNY/9cXFwICQnB3d2d0NBQjQlMoiYMaEJoWAQjv98UY1sqN2fcU7ly90EwADkyezO2X0MWrv93vepZK/cy4bOmNO47k+DHYbxdPDd13y9GuZbfWB1DjszpuHbrAQAuzk4M6lyDgHtB/HXpn1e8OhH7qVG/KTXqN7VoW75wJsaoKFp27MmRA3tYvnAGefIXxjdzVqKiolizdD75CxfDyzs9AHdv/0P6jL4YDAaioqLYtmkNdwL+oYhf9Cy+t/+5SQafTDg4OGAymdjzy2Z+O3GUtt00hlaiKVcnT0eXzaTGoAn4/36U4LsBZHijAGVb9+SHTnUAmFq9YIx9RvwVwewmZTFGRWFwcCAsJJi32/bl8OKpmEwm0mV/g5JNO7JhSMxluBydnSnTqieZC/mxddTLTcQokhxVK/8WbQdO5NCpv3i7RPQyt3uP/sHFa7d4963oSSWv37pD9szRE52GhoUzYf46svqmp8Ab2ewWt8TO7gW2m5sbrVq1olatWvTq1Ys33njDPDspQJkyZdi2bRsNGzZkx44dlCz5akvPiO15eaai24cVOXf5Hw4t/9zcbjKZqN/ze5wcHVgztRvOTo5ERhkJDYtg2tLdLN/y75PuResPkilDGg4v/5zIKCN37gfR4tO53AuMedcuPCISoynm05JPO1SnQsk8hIZH4mAwsPPwXzTsPSNhLlrEjpycnIgyGAAo825FjMYoJo8eQnh4GEZjFPkLF6f/0K/N/Xf+vJF927fi5OwMmMhToAhfTZptfrq9fsUiTh87hIurKwaDAzlz5+Hr7xaQzlszk0o05erk6dLBnRxa/B3tf9iJyWgk/MljNg3vaR6THZvIsFDzK+Mmo5GlXetRud9XdFt/HGNUFBGhj/nl20FcP/krAD55C9Nw7AIAHJycuHRwJ0s61CDqOUu/ibzunJ0dcYrjLTFnZ0ccHAwWbVl90zN9WHcmLljH2NmrAMic0Zvvh/ckrac74RGRfPbtAh48DMbNNfoG5vtlijLrq94YDIYY5xD7MpjsPDK+fPny7N+/H4DQ0FA6d+5M1apVadu2LQB//fUX7dq1o1KlSuzdu5d58+ZRoECBlz5fKr9eNolbJKU7tsn6twtE5PkKZ419ndOkIrFz9YgCegIuYgvDt/5i7xBEkg1D7vet6pekBk25ubkxYcIE5s+fz/nz0ZNuFChQgAULFvDGG28wd+7cV0rYIiIi8mqUq0VEROKWpApsAB8fHz755BPGjRtnbitYsCCdO3emYMGYY4FEREQkcSlXi4iIxM7uBfayZctitNWrVw8HBwfu39carCIiIvamXC0iImIdu09ylj179ljbZ82alciRiIiISGyUq0VERKxj9yfYIiIiIiIiIsmBCmwRERERERERG1CBLSIiIiIiImIDKrBFREREREREbEAFtoiIiIiIiIgN2HUW8dOnTxMeHh6vfZydnSlRokTCBCQiIiIWlKtFRESsZ9cCe+rUqfFO2i4uLsybNy+BIhIREZFnKVeLiIhYz64FtpKviIhI0qZcLSIiYj27FtizZ89+qbviXbp0SaCIRERE5FnK1SIiItaz6yRnJpMpRtv8+fPtEImIiIjERrlaRETEegZTbJnTjsqXL8/+/fsBMBqNrFy5kubNm2MwGGxy/FR+vWxyHJGU7timb+wdgkiyUTiru71DiJeEztUjCjjb5DgiKd3wrb/YOwSRZMOQ+32r+tl9ma6AgAACAwPNn729vQGIjIxkwIABnDx50mYJW0REROJPuVpERMQ6dh2DDdCmTRtu3LiBn58f9evXZ82aNVy6dImBAwdSvHhxhgwZYu8QRUREUjTlahEREevYvcAOCQlh165d7N69m82bNzNp0iQeP37MqFGjqFOnjr3DExERSfGUq0VERKxj91fEAXx8fGjWrBkLFy5k6tSp5M2bl23bthEaGmrv0ERERATlahEREWskiQL7WaVKlWL58uX4+PjQtGlTizFfIiIiYn/K1SIiIrFLcgU2gKOjI0OHDqV+/fp069aNsLAwe4ckIiIiz1CuFhERicnuBfa4cePi3NapUyf8/PxYu3ZtIkYkIiIiz1KuFhERsU6SWwc7oWkdbBHb0DrYIrbzuq2DndC0DraIbWgdbBHbeW3WwRYRERERERFJDuy6TNeRI0cIDw+PdVvJkiUJCQnh/PnzmEwm8ubNS8aMGZkxYwbdu3dP5EhFRERSJuVqERER69m1wJ4+fToREREx2g0GAyNHjmTw4MGYTCYMBgNGo5HVq1ezfv16JW0REZFEolwtIiJiPbsW2IsWLXru9sDAQLZt2wZAlSpVAEhhQ8ZFRETsSrlaRETEekl6DLbBYLB3CCIiIvIcytUiIiL/SnIF9uzZszlx4gSgO+AiIiJJkXK1iIhI7JJUgX3x4kUWL15Mrly57B2KiIiIxEK5WkREJG4vXWB//fXXVvWLa+bR/7p69So9evRg2LBheHt7v2xYIiIi8v+Uq0VERBLXSxXYUVFRLF68+IX9Tp06ReXKleNM3GPGjGHGjBlMnz6dVq1a0aNHD6pVq2beHtu4Lo31EhEReTHlahERkcSXYLOIX7t2jb59+9KvXz9cXFxi7ePt7Y2/vz/79+/H3d2d/PnzW2x/dlxXcHAwgwYNIjAwMKFCFhERSVGUq0VERGzL6gK7SJEiREVFmT+bTCYKFixo/vzZZ5/RsGFDjhw5wvXr11mwYAHdu3encePGcR6zW7duABiNRjZu3EinTp349ttvKVeuHAA9evQw950wYQJXr16ldu3a1l+diIhICqJcLSIiYl8Gk5XTf169evW5Y7QyZ87MjRs3+PTTT7l27RqlS5dmwoQJeHl5WR3M6dOn6dmzJ8uWLSN79uxW7xcfqfx6JchxRVKaY5u+sXcIIslG4azuNjlOcsnVIwo4J8hxRVKa4Vt/sXcIIsmGIff71vWztsCOj8DAQGbOnMmmTZuYO3cuBQoUsHrflStXcvbsWUaMGGHrsAAV2CK2ogJbxHZsVWDHR1LO1SqwRWxDBbaI7VhbYCfIGGwvLy8+//xzcuXKRceOHVm3bh0+Pj5W7dusWTOL19tERETE9pSrRUREbM/qAnv48OHcu3ePd955h3r16uHh4RGjT2RkJHv37jVPeJIxY0ZKlixJQECA1UkbwNHR0eq+IiIiEk25WkRExL6sXqZr9erVZMuWjXXr1lG1alW2bNkSo09wcDALFiygV69ezJ8/n4ULF3Ljxg06depk06BFREQkJuVqERER+7L6CXZUVBT9+/fHxcWFnTt3MmTIEG7evGmRkL28vFiyZAkFChRg7ty5pEqVirCwMIoXL54gwYuIiMi/lKtFRETsy+on2AaDwfz3ypUr88MPPzBnzhy2b9/+3L4Gg8His4iIiCQM5WoRERH7eulJzt58803Gjh3LoEGDKF26NGnTpiU8PJxTp04BcPz4cVxdXXn48KGStoiIiB0oV4uIiCSuV5pFvFKlSpQpU4Zp06YxZMgQAgICGDNmDPnz52f8+PFA9F3xunXr2iRYERERiR/lahERkcRjdYEd13LZffv2pXHjxnTr1o3s2bOzfv16W8UmIiIi8aBcLSIiYl9Wj8HeunUrLi4uMdrffPNNBgwYoPUwRURE7Ey5WkRExL6sfoKdO3fuOLe1atXKJsGIiIjIy1OuFhERsS+rn2CLiIiIiIiISNysfoI9evRoIiIi4n0CFxcXBg8eHO/9REREJH6Uq0VEROzL6gI7Y8aMhIeHx/sEsY0FExEREdtTrhYREbEvqwvsLl26JGQcIiIi8oqUq0VEROzL6gJ7xIgRhIWFxfsErq6ujBgxIt77iYiISPwoV4uIiNiX1QV2rly5Yrx2NmnSJD7++GMMBkPcJ3Cy+hSJ4sHRafYOQSRZ2Hf+rr1DEEk2Cmd1t8lxkkuuHnHilr1DEEkWjGfW2jsEkWTDkPt96/qZTCbTy56kYMGCnDlzBgeH6MnIT548iYeHB3nz5n3ZQya40Eh7RyCSPKjAFrGdDwpmSLBjv465msf6+SJiCyqwRWzHobR1w7DitUxXbLX40zviR44coXv37ty6pbvOIiIi9qJcLSIiYj/xeiesSpUqODo6UrNmTZo2bcqBAwcwGAzMnz+fOXPmMH78eMqXL59QsYqIiMgLKFeLiIjYT7wK7Js3b/Lll1+yb98+6tWrR6VKlbhw4QJubm4sX76cnDlzJlScIiIiYgXlahEREfuJ1yviBoOBBg0a8N1337F79258fX25cuUKNWrUUMIWERFJApSrRURE7CdeBfaz0qZNy8CBA9m0aRObNm2ib9++PH782JaxiYiIyCtQrhYREUlcL11gP5UjRw6WLl2KyWSia9euMZYHEREREftSrhYREUkc8SqwXV1dzct8PMvNzY3Jkyfj6elJv379Yp3BVERERBKecrWIiIj9xKvAPnnyJE5Osc+L5uDgwOTJk8mcOTMhISE2CU5ERETiR7laRETEfgymFHYLOzTS3hGIJA/7zt+1dwgiycYHBTPYO4Sk5bF+vojYgvHMWnuHIJJsOJTuYlU/q5fp2rJly3PHbFWpUgV/f3/OnTsHQIECBcifPz+9evVi2rRp1p5GREREXpJytYiIiH1ZXWCvWrWKsLCwWLc5ODhQvHhx2rRpQ65cuTAajdy6dYsDBw6wfft2mwUrIiIicVOuFhERsS+rC+wFCxa8sE9ISAgrV64EoEiRIi8flYiIiMSbcrWIiIh9vfIyXc8yGAy2PJyIiIjYmHK1iIhIwnnlAnvp0qU8ePAAQEt+iIiIJEHK1SIiIonjlQrso0ePMmnSJCVrERGRJEq5WkREJPG8dIF948YN+vfvz6BBg/D29rZlTCIiImIDytUiIiKJy+pJzh4+fIinpycODg7s2bOHQYMG0bJlSxo1amTu86rjui5dusShQ4e4desWDx8+JG3atGTOnJmyZcvy5ptvvtKxRUREkjvlahEREfuyqsCOiori7bffxsnJCR8fH27evMmXX35J06ZNn7vf89bifPbY69atY8GCBTg7O1OyZEmyZMlCjhw5ePjwIRcuXGDZsmUYjUbatWtHw4YNcXKy+r6AiIhIiqBcLSIiYn9WZT9HR0cOHDjAzZs3OX36NKtWrWLGjBnkz5+fYsWKxbpPhgwZKF68OJkzZ47zuGfPnmXs2LGULFmS2bNnkzVr1jj7Xr9+nVWrVtGuXTuGDBlCwYIFrQldREQkRVCuFhERsT+D6SVnPVm6dCkTJkxg1qxZlCpVCoge65UtWzYAHj9+zIMHD0iXLh2pU6eO9RhTpkyhQ4cOeHp6Wn3ewMBAFixYQL9+/V4mbEIjX2o3EfmPfefv2jsEkWTjg4IZEuS4r2uu5rF+vojYgvHMWnuHIJJsOJTuYlW/ly6wATZu3MioUaNYv379c+9+JyUqsEVsQwW2iO0kVIENr2euVoEtYhsqsEVsx9oC+5WW6apbty716tVj69atr3IYERERSSDK1SIiIonnlZ5gv470BFvENvQEW8R2EvIJ9mtJT7BFbEJPsEVsJ1GeYIuIiIiIiIhINLuvoVG8eHGioqJe2M9kMuHq6sqJEycSISoRERF5SrlaRETEOnYvsBs3bsy1a9cYOXLkC/s6OzsnQkQiIiLyLOVqERER69h9DLbRaKRnz54UKVKEnj17Jvj5NAZbxDY0BlvEdpL6GOzEztUagy1iGxqDLWI7r80YbAcHByZNmsQbb7xh71BEREQkFsrVIiIi1rF7gQ3g5uZGzZo17R2GiIiIxEG5WkRE5MWSRIEtIiIiIiIi8rqza4H9xRdfcO3atXjtc+XKFYYOHZpAEYmIiMizlKtFRESsZ9dZxHv37s3IkSNJlSoVzZs3p3Tp0nH2PXLkCMuWLSMsLIzhw4cnYpQiIiIpl3K1iIiI9ew+izjAoUOHmDdvHmfOnKFYsWJky5YNDw8PgoKC8Pf35/Tp0xQuXJiOHTtSrly5VzqXZhEXsQ3NIi5iO0l9FnFI3FytWcRFbEOziIvYjrWziCeJAvup4OBgjh8/jr+/P0FBQXh6epI1a1ZKliyJh4eHTc6hAlvENlRgi9jO61BgP5UYuVoFtohtqMAWsR1rC2y7viL+Xx4eHlSsWNHeYYiIiEgclKtFRETiliRmESyYBScAAI+QSURBVI+IiGDTpk0AXLx4kXPnztk5IhEREXmWcrWIiMiLJYkCOzg4mFmzZgFw4sQJDh8+bOeIRERE5FnK1SIiIi9m1wI7ICCAmzdvEhAQQGRkJLdu3eLhw4c8fPiQmzdvEhISAsCTJ084ePAgjx49sme4IiIiKY5ytYiIiPXsOslZhQoViIiIILYQDAYDrVu3pm3btjRq1AgnJydCQkJYuXIlPj4+L31OTXImYhua5EzEdpLyJGf2yNWa5EzENjTJmYjtvJaziD/1+PFjAFKnTs0PP/zApUuXGDZsGLNnzyYoKIhPPvnkpY+tAlvENlRgi9hOUi6w45KQuVoFtohtqMAWsR1rC+wkMQb7vxYtWsS6desA2L17N02bNgWgSZMm7Nmzx56hiYiICMrVIiIisbH7Ml23bt3C398fgJw5c5IxY0YyZ87MmTNngOixX7ly5QLA29ub4OBge4UqIiKSIilXi4iIWMfuBXaDBg3Ili0bkZGRGI1GNm7cSLZs2di5cycA4eHhODs72zlKERGRlEu5WkRExDp2L7Dd3NxYs2YNAOXLlwcgU6ZMPHjwAIB06dJx7949fH19iYyMxNHR0W6xioiIpETK1SIiItax+xhsg8EQo83Ly4vQ0FAASpQowf79+wE4fPgwhQoVStT4REREUjrlahEREevY/Ql2bNzc3MxJu3HjxrRt25azZ8+yc+dOxo4da+foRERERLlaREQkJrs/wX6W0WjEaDQSERFBeHg4AHnz5mXq1Km4uroycuRIypYta+coRUREUi7lahERkbjZ/Ql26tSpzX/38vKicOHCAFSsWNHcXqpUKUqVKpXosYmIiIhytYiIiLUMJpPJZO8gnvX0briLi0uCHD80MkEOK5Li7Dt/194hiCQbHxTMYO8Q4iWhczWP9fNFxBaMZ9baOwSRZMOhdBer+tn9CfZ/JViyFrv73w+LWbdmFQYMhEeEU7hIUfr2+xRfX19znz27d7F44XxCQkIICwujdJmyDB46zLz90cOHzPx+GseOHgEgPCKcyVOnkyv3G4l+PSKJwRgVxYTPuxEZEW7Rfi/gJu0//ZLCJcvRp1EFMufIbbG93kddKVzqHfPnx8GP2LJ8Puf/OAlAZGQEXQZ9jW/WnOY+vx89wM4Nywh9/JiIiDDyFX2LZl0+ScCrk9eVcnXKERERyaz5i9m2Yw+RkZGkT5+OkUMG8Eauf3923L//gO4fDyR3rhyM/XKoHaMVsb81e35n5IIdbP22PVkzpjW3/7j/LP/75RQRkZFERpn4oHQeejZ8BweH6EkkB8/6id8u3sLR0YHIKCMflM5Lj4blcHGKXpWhx4R13LoXZHGuf+4H0afJu7SoWiLRrk9eLMkV2AAfffQRP/zwg73DEBur+H4lmjRtjqurK5GRkcz8fhq9e3Rl5Zr1AKxdvYr169bw9bjxZM2aDYCIiAjz/sHBwXRo9xEftviITz77HEdHR6KiomKd3VYkuXBwdGTAt3Ms2iLCwxjRrRm58xcBwGiM4rMJ83B0jP1H+pPHIUwe0osKtRrTqH1vHBwdMUZFwTPfnV9/+ZGD2zfTrv8I0vtmBiAqUq/8SNyUq1OGyd/P5ubNf1i1ZDaurq4cPX6KPp8OYd2yhTg7O3H56jX6DBjKG7lyEhkVZe9wRexqyqoDnLn8D2ndXYmMMprbNx/8i//9coqZnzYgnWdqQp6E88n0zczfcpROdcoA0LluGXJlTofBYOBRSCifTt/M+GV7Gdy6EgDff9IwxvnqfLaAsoWyJ87FidWS1CRnT125ciXObU9fS5PXT7Zs2XF1dQXAycmJHr364H/jOrdvBxAUFMTUyROYOPk7c3EN4OzsbP774oXzKV2mLE2aNTevsero6IiDQ5L831gkwRzfv4P8xUqR2sPTqv47NywjX9G3KF+9Pg7//91xeOa78yQkmB+XzKLz52PMxTWAo1OSvAcrSYRydfJnMplYtmodwwd/as7fpUuW4K0Sxdh/8DAAd+/e55svh1Kx/Nv2DFXE7oxGExm93JnxaUNcnC3z56Ez16hdrgDpPKPns3BP5ULDCoU5cc7f3Cd3Fm/zQ6M07m70afIue09fjvN8R/68jpdnKt7Ikj4BrkZehV1/e+rXrx9G4793d/LmzUuvXr0s+owdO5bz58/z3nvv0a5dO+rUqcO2bdsSO1RJAKFPnmAwGPDySseOX7ZRukxZMmTMGGf/n7ZuZtKU6YkYoUjSdODnDdRv093q/sf3bafzoK/j3H7m+EHyFnmLNOmUpCUm5eqU6+69+zg7O+OVNo1Fe943c/P7mT+pVOFdSpcsAcBff5+3Q4QiSYeDg4GWH5SIdVuJvJlZ8vNJGrxXiDTubgQ9DmPBlmNUL5MvzuM9DAnFN51HnNtX7vyNppWK/R979x0VxfX2Afy7CyxdBEVUxBpFRUVsqMEgaCzYu8besGvQqLFGYom/xNhbMGjsir0bYxcVFQvGXrAAIjaQXnZ33j942bDuAosu7ALfzzme487cmXkGnX14Zube+6VhUx7Q6aM/Dw8PNG/eHFevXoW7uzs2b96s0ubo0aPo0aMHdu7cCQCQ8pXFQuHJk8eY8oMPRowaC4lEgocPH6BipcpYu3olenbrjN49umLNqhWKpyDJycmICI9AUlIiRnkPRfcuHTB2lDf+vX1bx2dClL8inj9FYkIcvnKqq1H71JQUvH8TidTkZKzynYgFEwZgzdwf8PzRvUz7fAK7cuVxdMd6LPQZhP9NHIIj2/2RlsankMRcXZRZWlggMTEJsXHK/T5fhEXg3fsPOoqKqODp0qwW6lYti07TNmL57ovoNG0jHB1sMbBNfZW2UpkcQXdfYtH285jQ42u1+4uOS8SVey/RulHVvA6dPoNOC+yOHTuiS5cuMDMzQ9euXWFqaqrSxsLCAm3atFG6e04F1+JF/4PnN1+jW6f2sLUthb79BwAAPsbEYN/e3Sjn4IDtAXuwfuMWPHsWivlz56Sv//gRhoYG+GPNasyZuwC79x3CoCHDMG7MCDx/nvXrM0SFTeDf+9G0ZQeV5at9J2H++P74bfJwnDm4U/GdmRgfC7HYAMd2bkDfsdMwfdkmtOzSF2vnT0ZUxEsAQELcR1w+eRglS9tjyiJ/fL9gFaIiXiBg7e/5em6kn5iriy4TE2O0b9MSC35bhqSkZAiCgPMXg/DP6XPQs0loiPSaWCxCj+a1YWpshDX7gyAWi9DRrYZigLMM/ebuQJORq+D92158921d1Ktmr3Z/e8/dRetG1WAiMVK7nnSLnVcpX038YSpOn7+IcxeDIDE2xuwZ0wAAIrEY9es3RPsOnWBgYAAzMzPMmPkTjh4+hJSUFIjFIiQnJ2PS5CmKUccbNGyEtl7tcOTQQV2eElG+SUlOws1Lp+Hq2VZp+YINBzHu52WYsXwzhvzwM24FncM/e9KfMopEIqSlpqDL4DEoXiK9C0bVWi5o0OxbXDv39/+3EeMrp7po1Lw1xAYGMDYxRa8RP+Da+RNIS03J35MkIr3iO2My7MuWQd+ho9Gx5wCcOnsBfXt1g1WxYjlvTEQAgLM3QzH0f7vRq4UzLq0ZjcFeDTBmyQEEnFF+E3PLrN64tm4cDvwyAIcu3sfec3dU9iUIAgLO3EZPT74erq/0dgSbCRMm8O5oIVa8uDWmTpsBt8YNEBc3EzY2NihZUnkeWKvixWFqaob4uDgUtyoOQ0NDOJSvoNTGoXwFhD59kp+hE+nM9QsnUa12fVgUK660PHPf6RJ2ZdCx3wjs+nMpWvcYCHNLK4gNDGBbupzSNiVL2+N1+HMAgKVVcRSztlFab25ZDBITEyQlJsBIYpwn50MFH3N14SeRSDBu5FCMGzlUscz3l99Rt04tHUZFVLCsO3QFU79zR5dv0q+bvt+6oKp9Sfyw+gh6qulHXamMDSb3ccdP6/9BV3flay3o7ksUtzBFNYesxy0i3dLbJ9gZfb6o8EpNTUVaWhrkMhlq1aqNx48fKa2PiYmGXC6DTYkSMJJI8FXVanj6RHkQlZcvXqgU3USFVeDf+/H1tx1zbCeXyxUj7RsaGaFshSqIDFPuSvE2MlxRdJevWgOvXjxVWh8f+xGCTA5LK2stRU+FEXN10ROfkIDT5wLh7tZE16EQFRjxSamoYq88kGhVh5KIS8z6LbG4pBS1NzB3nr6NHh61tR4jaY/eFtidO3dG165ddR0GaUlaaiqiXr9WfI6NjcWs6VPRslVrWBUvjq/dmuHJ48c4feokgPTie8G8n9Gnb3/FlAW9+nyH//0yHwkJ8QCAWzdv4Mypk+jYqXO+nw9Rfgt7+hCJcbGoVkd5QJTUlGTEfYxWfH4fFYl9f61E4xbtFMu+adsVu9YtRXJSAgAg9MG/uH3lguJV85oujfHq5TOEBJ0HAKSlpSLA73e4t+/OeeYpW8zVhZ8s09zWUW/eYtyk6RjUt5fKyOJElLWeHnWwZGcg3n9MBACkpEqxbFcgOjVzAgBExyUpFdvPX0djweYz6PPJqOTvPiYg6N5LeDWunm+xU+7p7SviWeEvewXTh+hoTBg3GklJiTCWGEMkFsOrXXt81y99kDMjiQTLV67GXN+fsOT33yDI5WjZqjVGjBqj2EfXbj3w7u1b9OzWGQYGBrCxKYHfly6H9SevthIVRpf+OQS3tl1UvgMT4+Owdt5kyGRSiMUGMDI2RvP2PdGoeWtFm6bfdkBs9Hss/H4QxAYGsLSyxrCp8xWvmhsaGWHE9P9hx5pfsX/TaghyOVyaeqBtr8H5eYpUiDBXFx5r/Tfh9LlASKVSmBgb47te3dCpXWuVdkZGRjAy4oBLRABgZGgAQ0MDxee+rVxgZGSAEYv2QiaTQwDQrE5FjOuePkr4v6Gv8evWs4BIBImhGGbGEnzf42u0bKA8Svj+C3fRrkl1mJnwWtNnIkGHnafGjBkDmUyGoKAgNG7cGMHBwQgODoabmxsCAwMBAG3btsWxY8fQpEkTtGjRAv/88w+uXLny2cdM5swhRFpx4fE7XYdAVGh8W6Nkzo10RBe5Gon8fiHSBvndvboOgajQEDf01qidTp9gd+3aFVKpFF26pD+VGTt2rEqbkSNHAgAWL16M0NBQtGvXTqUNERER5Q3maiIiIs3p9Al2VjLfFdc2PsEm0g4+wSbSHn1+gp2VvMzVfIJNpB18gk2kPZo+wdbLQc4GDhyo6xCIiIgoG8zVREREqvTyCXZe4hNsIu3gE2wi7SmIT7DzFJ9gE2kFn2ATaU+BfoJNREREREREVNCwwCYiIiIiIiLSAhbYRERERERERFrAApuIiIiIiIhIC3Q6D3ZISAhSU1NztY2RkRHq1q2bNwERERGREuZqIiIizem0wF6+fHmuk7ZEIoG/v38eRURERESZMVcTERFpjtN0EdFn4TRdRNrDabo+wWm6iLSC03QRaY+m03Tp9Am2n5/fZ90V9/bW7OSIiIjoyzBXExERaU6ng5ype3i+fv16HURCRERE6jBXExERaU7vXhF3c3NDYGAgAEAulyMgIAC9evWCSCTSyv75ijiRdvAVcSLtKWiviOd1ruYr4kTawVfEibRH01fEdT5NV1RUFGJiYhSfbWxsAABSqRSTJ0/GzZs3tZewiYiIKNeYq4mIiDSj0z7YADBgwACEh4fDxcUFnTp1wp49exAaGoqpU6fC2dkZM2bM0HWIRERERRpzNRERkWZ0XmAnJCTgzJkzOHv2LI4cOYIlS5YgMTER8+bNQ/v27XUdHhERUZHHXE1ERKQZnb8iDgClSpVCz5498ddff2H58uWoWrUqTpw4geTkZF2HRkRERGCuJiIi0oReFNiZNWjQADt27ECpUqXQo0cPpT5fREREpHvM1UREROrpXYENAAYGBpg5cyY6deqEkSNHIiUlRdchERERUSbM1URERKp0XmD/+uuvWa4bNmwYXFxcsHcvpxggIiLSFeZqIiIizejdPNh5jfNgE2kH58Em0p6CNg92nuM82ERawXmwibSnwMyDTURERERERFQY6HSarqtXryI1NVXtuvr16yMhIQGPHz+GIAioWrUqbG1tsWbNGowaNSqfIyUiIiqamKuJiIg0p9MCe9WqVUhLS1NZLhKJ4Ovri+nTp0MQBIhEIsjlcuzevRv79+9n0iYiIsonzNVERESa02mBvXHjxmzXx8TE4MSJEwCAFi1aAACKWJdxIiIinWKuJiIi0pxe98EWiUS6DoGIiIiywVxNRET0H70rsP38/HDjxg0AvANORESkj5iriYiI1NOrAvvp06fYtGkTKlasqOtQiIiISA3maiIioqzpTYH94sULjB49GrNnz4aNjY2uwyEiIqJPMFcTERFlT6eDnC1YsADW1taQy+XYvn07Jk+ejFatWinWq+vXxb5eRERE+Ye5moiISHM6LbBtbGwQERGBwMBAmJubw9HRUWl95n5d8fHxmDZtGmJiYvI5SiIioqKLuZqIiEhzOi2wR44cCQCQy+U4dOgQhg0bht9++w1NmjQBAIwePVrR9vfff8eLFy/Qrl07ncRKRERUFDFXExERaU4k6NHwnyEhIRgzZgy2b98OBweHPDlGsjRPdktU5Fx4/E7XIRAVGt/WKKnrEDSWH7kaifx+IdIG+d29ug6BqNAQN/TWrF0ex5Erzs7OGD9+PPz9/XUdChEREanBXE1ERJQ1nb4irk7Pnj0hk8l0HQYRERFlgbmaiIhIPb16gp3BwMBA1yEQERFRNpiriYiIVOllgU1ERERERERU0LDAJiIiIiIiItICFthEREREREREWsACm4iIiIiIiEgLWGATERERERERaQELbCIiIiIiIiItYIFNREREREREpAUssImIiIiIiIi0gAU2ERERERERkRawwCYiIiIiIiLSAhbYRERERERERFrAApuIiIiIiIhIC1hgExEREREREWmBSBAEQddBEBERERERERV0fIJNREREREREpAUssImIiIiIiIi0gAU2ERERERERkRawwCYiIiIiIiLSAhbYRERERERERFrAApuIiIiIiIhIC1hgExEREREREWkBC2wiIiIiIiIiLWCBTURERERERKQFLLCJiIiIiIiItIAFNhEREREREZEWsMAmIiIiIiIi0gIW2ERERERERERawAKb1GrdujWioqJw8+ZNDBkyJMt2EyZMgKurq+KPr6+v1mPp06cPrl27pnbdhw8f4OLionadh4cHXr16pXZdVFQUZs6cqXEMs2fPxuvXrzVuT5Qhv66lkydPYvTo0VmuP3DgAL7//vtc7TNDs2bNsvz/n9traenSpbh79+5nxUFEypirlTFX0+dirlbGXP1lDHUdAOmOn58ftm3bBplMBjc3N8ycORPm5uYAgLS0NKSlpSE1NRVpaWlZ7mPZsmWfffywsDD07t1baVlycjJsbW1x/PhxxTKZTJZlDK9fv4a1tbXaddnF7uvriylTpig+R0VFwdfXF9evX4ehoSG8vLwwefJkSCQSAMCwYcMwZ84crF27NlfnSEWDrq8lAJBKpZDJZFmul8lkkMvlKsvbtm2LhIQEpWUpKSnYu3cv7O3tAaRfS1KpVO1+P72WMo41f/587N69G7dv31ZaN2TIEIwZMwbr16+HkZGRRudGVJTp+vuFuZoKC11fSwBzdVHBAruIOnDgAPbs2YN9+/bB1NQU3t7emDp1KlauXKnR9uPHj8f169fVrrOwsMD06dPh7u6e7T4cHBxw8eJFpWVbt27FoUOHNDsJAE+ePEGxYsU0bg8Aly9fhqmpKSpWrAgg/Ut12LBh8PLywrJly5CYmIipU6di3rx5+PnnnwEA5cuXh4WFBS5fvowmTZrk6nhUuOnDtZQhKCgInp6eatclJCTA1dVVZfmxY8dUlnXt2hURERGKpA0AsbGx+PDhAywsLBS/zH56LQFAUlISfHx8kJaWpjbRFytWDPXq1cP+/fvRo0cPjc6LqKjSh+8X5moqDPThWsrAXF34scAuojZu3AgfHx/FHWVfX1+0adNGccHn9IrV8uXLVZZdunQJa9asgZWVFZydnXMdU3R0NJYvX46FCxdqvM3Bgwfx6NEjvHnzBqVKldJoG39/fwwfPlzx+dy5czA3N8eoUaMAAFZWVvjll1/g6emJSZMmwcrKCgDQq1cvrF27lkmblOjLtSQSieDq6go/Pz+16/fs2YNz585ptC91ydbHxwdGRkbw9vZGx44dAaheSwBw5swZ1KpVC507d0arVq3U7r9Hjx7w9vZm0ibKgb58v2TGXE0Fkb5cS8zVRQML7CIoNTUV9+/fR+PGjRXLKlWqhIoVK2Ly5Mlo2bJllnfWPt3PrVu3cPbsWRw/fhyRkZHw9vbG8OHDYWFhkauYkpOTMWbMGLi5ucHDwwNjxozBrVu3AAAfP35Uu01ISAiCgoLg6uqKZcuWYf78+SptevXqBQMDA4wdOxZ9+vRBfHw87ty5g4YNGyranDlzRuV8ra2tUbduXQQGBqJdu3YAgPr16+PevXuIj4/P9flR4aRP11LZsmURHByMb775Ru36pKQk9OvXT2W5l5cXPnz4AAMDA8UyKysrVKhQQamdv78/ypUrp/is7lrK2B8AhIeHZxlruXLlYGhoiKdPn6JKlSo5nxxREaRP3y8ZmKupINKna4m5umhggV0ERUdHw9DQEMWLF1dabm9vj6SkpBy3DwgIwL59+/DmzRvUqVMHzZs3R58+ffDvv/8iKCgI/fr1Q3JyMlq3bg0fH58c9/fmzRtMnDgRZmZmuHnzJi5cuIBVq1Yp1vfs2VNlm7i4OEyePBn9+/fH6NGj0bt3b/z1118YNGiQUrudO3cqffkEBwfD2dkZYvF/4/u9ePECHh4eKseoVKkSHj16pEjaYrEYderUQXBwMJo3b57jeVHhp0/XUu3atXHjxo1cxZ+amoqnT5/izp07OfaxOnr0KKytreHi4oKvvvpK7bWUGw0aNEBQUBCTNlEW9On7BWCupoJLn64l5uqigQV2ESQSiSCXyyEIAkQikWK5VCqFra1tjtu7urqiSZMmcHBwUFru4OCguCOWnJyM+Pj4bPcjCAIOHTqERYsWYfDgwRg8eDDu3r2LSZMmwd7eHrNmzVLqL5Lh+fPnGDVqFJydnfHDDz/AwMAA69evx6hRoxAcHIyFCxdmeSfx074qQPropur6hllaWiImJkZpWdmyZbMc7ZSKHn24lvz8/LBx48ZcxV2hQgVs27ZN8TljQJfk5GTExMQgKioK4eHhiIiIUPwinJSUBIlEonglTd21lBu8loiypw/fLwBzNRV8+nAtMVcXLSywiyAbGxuIRCK8fv0aZcqUUSwPCwvDDz/8AIlEorYvSlhYGPr06QNBEHJ1PD8/Pzg5OaksHzFiBGQyGfz8/FC9enUAgJOTEw4ePIhdu3ZleZdu06ZN6NatG4YOHar4orSzs8OOHTuwd+9emJiYZBlLXFwcLC0tlZZJpdIszynzFzGQPuhDbGxs1idLRYo+XEve3t7w9vZWabt3716cPXtWbb+xDBKJBO7u7ujUqROMjY1hbGwMExMTWFtbo3Tp0kpPlLp166b02pm6ayk3ihUrhhcvXnz29kSFnT58vwDM1VTw6cO1xFxdtLDALoIMDQ1Rt25dnD17Fn369AEA3L59G46OjoqpLdT1RXFwcEBgYKDW4vjll19QokQJleUSiQR9+/ZVfJ42bRq++uorxefZs2er3Z9EIlGaSmTu3LkoXbq0UhtLS0tERUWpLIuLi1PZX2xsrMrd8o8fP8LOzi6bs6KiRF+upS+R1UArmfXv31/l1Tp111JufPz4MdejChMVJfry/cJcTQWdvlxLX4K5umBhgV1EDR8+HNOmTUODBg1QrFgx+Pr6YtasWfkaQ+aE/eDBA2zZsgVXr15FSkoKBEGAlZUVPD090a9fvyzvvuW0nbGxsVJ7e3t7ldEZK1asiNDQUJV9P3v2DB06dFBa9urVK/bpIiX6cC0BwP79+9XO/dqmTRsA6QOdeHl5Yfr06Wq3f/z4MXbv3o2QkBB8+PABEokEdnZ2aN68OQYNGqTyKqe6ayk3Xr16pfTLOBGp0ofvF+ZqKgz04VoCmKuLChbYRZS7uzumT5+OqVOnAgBGjx6NunXrarTtyZMnFXNOqiOXy2FkZIRjx45l+wpYhnv37mHw4MGYPHkyfvzxR8WXw6tXr7Bz5050794dBw8eVEzB8SXb1a9fH1OnToVcLlcM+NC0aVMEBAQovboTHR2NW7duYcGCBYplMpkMISEhWLx4sQY/JSoq9OVa6ty5Mzp37pzl+mPHjiEgIEDtuuDgYIwbNw4TJ07EoEGDUKJECaSlpeH58+fYvXs3unbtin379sHc3FyxjbprKTeuXbum9PSLiFTpy/cLwFxNBZu+XEvM1UUDC+wirH379mjfvn2ut2vZsiVatmyZbZv69evj/fv3Gg2sEBgYCA8PD3Tv3l1pedmyZeHj44Pz58/j1q1bcHd3/+LtLC0tUatWLVy9elUxXUP79u2xdu1arF27FsOGDUNCQgKmTZuGVq1aoWzZsoptr127hlq1anHaD1KhD9fSpUuXMHHixCyfIInFYrWj/ALAqVOn0KZNG6W5LiUSCZycnODk5AQvLy/cunULX3/9tWK9umtJU2FhYZDJZLwrTqQBffh+AZirqeDTh2uJubpoYIFNeUIkEmk8KISbmxs2bNiAQ4cOoWXLljA1NQUAvH37FgEBAYiJiYGLi4vWths6dCh27Nih+KIxNjbG+vXrMXfuXDRp0gQGBgZo06aN4i5nhoCAAAwZMiRXPweiL6XptfTs2TN4enoqPcnRVOPGjTF79mx4enqicePGikGL3r9/jz179iA+Pl7t4EefXkuZGRkZqbz2mSEgIACDBw/OdZxEpF3M1UTawVxNmbHAJrUMDQ1hZGSk+JOXatasCX9/f2zevBkrVqxAamoqgPS7bh4eHti1a5faARY+d7umTZti06ZNCA0NReXKlQGkD2SR3QASz549Q0JCgtJdQSJN5Ne1VKlSJSxduhRBQUFZthGLxTh8+LDKK2zu7u5YuHAhtm/fDl9fX0ilUohEIlhYWOCbb77Brl27VAZOAdRfSxns7Oxw8+ZNlW1iYmJw/fp1jBs37vNOlIgUmKuVMVfT52KuVsZc/WVEQm7HnifSwKFDh9CqVass74rpWlRUFJYtW6bxHcQZM2Zg7NixStM7EOWHwnYtLV68GK1bt1Z7l52I8ldh+35hriZdKWzXEnP1l2GBTURERERERKQFuR9OjoiIiIiIiIhUsMAmIiIiIiIi0gIW2ERERERERERawAKbiIiIiIiISAtYYBMVEUFBQejQoQPq1q2LgQMHIjQ0VLHuw4cPcHZ2BpA+0mTDhg3V7iM6OhrVq1eHo6Oj4k/fvn2zPGZoaKhS24w/NWvWxOzZsxXtnj9/zpEqiYioyGOuJir4OA82URHw8uVLjB49GrNnz0aLFi2wc+dODBs2DAcOHIClpSVkMhmSk5MBAGlpaYq/ZyaVSmFpaYng4GDI5XLFckNDQwiCAJFIpLJN5cqVcfv2bZXlixcvRlhYmOJzamoqpFKpNk6ViIioQGKuJiocWGATFQEbN25EixYt0LlzZwDAsGHDcP78eezduxcDBw7Mcfvg4OBs734bGhqib9++mD59uso6dXNCXr9+HV26dNH8BIiIiAo55mqiwoEFNlERcPHiRYwfP15pWZs2beDr64sFCxbkuH2DBg3w8OFDleXh4eFYunQprl27hrZt22oUy+nTpxEWFoaOHTuqrMu4M25gYKD2LjsREVFhxVxNVDiwDzZRERAeHo6KFSsqLatWrRrMzMzw8OFDBAYGarwvqVSKc+fOYcKECWjTpg1sbW1x5MgRuLi45Ljt06dPMX36dMycOROWlpYq652cnODk5KTRLxJERESFCXM1UeHAJ9hEhVxaWhrS0tJgbm6utLx48eJITEzMsT+VIAh4/Pgxbt68iStXriAwMBAVKlRA7dq1UalSJezZswcRERGoU6cOHB0d0bhxYxgZGans58yZM/jxxx8xdOhQdOjQQe2x1N15JyIiKuyYq4kKDxbYRIWckZERjIyMEBsbq7Q8JiYGJiYmMDTM/mvg0aNHGDduHOrUqYNGjRph8uTJKFOmjGL9+/fvce3aNdy6dQtBQUGoV6+eUtJ++vQpli1bhitXruDnn39G69attXuCREREBRxzNVHhwQKbqAhwcHDA06dPUbt2bcWyhw8fokSJEtlul5aWhooVK+LQoUNKy1NSUhR/t7CwgIeHBzw8PBTLpFIpDA0NsWXLFvz222/o3r07jh8/Dmtray2dERERUeHCXE1UOLDAJioCvv76a5w+fVoxMikAHDt2DBEREXB0dMxyu/bt2+P58+e5Pp6bmxv8/f3x7bffonXr1rC1tc22fdmyZTFlypRcH4eIiKiwYK4mKhxYYBMVAQMGDECnTp2wf/9+tG7dGps2bcKNGzewa9cu1KlTB2/fvoWbm5vKdn///fcXHdfOzg4AEBYWhlKlSimmAYmOjoaFhYXi9bSwsDBOBUJEREUaczVR4cBRxImKgPLly2P16tVYt24dGjRogKNHj+KPP/5AnTp1NNo+LS0NKSkp2f6Ry+VZbj927FjcunVL8Xn8+PE4d+6c4vMPP/yAq1evfvb5ERERFXTM1USFA59gExURTZo0wZEjRz5rW09PT7x58ybbNhKJBBs2bECDBg3Urh8wYIDS54EDBwJIv0P+8uVLhIWFfVZsREREhQVzNVHBxwKbiHJ04cKFHNsMGDAADx8+zDJp+/n5KdYNHz5csfyPP/5Aw4YNsWHDBrRq1QoVKlTQTtBERERFCHM1kX7gK+JEpBVGRkYQBCHL9SYmJjA3N4e5uTkMDAwAADt27MChQ4ewaNEijB49Gv3798fNmzfzK2QiIqIihbmaKO/xCTYRwcDAABKJBEB68s0Y4ERbRCIR4uLiFFOGJCQk4MCBAwgODsaff/4JGxsb9OvXDyYmJhg7dixOnToFExMTrcZARERUkDFXExUMIiG721hERBoaP3483N3d0a1bN5V1U6ZMwcGDBxV3zS0tLbF+/XrY2dkpRi/NkJKSovVfGoiIiIi5mig/sMAmIiIiIiIi0gL2wSYiIiIiIiLSAhbYRERERERERFrAApuIiIiIiIhIC1hgExEREREREWkBC2wiIiIiIiIiLWCBTURERERERKQFLLCJiIiIiIiItIAFNhEREREREZEWsMAmIiIiIiIi0gIW2ERERERERERawAKbiIiIiIiISAtYYBMRERERERFpAQtsIiIiIiIiIi1ggU1ERERERESkBSywiYiIiIiIiLSABTYRERERERGRFrDAJiIiIiIiItICFthUoJ08eRLNmzdHYmKiTvdRWP3vf//D6NGjdR2GVty5cweNGzfGq1evtL7v6dOnw9HRUfGnevXqiImJyXabM2fOwNnZWWk7dX927dqldvvM29asWRNpaWkAgKioKDRs2FDRrmXLlnj48KHi89OnT1WOUaNGDfj4+Kgco02bNggODv6MnwgRUdaYu/NWYcrdX2rVqlUqOe/evXvZbnP37l3Ur18/x/y8ZMkStdt7eXkptQsLC1Osc3Z2RnR0NABg4MCBOHPmjGJdfHw8atasqfL7RK9evVSOMXToUBw4cOBzfiSUDwx1HQAVLqtXr0ZISAj++OOPfDmelZUVKlasCENDzf4rBwcHIy4uDh4eHp+9DwBwcnKCVCoFAIhEIlhbW8PLyws+Pj6wsLDI3UnoMTs7O8hksnw7XuvWrfH8+fMs13/99ddYv379Z+3b3NwclSpVgrGx8WdG95+0tDRcvHgRgiAASC9iPT09ldrcvHlT8Xc7OzvUrFlTaf3du3fRuHFjrFq1Kttjffr/Ui6XQy6XIygoCHK5HAAgFoshEokgCALS0tKQnJysaJ+amorU1FTF5ypVquDu3btK+zx37hzmz5+vcuxPtyWiwom5m7n7S+Rl7s7w+vVrnDx5Ev369cuxbWBgoOKmc40aNVTybFRUFKKiogCk/z+qV6+e0vrHjx+jbNmy2Lt3L0QiUZbHMTAwUPosCAJkMhn27t2r+PmLRCJIJBLI5XKIxWIkJycr/g+mpqYiJSVFsb2FhQX+/fdfxe8WAPDkyRN06tRJ5djMz/qNBTZplUwmU3xx5IeGDRvir7/+0rj95cuXERERoZSkc7sPAJBKpdiwYQNq1aqF1NRUPH78GCtWrMCwYcOwY8eOXO1Lnw0aNChfj7dv3z7F/587d+5g8ODBuHbtmmK9RCL57H1XqlQJ27dv/+IYgfTEduXKFY3bZzxlzkwQBJiZmeXql0MAGDduHC5duqR2naenp9on0Z/69JimpqaKv9etWxdJSUm5iomICjbmbubuL5GXuTvDixcvsH79eo0K7KtXryoK7JyULl1apcCWy+UwNTWFkZFRrmKcP38+9uzZo3Zd9erVNfod5NOiPXN+bteuHZ48eaL43LFjx1zFR/mHBTbRZzIzM0OxYsUAACVLloSjoyOaNm2Kp0+fokqVKjqOrmAyMzNT+XvGz1ifmJubY+rUqQCABw8eYOvWrbh16xbevn0LU1NTlCtXDm3atEH37t218sQ8s4w78QkJCbh//z4EQUCNGjUUT1/Cw8Oz3T4lJQWLFy9GYmKi4s7869ev0bRpUwDArVu3FG0/fSpPRFTQMXdrn77l7okTJwIAwsLCsHnzZly5cgVv376FoaEhypYtC09PT/Tu3VvrMc6cORMzZ85EamoqHjx4gISEBNSoUQPFixfXeB/Lly/HmzdvIBan9+KNiYmBm5sbAODIkSOKdv3799dq7KRd7INN+e758+cYN24cGjZsCGdnZ/Tu3RuBgYEq7f7991/07dsXzs7OcHV1xdy5c3Hx4kW0adNG0SY4OBguLi6KzwkJCZg+fToaN26MOnXqwMvLC3fu3MGNGzfg6OiIlStXYt++fXB0dMSQIUPU7gNIv5u/fv16tG3bFrVq1UL9+vUxe/bsbM/LxsYGxYsXx8uXL5WWb9iwAZ6enqhduza6du2Kixcvqmy7YcMGtGzZErVq1YKXlxeOHj2KWbNmwc/PT9FmxowZ2LJlC9avX4+GDRuib9++inUXLlxAly5dULt2bbRo0ULlrv7Tp08xZMgQuLi4oF69eujVq5fitaTs1q1evRojRoxQ2pcm/3579uzByJEjsX//frRu3Rp16tRBu3btcPjw4Wx/hjkJDg5G165dcf/+fXTo0AEuLi549OgRAMDPzw9eXl6oW7cuvv76a3z//fd4+/atYtvXr1+jevXq+PDhA4D0xFuvXj38+++/6NWrF5ydneHh4YElS5Zo/Grd9evX0b9/f1SrVg1r167F+fPncejQIfj4+ODYsWPw9vbOcluRSISkpCRIpdJs/2R+VSzDxYsX0bZtW6xbtw7r169Hu3btcP78ecX61NRURf+tjNfgMty+fRt///035s6di59//hk///wz/Pz8MG/ePADpT7Azto2IiNDo50BEhR9zN3P3l4iPj8ecOXPg6uqKunXrYsSIEUp9kwFg3bp18PDwQK1atdC8eXPFGCS1atXCgAEDEBERAUdHR9SqVSvH4z1//hzdu3dHsWLFsGzZMpw5cwbHjh3DrFmzcOfOHfTq1SvLV6wzXuVOS0vLdX6+f/8+vLy8sGTJEmzbtg0dO3bEvn37lNq4ubnB0dERN27cUFr+6tUrrFq1Cr6+vor8vHz5cvj7+wNIf4KdkZ+vXr2a48+AdIdPsClfhYeHo3fv3mjUqBF27NgBCwsLHDt2DKNHj8aKFSvg7u4OIL1/zODBg9G2bVssWLAAYrEYq1evxsyZM5X6w3z6Wttvv/2GV69eYcuWLbC2tkZERATKlCkDGxsbXLt2DX5+foiMjMRPP/2keGVJ3atxEydOxJMnTzBlyhTUrl0bycnJikEpshIZGYmYmBiUL19esWzlypXYvXs3fH19UbVqVZw9exZjx45FQEAAqlatCgDYunUrli9fDl9fXzRt2hTPnj3DzJkzkZKSgm7duimda2BgICwtLbF//37Fa76XL1/G+PHjMXnyZLi7u+Pp06eYPn06zMzM0LNnTwDprxU3a9YM8+fPh4GBAZ4+fao4/+zWffqz0fTfTyQS4c6dO3j27JliALDg4GBMnz4dFSpUQO3atXP8v6KOTCZDamoqfvnlF/j6+sLe3h7W1taKp7kzZ85EpUqVEBsbi59++gkzZ85U9CnMSIaZ+0WlpKTAx8cHw4cPh5ubG16/fo0pU6agWLFiGDp0aI7xBAYGonLlykp3kiUSCerVqwdvb28MHz4cSUlJSq94ZXBycsK6devg5OSU7TFGjhyp9Nq3IAiYMmUKli1bhgYNGgBIfyVv2LBhil+WJBKJog/4p0+h09LSFHfG1eETbCL6FHM3c/eX5G5BEDBmzBjI5XKsW7cOxYoVw8aNGzFo0CAcO3YMEokER48exZYtW/D777+jcuXKipvhABAUFIRr167B19cXBw8ezDaHZQgODoaRkRHGjh2rWGZsbAwnJydMmDABXl5eCAsLU/vWQtWqVREREZFjId+hQwcsWrRIadmsWbMwduxYdO7cGQAQERGBrl27ws3NDba2tgCA8+fPo0SJEipPoTNea//0NfEMfIJdgAhEWrR8+XJhyJAhWa6fOHGi0L9/f0EulystX7VqleDp6SnIZDJBEARh2bJlQqdOnZTayWQyoW3btoKHh4diWVBQkFCrVi3F53bt2gmnT5/ONr6pU6cqLft0H0ePHhVcXFyEd+/eZbmfatWqCTdv3hQEQRBSU1OFq1evCh06dBBmzpypaPP+/XvByclJCAkJUdr2559/Fn788UfFZw8PD2HDhg1KbW7evClUq1ZNWL58uWLZ1KlThUaNGgnJyclKbTt37iysW7dOadnx48cFT09PQS6XC+/fvxeqVasmxMfHq5xHdusEQfXfU9N/vz179gjVqlUT/v33X6V206ZNE+bMmaP2WJ/K+BlkFhQUJFSrVk04cuRIjttfu3ZNqFGjhpCWliYIgiCEhYUJ1apVE968eaP02d/fX2m7ffv2CV5eXhrF+PjxY6Fx48bC/PnzhStXrghPnjwR7t+/Lxw8eFBo27atMGPGDI32IwiC8OTJE6FGjRo5tnv79q3g5OSk8m/QqFEj4eXLl0JYWJjS/+dmzZoJt2/fVny+dOmS0LRpU8W/VUJCghARESEEBwcLAQEBwocPHxRtPTw8hIsXL2p8DkRUMDF3M3cLQt7l7pMnTwpNmjQREhISlJa3b99e2Lt3ryAIguDr6yssXLgwy/0GBQUp/R/KyZs3bwQPDw9hypQpQmBgoPD48WPhwYMHwokTJ4RevXoJQ4YMUZx3TpKTk4Vq1aoJkZGRObatXbu2SrsuXboIly5dEgRBUPo9pHfv3sKxY8cU7V6+fClUq1ZNSExMFARBEJKSkoTIyEjh1q1bwt69e4WXL18q2vbr108ICAjQKH7Kf3xFnPKNXC7H6dOn0a9fP5VRGfv06YPw8HDF6MbXr1+Hp6enUjuxWKy4I5iVGjVqYOfOnYiLi/vsOA8fPoyuXbuiRIkS2bYbPHgwGjRoAGdnZ/Tr1w+NGjXCnDlzFOsvXboEe3t71KlTR2k7V1dXxVPCyMhIREREoEWLFkpt6tati8qVK6scs0mTJkp9et+8eYN79+6pDHTh6uqK8PBwvH//HlZWVrC3t8eGDRtUXn3Obt2ncvPvBwDFixdXufvr6OiYYx/hnIjFYsXd9uw4ODhAJpMpvSauztdff630uXr16hrH+NVXX2H//v2wsrLC+vXr0aNHD/j4+ODSpUv44YcfMHfuXJVt5HK52lfNMkYEz+pVtIz1JUuWhJ2dHXbv3q3Y59GjR2FiYoKyZcvmGHPlypUhCAKcnJzg6OiIhg0bonv37pg3bx6CgoIQHx+v0bkTUdHA3J2Oufvzc/e5c+fQsmVLpb7agPLPtEaNGjh16hSePXv22cfJzNbWFvv27UP16tWxY8cO9O/fHyNHjsTff/+Nvn37Yu3atSpPwrPKzxk/44w3A7LKz0D6/4HMA+YFBwcjPDwc1atXzzFmOzs7VKhQAfXq1UP16tVRr149dOrUCTNnzsTZs2dznP6T9AdfEad88/79eyQmJqp9Hcfa2holSpRAWFgYateujTdv3qBcuXIq7TK/wqXOTz/9hPnz5+Pbb7/F0KFD0b9/f5iYmOQqztDQUDRr1izHdr/++itq1KgBIyMjxaBRmV/riYiIQHh4uOI13gwymUzxpf7mzRuIRCKNz7VMmTJKnzP6yHp5eamN8c2bNyhZsiT+/PNPzJgxA0eOHMH48ePRpk0biEQiGBgYZLnuU7n598tY9ilLS0ulKaQ+h5WVFczNzVWW3759G9u3b8f9+/fx7t07RV+0nH75sLGxUfpsYWGRqxjt7OwwZswYAOm/rPTo0QNdu3bNsr2Xl1e2v0Bk9cq4m5uboh/W0qVL4ePjAz8/P4jFYqSlpWHp0qWK/3/ZTStiZ2eHS5cuIS0tDYIgZDu6a5cuXWBvb5/leiIq/Ji70zF3f37ujoiIwLVr13D06FGl5SkpKYoBvLp3747o6Gj06tULbdq0wZgxY2BnZ/fZxwTSf18YPHgwBg8ejB9++AEVKlTAuHHjsmw/fPhwteMKZMiq21SlSpVw/PhxAMC8efMwfvx47Nu3DxYWFoiOjsYvv/yi9HPNKkdLJBKcOHFCo/zcqlUrVKtWLcv1pFsssCnfZPdL/6cy3w3MLKeEa2FhgV9++QX37t3D/PnzsWPHDmzbti3XX9KaDHJla2urSK7Dhg1Dly5dMH78eJQuXVrRxtHREcuXL1fZNmPqB5lMBpFIBLlcrtLnRt3o05/e/QXSf667d+9WmXpJJBIpYqlcuTK2b9+Of/75BwsWLMC+ffuwZs0aGBgYZLvu0/3pA3U/g/Pnz2PUqFHo2LEjRo4ciXLlyiE1NRV9+vTR+vH/+OMPLF68OMv1N27cwLRp09Suu3DhgiIJf0oulyM5OVnt+X2qdu3a+Pvvv/H8+XPI5XJUqlRJ8e9funRpbNy4UdFWLBarnQrsxo0bGDx4cJbHEIlEsLW1VfQFJKKiibn7P8zdn6979+6KAeoyy7hhLhKJ4O3tjS5dumDZsmVo3bo11qxZgyZNmmh8jMOHD2PSpEnZtlm5cqXa5Tt27FDcxP6UIAiK8VRy+nmWL18e+/btQ1hYGBITE1G5cmWlQnnbtm2KG/tZ5efXr1+jTZs2agdRy2BlZZVlvKR7LLAp39jY2MDCwkLtVBgxMTF4//49KlWqBCD9KZu615E0fXWoZs2a2LBhAwYOHKi4ywtolmgqV66Me/fuaXScDFWrVkXjxo2xfv16TJ8+HUD6Obx9+1btHe4MpUuXhlwux6tXr+Dg4KC07tmzZ4rBVLJiZ2cHQRAgCEK2x8nw7bffok6dOmjfvj3OnDmDli1barQOyN2/X377888/0bdvX8XPHgBCQkLy5FjDhw//rDlGRSKRyt3oy5cvY/fu3bh+/Tpev34NQRBgYGAABwcHuLi4oF+/flkOsmJgYIAqVaogKCgIW7duRUhICN69e4e0tDSULFkSVatWhYeHBw4cOAArKyuV7V1dXbP9fy6Xy+Hu7o7Q0NAvfopARAUXc7cq5u7cKVWqFD5+/KjRudra2mLevHkoVqwYFi5ciAMHDgDQ7P9Au3bt8O23335WjJ/eGLlz5w62b9+Oa9euITw8XPEGQ+nSpVG3bl307Nkzy+JfJBKhfPnyuHPnDhYvXozg4GC8e/cOSUlJsLGxQaVKlfDNN99gxYoVaqfwcnBwUHptX51evXrh3r17qFmz5medL+Ut9sGmfCMWi9GpUyds3rxZZd2WLVtQs2ZN1KhRAwDg7u6OgwcPKo2CKZPJsHPnTsUd5JxIJBLUqlVLaaohiUSiGKUxK23btsXBgwdVpo/IydChQ7Fr1y5FH5mGDRvi7du3OHXqVJbblC1bFlWrVlWZwiE4OBiPHj3K9vWgjO0dHByU+vvkxM7ODmXLllX7S1B263Lz75ff3r17p/ILzT///JMnxxKLxTA2NkZUVBRGjhwJY2Njjf58+m8ZEBCACRMmoFq1alizZg2Cg4Px77//4uLFi/jll19QrFgx9O3bF1euXMkylrVr12LatGlwcnLCsmXL8Pfff+P8+fPw9/dH+/btsXv3bnh7e2c5FUlOsrt7TkRFA3O3Kubu3HF1dcWpU6dyHBMls3r16in9HzA2Ns7x/4BIJIKxsTGkUin69esHQRA0ztGZnTt3Dv3794eNjQ0WLVqEy5cv499//8WVK1ewfPlyVKpUCWPGjFEU/+ocOHAAw4YNQ+nSpfG///0Phw8fRmBgIDZv3ozvvvsOly5dQu/evREbG6vxz4QKDhbYpHUymQyxsbFKfzL6w44YMQJPnz7Fjz/+iKdPn+L169dYvXo11q5di8mTJyv20bt3b4hEIkyYMAEvXrxAaGgoxowZg6SkJJW+TJnt2rULjx49wrt373Dy5Ens27cPzZs3V6wvW7Ysrl27hqdPn+LBgwdq+xR5eXmhQYMG6NOnD06fPo3379/j1atXOd5NbNKkCcqXL69IYvb29ujRowemTp2Kffv24d27d3j58iV27dqFBw8eKLabPHky1q1bh23btuHdu3c4d+4cfHx8YGtrq/TKWlbGjx+PTZs2YcmSJYiIiEBkZCROnz6tKDA/fPiA/fv3IywsDFFRUfDz80NoaCiaNGmS7Tp1NP33y2/169fH1q1bce/ePYSHh+PPP//EpUuXct2HLzc+fvyIf//997O3P378OPr06YMRI0agRo0asLCwgEQigbW1NerVq4fp06ejadOmOHv2bJb72LdvHyZPnowePXqgfPnyMDMzg0QigZ2dHVq0aIH169fjwYMHirnCMwsLC4Orqytq1qyp9k/t2rUVT8mJqPBj7mbuziteXl5wcHDAgAEDEBQUhPfv3+PRo0dYtWqV4gbwyZMncfPmTbx79w4hISFK04cB6f3Y3759i3PnzuHFixd48+ZNlsdLSUnB7du3P/vm8smTJ9GiRQtMmjQJderUgZWVFSQSCYoVK4batWtj/Pjx6Nq1a7Y3YQ4ePIghQ4Zg0KBBqFKlCiwsLGBkZISSJUvCzc1N0QVB3U30hIQENG/ePMv8XLNmTbx48SLHaT5Jd/iKOGmVgYEBLl++jIYNGyotb9WqFVasWAE7Ozvs3LkTv/32G3r37o3U1FQ4OTnB398frq6uivbm5ubYvHkzFixYgM6dO0MikaBjx46wsLBQGonRwMBAqf/KwYMH4evrC7lcjnLlymHcuHFKfUhbtGiBI0eOoFu3bihZsiS2bNmisg+xWIw1a9Zg1apVmDt3LqKiomBkZIRWrVrht99+A5B+N13dPIVDhgzBggULMGLECEgkEvz0008oU6YMVq9ejVmzZsHc3Bw1a9ZUOld3d3csXboUS5cuxYIFC1ChQgV8//33WLx4sVKyNDAwUHvMjh07wsjICH/++Sc2bNgAAwMDVKpUCePHjwcAxMfHY82aNXj58iWMjIwUT0wdHR3x8uXLLNep+/lq+u/36XYZ1D3JzYpEIlFpm9XP4Mcff8TChQvh7e2NxMREuLm5Yc2aNWjfvr2iT6ChoaFicBh1nzMYGRmp7UP3KbFYDJlMhqSkpBzn5FS3v2+//RZLly6FtbU13NzcYG9vD2NjYyQmJuLFixf4+++/cenSJQwYMCDL/bZv3x4rVqyAoaEhGjZsqBhEJTExEXfv3sWmTZvw1VdfqR0IJTIyEoaGhrh7967e9NEjIt1g7mbuVrddhi/N3RKJBBs3bsTvv/+OSZMm4ePHjyhevDgaN26s+NmEhIRg69atSEhIgK2tLb799lul4r9UqVIYMWIEpkyZArFYjPnz52c56FhGTk5ISMgxn0skEpUc2LJlS3z//fdYuXIlWrZsCQcHB5iamiI5ORnh4eE4e/Ys9u3bp+jCoI6XlxeWL1+OUqVKoWnTpihVqhQAIDU1FQ8ePMDu3bshk8nQqFEjlW1jYmIQGRmJW7duwdTUNNv4ST+JBL4DSHro48eP2Lp1Kzw9PWFra4t3797h0KFDOHnyJPbs2aN2FOmC6ty5c4iNjUXdunUhkUgQGhqKZcuWoVGjRpg4caKuw6MsxMbGomPHjoiMjMyx7caNG9G4cWOV5WfOnMH27dsREhKiNP1GmTJlUL9+fQwYMADOzs7Z7vvMmTM4fPgwbt26hdjYWMjlcpibm6NatWpo0aIFunbtqvYXjPDwcHTr1i3HaT/69u2L2bNn53iORETM3czd+kAul6NLly5KbxxkZcGCBejWrZvK8uvXr2Pjxo24fv063r17p1hesmRJ1KtXDz179sxx1Prg4GDs27cPwcHBiI6OhlQqhZmZGSpVqoTmzZujZ8+esLS0VNkuMTERbdu2xevXr7Pdf/PmzfHHH3/keI6U/1hgk15KTk7G1KlTcePGDURHR6NYsWJwd3fHpEmTULJkSV2Hp1VBQUFYunQpnjx5guTkZFSoUAF9+vRBv379dB0a5aPk5GSkpqbCzMxM7RMEIiJ9x9zN3F0YpaamKkYR1/RJPhVtLLCJiIiIiIiItICDnBERERERERFpAQtsIiIiIiIiIi1ggU1ERERERESkBSywiYiIiIiIiLSgyA1Va+oyVtchEBUODk66joCo0Eg6OErXIeiVOdWNdB0CUaFQ1oxjGRNpi/cNqUbt+ASbiIiIiIiISAtYYBMRERERERFpAQtsIiIiIiIiIi1ggU1ERERERESkBSywiYiIiIiIiLSABTYRERERERGRFrDAJiIiIiIiItICFthEREREREREWsACm4iIiIiIiEgLWGATERERERERaQELbCIiIiIiIiItYIFNREREREREpAUssImIiIiIiIi0gAU2ERERERERkRawwCYiIiIiIiLSAhbYRERERERERFrAApuIiIiIiIhICwx1HUBmCQkJCA4ORmRkJGJjY1GsWDGUKVMGDRo0gLm5ua7DIyIiKvKYq4mIiLKmFwV2UFAQ/vzzT9y/fx+1a9dG2bJlYWlpicjISJw5cwZTp05FrVq1MHToUDRp0kTX4RIRERU5zNVEREQ502mBHRUVhTlz5sDS0hIjR45E/fr1IRKJVNrJ5XJcu3YNAQEB2LhxI3x9fWFnZ6eDiImIiIoW5moiIiLN6bTAXrVqFaZPnw4HB4ds24nFYri6usLV1RXPnj3DypUrMXfu3HyKkoiIqOhiriYiItKcSBAEQddB5CdTl7G6DoGocHBw0nUERIVG0sFRug5Br8ypbqTrEIgKhbJmRerXfKI85X1DqlE7veiDDQBxcXG4cOECHj16hI8fP0IkEsHS0hIVK1ZEkyZNULp0aV2HSEREVKQxVxMREWVP59N0paWlYfbs2WjevDn27NmDuLg4WFlZwdLSEnFxcTh48CDatm2LadOmISUlRdfhEhERFTnM1URERJrR+RPsRYsW4e3btzh16hSKFy+utk10dDSmT5+OX3/9FbNmzcrfAImIiIo45moiIiLN6PwJ9pEjR/Drr79mmbABwNraGgsXLsSxY8fyLzAiIiICwFxNRESkKZ0X2FKpFGZmZjm2s7CwgFSqWcdyIiIi0h7maiIiIs3ovMCuX78+/P39c2zn7+8PFxeXfIiIiIiIMmOuJiIi0ozO+2DPnj0bw4YNw5kzZ9CiRQtUrlwZxYoVgyAIiI2NxbNnz3Dy5ElER0drlNyJiIhIu5iriYiINKMX82BLpVKcO3cOZ86cwYsXL/DhwwdIpVLF1B9NmzZF+/btIZFIvvhYnAebSEs4DzaR1hSEebDzM1dzHmwi7eA82ETao+k82HpRYOcnFthEWsICm0hrCkKBnZ9YYBNpBwtsIu3RtMDWaR/sWbNm4eXLl7na5vnz55g5c2YeRURERESZMVcTERFpTqd9sMeNGwdfX1+YmpqiV69eaNiwYZZtr169iu3btyMlJQU//fRTPkZJRERUdDFXExERaU4vXhEPCgqCv78/7t69izp16qBcuXKwsLBAXFwcIiIiEBISAicnJwwdOhRNmjT5omPxFXEiLeEr4kRaUxBeEc/PXM1XxIm0g6+IE2lPgeyDHR8fj+vXryMiIgJxcXGwtLSEvb096tevDwsLC60cgwU2kZawwCbSmoJQYGfIj1zNAptIO1hgE2mPpgW2zqfpyszCwgLu7u66DoOIiIiywFxNRESUNZ0OcvapnTt36joEIiIiygZzNRERUdb0qsBesWKFrkMgIiKibDBXExERZU2nr4i/fv0aaWlpis9yuRxhYWGKz3Z2dpBIJIiLi8OtW7fg4uKitf5dRERElDPmaiIiIs3ptMD+7rvvkJqaqvgsFovRp08fxed58+ahVq1a6N69O2xsbBATE4Pdu3fDxsZGF+ESEREVOczVREREmtOrUcTVWbp0KQRBgI+PD1atWoXU1FT4+Ph89v44ijiRlnAUcSKtKUijiKuj7VzNUcSJtIOjiBNpj6ajiOtVH+wMCQkJkMvlAIAzZ84o7pT36tULZ8+e1WFkREREBDBXExERqaOXBfa0adOwe/duAEBMTAxKly4NAChZsiTi4uJ0GRoRERGBuZqIiEgdvSuw//rrL4SHh6NLly4A0vt6ERERkf5griYiIlJPp4OcZfbu3TssXboUISEh8Pf3h5FRev8riUSChIQEmJubIzk5WbGciIiI8hdzNRERUfZ0WmC7uLjAxsYGVlZWePToEVxdXbF9+3al6T0aNWqEEydOoEuXLjh16hTq16+vw4iJiIiKFuZqIiIizem0wD516hSioqLw5MkTHDhwAEFBQVi7di0mTZoEkUgEAOjbty8GDRqEq1ev4vz58/D399dlyEREREUKczUREZHm9GqarpCQEEyZMgUuLi5YuHChYvn9+/cRGBgINzc31KhR44uOwWm6iLSE03QRaU1BmqYrP3I1p+ki0g5O00WkPZpO06VXBTYAxMXFoVevXujRowcGDx6s9f2zwCbSEhbYRFpTkApsIO9zNQtsIu1ggU2kPQV2HmxLS0usXr0a4eHhug6FiIiI1GCuJiIiUk/vnmDnNT7BzlsDOjXG8um9UKfzXLyM/KC0rm2zWpjQ3xOW5iYwMTbC+WuP4PO/XYr1U4e1Rs82DSAIAu4+eYWx83YgLiFZaR99O7hiaNemMDGWwFhiiO1HrmLRhn9Qp5o9/H7urxJPra/KwtZtEpKS0/LmhIsyPsHOcwNaVsfyUd+gzqjtePlG/bzCf8/viPKlLFFj+Fa1693r2OP4vI4YtvQ0tp5+qFjuWK44Vox2RzEzCQQIWLjzOg5cfqa0rYFYhCUjmqFVPQdUz2L/pB0F7Ql2XuMT7Pzh2n8s6nUfAkEQYCiRIOLf6zj5+3TEvXkFAKjY6Bt4fj8XxuaWEBsa4tL6Jbi5Z4NieyNTM7ScOB8VG7nDQCLBu9CHODxnDOLfvla0mX0nCW8e31U67qklM/H4/PH8Ockijk+w849T77Go3mUIIAgwMDLG23vBuLJ8OhLfvlK0Kd+sHer084GRhSUMJCaIDD6Li/+bAFObUmi78gjw/+NaZChesTr2ftcAMc8ewG36KpSq7aq03tSmFB4f2Yqry6flyzkWdZo+wdababqo4Js9uh3q1SyP6NgkGBoqvxwxqEsTDOzUBAOn/aUovDO3GdrtazSqXQlN+vwPqWlSTBzYEmtmf4d+U9cr2vw0uj2cqpZFz4nr8C46Xmkftx9FoHHvhcisYa0K+G1ydxbXVCDN7tsQ9b4qhej4FBgaiNS26e1eFYkpUhgZqH8ZyUAswvyBjXHudoRSG2MjA+ya0RajV55F4N1I2BU3xYkFnfE08iPuPE+/Ps1NDLFlSiu8/ZgEwyz2T0QF28PTh3F95zpIU1MgNjCA+5hZ+G7tAfzRtSFKVauFzr+sx9YRHfH2yT2YWFrhu7UHEBPxHM+CzgAAOs1fh7g3r7C2c30IggCnNt3RffFW/NW/heIYYkND+HV3hVwm09VpEuWLl+cP48HedZClpkBkYID63rPRZtkB7P2uIQDAsfMQOHYajNPT+yE+8gUAQGSYXoolfXijaJfBzLYsOm04j48vHgEAAheMUTlmmxWH8erambw8LfoMOi2wg4ODkZaWdfFTu3ZtWFhYIC4uDrdu3YKLi4vStCCkP0QiEV6/jUXX8Wtx79AcpXXFLEzw87iOaNhjAaLe//cUTiqVK/4+tJsbBs/4C6lp6XeGlmw6hQdHfGFjZY4PHxNQpbwtBnRqjJod5iAlVap2H58a1r0Z1u+9qKUzJMo/IhHw+kMius49int/fKe2jYWpEX7oXg/Dl57Crhlt1bYZ27EO/r7+Eg62yt+bLV0cEBL6DoF3IwEAUTFJWHbgFga2rIHJf6ZfM8XMJNhy6iGuPX4DT+dyWjw7KmiYqwuvmIjnir/LZTKcXeEL1/5jYVmqDBr08kbQxuV4++QeACA57iNO/DoVTYf44FnQGZjb2KJSYw/83swBGS9D3j2+Gy7dBqFUVSeVp9ZEhV3cq+eKvwsyGYLXzkGt3mNhVrIM0pIT0GjcfOzuWRdJ76P+ayfN+olo9S5D8ejwFghy9b/rWpatiOIVqiE86B+tnQNph04L7MWLF0OW6Y7mvXv3ULNmTQDpBdu0adNgb2+P7t27w8bGBjExMdi9ezdsbGx0FTJlQRAE+O26oHZdGzcnnL/2WKm4zszGyhxlS1nh4bNMXziCgKCQUDRvWA17T95El5Yu2HH0mlJxnR0rC1O0+romfBYG5P5kiHRMEAC/Y9n/cjqjdwOs//se3selqF1f2toMA1pWh9vEPVg2qpnSOk9ne1y480pp2YU7kRjToY7ic+SHROy5+BTlS1l+5llQYcFcXXQYmZoBgoDE6PewKV8ZTy4ov8b95sldlK3VAABg7VAZH1+9VHky/ebJPZSt3YAFNhV5hiZmECAg+eN7VPLsglfXzioV19kRicVw7DgQh4Z7ZtmmetdheHhwY/ovDaRXdFpgb9u2Temzm5sbdu7cqbRs6dKl6NSpE3x8fLBq1Sps3LgRPj4++RkmfaHa1ezx8HkUpnu3RQePOpDLBRw9fwe/rT+B1DQpSpcshoioGJXtwl9Ho1K5EgCAOtXsceH6Yyya3A1u9asiLU2K7UevYfX2c2qP+V37Rjh09jYSk1Pz8tSIdMKxXHF4OJfD1xN3w76k+ieFCwY3wa8BN5Ck5qZUGRtznLqlPDhV+Nt4VLIrlifxUsHGXF002H5VE9/+8AvOrpoHWVoqEj68g7VDZaU2NuW/gkVJOwBAwoe3sCrjAJFYrPSEzaZ8FSR+eJuvsRPpG+vKNeE6YSFu+M2FPC0VJao5I+b5Q9TznoWKzTtCEOR4ef4Ibq5fCHma6u+qDm5eiHn+EPGRL9XuX2RoiKrt+mH/gKZ5fSr0GfSyY93Lly8RGZn+6uKZM2fQp08fAECvXr1w9uxZHUZGn8PGyhyDOjdBaPg7fN33V3w7dCkcK9lh2fSeAIDilqZISVV9/TA5VQpTE4liHxP6tcDfF++hce+F6DxuDTp6OOPH4W3UHnNot6+xga+HUyG12LsZZm4Mgkyu/q711zXLoKKdJXaef6x2vZW5MZLTlJ86JadJYWrMYTlIc8zVhcO3kxfihwthGHM4BHFvInFl03IAwM29G9B4wDjYVkmf09yyVFl4TvBVFNPRYaF48+QePMbPgdjQECKxGM6d+sHBpQlEYuVfL/utO4JRB29i2M6LaDxgPEQi9eNKEBV0rt//D/1OhKPH7ttIePsK/25Lv56MrWxQvfNgxIY/xb5+rjg01APFKzrCbdpKtfup2c0bD/b+meVxKjbvhPcPbykNoEb6Q68K7Lp16wIA5s6dq0jOMTExKF26NACgZMmSiItT/5ox6S+5XEDgjSfYcfQa5HIBicmpmLBgJ3q3bQhjiSFSUqUwlqiOGGtqbITklDTFPvaevIl/Lt0HALyPScDU3/diSBfVO3dN61ZGSqoUN++H5e2JEelA168rIylVipM31f//FotFWOT9NX5Yl/UNppQ0GUyMDJSWmUoMkaxhFwwq2pirC5d/fvsRi5o54H+N7SBNTUanX/wBAM+vnMMR33FoO3MpRh24ga6//oVLGxYjJT5Wse3Osd1hZGKG4QGXMXJfMEpWqY7bB7chKSZa0WaRWzlsGtIGazq6YPfE71Dj285w856S7+dJlB+uLJ2KLa3KYaNHKchSk9F8Tvr1BEGOyBsX8OToNghyOaTJiQj8ZSy+avsdDCTGSvswL+2AEo7OeH7+UJbHqdHNG/ezKcBJt3T+uMLLywvFixfHiBEjsHLlSgQGBiI8PBzdu3cHAIjFenUPgD7D2+g4RL2PVVoWHZuIhKRUWFmYIuJNDBzKWKtsV660NW4/ikjfx4c4PH7xRmn907C3KGmt+nrs0G5u2LDvkhbPgEg/GBmK8fOAxug050iWbYa0qoHboe9x40nWr2hGvI9XGfisXEkLRLxP0FqsVLgwVxd+STEfcHy+D3689g7HLIohJT4WTwJP4EngCUWbsrWU+1Ynx33E3wt/UNrPd2sP4P6JfYrP8e/+63MaE/ECp5bMQtsZS3Dhj//l4dkQ6VbKxw+49JsPBp17D6PfvkfSh7dI/KT/dUpsNKRJCZBYWCHpw3+/49boMgyPj2zNcgC0Yg5VULxCNYQFHs3Tc6DPp/MC+82bN+jbty+mTp2KZs2a4ebNm1i+fDmMjNKfaEokEiQkJMDc3BzJycmK5VRwXL/7Ev07KM/bZ2NlDgMDEd58SH/KkZCYguqVS+NBaPrcmSKRCE3rVsbsFQfT93HvBWpVLau0j6/K2+Jp2DuV/bb6uia+5+BmVAhZmhpBYijG1qmtFMskhmLYWpkiaGkP/LrrOhxsLdHI0Q5BS3so2jjYWqB5HXv0/OYreM06hKAHUWjboDz+OPrfL8rNapVF0P3XIFKHubpoMJAYw8BIArGBgdr19XoMwb1MxfOnipUuh1JVnRB263KWbUQGYshlfFuGCj8DiTHERhKIxQZ4e/caqnUcqLTe2MoGIgMDpeJaZGAAx06Dsh3crEY3bzw6tCnL0cVJ93R+y9nExAR9+/bFsWPH8OrVK1SuXFkxOikANGrUCCdOpN89PXXqFOrXr6+rUOkznbh4DzW/KosOzdNHKJYYGWLptJ5KA5St3n4O8yd0hpFhelL3GdACtx9F4HnEewDAzmPB6NrSBa51KgFIn/pr4cSuWLH1tNKx+nVwxZFz/yIuITk/To0oX32IS0G1oVvQ+Ptdij+dfz6Ktx+T0Pj7Xdh7MRQ/bb4ClzE7lNocufocC3Zch9es9NfN9l18iobV7ODmVAYAYFfcFN93ccYfR+/o8vRIjzFXFz4GRkYoZmev+GxiaYUuC9fj3t97kfQxWqVtk0Hfo0xNF9zcs16xPHNf6xKVqqH3qj048esUxS/+RiamMLMuqWhT3L4CWk35FTf3/JVHZ0WkG2JDI5iX+u96klhYobnvBjw7tQcpsdEIu/Q3rKs4oULzjuntjSRw+3EF7mxX7oNdwb0DYl48QmzY0yyPU7VdPzzYv17tetIPOn+CncHa2hr+/v4YPnw4Nm7ciIED0+/y9O3bF4MGDcLVq1dx/vx5+Pv76zhSyklqmgxS6X8DKKVJZej+/R9YObM35n/fGWKRCPtO3cQCv2OKNiu2noGNlTmu7pwGuSDg4bPXGD57s2L9+5gE9P9xPX6f2gMWphKIRCKs33sRmw4EKR17QKfGGOW7Ne9PkiifpErl2c73LpPJkSbL/i52mlS5TWKKFN3nHcOyUc1gbmIEsUiEeduCce3RG5VtpVI5Uj4ZEI2KLubqwsPM2ha9V++FxNQM0pQUCHI5/j2yHUGbVgAASlV1QpeFGwAAYkNDhF4+jc1D2kCWaU50r5nLULZ2AxgYSZAcG43TS2YpvVJuUswa3609AANDQ8hlMqSlJOHKphW4fUh5ZHqigs7E2hatluyFkYk5pKnJgFyOJ8d34N/t6YOcyaVp+NunC5rNWAPXCQshEovx7ORe3Fg3V2k/1TsPxb2ANVkep6JHJ7y9F4z4yBd5ej70ZUSCoNvJ09zc3BAYGKj4/ObNG/To0QN//vknqlatCgC4f/8+AgMD4ebmhho1anzR8Uxdxn7R9kT0/xycdB0BUaGRdHCUrkPIVn7n6jnV+Yo5kTaUNeMcyUTa4n1Ds+4tOn9F/FOlSpXCpEmT8OuvvyqW1ahRA8OHD//ihE1ERERfjrmaiIhIPZ0X2Nu3b1dZ1rFjR4jFYnz48EEHEREREVFmzNVERESa0XkfbAcHB7XL//jjj3yOhIiIiNRhriYiItKMzp9gExERERERERUGLLCJiIiIiIiItIAFNhEREREREZEWsMAmIiIiIiIi0gIW2ERERERERERaoNNRxENCQpCampqrbYyMjFC3bt28CYiIiIiUMFcTERFpTqcF9vLly3OdtCUSCfz9/fMoIiIiIsqMuZqIiEhzOi2wmXyJiIj0G3M1ERGR5nRaYPv5+X3WXXFvb+88ioiIiIgyY64mIiLSnE4HORMEQWXZ+vXrdRAJERERqcNcTUREpDmRoC5z6pCbmxsCAwMBAHK5HAEBAejVqxdEIpFW9m/qMlYr+yEq8hycdB0BUaGRdHCUrkPIlbzO1XOqG2llP0RFXVkzvfo1n6hA874h1aidzqfpioqKQkxMjOKzjY0NAEAqlWLy5Mm4efOm1hI2ERER5R5zNRERkWZ02gcbAAYMGIDw8HC4uLigU6dO2LNnD0JDQzF16lQ4OztjxowZug6RiIioSGOuJiIi0ozOC+yEhAScOXMGZ8+exZEjR7BkyRIkJiZi3rx5aN++va7DIyIiKvKYq4mIiDSj81fEAaBUqVLo2bMn/vrrLyxfvhxVq1bFiRMnkJycrOvQiIiICMzVREREmtCLAjuzBg0aYMeOHShVqhR69Oih1OeLiIiIdI+5moiISD29K7ABwMDAADNnzkSnTp0wcuRIpKSk6DokIiIiyoS5moiISJXOC+xff/01y3XDhg2Di4sL9u7dm48RERERUWbM1URERJrRu3mw8xrnwSbSEs6DTaQ1BW0e7LzGebCJtIPzYBNpT4GZB5uIiIiIiIioMNDpNF1Xr15Famqq2nX169dHQkICHj9+DEEQULVqVdja2mLNmjUYNYp3+omIiPIDczUREZHmdFpgr1q1CmlpaSrLRSIRfH19MX36dAiCAJFIBLlcjt27d2P//v1M2kRERPmEuZqIiEhzOi2wN27cmO36mJgYnDhxAgDQokULAEAR6zJORESkU8zVREREmtPrPtgikUjXIRAREVE2mKuJiIj+o3cFtp+fH27cuAGAd8CJiIj0EXM1ERGRenpVYD99+hSbNm1CxYoVdR0KERERqcFcTURElLXPLrB/+eUXjdplNfLop168eIHRo0dj9uzZsLGx+dywiIiI6P8xVxMREeWvzyqwZTIZNm3alGO7W7duwdPTM8vEvWDBAqxZswarVq1C3759MXr0aLRq1UqxXl2/Lvb1IiIiyhlzNRERUf7Ls1HEX758iQkTJsDHxwcSiURtGxsbG0RERCAwMBDm5uZwdHRUWp+5X1d8fDymTZuGmJiYvAqZiIioSGGuJiIi0i6NC+xatWpBJpMpPguCgBo1aig+T5kyBV26dMHVq1cRFhaGDRs2YNSoUejWrVuW+xw5ciQAQC6X49ChQxg2bBh+++03NGnSBAAwevRoRdvff/8dL168QLt27TQ/OyIioiKEuZqIiEi3RIKGw3++ePEi2z5aZcqUQXh4OH744Qe8fPkSDRs2xO+//47ixYtrHExISAjGjBmD7du3w8HBQePtcsPUZWye7JeoyHFw0nUERIVG0sFRWtlPYcnVc6ob5cl+iYqasmYc5Z9IW7xvSDVqp3GBnRsxMTFYu3YtDh8+jD///BPVq1fXeNuAgADcu3cPc+bM0XZYAFhgE2kNC2wirdFWgZ0b+pyrWWATaQcLbCLt0WmBnWHHjh1YsWIF9u3bh1KlSmm8nUwmg4GBQZ7ExAKbSEtYYBNpjS4K7Az6mKtZYBNpBwtsIu3RtMDWuA/2Tz/9hPfv36Np06bo2LEjLCwsVNpIpVKcP39eMeCJra0t6tevj6ioqFwl7bxK2ERERIUZczUREZFuafwE28nJCf3798f169cRFhaG2bNnw8vLS6lNTEwMxo0bh+DgYNSrVw9isRgJCQmIiIjAlStX8uQEcotPsIm0hE+wibRGW0+wC0uu5hNsIu3gE2wi7dH6E2yZTIaJEydCIpHg9OnTmDFjBl69eoVhw4Yp2hQvXhybN29G9erV8eeff8LU1BQpKSlwdnbO/RkQERFRrjBXExER6ZZY04YikUjxd09PT2zZsgXr1q3DyZMns20rEomUPhMREVHeYK4mIiLSLY2fYH+qSpUqWLhwIaZNm4aGDRvCysoKqampuHXrFgDg+vXrMDY2xsePH5m0iYiIdIC5moiIKH99doENAB4eHmjUqBFWrlyJGTNmICoqCgsWLICjoyMWLVoEIP2ueIcOHbQSLBEREeUOczUREVH+0bjAzmostAkTJqBbt24YOXIkHBwcsH//fm3FRkRERLnAXE1ERKRbGvfBPnbsGCQSicryKlWqYPLkyZDJZFoNjIiIiHKHuZqIiEi3NH6CXalSpSzX9e3bVyvBEBER0edjriYiItItjZ9gExEREREREVHWNH6CPX/+fKSlpeX6ABKJBNOnT8/1dkRERJQ7zNVERES6pXGBbWtri9TU1FwfQF1fMCIiItI+5moiIiLd0rjA9vb2zss4iIiI6AsxVxMREemWxgX2nDlzkJKSkusDGBsbY86cObnejoiIiHKHuZqIiEi3NC6wK1asqPLa2ZIlS/D9999DJBJlfQBDjQ+RL6KvrdR1CESFwubrL3QdAhF9orDk6jk3InUdAlGhID8+W9chEBU5IkEQhM/duEaNGrh79y7E4vTByG/evAkLCwtUrVpVawFqW7JU1xEQFQ4ssIm0Z7hrhTzbd0HM1Uh8p+sIiAoFFthE2iPuulqzdrnZqbpaPOOO+NWrVzFq1ChERvKuMxERka4wVxMREelOrt4Ja9GiBQwMDNC2bVv06NEDFy9ehEgkwvr167Fu3TosWrQIbm5ueRUrERER5YC5moiISHdyVWC/evUKP//8My5cuICOHTvCw8MDT548gYmJCXbs2IEKFfLuFTciIiLKGXM1ERGR7uTqFXGRSITOnTtjxYoVOHv2LOzs7PD8+XO0adOGCZuIiEgPMFcTERHpTq4K7MysrKwwdepUHD58GIcPH8aECROQmJiozdiIiIjoCzBXExER5a/PLrAzlC9fHtu2bYMgCBgxYoTK9CBERESkW8zVRERE+SNXBbaxsbFimo/MTExMsHTpUlhaWsLHx0ftCKZERESU95iriYiIdCdXBfbNmzdhaKh+XDSxWIylS5eiTJkySEhI0EpwRERElDvM1URERLqTq1HEM+bRzIpEIsHMmTO/KCAiIiL6fMzVREREuqNxgX306NFs+2y1aNECERERePjwIQCgevXqcHR0xNixY7Fy5covj5SIiIiyxVxNRESkWxoX2Lt27UJKSoradWKxGM7OzhgwYAAqVqwIuVyOyMhIXLx4ESdPntRasERERJQ15moiIiLd0rjA3rBhQ45tEhISEBAQAACoVavW50dFREREucZcTUREpFtfPE1XZjn1+yIiIiLdYq4mIiLKO19cYG/btg3R0dEAwCk/iIiI9BBzNRERUf74ogL72rVrWLJkCZM1ERGRnmKuJiIiyj+fXWCHh4dj4sSJmDZtGmxsbLQZExEREWkBczUREVH+0rjA/vjxI+RyOQDg3Llz6NmzJ3r16oWuXbsq2rBfFxERke4wVxMREemWRqOIy2QyNG7cGIaGhihVqhRevXqFn3/+GT169Mh2u+zm4lQnNDQUQUFBiIyMxMePH2FlZYUyZcrA1dUVVapUydW+iIiIihLmaiIiIt3TqMA2MDDAxYsX8erVK4SEhGDXrl1Ys2YNHB0dUadOHbXblCxZEs7OzihTpky2+5bJZNi3bx82bNgAIyMj1K9fH2XLlkX58uXx8eNHPHnyBNu3b4dcLsegQYPQpUsXGBpqPLsYERFRkcBcTUREpHsi4TNHPdm2bRt+//13/PHHH2jQoAGA9L5e5cqVAwAkJiYiOjoa1tbWMDMzU7uPe/fuYeHChahfvz66d+8Oe3v7LI8XFhaGXbt24caNG5gxYwZq1KjxOWEjWfpZmxHRJzZff6HrEIgKjeGuFfJkvwU1VyPx3edtR0RK5Mdn6zoEokJD3HW1Ru0++/byd999B0tLS4wZMwb79+9HmTJlFAkbAMzMzLJM1hn++ecfrFq1CpaWljkez8HBARMnTkRMTAw2bNjw+UmbiIioiGCuJiIiyl+f/QQ7w/z581GmTBkMGTJEWzHlKT7BJtIOPsEm0p68eoKdoaDlaj7BJtIOPsEm0p48f4KdYcaMGV+6CyIiIspDzNVERET547PnwSYiIiIiIiKi/7DAJiIiIiIiItICnc+h4ezsDJlMlmM7QRBgbGyMGzdu5ENURERElIG5moiISDM6L7C7deuGly9fwtfXN8e2RkZG+RARERERZcZcTUREpJkvHkX8S8nlcowZMwa1atXCmDFj8vx4HEWcSDs4ijiR9uT1KOJfKr9zNUcRJ9IOjiJOpD2ajiKu8z7YYrEYS5YsQeXKlXUdChEREanBXE1ERKQZnRfYAGBiYoK2bdvqOgwiIiLKAnM1ERFRzvSiwCYiIiIiIiIq6HRaYM+aNQsvX77M1TbPnz/HzJkz8ygiIiIiyoy5moiISHM6HUV83Lhx8PX1hampKXr16oWGDRtm2fbq1avYvn07UlJS8NNPP+VjlEREREUXczUREZHmdD6KOAAEBQXB398fd+/eRZ06dVCuXDlYWFggLi4OERERCAkJgZOTE4YOHYomTZp80bE4ijiRdnAUcSLt0fdRxIH8zdUcRZxIOziKOJH2aDqKuF4U2Bni4+Nx/fp1REREIC4uDpaWlrC3t0f9+vVhYWGhlWOwwCbSDhbYRNpTEArsDPmRq1lgE2kHC2wi7dG0wNbpK+KfsrCwgLu7u67DICIioiwwVxMREWVNL0YRT0tLw+HDhwEAT58+xcOHD3UcEREREWXGXE1ERJQzvSiw4+Pj8ccffwAAbty4gStXrug4IiIiIsqMuZqIiChnOi2wo6Ki8OrVK0RFRUEqlSIyMhIfP37Ex48f8erVKyQkJAAAkpKScPnyZcTGxuoyXCIioiKHuZqIiEhzOh3k7JtvvkFaWhrUhSASidC/f38MHDgQXbt2haGhIRISEhAQEIBSpUp99jE5yBmRdnCQMyLt0edBznSRqznIGZF2cJAzIu0pkKOIZ0hMTAQAmJmZYcuWLQgNDcXs2bPh5+eHuLg4TJo06bP3zQKbSDtYYBNpjz4X2FnJy1zNAptIO1hgE2mPpgW2XvTB/tTGjRuxb98+AMDZs2fRo0cPAED37t1x7tw5XYZGREREYK4mIiJSR+fTdEVGRiIiIgIAUKFCBdja2qJMmTK4e/cugPS+XxUrVgQA2NjYID4+XlehEhERFUnM1URERJrReYHduXNnlCtXDlKpFHK5HIcOHUK5cuVw+vRpAEBqaiqMjIx0HCUREVHRxVxNRESkGZ0X2CYmJtizZw8AwM3NDQBQunRpREdHAwCsra3x/v172NnZQSqVwsDAQGexEhERFUXM1URERJrReR9skUiksqx48eJITk4GANStWxeBgYEAgCtXrqBmzZr5Gh8REVFRx1xNRESkGZ0/wVbHxMREkbS7deuGgQMH4t69ezh9+jQWLlyo4+iIiIiIuZqIiEiVzp9gZyaXyyGXy5GWlobU1FQAQNWqVbF8+XIYGxvD19cXrq6uOo6SiIio6GKuJiIiyprOn2CbmZkp/l68eHE4OTkBANzd3RXLGzRogAYNGuR7bERERMRcTUREpCmRIAiCroPILONuuEQiyZP9J0vzZLeUjX17d2P+z3Nw4Mhx2NuXUywPffoU837+CfFxcYBIBO+Ro9Hy21aK9dHRH7Do14V4+OA+UlJS4excF9NmzoK5uYWizYm/j2GD/zqkpqZBJALGjvdBcw/P/Dy9Imvz9Re6DqHISEtNwdXDOxF6KwiCXIA0LRUtB45F+ZouAIDQkKu4engnUpMSIZNJUb5GXXzTexiMJMYAgAu71uPJjcsQicWQpaWhQq16aNZ9MIzNzAEAL+/dwvkAf0jTUiGXyWBR3AZu3QahbFX2o80vw10r6DqEXMnrXI3Ed3mzX8rRuQuXsH7LDnyIjoEgl6Ne3TqYNmk8TE1NAAA1G3yDqlUqKW0zcewIuDdrCgBYve4vbN25ByVL2CjWlylth7XLfs2/kyAF+fHZug6hyNkT/Aq++x/g2KQmsLc2VVp35v47/BX4AvHJMqRI5XCtbI1ZnRzxLi4F3htu4dOiLPRtIvaOa4Qqpcxx5ekHLD7+FMlSOWRyOWwtjTH+2ypwqWCVfydXxIm7rtaond4V2HmNBXb+Wrl8Ke7dvYMH9+/jr83bUL5C+i+RKSkp6N6lI37ynYsGDRvh3du3GDKoHxYtXoZqjtUhCAIG9O2N1m3aot+AQQCAv9b/iUePHmLBwt8AABcvnMfvi37Fmj/+hF3p0oh6/RqjRw7Hb78vReUqVXR1ykUGC+z8IZfJEPC/qShfwxmN2veCoZEEgiBAkMshNjBAxOO7OO63CN2nLoRVSTtI01JxatMqiA0M8O2g8QCA6NcRsLItDbGBAdJSknFq0yokJ8Si8/e+AIDE2BiIRGKYWhYDADy5cRnH/H7D4F/WwcK6hM7OvSgpaAV2nmOBrTPXrt9CeQd72JWyhVQqxdTZ81CqZElMnTgWAODo8jXuXjsHQ0P1L0GuWOsPqUwGnzHe+Rk2ZYEFdv5aduIp7kbE4f6rOGwZUR8VSv739s+uaxHYGxyJRb2dFIV3mkwOIwP1PXajPibju7XXcWJyUxiIRfgQnwqRSARr8/QpEU/fe4tpu+7hkE9jlCpmnPcnRxoX2HrVBztDv379dB0CaYFcLoetrS1WrP4DxsbKF/7li4GoXqMGGjRsBAAoaWuLAQOHYP/e9Glg7t75FynJyYriGgAGDh6Khw8eIDY2FgCwfdsWjB3/PexKlwYA2JUujWHeI7Fv7+58ODui/HH34kkYm5qjaZf+MDRKf1ooEokg/v9pkMLuh6By3UawKmkHADA0ksDZox0iHt9V7MO6tL2ivZGxCb7pPQzPbgcr1psVK64orgHgq3pNYF/VCWH3Q/L8/KjgYq4unBrWrwu7UrYAAENDQwwb+B0Cg67qOCoi/SeXC7C1NMaagc6QGCqXWHHJUiz5+ymW96ut9FQ7q+IaAHZfe4VO9UrDQJw+i4ONhURRXAOAZ01buFSwwtXQaC2fCX0pvSywnz9/nuW6jNfSSP+JxWL06tNX7XyoQUGX0aBBQ6VlDRo2xOXLlwAAYWFhcCiv/ERHJBKhQoWKeHD/3v+3eQmH8uWV2nz11Ve4e+dfbZ4GkU49DDoLZ892Wa4v+1UNPLx6AbHv3wAAZNI0BB3aBgfHOlluk5IQD/PiNlmuB4DkxDhY2JT8vKCpSGCuLhpiPsbBOK+6AhAVImKxCN81KacoiDM7/+AdXCtbw9ZSsyfNMrmAvdcj0a1B2WzbxSZL+fRaD+l0kDMfHx/I5XLF56pVq2Ls2LFKbRYuXIjHjx+jWbNmGDRoENq3b48TJ07kd6ikZW/fvEHjJk2VltmVLoOI8DAAgI2NDcL//++Zhb18gffv3wMArK1tEBEWhqpVqynWv3z5Eu/f89VCKjzehIXC0EiCA8t/RnRUBEwtiqFRu56oVCf9BlX5mi5w9myHzbPHoE5zLzy9eRlWtqXxTe9hKvsS5HK8fvYIZ7athXvv4WqPFx/9Hjf+2Q8zSys4VM+6SKeig7m6aNuxez86t2+j6zCICrQHr+NRydYMq06G4tS9txCJRPCoURLezSuqPO0GgPMP36GyrZlKH+4Mb2JTsOVSGGzMjdCosnVeh0+5pNMn2B4eHmjevDmuXr0Kd3d3bN68WaXN0aNH0aNHD+zcuRMAIJWyE3VhEBcXq/LauLGxMVJSUiAIAurVb4CkpEQE7NyumA7Gf90fiIqKgvD/v+h17dYDa9eswuvISADAs9Cn2PTXesjlRWpYASrkkuNjEXRwG9y6D8Kg+X/As+8onFi/FC8zvb5d3bU5rO3sceXQdsRHv0dt97aKAc4yHF69AKvG9MDWnyegYq36cGz0jdL6B1fOwW9if/zxfV+E3Q9BqyE++XJ+pP+Yq4uuC5eu4MHDx+jZtaPS8mFjJqFDj/7o0X84/tq6U+kGjEgkwvETp9FzwHC07fodvp86C0+ePsvv0In0SkxiGvYER8KhhCl2jW2EzSPqI/RtAnwPPFDbfseVCPRoZK+y/NjtKLT89SI8FgbiSmg0fu5SI69Dp8+g0wK7Y8eO6NKlC8zMzNC1a1eYmqrepbGwsECbNm2Uvryp4JNIJEhJSVFalpycDIlEApFIBCMjI6xbvwn37t5Br26d0bdXdxgaGsK1SRNYWaWPltixcxf0HzgIUydPRLfOHbB40W8YOHioYj1RYSASidHQqydKlE3vDmFbvjLqt+mKO+f/BgBEPX+Mrb7jUaFWPYxauRMt+o/BqU0rELh7g9J+2o+ejrFr9mDEki14F/ECF/duUlpf3dUd3os3Y8KfB1HbvS0CFk6BlK/5Epiri6rI11GYPfd/WLTgJ6XR4gP/OYi//liGQ7s2Y8n/fsY/p87Bb8N/N10GftcTB3ZuRMCmdTgUsAnffN0Yg0d9j5iPsbo4DSK9IBYBDSoWR0eXMjAQi2AmMcDsTtVx+FYUUtJkSm1fxSTjQWQ8PGqodtNqW8cOJ6d8jZs/e6B7w7IY9OcNle1J9/SyDzYVfqXsSiuePGeIeh0JO7vSis92dnaY8/N87Np3EAF7D2Dg4KF48vgxvsr0Sni79h2xcct27Nl/CCtWr4VUmoavqlbNt/MgymtmxaxgXUb5Lra1XVkkxsUAAIKP74HLt53wddcBMC9mjRpNPdFr2iJcPbILaakpKvuztLFFywFjcfOfA2qPZ2gkQZ3mbWFZohSe37mu9fMhIv2XmJSEMROnYcIYb9R2Un5CZlvyv5kFypUtA59xI/D3ybOKZZaWFjAxSX+DxtDQEF07tkOVShVx/SYHTaSiy8ZcgoqZRhQHgOJmRjA1EiPukymOdl2NQEeX0tkOgCYxFKNHQ3uUKW6Ci48/5EnM9Pl02gc7OxMmTEARm0GsSKlb1wUXzp9F7+/6KpYFB1+Ds4tLltuE3LoJMzMzxajh6uzdvRv9BgzQaqxEulS6kiPehT1HcdsyimXRryNgXSq96E5NSkQJe+UBAa1KlYGhRILUpESVV8UBICUpAYKQ/ZPG1MSc2xAxVxc+MpkME3/8Cc2+bqxR32u5TK52MFOlfcplMMyhDVFhVrtcMey7ofxgKTohDXIBKGHx3xsiUpkce69HYtPwehrtNz5ZCvaM1D96+wQ7o88XFU4tW7XGv7dvI/ha+tQf796+xaYN69Grz38Ft0z23ysvt2+HYPbMaZg8dZpiWeZXERMTE/H7b/+DRGIEt2bu+XAGRPmjbosOuLBrPRJi0u9Qv494iRv/HEDdlh0AALXd2+LKoe2IeZueuOVyGYIObEXZqjVhbmWN1KREJMbGKPYXH/0ef/svgUvL//pUZmwLpM+7ffVIABJjY1CxdoN8OEMqyJirC5/5vy2FsbExvh+tOhBiUlIyPnz4b0qg8FeR+N+SlejW6b+ZDiJfRyluushkMmwN2IvI11FwbVg/74Mn0lNu1Urg8et4nLz7FgCQKpVj7sEH6Ne0HESi/0YdP33/HSqVNFOaPztD+Ickxd+lMjn+PPcC7+NT4VYt+1lBKP/p7RPszp07AwD+/PNP3QZCWmFoZARDo//+u5mZmWHZyjVYMHcOEhMTIRcEjBozDnXqOCvaTPp+HN5ERSElNRWlS5fGvAW/onad/0Y1vnzpIlYsW5JeaAsCPFt+i0VLlufreRHltQq16qF+667YMX8SRGIRjIxN8O2g8Yo+2V/VawJBLsPRNf+DNDUFckEO+69qov2o6QCA6KhXOLbuN8hlMhgaGkFsaAhnj3ao9U1rxTHObl2LdxEvYCQxAUSAfbVa6D1rsdqn30SZMVcXLh9jY7F1515UqlgenXsPUiwXiUT4c9ViyGQyjBg/GVKpFAYGBjAxNsaA73qiU7v/vk/2HjyKQ8dOQGIkgQABdZxqYPO6lYrXxomKAiMDEQwN/iucJYZirB7gjJ/2P8CiY48hCECr2qUw2rOS0na7r71Cn8aqg5sBwMIjj/A4KgGmRgYQiYB6FYpj68gGMDHi2yH6Rm8L7KxkvstDBceho3+rLHOsXh0bt+7IcpulK1Znu8+v3Zrha7dmXxwbkb6r07wt6jRvm+X6qg3cULWBm9p1dhW/wqD5f2S7/87f+35RfESfYq4umKyKFcPDmxezbbN/x1/Zrh/jPRhjvAdrMSqiguf4D01VllUuZY7N3tm/yeE3uG6W61b2d85yHekXnRbYY8aMgUwmw/v37zFy5EjEx8ertMl4zSg2NhYzZ85U24aIiIjyBnM1ERGR5nRaYHft2hVSqRRdunSBSCTC2LFjVdqMHDkSALB48WKEhoaiXbt2Km2IiIgobzBXExERaU4k6OHwn25ubggMDMyTfX8yEj4RfabN11/oOgSiQmO4a4WcG+mZvMzVSHyXN/slKmLkx2frOgSiQkPcNfvuq4p2eRzHZxk4cKCuQyAiIqJsMFcTERGp0ssCe/hw1akhiIiISH8wVxMREanSywKbiIiIiIiIqKBhgU1ERERERESkBSywiYiIiIiIiLSABTYRERERERGRFuh0HuyQkBCkpqbmahsjIyPUrVs3bwIiIiIiJczVREREmtNpgb18+fJcJ22JRAJ/f/88ioiIiIgyY64mIiLSnE4LbCZfIiIi/cZcTUREpDmdFth+fn6fdVfc29s7jyIiIiKizJiriYiINKfTQc4EQVBZtn79eh1EQkREROowVxMREWlOJKjLnDrk5uaGwMBAAIBcLkdAQAB69eoFkUiklf0nS7WyG6Iib/P1F7oOgajQGO5aQdch5Epe52okvtPOfoiKOPnx2boOgajQEHddrVm7PI4jR1FRUYiJiVF8trGxAQBIpVJMnjwZN2/e1F7CJiIiolxjriYiItKMTvtgA8CAAQMQHh4OFxcXdOrUCXv27EFoaCimTp0KZ2dnzJgxQ9chEhERFWnM1URERJrReYGdkJCAM2fO4OzZszhy5AiWLFmCxMREzJs3D+3bt9d1eEREREUeczUREZFmdP6KOACUKlUKPXv2xF9//YXly5ejatWqOHHiBJKTk3UdGhEREYG5moiISBN6UWBn1qBBA+zYsQOlSpVCjx49lPp8ERERke4xVxMREamndwU2ABgYGGDmzJno1KkTRo4ciZSUFF2HRERERJkwVxMREanSeYH966+/Zrlu2LBhcHFxwd69e/MxIiIiIsqMuZqIiEgzejcPdl7jPNhE2sF5sIm0p6DNg53nOA82kVZwHmwi7Skw82ATERERERERFQY6nabr6tWrSE1NVbuufv36SEhIwOPHjyEIAqpWrQpbW1usWbMGo0aNyudIiYiIiibmaiIiIs3ptMBetWoV0tLSVJaLRCL4+vpi+vTpEAQBIpEIcrkcu3fvxv79+5m0iYiI8glzNRERkeZ0WmBv3Lgx2/UxMTE4ceIEAKBFixYAgCLWZZyIiEinmKuJiIg0p9d9sEUika5DICIiomwwVxMREf1H7wpsPz8/3LhxAwDvgBMREekj5moiIiL19KrAfvr0KTZt2oSKFSvqOhQiIiJSg7maiIgoa3pTYL948QKjR4/G7NmzYWNjo+twiIiI6BPM1URERNnT6SBnCxYsgLW1NeRyObZv347JkyejVatWivXq+nWxrxcREVH+Ya4mIiLSnE4LbBsbG0RERCAwMBDm5uZwdHRUWp+5X1d8fDymTZuGmJiYfI6SiIio6GKuJiIi0pxOC+yRI0cCAORyOQ4dOoRhw4bht99+Q5MmTQAAo0ePVrT9/fff8eLFC7Rr104nsRIRERVFzNVERESaEwl6NPxnSEgIxowZg+3bt8PBwSFPjpEszZPdEhU5m6+/0HUIRIXGcNcKug5BY/mRq5H4Lm/2S1TEyI/P1nUIRIWGuOtqzdrlcRy54uzsjPHjx8Pf31/XoRAREZEazNVERERZ0+kr4ur07NkTMplM12EQERFRFpiriYiI1NOrJ9gZDAwMdB0CERERZYO5moiISJVeFthEREREREREBQ0LbCIiIiIiIiItYIFNREREREREpAUssImIiIiIiIi0gAU2ERERERERkRawwCYiIiIiIiLSAhbYRERERERERFrAApuIiIiIiIhIC1hgExEREREREWkBC2wiIiIiIiIiLWCBTURERERERKQFLLCJiIiIiIiItEAkCIKg6yCIiIiIiIiICjo+wSYiIiIiIiLSAhbYRERERERERFrAApuIiIiIiIhIC1hgExEREREREWkBC2wiIiIiIiIiLWCBTURERERERKQFLLCJiIiIiIiItIAFNhEREREREZEWsMAmIiIiIiIi0gIW2ERERERERERawAKbiIiIiIiISAtYYBMRERERERFpAQtsIiIiIiIiIi1ggU1qtW7dGlFRUbh58yaGDBmSZbsJEybA1dVV8cfX11frsfTp0wfXrl1Tu+7Dhw9wcXFRu87DwwOvXr1Suy4qKgozZ87UOIbZs2fj9evXGrcnypBf19LJkycxevToLNcfOHAA33//fa72maFZs2ZZ/v/P7bW0dOlS3L1797PiICJlzNXKmKvpczFXK2Ou/jKGug6AdMfPzw/btm2DTCaDm5sbZs6cCXNzcwBAWloa0tLSkJqairS0tCz3sWzZss8+flhYGHr37q20LDk5Gba2tjh+/LhimUwmyzKG169fw9raWu267GL39fXFlClTFJ+joqLg6+uL69evw9DQEF5eXpg8eTIkEgkAYNiwYZgzZw7Wrl2bq3OkokHX1xIASKVSyGSyLNfLZDLI5XKV5W3btkVCQoLSspSUFOzduxf29vYA0q8lqVSqdr+fXksZx5o/fz52796N27dvK60bMmQIxowZg/Xr18PIyEijcyMqynT9/cJcTYWFrq8lgLm6qGCBXUQdOHAAe/bswb59+2Bqagpvb29MnToVK1eu1Gj78ePH4/r162rXWVhYYPr06XB3d892Hw4ODrh48aLSsq1bt+LQoUOanQSAJ0+eoFixYhq3B4DLly/D1NQUFStWBJD+pTps2DB4eXlh2bJlSExMxNSpUzFv3jz8/PPPAIDy5cvDwsICly9fRpMmTXJ1PCrc9OFayhAUFARPT0+16xISEuDq6qqy/NixYyrLunbtioiICEXSBoDY2Fh8+PABFhYWil9mP72WACApKQk+Pj5IS0tTm+iLFSuGevXqYf/+/ejRo4dG50VUVOnD9wtzNRUG+nAtZWCuLvxYYBdRGzduhI+Pj+KOsq+vL9q0aaO44HN6xWr58uUqyy5duoQ1a9bAysoKzs7OuY4pOjoay5cvx8KFCzXe5uDBg3j06BHevHmDUqVKabSNv78/hg8frvh87tw5mJubY9SoUQAAKysr/PLLL/D09MSkSZNgZWUFAOjVqxfWrl3LpE1K9OVaEolEcHV1hZ+fn9r1e/bswblz5zTal7pk6+PjAyMjI3h7e6Njx44AVK8lADhz5gxq1aqFzp07o1WrVmr336NHD3h7ezNpE+VAX75fMmOupoJIX64l5uqigQV2EZSamor79++jcePGimWVKlVCxYoVMXnyZLRs2TLLO2uf7ufWrVs4e/Ysjh8/jsjISHh7e2P48OGwsLDIVUzJyckYM2YM3Nzc4OHhgTFjxuDWrVsAgI8fP6rdJiQkBEFBQXB1dcWyZcswf/58lTa9evWCgYEBxo4diz59+iA+Ph537txBw4YNFW3OnDmjcr7W1taoW7cuAgMD0a5dOwBA/fr1ce/ePcTHx+f6/Khw0qdrqWzZsggODsY333yjdn1SUhL69eunstzLywsfPnyAgYGBYpmVlRUqVKig1M7f3x/lypVTfFZ3LWXsDwDCw8OzjLVcuXIwNDTE06dPUaVKlZxPjqgI0qfvlwzM1VQQ6dO1xFxdNLDALoKio6NhaGiI4sWLKy23t7dHUlJSjtsHBARg3759ePPmDerUqYPmzZujT58++PfffxEUFIR+/fohOTkZrVu3ho+PT477e/PmDSZOnAgzMzPcvHkTFy5cwKpVqxTre/bsqbJNXFwcJk+ejP79+2P06NHo3bs3/vrrLwwaNEip3c6dO5W+fIKDg+Hs7Ayx+L/x/V68eAEPDw+VY1SqVAmPHj1SJG2xWIw6deogODgYzZs3z/G8qPDTp2updu3auHHjRq7iT01NxdOnT3Hnzp0c+1gdPXoU1tbWcHFxwVdffaX2WsqNBg0aICgoiEmbKAv69P0CMFdTwaVP1xJzddHAArsIEolEkMvlEAQBIpFIsVwqlcLW1jbH7V1dXdGkSRM4ODgoLXdwcFDcEUtOTkZ8fHy2+xEEAYcOHcKiRYswePBgDB48GHfv3sWkSZNgb2+PWbNmKfUXyfD8+XOMGjUKzs7O+OGHH2BgYID169dj1KhRCA4OxsKFC7O8k/hpXxUgfXRTdX3DLC0tERMTo7SsbNmyWY52SkWPPlxLfn5+2LhxY67irlChArZt26b4nDGgS3JyMmJiYhAVFYXw8HBEREQofhFOSkqCRCJRvJKm7lrKDV5LRNnTh+8XgLmaCj59uJaYq4sWFthFkI2NDUQiEV6/fo0yZcooloeFheGHH36ARCJR2xclLCwMffr0gSAIuTqen58fnJycVJaPGDECMpkMfn5+qF69OgDAyckJBw8exK5du7K8S7dp0yZ069YNQ4cOVXxR2tnZYceOHdi7dy9MTEyyjCUuLg6WlpZKy6RSaZbnlPmLGEgf9CE2Njbrk6UiRR+uJW9vb3h7e6u03bt3L86ePau231gGiUQCd3d3dOrUCcbGxjA2NoaJiQmsra1RunRppSdK3bp1U3rtTN21lBvFihXDixcvPnt7osJOH75fAOZqKvj04Vpiri5aWGAXQYaGhqhbty7Onj2LPn36AABu374NR0dHxdQW6vqiODg4IDAwUGtx/PLLLyhRooTKcolEgr59+yo+T5s2DV999ZXi8+zZs9XuTyKRKE0lMnfuXJQuXVqpjaWlJaKiolSWxcXFqewvNjZW5W75x48fYWdnl81ZUVGiL9fSl8hqoJXM+vfvr/JqnbprKTc+fvyY61GFiYoSffl+Ya6mgk5frqUvwVxdsLDALqKGDx+OadOmoUGDBihWrBh8fX0xa9asfI0hc8J+8OABtmzZgqtXryIlJQWCIMDKygqenp7o169flnffctrO2NhYqb29vb3K6IwVK1ZEaGioyr6fPXuGDh06KC179eoV+3SREn24lgBg//79aud+bdOmDYD0gU68vLwwffp0tds/fvwYu3fvRkhICD58+ACJRAI7Ozs0b94cgwYNUnmVU921lBuvXr1S+mWciFTpw/cLczUVBvpwLQHM1UUFC+wiyt3dHdOnT8fUqVMBAKNHj0bdunU12vbkyZOKOSfVkcvlMDIywrFjx7J9BSzDvXv3MHjwYEyePBk//vij4svh1atX2LlzJ7p3746DBw8qpuD4ku3q16+PqVOnQi6XKwZ8aNq0KQICApRe3YmOjsatW7ewYMECxTKZTIaQkBAsXrxYg58SFRX6ci117twZnTt3znL9sWPHEBAQoHZdcHAwxo0bh4kTJ2LQoEEoUaIE0tLS8Pz5c+zevRtdu3bFvn37YG5urthG3bWUG9euXVN6+kVEqvTl+wVgrqaCTV+uJebqooEFdhHWvn17tG/fPtfbtWzZEi1btsy2Tf369fH+/XuNBlYIDAyEh4cHunfvrrS8bNmy8PHxwfnz53Hr1i24u7t/8XaWlpaoVasWrl69qpiuoX379li7di3Wrl2LYcOGISEhAdOmTUOrVq1QtmxZxbbXrl1DrVq1OO0HqdCHa+nSpUuYOHFilk+QxGKx2lF+AeDUqVNo06aN0lyXEokETk5OcHJygpeXF27duoWvv/5asV7dtaSpsLAwyGQy3hUn0oA+fL8AzNVU8OnDtcRcXTSwwKY8IRKJNB4Uws3NDRs2bMChQ4fQsmVLmJqaAgDevn2LgIAAxMTEwMXFRWvbDR06FDt27FB80RgbG2P9+vWYO3cumjRpAgMDA7Rp00ZxlzNDQEAAhgwZkqufA9GX0vRaevbsGTw9PZWe5GiqcePGmD17Njw9PdG4cWPFoEXv37/Hnj17EB8fr3bwo0+vpcyMjIxUXvvMEBAQgMGDB+c6TiLSLuZqIu1grqbMWGCTWoaGhjAyMlL8yUs1a9aEv78/Nm/ejBUrViA1NRVA+l03Dw8P7Nq1S+0AC5+7XdOmTbFp0yaEhoaicuXKANIHsshuAIlnz54hISFB6a4gkSby61qqVKkSli5diqCgoCzbiMViHD58WOUVNnd3dyxcuBDbt2+Hr68vpFIpRCIRLCws8M0332DXrl0qA6cA6q+lDHZ2drh586bKNjExMbh+/TrGjRv3eSdKRArM1cqYq+lzMVcrY67+MiIht2PPE2ng0KFDaNWqVZZ3xXQtKioKy5Yt0/gO4owZMzB27Fil6R2I8kNhu5YWL16M1q1bq73LTkT5q7B9vzBXk64UtmuJufrLsMAmIiIiIiIi0oLcDydHRERERERERCpYYBMRERERERFpAQtsIiIiIiIiIi1ggU1ERERERESkBSywiYiIiIiIiLSABTZREREUFIQOHTqgbt26GDhwIEJDQxXrPnz4AGdnZwDpUzk0bNhQ7T6io6NRvXp1ODo6Kv707ds3y2OGhoYqtc34U7NmTcyePVvR7vnz55wKgoiIijzmaqKCz1DXARBR3nv58iVGjx6N2bNno0WLFti5cyeGDRuGAwcOwNLSEjKZDMnJyQCAtLQ0xd8zk0qlsLS0RHBwMORyuWK5oaEhBEGASCRS2aZy5cq4ffu2yvLFixcjLCxM8Tk1NRVSqVQbp0pERFQgMVcTFQ4ssImKgI0bN6JFixbo3LkzAGDYsGE4f/489u7di4EDB+a4fXBwcLZ3vw0NDdG3b19Mnz5dZZ2xsbHKsuvXr6NLly6anwAREVEhx1xNVDiwwCYqAi5evIjx48crLWvTpg18fX2xYMGCHLdv0KABHj58qLI8PDwcS5cuxbVr19C2bVuNYjl9+jTCwsLQsWNHlXUZd8YNDAzU3mUnIiIqrJiriQoH9sEmKgLCw8NRsWJFpWXVqlWDmZkZHj58iMDAQI33JZVKce7cOUyYMAFt2rSBra0tjhw5AhcXlxy3ffr0KaZPn46ZM2fC0tJSZb2TkxOcnJw0+kWCiIioMGGuJioc+ASbqJBLS0vD/7V3L6HwvXEcxz9iNDWUS0yU22pWZiFEpkQxG7JgyVjIRsMKWdv6bWyUe8lCSbnktkBi4Ra2Q0qm2ZCIqGlk/otfv1Ny+/38z//X38z7VVNznuc853nOZr7zfc45zwmFQrLZbC/Kk5KS9Pj4+OnzVOFwWKenpzo6OtLu7q62t7eVk5Oj/Px85eXlaWZmRoFAQE6nUw6HQyUlJbJYLK+Os7GxoZ6eHrW0tKi2tvbNvt6aeQcAINIRq4HIQYINRDiLxSKLxaK7u7sX5be3t7JarYqL+/hn4OTkRO3t7XI6nSouLlZXV5cyMjKM+uvra+3v7+v4+Fg7OzsqKCh4EbTPzs7U39+v3d1d9fb2yu12m3uCAAB8c8RqIHKQYANRICsrS2dnZ8rPzzfKfD6fUlNTP2wXCoWUm5urhYWFF+XBYND4npCQoIqKClVUVBhlT09PiouL0+TkpPr6+tTQ0KCVlRUlJyebdEYAAEQWYjUQGUiwgShQVlam9fV1Y2VSSVpeXlYgEJDD4Xi3XU1Njc7Pz/+4P5fLpdHRUVVVVcntdistLe3D/TMzM9Xd3f3H/QAAECmI1UBkIMEGooDH41FdXZ1mZ2fldrs1MTGhw8NDTU9Py+l06urqSi6X61W71dXVf9Wv3W6XJPn9fqWnpxuvAbm5uVFCQoJxe5rf7+dVIACAqEasBiIDq4gDUSA7O1sDAwMaHh5WYWGhlpaWNDg4KKfT+VvtQ6GQgsHgh5/n5+d323u9Xh0fHxvbHR0d2tzcNLY7Ozu1t7f35fMDAOC7I1YDkYEr2ECUKC0t1eLi4pfaVlZW6vLy8sN94uPjNT4+rsLCwjfrPR7Pi+3m5mZJP2fILy4u5Pf7vzQ2AAAiBbEa+P5IsAF8amtr69N9PB6PfD7fu0F7aGjIqGttbTXKBwcHVVRUpPHxcVVXVysnJ8ecQQMAEEWI1cD/A7eIAzCFxWJROBx+t95qtcpms8lmsyk2NlaSNDU1pYWFBf348UNtbW1qamrS0dHR3xoyAABRhVgN/Pe4gg1AsbGxio+Pl/Qz+P5a4MQsMTExur+/N14Z8vDwoLm5OR0cHGhkZEQpKSlqbGyU1WqV1+vV2tqarFarqWMAAOA7I1YD30NM+KNpLAD4TR0dHSovL1d9ff2ruu7ubs3Pzxuz5omJiRobG5PdbjdWL/0lGAya/qcBAAAQq4G/gQQbAAAAAAAT8Aw2AAAAAAAmIMEGAAAAAMAEJNgAAAAAAJiABBsAAAAAABOQYAMAAAAAYAISbAAAAAAATECCDQAAAACACUiwAQAAAAAwwT8f0ZWaRa3V1QAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "선택 모델: LightGBM\n", + " precision recall f1-score support\n", + "\n", + " 정상 0.9825 0.9288 0.9549 7672\n", + " 불량 0.7674 0.9341 0.8426 1928\n", + "\n", + " accuracy 0.9299 9600\n", + " macro avg 0.8749 0.9315 0.8987 9600\n", + "weighted avg 0.9393 0.9299 0.9323 9600\n", + "\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9gAAAGyCAYAAAAf2mxkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXyhJREFUeJzt3XlcVGX///H3ADMsCiomau6aaW65oWUWubW4lHcuFJZLqGhYLm1ulVaapqWVWprZphapuaSZ3Zap2V2pWZpZLmjivqKCwgwz8/uDL/NzHJDFAwzyej4ePGLOOdc5n0OXyvuc61zH5HQ6nQIAAAAAANfEp7ALAAAAAADgekDABgAAAADAAARsAAAAAAAMQMAGAAAAAMAABGwAAAAAAAxAwAYAAAAAwAAEbAAAAAAADEDABgAAAADAAARsAACQKYfDUdglAABQpBCwAaAIO336tOrWratLly5luU1cXJwGDhzosXzKlCmqU6eOx1fr1q116tQp13bR0dFatmxZtrXs2LFDzZo1y3SfCxcudG03Z84cjR492qO90+lUWlqax9eVtmzZovbt22dbT375888/ddttt+nIkSOFVkNBcDqdatiwoQ4cOJDp+t69e2vVqlUey+fPn6+YmBhDati6davuueeeTNfVr19fx44dc33u06ePVq5c6bFdy5YtM+2Tl381adJE69evN6TmnLiWPtSgQQMdP348H6oCABjBr7ALAADkncPhkNPpVOPGja+6XevWrT2WPfPMMxo+fLjH/iIiInTgwAHdcMMNkiSr1SqbzZZtLXv37lXVqlW1aNEij3V+fv//n5vU1FRZrVaPbebMmaM333zTY7nFYtGcOXN0++23u+rJrP3l7r333iyDoSTdcccdmjdv3lX3kZUSJUqoRo0a8vf3z1P7DD169NBDDz2kCRMmXPXn27NnT73yyivXdKzdu3dr165devDBB3PcJikpSWlpaQoODs50vc1mU2pqqsfyrC6M5MXV9nXluqz6xf/+979s78SPGjVKv//+uyIiIq6t4P9z7Ngx3X333frpp58UGhrqsf5a+pDNZsvRn8djx45p7dq1evTRRzNdf+7cOX3yySf6/vvv9e+//8pqtSokJER16tTRsGHDdOutt7q27devn3766SdJUmBgoCpVqqROnTopOjra7RzGjh2rRYsW6cknn9SQIUOyrO3ChQuKiIjQxYsXs/wZAUBRRcAGgOvAli1bFBgYmOm6uLg4ff/99x7LTSaTW/DNYDabZbfb3ZZ98803io+PV8mSJRUbG5vpcZxOp8xmc6b7zImYmBiPO59nz57VbbfdplKlSuVqX0uXLnWFrz///FP9+vXT5s2bXestFkueapSkGjVq6LPPPstze0lKSEjQn3/+qZkzZ6pLly6uAPjtt99qxowZWrFihWvbgICAazqWlP4zWLp0aa4C9t69e+Xr62vI8QuTj4+PfHyuPmAvODjYo89fi7S0NDmdziz3aUQfys6///6refPmZRqwf//9dw0ePFi33HKLYmNjVa9ePfn7+ysxMVFbtmzxCP5paWkaMGCABg4cqEuXLmnnzp2aOHGijh8/rvHjx7ttV61aNS1evFhPPPFElj/3VatW6YYbbtC///5r6M8dALwBARsAijCTySQp/a7W1e40ZuXKEOBwOGS1WuXr6+u23aFDh2S1WrMNuklJSfrll1/c9pWamqq77rorT0Ht66+/Vp06dVSvXr1ctQsKCvL4PiQkJNfHzy+rV69WkyZNFBYW5rY8MDBQPj4+XlHr+vXrZbfbtXjxYvXp00fLli3T888/77ZNjx49Cqk6Y9lstmxD+PXiyJEjGjhwoKKjoz0uaJUtW1a1atXKtJ2/v79CQkIUEhKi8uXLy9fXV0899ZReeuklt5/dbbfdpk2bNmnjxo1ZjghYunSp/vOf/2j69OmGnRcAeIvi8a8JAFynQkJCVKFCBd1+++1ZPl86efJk1a5d26Pt+++/r/r167t9NWzYUBaLRTVq1HDbtn///vr00081Y8aMq9Zz9OhRTZ06Va+99pqmTJmi2bNna9GiRbp48aLbdl999ZWrvn379mW6L7vdrs8//1y9evXK5U8le1u2bNFDDz2kXbt2qUuXLmrSpIl2794tKX2oeseOHdW4cWPdcccdGjZsmE6ePOlqe+zYMdWtW1dnzpyRlH43umnTptqxY4ciIyN16623qk2bNpo2bVqWd+e++eYb3XfffTmu99SpU3r66afVtGlTNW/eXE8//bTr+FL6z2ry5Mlq3bq1GjRooPbt2+uHH37Q8ePHVadOHY0aNUq//vqr6tSpo3vvvTfb4yUnJ2vJkiWaMGGC3n77bR04cEBdu3bVzp07XV9NmzbNtK2vr6+sVmumz9Nf/uV0OnN8/vktJSXF7aJMfruyD0n///9xeHi4GjdurEGDBikhIUENGzb0eOZ669atioqKUuPGjdWkSRMNGzZMFy5ccK1v0KCBevfurcOHD6tOnTpq0KCBa90777yjpk2bXvNz8jVq1FBKSorOnj3rsa5bt25asmRJpu327dunffv2ZflsPQAUddzBBoAizGKx5Hlypt27d2vAgAEez2Fn5s8//1RwcLACAgJ09913Z7ld7dq19cUXX2S7v86dO2vixIkymUxZDtf++OOPZbfb1a1bt2z3l1t2u11Wq1Wvvfaaxo8fr0qVKqlMmTJKTk7Wrl27NHbsWNWoUUPnz5/XSy+9pLFjx2r27NmSPIf/mkwmpaamavjw4RowYIBat26tY8eO6bnnnlNISIiio6Pdjp2QkKBdu3bp3XffzVGtqamp6tOnj2rXrq2FCxfK19dXb7/9tmJjY13DjOfNm6dNmzbpvffe04033qgTJ06oZMmSKl++vLZs2aIVK1Zo5cqVmj17do6G8E+cOFG33367unfvrmPHjqlv376aN2+eatasmW3bBg0aaNq0aapfv/5Vt7vnnnv0zjvvZLu/jJCYn86fP5/lCJD8cGUfcjqdGjRokPz8/PThhx8qLCxMq1evVu/evZWWluYxCmXixIl6+umnNXnyZCUlJWnMmDGaOHGiXnvtNUnSzz//rM2bN2v8+PFasWKF6w6zzWbTN998k+2FspzYuXOngoKCVKZMGY913bp10z333KMzZ854PF+9dOlSdezY8ZrnMAAAb0XABoAiyOFw5GiioytdGWgdDodrX0lJSUpMTNThw4d16NAhHTp0SFFRUZKkM2fO6ODBg1k+5y2lP+t6+aRTDodDFy5c0KlTp3Tw4EGZzWbXZGsmk+mqv2Dv27dPb7/9tiIiIvL8THd29uzZo2nTprndibVYLJo2bZrrc8WKFfXMM8+4gk5WtaSlpSkqKkqRkZGSpEqVKunJJ5/U+++/7xGwV69ercaNG6t8+fI5qjMuLk4+Pj6aNm2a65GAqVOnKiIiQr/++qtatGihLVu2qGfPnq47lZeHmuDgYAUGBsrPzy9HQ88XLFigH3/80TVzfMZkVd26ddNLL72krl27XrV9kyZN9Ntvv+Xo3HKiUqVKmc4hkNvQvWzZMjVs2FC1atVScnKyFixYoP79+8vHx0dnzpxxTeqXlVWrVumll15yffbx8dGvv/6aqxqy8ssvv+iff/7RunXrXHX06dNH+/btU1xcnMf2w4YNU8+ePV2fx44dq+joaNdFq5IlSyooKMjjcYMDBw7o4sWLbhOY5ZbVatXPP/+s1157TQMHDsx0aH358uV1++23a+nSpW793263a/ny5YYEfADwVgRsACiC3n///Uxn3M6JjRs3KiwsTPXr19fUqVP10UcfKSAgQP7+/goMDNQNN9ygihUrqkaNGjKbzZKku+66K9vnbevWrau9e/eqYcOGktLvlgUFBalcuXKqXLmy2rZtm+ls5lc6ceKEYmJi1L9/f3355ZdasGBBvgwT9/HxydGs0VWqVJHdbtfJkydVsWLFLLe744473D7XrVtXhw4d8tjum2++ydVkY+vXr1fnzp1d4VpKfx62cePG+v3339WiRQvdcsstWrFihe655x6P57pz4+WXX9bXX3+tTz75xO3O5JAhQ9SiRYurTg533333af/+/bk+ZuvWrfXBBx/kqd7cWLhwoR5++GHVqlVLZ8+e1RtvvKE+ffrI399fR48e1Y033njV9m3atHELpkY+s71161bdeuutHiG/W7dumQbs8PBwt8+33HKLLl68qNOnT1/1QsH58+fl6+urkiVLui3v3bu3/vrrL9fnEiVKeIyMmTNnjj7++GMlJyfL4XBowIABGjx4cJbH6t69u9544w23gP3jjz8qODhYt956a6Z/NgDgekDABoAiKLMZtzP07NlTvXr1yjbE9e3bV3379jWsprp162rLli1KTk6Wn5+fgoKCPCZLy86hQ4cUHR2tTp06aciQIerQoYN69+6tsmXL5uqZ5ZwoVaqUSpQo4bF8+/bt+uyzz7Rr1y6dOnXK9Sqq7GY7vnIobMmSJZWSkuK2LCEhQX/99ZdmzZqV4zoPHTqkrVu36v3333dbnpKSosqVK0uSnnjiCaWmpqpTp056+OGH1b9//1zPvC6lTwi3ePFi134v16JFi6u2/frrr7N9HVZmCntyMbvdrhYtWnjMO3CloKCgfHtO+8SJE5n+zKtUqZLp9ldOGJgxsiSz16ZdLiQkRHa7XcnJyW59f/r06a55Ev744w+NHDnSo23v3r318MMPKzk5WX///bfef/99nTp1SpMmTcr0WHfffbfGjRunLVu2qHnz5pKkL7/8Ml8e+QAAb0LABoAibNeuXYqMjHSbMMpms+mvv/7S2LFjJaW/g7p37945etZaSh/afXnoadmyZaa//GfGYrFk+wqsDh06KDEx0WP5li1bNHToUHXv3t1Va506dTR79mwNGjRIp06dyvKdvnmRWVjasGGDBg8erAceeECDBg1S5cqVZbVa9cgjjxhyzIzh4RUqVMhVuyeeeEIdO3b0WJ4Roi0Wi55//nk98sgjmjRpku699159/PHHuR5G/cwzz7h9Xrt2rRYvXqzdu3fr5MmTCg4OVtWqVdWpUyf16NFDzZo1c217tddhOZ1OtzvwOWUymWSz2Tz6ZEaQzMs+r+Tr65vn0SBGyerCRG5n3s9u4rhq1aopICBAO3bs0G233eZaHhoa6rpAdPjw4UzblipVyhX469atq7vuuksdOnTQ/fffn+lIED8/Pz300ENasmSJmjdvrnPnzmnDhg164YUXcnVOAFDUELABoAi75ZZbtH379qtus2zZMn3++edZrk9NTdXHH3+sNWvW6NChQzp37pwsFovKlSunO+64Q5GRkdlOWHW5p556St9++22Wv+z7+vpq6NChbr/gHzhwQIMHD9ZLL72kzp07u23fuHFjLViwQFu2bMlxDXk1d+5c9erVS6NHj3Yt++OPPwzb/zfffKMHHnggV23Kly+vpKSkHF3kqFq1qmbOnKnhw4frrbfect0pz0sQnTRpklauXKknn3xSY8aMUdmyZXXhwgXt2LFDH374oRITE9WhQ4dM2/7111/6/PPPtXXrViUkJCg1NVVBQUGqUaOGWrRooV69emV5d/ZylSpVUkpKim655ZZM15UtWzbX5+WNypcvr59//tljeV6G3GfI7P+5xWJR27ZttWDBArc/f3kRGhqq2rVr659//snyUYvu3bvrwQcf1JgxY7Ry5Urdfvvt2T7rDgBFHQEbAK5z2Q1tfuqpp3Tu3DkNHTpU9evXV0hIiFJTU3Xo0CF9//336t27t959991shwhn+PPPPzVjxowsZxt/4403tHfvXrdl1atX15o1azyGWWeoVatWlu/nNdKpU6c8Xmn23//+15B952V4uJQ+giAuLk5PPPFEju5omkwmNW7cWEuXLnUt8/f3z9WkeElJSfrkk0/0+eefq1GjRq7lQUFBKl++vNq0aaOuXbtq+fLlHqMKVq5cqZdfflm9e/fWpEmTVKNGDQUGBur8+fPat2+fVq9erf/85z+aN2+e274zU6lSJW3evDnHdV/Obrd7XORxOBxKS0tz3TG22+1uE/NJ6ReAjLgznhsRERGaNWuW/v33X1WrVs21fOHChZKU7aiQzGT1/3zo0KF66KGH9Omnn+qxxx7Lc81JSUnav3//VZ9dr1q1qho2bKiVK1fqyy+/vOoz2wBwvSBgA0ARdubMGXXp0kXnzp3LMhT4+fnp8ccfz3Sd0+nUhg0btGTJEtWrV8+13Gw2q27duqpbt67279+vdevW5ThgS+lBLKsZt4OCgjK9u51VuC5IzZo104IFC1wXGr755hv99NNPuR6qm5m8Dg+PiorSZ599pr59+2r06NGqVKmSjh07ph9//NH1HP5XX32lmjVrqnz58tqzZ48++ugjt2fwK1asqL///ls7duxQUFCQbrjhhhw9o53VTO8+Pj6uCfCutGTJEj3yyCOu2cczlClTRs2bN1fz5s11+PBhrVy5MtuAfS0aN24sq9XqtuyPP/7QmDFjXJ+bNGni0S4yMlIvv/yyITUkJSW5/Qx9fHw8JhiTpIYNG+ree+9VTEyMXn/9dZUvX14LFy7Ujz/+KH9//zz92ahYsaJOnjyp9evXq3r16goMDFRYWJiqV6+umTNnaujQofr555/Vs2dP1alTR/7+/jp79qx++umnTIf6p6am6vz58zp37px2796t2bNnq2zZsmrfvv1V6+jRo4feeOMNWa3WHE0qCABFHQEbAIqwEydO6OLFi9qxY0een3Ft06aNXn31VT355JOqW7eugoODZbPZdOTIEX333Xf64Ycf9N577+Vqv0lJSVlOuHTx4sUCvUOY2XPhvr6+mU7ANnLkSE2aNEkDBw7UxYsX1bp1a7377rvq3Lmz666nn5+fTCaTq/2VnzOYzWa3cJWT4eH+/v4etZYpU0afffaZpk6dqgEDBig5OVnlypVzG56d8WxrSkqKKlSooK5du+rJJ590rb/11lvVqVMn9e3bVyVKlNDMmTNds71npmTJkurVq5cGDx6sYcOGqWXLlgoNDVVycrJ27typDz/8UCkpKZlOpPfggw/qtddeU2BgoCIiIlSlShUFBgbqwoULio+P15o1a7R582YNGjToqj+La7Vjx4583f/VZPSFKyfm8/X11c8//5xpn5k8ebKmTZumQYMG6eLFi7rtttsUFRWlrVu3ul2s8vf3z/TixpXLw8LCFBMTo+eee04+Pj6aMGGC2rZtK0m6/fbbXbPFv/HGG0pISJDdblfZsmV1yy236JVXXnHbt5+fn2bMmKEZM2YoICBAVapU0d13363+/fu7XXyyWCweF2XuvfdeTZgwQT169HCrz2w2y8/PL99ewwcAhcXkzG5GDACA18q4g33mzJmrhlaTyaQ1a9Zk+hzv5c9gJyQk6Pz58zKbza5nsB955BG3u9vZGTx4sNatW5flM9h+fn565pln1K9fvxzv83JbtmzRyJEjtXbt2jy1LwwJCQnq0KGD1q1bd9VXfXmb1atXa9GiRfr777915swZBQUFqXr16urcubN69uyZ6d1YSdq2bZu++OIL/fbbbzp06JDS0tLk7++vatWqqWXLlnrsscfchkIboU+fPurRo4fHM/xFxZw5c9S0aVNVrVpVly5d0v/+9z/NmjVLs2fPzvQZdACAdyJgAwDcXDljM67d7t279euvvxo6C3pBu5Z+YbPZshxSjnRvvfWWVq1apaNHj8psNqtp06YaNmyYGjRoUNilAQBygYANAAAAAIABuEUBAAAAAIABCNgAAAAAABiAgA0AAAAAgAF4N8Jltm3bJqfTyUQsAAAAAABJ6ZN1mkwmNWnSJNttCdiXcTqdWb5WBgAAAABQ/OQmIxKwL5Nx57phw4aFXAkAAAAAwBvs2LEjx9vyDDYAAAAAAAYgYAMAAAAAYAACNgAAAAAABiBgAwAAAABgAAI2AAAAAAAGYBZxAAAAACgi7Ha7bDZbYZdx3TCbzfL19TVsfwRsAAAAAPByTqdTx44dU2JiYmGXct0pXbq0KlSoIJPJdM37ImADAAAAgJfLCNdhYWEKCgoyJAwWd06nUxcvXtSJEyckSRUrVrzmfRKwAQAAAMCL2e12V7guW7ZsYZdzXQkMDJQknThxQmFhYdc8XJxJzgAAAADAi2U8cx0UFFTIlVyfMn6uRjzb7lUB++zZs4qKilL//v1ztP2WLVvUs2dPhYeHq0OHDoqLi8vnCgEAAACgcDAsPH8Y+XP1miHiBw8e1KBBg1SuXDmlpaXlaPvY2Fi9/vrrioiIUHx8vGJiYlSiRAl17ty5ACoGAAAAAOD/85o72J9//rmeffZZPfjggznafv78+YqMjFRERIQkqWbNmho7dqzmzZuXn2UCAAAAQLFx/PhxhYeHe3yfwWq1asKECbr99tvVtGlTDRkyRMePH3fb5siRI2rQoIHsdrvH/u12u9LS0ty+nE6n2zZz5szR6NGjDT6z/OE1Afu5555TmzZtcrz9unXr1K5dO7dlrVq1Unx8vGsWOAAAAABA1ubPn68GDRqoTp06bl9vvvmmpPTnklNSUjy+zzBy5Ej9/fff+uyzz7R27VqFhYWpd+/eunjxomsbm80mm83mEZy7dOmievXqqX79+m5fL774ott2qampslqt+XH6hvOaIeK5YbfblZCQoJo1a7otN5vNqly5svbs2aOwsLA87TtjqnYAAAAA8AapqalyOByy2+2Z3gW+Fjt27FBUVJSefvppt+W+vr6y2+1yOByS5PG9JO3atUtr167Vf//7X91www2SpNGjRysyMlLz589XdHS02/Z2u931vLPdbtfu3bv19ddfq3r16h51XX6eDodDTqfT8HO//FgOh0OXLl1ynePlnE5njp/TLpIBO+Pl6sHBwR7rgoODde7cuTzv22azadeuXXluDwAAAABG8/PzU2pqquH7zQi9V86DlfE545gpKSlu30vSmjVr1LRpU5UsWdLtzvY999yj1atXq1evXh778PPzc9u/w+HwuCt+pbS0NNnt9my3y6vU1FSlpaUpPj4+y20sFkuO9lUkA3bGuPzMriRcOewgt8xms2666aZr2gcAAACAosWbZ+hOTU3VkSNHFBAQoICAAEP37evrKz8/vyz36+/vL0kKCAhw+16SEhIS1KRJE4+2rVq10rvvvutafnm7KwO2v79/tufk5+cnX19fw8/9ymNUrVrVVevl9u7dm/P9GFlUQcm4c33hwgWFhIS4rctsWW6YTCbeLwcAAAAUMw6HQz4+XjNFlRuTySSTySQfHx9Da8y4YWkymeTr6+ta3qNHD23fvt312WKxyNfX13XsjG1Pnz6tZs2aubWVpAoVKujSpUtKSkpSqVKlXOt9fX1d32fcGPXx8XFrb7PZZDablZKSogsXLkhKv/N9ZY1Gyji3wMDATEN8bi6+FMmAHRQUpLCwMO3fv1+33nqra7nNZtOhQ4dUrVq1QqwOAAAAQFHj4+OjGXE/6PDJxMIuxUNwgJ/ublRRgafPyc98yZB9Wvz8FBbq+citJMXFxbmeRT5y5Ig6deqUq31nhOecjC5+4IEH5OPjI4fDIavVKpPJpLi4OG3cuNH1hqiUlBR16NAhVzUUliIZsKX0YQdr1651C9ibNm1SWFiYqlSpUoiVAQAAACiKDp9M1IEjpwu7DA+hwf5KSysvm80uhzMt+wY54Ovjk2UAvvxO+dXumN9www06e/asx/Ljx48rMDBQpUuXzraOL774QhUqVJCUPlzcbDZLkurVq6eYmBhJ0jvvvKN///03231lJzeTleVVkQnYw4cP1yOPPKIWLVpIkqKjo/Xoo4+qefPmioiIUHx8vCZOnOj6nwAAAAAAyJyPT/rQcLv1ouyXziv1dOYB1pp4TJJTqaf/dftekqrfeIO2bf5ZqacfdGvz0w9rdFPNaq7trImHJUmppw/K7pc+zDstLX1GcJ+U0zKnpodqR6qU2TRuaRcT5UhNzrLGnDD5WWQpVTHP7XPK6wK2xWLJdIa2+Ph4t6sjN998s6ZPn64pU6ZoxIgRKlWqlPr06aPu3bsXZLkAAAAAUGT5mqSkpPO6cO6s7Ha70tLSdPzkaf2bcFgmk48a1rtZkuRMS5Uzzer6XpLa3hGueZ9+rlMnjqlsaJn0dU6nVn/7vbrc29a13eXtnEoP2Kb/G4J+Mem8LiYFymZLU0pqqo4dP6mDh4/q5Kkz6hfVLb1Ih11Op8O1P2/mdQG7c+fO6ty5s8fy5cuXeyxr1aqVli5dWhBlAQAAAMB1p0Wzxho/aZq+WLZafr6+KlkySGVDy6hyxQq6LbzxVdvWrlVd7SJa6blxr2v8yKEKCS6pGe9/qlSrVd0fuO+qbX18fHRr/brq1meIJMnX10fBJUvohtBQVapYXrVrVZPdbs+3ic3yi9cFbAAAACAr3jzTc34pjueMgtPp3nbq2K51lusPHz1+1fbjnntK09/7SI8OekZWq1W3hzfR+9MmyN8/+/dGf/LuFF36vxnC/S0Wr35VWk4RsAGgGCuOv7QVx3MGrifePNNzfqhUrrSGRN5d2GUAWbJYzHruqQF67qkBeWofmI/vti4MBGwAKMb4RRVAUeStMz0DAAEbAIo5flEFAABZ8fP1lf//TUJtNvu5vs8Ns9lPZrOf8joC3GIxy/J/r+/ydgRsAAAAAECmyofdoB+//lySFHZDWdf3uVGxfJi2fJf3yamjH+2R57YFjYfQAAAAAAAwAAEbAAAA8FKlSgbK6bAXdhkFqridL64vDBEHAAAAvFSJQItMPr46uvo1Wc8cLOxy8p0ltKoq3j+qsMsA8oyADQAAAHg565mDSj2xt7DLAJANhogDAAAAAGAAAraBHA5HYZdQ4IrjOQMAAABAZhgibiAfHx/NiPtBh08mFnYpBaJSudIaEnl3YZcBAAAAAF6BgG2wwycTdeDI6cIuAwAAAABQwBgiDgAoNnjdDQDgeuPr6yOL2S/XX36+6VHQ5GuRyc8/11/yKfx7tTabTVEDR2jPvgOFXYpL4f9UAAAoILzuBgBwPfH19VHlsDLy9c37fVNL6Yp5ame322U786/kSMtxm1GvvKGN/9ssKT0cp6XZFRgYICn9cdvl899VmdKlcrw/s9mshXPezF3h+YyAjTzLuBNk8vEt7FIKTHE7X+B6xetuAADXA18fH/n6Fvw8UBlzMaX5+MqZi4D92gtPu75fvnqtVn37g+ZMezU/Siw0BGzkGXeCAAAAgMLHPFDeg4CNa8adIAAAAADX4sFHB+mVUcP0zvufatfufZo2YYwa1aujCdPe1f82b9OlSykqXSpEfR95SN0fuM/V7rZ7e2jFgvcUdkNZ/frbds399AtFtGqhT+KWKin5oqpVqaRRwwapUaOGBXIeBGwAAAAAQKGyWm16a84nGhbTVw3r3Syn06mk5Iu6vXljPffkAJUsEaQDCYcV/eQoNbjlZtWtXfP/2llls6UPUzeZTNrx1275+fnqk3enqlzZMlq84hsNHzNBqxZ/LP8COA9mEQcAAAAAFLqba1ZXw3o3S0oPy8ElS+j+9hEqWSJIklS9SiW1aHartm3/K8t9XEpJ0Sujhql8ubLy8fFRz64d5ePjoz//+qdAzoE72AAAAACAQtfs1voey37Y9KsWL1+tfQcO6tz5C7LabKpW+cYs91HuhlCVDS3jtqxi+XI6cbJgnlHnDjYAAAAAoNCVLh3i9nn1dxs0dsKbuqtVuD54+zVtWPmZ7m8fIafTmeU+/C0Wj2V+fr5yOOyG15sZ7mADAAAAAAqdj4/7/d+4pas0NKaPejx4v2vZiZOndWP5sIIuLce4gw0AAAAA8DqJied1Y8Xyrs8XkpK1o4Cepc4r7mADAAAAQBFWqVzp6/J4DevdrGWr/qvmtzbQxUuX9PKUmaroxXevJQI2AAAAABRJdodDdrtDQyLvLvhj2+1yXsNzzRazWRaz+f9/tpg9np9+9skBemXqDN3b43FZzGY92vNBNbilti6lpF7WziKzOT3W+lvMru/djmWxyJLJs9n5gYANAAAAAEWQ3e7QoRNn5euT+yd/AwPMKluqpKyJR+W0W3Pd3umwS460XLfLcH/7CN3fPsL1efn89zy2CQkuqSnjR151Pz+vWeT6vlH9ulr6ySyPbd6dOl4mv4J4CzYBGwAAAACKLLs9/S52bpnNvpIkp90qZ1pqNlsjp5jkDAAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAIDhHI7cPw9Y1BXHcwYAuGOSMwAAYDgfHx/NiPtBh08mFnYpBaJSudKF8pocAIB3IWADAIB8cfhkog4cOV3YZQAAUGAYIg4AAAAAgAEI2AAAAAAAGIAh4gAAAABQRPn6+sjXJ/f3Tf1809uYfC15Oq7TYZccablqM+qVN7Txf5slSTabTWlpdgUGBkhKn7tj+fx3VaZ0qTzV4y0I2AAAAABQBPn6+qhKWGn5+PrmeR+W0hXz1M7pSFPq6YO5CtmvvfC06/vlq9dq1bc/aM60V/N0/Mut+vYHbfl9h1567slr3te1ImADAAAAQBHk6+MjH19fHV39mqxnDhbYcS2hVVXx/lEy+fjKmcu72PkhzZ6mtLTCr0MiYAMAAABAkWY9c1CpJ/YWdhnXxG636915C/Xlqm+VkpKq8CaNNPbpJ1TuhlBJ0pbfd+j1d+bqyNHjMpvNiu7VXVHdu+iebv10ISlJaXaH1v34iwb0jlSfh/9TaOdBwAYAAAAAFKpZ8xbop1+36ZNZU3RD2TJ678PP9Oy4yfpoxmQ5HA49+9LrmvzSs2rRtJFsNpsuJF+Uj4+P1i79WMtXr9WWbTv0yujhhX0azCIOAAAAACg85y8kaeHilZo4doQq31hBAf7+empgbx09dkK7/tmrxPMXZLVa1bRRfUmS2WxWqJdOhkbABgAAAAAUmt379qvcDaGqUa2Ka5mPj4/q1amtf/YdUGjpUgpv2khPjXpZ+w4U3LPmecEQcQAAgGtUqmSgnA67TD55n8m3qClu5wsg/5w4eVqHjxxT644Puy23paWp6a31JElvvjJKy1d/pyHPjVfjBrfouacGeOUrvQjYAAAA16hEoEUmn4KfybewZMwgDABGCAoKUq2a1fTFB29luY2Pj4/+06mDOnW4W6NffUNjJrypWVPGF2CVOUPABgAAMMj1MJMvABS0W26upX8TDuvU6bO6oWyZq25rsZj1xOO9FNl/qGuZn6+fnM78rjJnCNgAAAAAUIRZQqsW6eOVL1dWbVvfpmdfmqyXnhui6lUr6+LFS9r6x07deXtzJV+8qIOHjqpu7Zqy2dK0eMU3uqV2LVf7G8qW0d974mW12pSSmqqQ4JKG1pcbBGwAAAAAKILsDoccdnuhPLLhdKTJ6bDnub3FbJbFbHZ9Hvf8U3rn/U/Vf9gYJSdfUomgQLW/u5XuvL25ziae1/AxE3TqzFkFBgSoScN6mjzuWVfbJg3rqVLF8mrz4KOqV+cmvT99wjWd27UgYAMAAABAEWS3O5RwIlG+Prl/OVRggFllS5WUNfGonHZrrts7HXbJkZbrdhnubx+h+9tHuD77+1v0zJBoPTMk2mPbyjdW0DeL5mW5L4vFrLdeG5vnWoxEwAYAAACAIspud8hud+S6ndmc/hYAp90qZ1qq0WUVW7wHGwAAAAAAAxCwAQAAAAAwgFcF7C1btqhnz54KDw9Xhw4dFBcXl22bzz//XA888IDCw8PVtm1bTZ48WRcvXiyAagEAAAAA+P+8JmAfPHhQsbGxio2N1ebNmzV79mzNnTtXK1euzLLNnDlzNH/+fE2ZMkWbN2/Wxx9/rG3btumFF14owMoBAAAAIP+kv+PZ+X9fMJrTwJdoe03Anj9/viIjIxURkT6TXM2aNTV27FjNm5f1bHHLly/XsGHDVKdOHUlSlSpVNHr0aK1bt65AagYAAACA/HbJmiaHwymHI/eTmSF7aWnps6H7+V37HOBeE7DXrVundu3auS1r1aqV4uPjdeLEiUzbVKhQQQkJCW7L4uPjVb169fwqEwAAAAAKVIrVrguXrLKlphR2Kdel8+fPy9fXV76+vte8L694TZfdbldCQoJq1qzpttxsNqty5cras2ePwsLCPNoNHTpUMTExKl++vDp27Ki1a9dq6tSpeuedd/Jci9PpzNMz3CaTSYGBgXk+LoqOS5cuGTqMJDsmk0kWf/88vd+wKLM7HLKmphboz7q44e+t4qMw/t6ibxUP9C3kF/qWp1//Oa7Q4ED5+vnJz2yRZLqm/dmsJqWkpMhqTZPTbjemSC9mcqTJmZIih8Ph6lsZ2e/cuXMqW7asLl26lGlbp9MpkylnP2+vCNiJiYmSpODgYI91wcHBOnfuXKbtGjVqpA8//FCDBw/Wm2++qZSUFH3wwQeuIeN5YbPZtGvXrly3CwwMVL169fJ8XBQd+/fvz/IPX37I6Fsz4n7Q4ZOJBXbcwlSpXGkNiby7wH/WxQ1/bxUfhfX3Fq5/9C3kF/qWp71HzmnzP8dUv7pN/mZfXWvA9rf46cLZAKUln5bTnmZMkV7M5Osnv0SrbDabW8B2OtOH3h86dOiq7S0WS46O4xUBOy0tzXVyV14ZuNqVq4MHD2rcuHGqXbu2unTpolWrVmnUqFGaOHGi6tatm6dazGazbrrpply3y+kVDRR9NWrUKPArqpJ0+GSiDhw5XWDH9QYF/bMubvh7q/gorL+3cP2jbyG/0Lcy98s/x7Vt30mVCDDrWktuUqeKHu14iw5/9bGspw8aU6AXs5StqkpdxiklJcWtb/n5+WU7NHzv3r05Po5XBOyMO9cXLlxQSEiI27rMlknpd5pjYmL0yCOPqHfv3pKkLl26aPHixerfv7++/vrrTNtlx2QyKSgoKA9ngeLC24cPXU/4WQPG4M8S8gt9C/mFvpU1a5pD1qTUa97PJZtDAQEB8rOek/3SSQMq825+1lIKCAhQQEBArtvm5gKMVzzUGRQUpLCwMO3fv99tuc1m06FDh1StWjWPNvv27dPJkyf12GOPuS3v3r27SpcurW3btuVrzQAAAAAAXM4rAraUPmP42rVr3ZZt2rRJYWFhqlKlisf2/v7+SklJUXJysttyh8OhxMREmc3mfK0XAAAAAIDLeU3Ajo6OVlxcnNavXy8p/XVbEydOVExMjKT0mcb79u2r+Ph4SenPZbRu3VqDBg3Svn37JEknT57UqFGjFBISoubNmxfOiQAAAAAAiiWveAZbkm6++WZNnz5dU6ZM0YgRI1SqVCn16dNH3bt3l5Q+EVp8fLySkpJcbd566y3NmzdPsbGxOnXqlEJCQhQREaFPPvkkx7O8AQAAAABgBK8J2FL6MPGlS5dmus7f318bNmzwWDZ48GANHjy4IMoDAAAAACBLXjNEHAAAAACAooyADQAAAACAAQjYAAAAAAAYgIANwOuUKhkop8Ne2GUUqOJ2vgAAANcjr5rkDAAkqUSgRSYfXx1d/ZqsZw4Wdjn5zhJaVRXvH1XYZQAAAOAaEbABeC3rmYNKPbG3sMsAAAAAcoQh4gAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABvCpgb9myRT179lR4eLg6dOiguLi4bNs4HA4tXLhQ3bp1U8uWLdWsWTONGDGiAKoFAAAAAOD/8yvsAjIcPHhQsbGxev311xUREaH4+HjFxMSoRIkS6ty5c6ZtnE6nRowYoZSUFE2ePFk33XST7Ha7jh8/XsDVAwAAAACKO6+5gz1//nxFRkYqIiJCklSzZk2NHTtW8+bNy7LN119/rYSEBM2YMUM33XSTJMnX11c33nhjgdQMAAAAAEAGrwnY69atU7t27dyWtWrVSvHx8Tpx4kSmbRYtWqTo6Gj5+XnNjXgAAAAAQDHlFcnUbrcrISFBNWvWdFtuNptVuXJl7dmzR2FhYW7rnE6nfv/9dw0bNkzDhg3TL7/8opCQEHXt2lX9+/eX2WzOUy1Op1MXL17MdTuTyaTAwMA8HRNFy6VLl+R0OgvsePSt4oO+hfxC30J+oW8hv9C3kF/y0recTqdMJlOOtvWKgJ2YmChJCg4O9lgXHBysc+fOeSw/e/asLl26pEmTJmngwIGaPHmyjh49queff17Hjh3T+PHj81SLzWbTrl27ct0uMDBQ9erVy9MxUbTs379fly5dKrDj0beKD/oW8gt9C/mFvoX8Qt9Cfslr37JYLDnazisCdlpampxOZ6ZXBrK6upCamipJ6tatm9q2bStJql69uiZNmqROnTrp6aefVkhISK5rMZvNrue5cyOnVzRQ9NWoUaPAr6iieKBvIb/Qt5Bf6FvIL/Qt5Je89K29e/fmeFuvCNgZd64vXLjgEYozWyZJAQEBkqTbbrvNbXmNGjUUHBys/fv369Zbb811LSaTSUFBQbluh+KD4UPIL/Qt5Bf6FvILfQv5hb6F/JKXvpWbCzBeMclZUFCQwsLCtH//frflNptNhw4dUrVq1TzalClTRkFBQa472ZdzOBwqWbJkvtULAAAAAMCVvCJgS+kzhq9du9Zt2aZNmxQWFqYqVapk2qZFixb6/vvv3Zb9+eefkqSqVavmT6EAAAAAAGTCawJ2dHS04uLitH79eklSfHy8Jk6cqJiYGEnpM4337dtX8fHxrjb9+/fX+++/r59//lmStHv3bo0cOVKxsbF5nkUcAAAAAIC88IpnsCXp5ptv1vTp0zVlyhSNGDFCpUqVUp8+fdS9e3dJ6ROhxcfHKykpydUmPDxcL7/8sl5++WUdPXpUZcqU0aOPPqq+ffsW0lkAAAAAAIorrwnYUvow8aVLl2a6zt/fXxs2bPBYfv/99+v+++/P79IAAAAAALgqrxkiDgAAAABAUUbABgAAAADAAARsAAAAAAAMQMAGAAAAAMAABGwAAAAAAAxAwAYAAAAAwAAEbAAAAAAADEDABgAAAADAAARsAAAAAAAMQMAGAAAAAMAABGwAAAAAAAyQ54D93XffGVkHAAAAAABFWp4Ctt1u15AhQ7Ld7vjx44qOjpbVas3LYQAAAAAAKDLybYh4amqqnnnmGdWoUUMWiyW/DgMAAAAAgFfwy+mG/fr1k91ulyQ5nU45nU717t3btT4qKkr33HOPzp8/r4SEBL388su68cYbNXr0aOOrBgAAAADAy+Q4YHfs2NFtqPd9993ntr5mzZraunWrHnvsMZlMJt1999166623jKsUAAAAAAAvluOA3aNHjxxt99NPP+mPP/7Qe++9p8cff1xvvfWWgoOD81wgAAAAAABFgeHPYIeGhqpNmzZasGCBypUrp8cff1ypqalGHwYAAAAAAK+S44C9YsUKffLJJ9q3b99Vt0tKSlJSUpJSUlI0cuRI3XjjjUpMTLzWOgEAAAAA8Go5HiI+duxY1a5dW2+88YaaNWumF198UdWrV3fb5uTJk7rzzjtlMpnkdDpd/929e7dWr15tdO0AAAAAAHiNHN/Btlqt+uyzz7R+/XrdfPPN6tmzp3755Re3bcqVK6e///5bTqdTv/32m3bt2qWffvpJBw4cMLpuAAAAAAC8So4DtslkkiSVLl1aI0eO1Lhx4zRkyBDt3bs3020zti9ZsqRBpQIAAAAA4L3yPMlZx44d1b9/fw0fPtz1fuzLZQTsS5cu5b06AAAAAACKiGuaRXzAgAEym81asGCBJGnfvn2qW7eunE6nmjRpoltuuUUtW7ZU5cqVDSkWAAAAAABvleNJzpxOp8cyHx8fjRgxQiNHjtTDDz+sWrVqafPmzW7bmEwmBQUFXXulAAAAAAB4sRwH7PHjx8tisXgsb926tZo3b66EhATVqlVLwcHBhhYIAAAAAEBRkOOAHRkZmeW66dOnG1ELAAAAAABF1jU9gw0AAAAAANIRsAEAAAAAMAABGwAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAAAAADAAARsAAAAAAAMQsAEAAAAAMAABGwAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAAAAADAAARsAAAAAAAMQsAEAAAAAMAABGwAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAAAAADAAARsAAAAAAAMQsAEAAAAAMAABGwAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAAAAADAAARsAAAAAAAMQsAEAAAAAMIDXBOwtW7aoZ8+eCg8PV4cOHRQXF5fjtna7Xd26dVOjRo3ysUIAAAAAALLmFQH74MGDio2NVWxsrDZv3qzZs2dr7ty5WrlyZY7af/DBB6pYsaLS0tLyuVIAAAAAADLnFQF7/vz5ioyMVEREhCSpZs2aGjt2rObNm5dt2/3792vZsmUaOnRofpcJAAAAAECWvCJgr1u3Tu3atXNb1qpVK8XHx+vEiRNZtnM6nRo7dqxGjx6twMDA/C4TAAAAAIAs+RV2AXa7XQkJCapZs6bbcrPZrMqVK2vPnj0KCwvLtO3ChQtVqVIltW7dWocOHTKkHqfTqYsXL+a6nclkIuQXE5cuXZLT6Syw49G3ig/6FvILfQv5hb6F/ELfQn7JS99yOp0ymUw52rbQA3ZiYqIkKTg42GNdcHCwzp07l2m7w4cP68MPP9SiRYsMrcdms2nXrl25bhcYGKh69eoZWgu80/79+3Xp0qUCOx59q/igbyG/0LeQX+hbyC/0LeSXvPYti8WSo+0KPWCnpaXJ6XRmelXgalcWXnzxRQ0dOlRlypQxtB6z2aybbrop1+1yekUDRV+NGjUK/Ioqigf6FvILfQv5hb6F/ELfQn7JS9/au3dvjrct9ICdcef6woULCgkJcVuX2TJJWrFihXx8fNSlSxfD6zGZTAoKCjJ8v7h+MHwI+YW+hfxC30J+oW8hv9C3kF/y0rdycwGm0AN2UFCQwsLCtH//ft16662u5TabTYcOHVK1atU82uzatUtbtmxR8+bNXcscDofsdruaN2+u9u3ba9KkSQVSPwAAAAAAkhcEbCl9xvC1a9e6BexNmzYpLCxMVapU8dj++eef1/PPP++27NChQ7rnnnu0ZcuWfK8XAAAAAIArecVruqKjoxUXF6f169dLkuLj4zVx4kTFxMRISp9pvG/fvoqPjy/MMgEAAAAAyJJX3MG++eabNX36dE2ZMkUjRoxQqVKl1KdPH3Xv3l1S+kRo8fHxSkpKynIfZrNZ/v7+BVUyAAAAAABuvCJgS+nDxJcuXZrpOn9/f23YsOGq7cuXL69t27blR2kAAAAAAGTLK4aIAwAAAABQ1BGwAQAAAAAwAAEbAAAAAAADELABAAAAADAAARsAAAAAAAMQsAEAAAAAMAABGwAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAAAAADAAARsAAAAAAAMQsAEAAAAAMAABGwAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAAAAADAAARsAAAAAAAMQsAEAAAAAMAABGwAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAAAAADAAARsAAAAAAAMQsAEAAAAAMAABGwAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAAAAADAAARsAAAAAAAMQsAEAAAAAMAABGwAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAAAAADAAARsAAAAAAAMQsAEAAAAAMAABGwAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAAAAADAAARsAAAAAAAMQsAEAAAAAMAABGwAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAAAAADAAARsAAAAAAAMQsAEAAAAAMAABGwAAAAAAAxCwAQAAAAAwAAEbAAAAAAADELABAAAAADCAVwXsLVu2qGfPngoPD1eHDh0UFxd31e03btyomJgYtWrVSrfddpuio6O1d+/eAqoWAAAAAID/z2sC9sGDBxUbG6vY2Fht3rxZs2fP1ty5c7Vy5cos2yQkJKh37976/vvvtWHDBjVs2FADBw7UxYsXC7ByAAAAAAC8KGDPnz9fkZGRioiIkCTVrFlTY8eO1bx587JsExUVpTvuuEMBAQGyWCwaOnSoJGnHjh0FUjMAAAAAABm8JmCvW7dO7dq1c1vWqlUrxcfH68SJEznah8lkUokSJZSUlJQfJQIAAAAAkCW/wi5Akux2uxISElSzZk235WazWZUrV9aePXsUFhaW7X4OHDigI0eOKDw8PM+1OJ3OPA0xN5lMCgwMzPNxUXRcunRJTqezwI5H3yo+6FvIL/Qt5Bf6FvILfQv5JS99y+l0ymQy5WhbrwjYiYmJkqTg4GCPdcHBwTp37lyO9vPmm2+qV69eCgkJyXMtNptNu3btynW7wMBA1atXL8/HRdGxf/9+Xbp0qcCOR98qPuhbyC/0LeQX+hbyC30L+SWvfctiseRoO68I2GlpaXI6nZleGcjp1YVly5Zp9+7dmjRp0jXVYjabddNNN+W6XU6vaKDoq1GjRoFfUUXxQN9CfqFvIb/Qt5Bf6FvIL3npW7l5U5VXBOyMO9cXLlzwuPuc2bIr/fnnn5oyZYo+/vhjBQUFXVMtJpPpmveB6xvDh5Bf6FvIL/Qt5Bf6FvILfQv5JS99KzcXYLxikrOgoCCFhYVp//79bsttNpsOHTqkatWqZdn26NGjio2N1SuvvJKnO88AAAAAABjBKwK2lD5j+Nq1a92Wbdq0SWFhYapSpUqmbS5cuKABAwaoX79+atu2bUGUCQAAAABAprwmYEdHRysuLk7r16+XJMXHx2vixImKiYmRlD7TeN++fRUfHy8p/bntIUOGKDw8XH379i2ssgEAAAAAkOQlz2BL0s0336zp06drypQpGjFihEqVKqU+ffqoe/fuktIDdXx8vOsd13v37tXPP/+sHTt26KuvvnLbV9euXTV27NgCPwcAAAAAQPHlNQFbSh8mvnTp0kzX+fv7a8OGDa7PdevW1T///FNQpQEAAAAAcFVeM0QcAAAAAICijIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANAAAAAIABCNgAAAAAABiAgA0AAAAAgAG8KmBv2bJFPXv2VHh4uDp06KC4uLhs26xdu1ZdunRReHi4unTporVr1xZApQAAAAAAuPMr7AIyHDx4ULGxsXr99dcVERGh+Ph4xcTEqESJEurcuXOmbbZu3apx48Zp1qxZatSokX7//Xc98cQTKlOmjJo1a1bAZwAAAAAAKM685g72/PnzFRkZqYiICElSzZo1NXbsWM2bNy/LNvPmzdOTTz6pRo0aSZIaN26s2NhYffTRRwVRMgAAAAAALl4TsNetW6d27dq5LWvVqpXi4+N14sQJj+2tVqs2bdrk0aZ9+/batGmTbDZbvtYLAAAAAMDlTE6n01nYRdjtdtWvX1+bN29WcHCw27rOnTtr1KhRuuOOO9yWJyQk6KGHHtLmzZs99tekSRMtXbpU1atXz1Udv/32m5xOp8xmc67PQZJMJpPOJ6coze7IU/uixt/sqxKB/rJfSpTTnlbY5eQ7k6+ffANLqzD+yNC3rm/0rYJD3yrAY9O3rmv0rYJD3yrAY9O3rmvX0rdsNptMJpOaNm2a7bZe8Qx2YmKiJHmE64xl586d81h+9uzZTLe/WpvsmEwmt//mRUiJgDy3Lap8A0sXdgkF6lr6x7Wgb13/6FsFh75VMOhb1z/6VsGhbxUM+tb1Ly99y2Qy5bidVwTstLQ0OZ1OOZ1Oj8KzusJwtSHgme0nJ5o0aZLrNgAAAAAASF7yDHbGnegLFy54rLtw4YJCQkI8loeEhOj8+fOZ7i8pKSnLu9sAAAAAAOQHrwjYQUFBCgsL0/79+92W22w2HTp0SNWqVfNoU6VKFV28eFGnTp1yW37s2DHZbDZVqlQpX2sGAAAAAOByXhGwpfQZw9euXeu2bNOmTQoLC1OVKlU8tg8ICFDTpk092nz33Xdq3ry5LBZLvtYLAAAAAMDlvCZgR0dHKy4uTuvXr5ckxcfHa+LEiYqJiZGUPtN43759FR8f72ozaNAgvfPOO9q+fbsk6Y8//tCMGTM0cODAgj8BAAAAAECx5hWv6crw008/acqUKTp48KBKlSqlPn36qE+fPpKk1NRUdejQQTNmzFCjRo1cbVauXKmZM2fqxIkTKleunIYMGaLOnTsX1ikAAAAAAIoprwrYAAAAAAAUVV4zRBwAAAAAgKKMgA0AAAAAgAEI2AAAAAAAGICADQAAAACAAQjYAAAAAAAYgIANoMA88sgj2rx5c67aLFu2TM8//3w+VYSi7vjx47r33nslSdu2bdPjjz/utn7GjBlq2bKl66tnz55u65cvX66nn346033/8ssvGj58uNq2bavWrVurdevWuueeezRq1Cht3749f04IAAAUaX6FXQC8zyOPPKIRI0YoPDzctWzjxo2aMGGC63PHjh311FNPuT7fddddWrRokcqXL1+gtcI7JCQk6OGHH3ZblpKSonLlyumbb75xLbPb7bLZbK7Pjz32mPbs2SOLxeJaduHCBT333HN65JFHJEk2m01Wq9XjmMOHD9emTZsUEBCQZV3/+c9/NHz48DyfF7zD6NGjtX79etdnk8mk1q1ba9KkSbLZbK4+ZbVa3fqXJA0ZMkRDhgzJct9X9skMcXFxmjdvnp5//nlNmDBBQUFBkqSzZ8/q22+/1cCBAzVjxgw1b97ciFNEPhgzZoy++uort79ffH199e2336pUqVKuZT/++KOGDRuml19+WR07dsx2vzt37tTbb7+tHTt2KCUlRZUqVdIHH3ygsLCwfDkPeK/Zs2frnXfeUUBAgHx8fFSyZEm1adNGQ4cOVUhIiMaOHasVK1bIYrHIbrcrMDBQDz30kJ566im3fpmdTz75RBMnTtRHH32k2267zWP9iy++qCpVqmjAgAEe69577z0dO3ZM48aNc1t++vRpzZ07V+vWrdOpU6eUmpqqUqVKafz48WrXrl2ufxbIvRUrVmjUqFEKDAyUw+GQJLVu3Vpjxoxx+306MTFR7733nr799ludO3dOISEhateunYYMGaLSpUtnuu/vvvtOCxcu1M6dO5WamiqHw6HGjRvr448/zlFtVqtVbdu2VY0aNfTpp596rM+4uP37779n2r5Bgwb64YcfdMMNNxhaV1FBwC5G8hqCJOnOO+902+ZKqampmf6SSggqHqpUqaJNmza5LVuwYIG++uqrq7bbvXu3Fi9erCpVqriWvfXWWzp48GC2x9y5c6fmzp2rRo0a5a1oFBkTJ050+zx79mxt2bIlX4/59ddf68knn1Tbtm3dlpcpU0aRkZGKj4/XunXrCNhezG63a9CgQXriiSey3GbJkiWaM2eOypYtm+m/YVfat2+fBg4cqPHjx2vWrFny9fXV33//rbJlyxpZOooIq9WqBx980HUDIjk5WRMmTNDIkSM1a9YspaWlufXBhIQEvfDCC5oyZYrGjBmT4+N8/vnnatGihRYvXpxpwM7s4mKGyy9CZvjrr78UExOjBx54QO+//77r3+CjR4/muCZcu7S0NIWHh+ujjz6SJJ0/f14zZ87UoEGD9OWXX8pkMunIkSN69NFH1bp1a3322WcqX768jh07phkzZqh79+5auHChx8W9F198Udu2bdPw4cN1xx13yN/fX1arVbt3785xbWvXrlWlSpW0fft2HThwQNWrV3dbn9XNj8vXp6WlGV5XUUHALkbyEoLWrVvn8cvt5WrWrKnZs2dnuZ4QVDydPXtWb7/9tiZNmpTttiaTye2zj0/OnlxxOp0ebVE8bNy40TUsPCsLFiy46t9NdevW1Zw5c7JcX79+fS1evFjh4eEeI3N27typ7777TiNGjMhd4fAqycnJ+u9//6uFCxdq2LBhOWqzePFidejQQe3bt3ctq1u3bj5ViKKmRIkSGjNmjMLDw3X27FmP9VWqVNHYsWPVo0ePHAfsbdu2KS0tTS+++KK6d++upKQklSxZMs81JicnKzY2Vs8884wefPBBt3UVK1bM835x7UJCQvTcc8/prrvu0p9//qmGDRtq3LhxatGihV5++WXXdhUqVNCrr76q559/XhMnTtT06dNd6z755BNt375dn332mVs/sVgsatCgQY5rWbJkiaKiovT9999r6dKl13wjzKi6igoCdjGWkxDUpk0btWnTRkeOHNF3332nI0eOqESJEmrWrJluu+22bAMOIaj4SUlJUWxsrFq3bq02bdooNjbWNYTo3LlzhVsciryTJ0/qjz/+0BtvvHHV7Xr16qVevXpJks6cOaO9e/cqNDRUN910U46O8/TTT+uDDz5QVFSU/P39VbZsWTkcDh09elRBQUEaNGhQjoYTw3uVKFFC7733Xq7bnTlz5qrr09LSNGfOHH355Zc6e/asLBaLXnjhBXXs2FFOp1MffvihPvvsM509e1ahoaGKiopS3759Xe1ffPFF1atXT7t379aqVavUu3dvxcbG6syZM3r11Ve1fv16mc1mPfDAA3r22WdlNptzfQ7IPyVKlFBoaKgOHTqU6fpKlSrp4sWLSkxMzHJ47+UWLVqkBx98UDfddJNq1Kih1atXq0ePHnmub8mSJapevbpHuIZ38PX1VcWKFXX06FGVLl1aP/74Y5YjSAcNGqTOnTvrxIkTCgsLU1pamt59913NmDHjmi7CHD58WH/88YdrP6+++qqGDRuW59/njaqrKCFgF1O5CUE//fSTXn75ZfXr10+tW7dWcnKy4uLitGTJEk2dOrUQqoe3OnHihEaMGKGgoCBt27ZNGzdu1MyZM13rr5xgSkq/CHO5jOeQgMy8//77ateuXY7ne5g1a5bi4uLUoEEDHT16VGazWbNmzdJ///tfzZkzR8nJyWrZsqVHO19fXw0cOFADBw7U8ePHlZiYKB8fH5UtW1ahoaFGnxaKiKioKD3yyCMaP368Ro4cKX9/f49tXnjhBR08eFBz585V9erVlZKS4hoq+e677+rrr7/WzJkzdfPNN2vfvn0aNmyYrFarBg4cKCl9uO8XX3yh7t2765dffnH9nRgbG6saNWrohx9+kM1m0/DhwzVz5swc331HwTh//rzOnTunG2+8MdP127dvV9myZd3mAchKcnKyvvnmG61YsUKS1KVLFy1btuyaAvaGDRuyHQGEwpOUlKT9+/erRo0a2rp1qxo0aKCqVatmum2NGjVUp04dbdmyRR07dtTOnTvl6+urZs2aXVMNX375pTp06KDAwEDdddddunjxon7++WfdfvvtedqfUXUVJQTsYii3IeiXX37RnXfeqcjISNey2rVre/wF3717d/n6+mrYsGHX9Jc/ih6n06mvvvpKU6dOVb9+/dSvXz/t3LlTTz/9tCpVqqQXXnjB4/kdKf0fhx49erhN9pKUlKRRo0Zle0yTyXTV539w/UlISNBnn33m8dzz0aNHdccdd8hms6lOnTqu5du2bdPSpUu1cuVKBQcHS5LefvttvfLKK5o+fboefvhhffnll/rhhx9cbWJjY7Vjx45c1fXggw9mORM5ri9VqlTR/Pnz9dxzz6lTp04aM2aM2rRp41r/xx9/6Pvvv9d3333nulOTMQfJhQsXNHfuXH300Ue6+eabJUm1atXSxIkT9fjjjysqKsrVJi0tTVFRUZLSH5vZuHGjjh49qk8//VR+fum/uo0fP16RkZGKjY3lLrYXcDgc2r9/vyZOnKjIyEiP5/JTU1P1yy+/aNy4cXrmmWdcdwM7d+6sY8eOSUr/d23NmjWui3hff/216tWrp8qVK0uSOnXqpKlTpyohIcFt7pLcOHLkSJaBDYXHbrdrz549mjBhgu655x7Vrl1b69aty/b/VbVq1Vz95/DhwznqF8uXL9crr7zi+tyjRw/X21ocDoe+/PJLvfbaa5Iks9ms++67T0uXLs1zwM5pXdcTAnYxktcQ1KdPHz377LPq3r27qlWrpuTkZP37779us4pL6c+mZfwjkIEQVDzExMTIbrdrzpw5rucR69evrxUrVmjRokVZ/vL3+eefZ7vvO++8U7fccovH8latWmno0KGuO+AXLlyQ2Wx2m1DvzjvvzNFz4PB+qampGjp0qJ566ilt2LBBK1as0AMPPCAp/bnB77//Xr/88otmzJjhanPgwAHVr1/fFa6l9H6zdu1aJSUl6fTp0zp9+rTbcS6/2ChJderU0ebNmxUSEiIpfeKX+fPnuyalgXd77733NG/ePNfnatWqacmSJde0z+rVq+vzzz/XF198oZEjR6pjx4568cUXZTKZ9N1336lt27aZDoPctWuXypQp4zEnScOGDRUSEqK///7bdfHo8rd4SOnB/a677nKF64w6nE6njh07Vux+efUmy5cv15o1a+RwOFSpUiV17dpVvXv3dq3P6IMZE8g+/fTTeuihh1zrV65cmeW+lyxZom7durk+ly9fXi1bttTSpUvd3uSSG1eOGkPh2rx5s5o3by673S6n06nWrVu7hd/88OCDD2b5iMBPP/0kp9PpNrLrgQceUP/+/ZWcnKwSJUrka23XCwJ2MZLXEBQaGqoPPvhA58+fV1RUlGJiYtS5c2dJ6a95uNoM4YSg4uG1117LdBZdi8Xieg5WkkaNGuXxDGxSUpK6deuW5dBwPz8/xcTEeEyCMW7cOLfXjjzzzDNq1qyZ6/VeuH6kpaVp1KhRrtfQdOzYUVFRUapUqdJVh4q3atVKb775plavXq27775bR44c0bRp0/TQQw9p/fr1WrRokU6ePKlatWoV4NmgIGU3i3he+fj46OGHH9bdd9+tXr16afHixerRo4fOnDmT5eu6Mp6TzExYWJjrLpSUPlv95Y4fP67ly5fr66+/dltutVp17tw5AnYhunwW8cxc3gdnzJihP//8M0f73bdvn/766y+9//77Hsd7++239eSTT7rugptMpiyDs9PpdJs89MYbb8zy+XAUvMtnEf/11181cuRI1//LcuXK6b///e9V2//777+6++67JaVfbL7W/7eLFy/WAw884Pa8dbNmzVS2bFmtWbPGdXHoahPSZtSfsQ8j6ipqCNjFSF5C0OOPP66kpCTXukOHDmnKlCl6/fXXZTKZFBoaquHDh8vHxyfTyQ8IQcXD5f3q77//1vz58/Xrr78qNTVVTqdTpUqVUtu2bfXoo4+63U2UpJIlS2rNmjVZ7nvBggXauHGjunbtml/lw4tdunRJw4YNU2BgoKZMmSIpfZKg119/XcOGDfP45fNy5cuX19y5c/X2229rypQpCg0N1UMPPeQaetupUyePIeIZRo0apS1btqhq1apud5AytGzZUiNHjtR//vMfY04URVKFChXUu3dvbdiwQT169FBoaKiOHDmS6balS5fWiRMnMl134sQJt2f7r/zltUSJEnr44Yc1evRo44pHgXvsscfUrl077du3L9sLe4sXL1ZqamqWrwL89ddfXXcZQ0JCsuxbx48fd7tgc8cdd+jbb7/NdE4UFK4WLVqofPny+vLLLxUZGakmTZpo9OjROnjwYKZDxePj4/XXX3+pcePGktJvmlmtVv3xxx+69dZbc338s2fPau3atbLZbJm+hWPp0qWugB0SEiK73a5Tp055vOv6+PHjMplMrnkGrrWuooiAXYzkJQS9/vrrrslZTCaT/P39FRAQIH9/f7dAvWrVKib+gf766y/169dPzz77rEaOHOkaJnnkyBHFxcWpe/fuWrFiRY4mdwEk6eDBg6pbt67HDKYtW7bUkiVLsn0EpU6dOoqKilJ4eLjbs/4ZqlSp4vrl5HIZz59lZerUqYqPj8/ZSeC6duzYMde/mW3atFF0dLTOnDnj8W9ikyZNdP78eW3fvt1tmPiOHTuUlJSkJk2aZHmMBg0aaN68ebyZo4grVaqUHn74Yc2YMUPTpk3Lcjubzably5fr008/VYsWLTzWjxkzRsuWLXMF7ObNm2vixImyWq1uf8+lpqbqxx9/1Pjx413LevTooXnz5mnVqlXq1KmTgWcHIwwePFgvvfSS/vOf/6h69epq0aKFZs6cqcmTJ3tsO3v2bIWHh6tatWqS0m+Y9e/fX+PHj9f8+fMVFBSUq2OvWLFCTZo00aeffuqx7vDhw+rQoYMOHTqkypUrq2TJkqpTp46+/fZb10XrDN99953q16/vGq16rXUVRQTsYig3IeiGG26Q1WpVu3btshzCazKZVL58eX322WeZ/gKL4uPHH39UmzZt1L17d7flN954o4YPH64NGzbo999/V0REhGudw+HQvffeK5vNlumQIz8/Pw0ePNj1efDgwdq+fXumx//f//7n9gxuhq5du+rZZ5/N62mhENWpU8dt4rLLhYWF5WjY2XPPPaeFCxe6fgm5XHh4uMfzrlL6xcUVK1YoMDAw031aLBb6VDG0detWWSwW1a9fXw6HQ2vXrtWyZcs0f/58Sekh+u6779aAAQP05ptvqlq1arJarbLZbCpRooQGDBigUaNGadq0abr55pv1999/6+mnn1ZMTEyWfU2S2rdvr7feekvjx4/XU089pdDQUB0/flwJCQlZ3uGEd3r88cfVrl077dmzR7Vr1850m++//16lS5fONFxLUmRkpPr06aMXXnhBQUFBateunT788EMNGTJEY8eOVZUqVXTw4EFNmDBBVatWdfs3Nzg4WO+8845iY2O1Z88e9ezZ0zXjecZjChUqVDD4rJFTd911l0JDQ7V48WJFRUXplVdeUVRUlEaPHq0nn3xSFStW1PHjxzVz5kxt3LhRCxYscGsfHR2tf/75R1FRURoxYoRuu+02WSwWWa1W7dmzR/Xr18/y2IsXL3b7fetylSpVUuvWrbVs2TINGTJEUvrrLJ999lmVKFFC99xzjyRpzZo1euuttzwuIF1LXUURAbsYym0Islgs2rhxY5b7czqdatGihU6ePKlKlSpJIgQVV61bt9aHH36or776Su3bt3f9wnjy5El98cUXSkxM9LhLc+nSJR08eFB///13ju7MvPvuu/lSO65fV3s+MSu7d+/WSy+9pA4dOuRTVchvFoslx7NrWyyWHF0gPn78uGbMmOF6H3r9+vX1wQcfuA33nTJlimbNmqXHHntMycnJ8vHx0ZgxY9S1a1cNHDhQAQEBGjJkiM6cOaOyZcuqd+/eevTRR91qufL1XwEBAfr44481adIk3XvvvXI4HCpbtqwGDhxIwC5E2fWxzNaHhobq4Ycf1rvvvqs333wz03ZLly696hDuRo0aqWbNmvruu+/UpUsX+fj4aO7cufrggw80YMAA17Ddzp07Kzo62uPf1iZNmmjp0qWaO3eu+vXrp9OnTystLU3lypXTmDFjCNgFJKv+Exsbq1deeUWRkZGqWrWqlixZohkzZigyMlLJyckKCgrSnXfeqSVLlqhixYpubX18fDR16lStXr1aH374oZ599lnZbDaZTCaFh4frvffey7SWnTt36tSpU2rfvn2W9UZFRem1115zBeyIiAi99957mjlzpmsupXr16um9995T06ZNDamrqDI5mU6w2Pnrr78UHR2t0aNHZxqCFi9erOXLl7tmzc2JjOGaV84ijuLnr7/+0qeffqqtW7e6hu8GBwerTZs26t27t8ezOg6HQ/fcc48cDod8fX0z3WdAQIC++uqrfK8dRc/x48fVp08fffPNN/rtt980Y8YMt1mjJWnAgAHavn272wzMlzOZTFq0aJHbLyqTJ0/W0qVLrzqUrVatWld9BhwAABQ/BOxiKrchKDsEbAAAAADFHQEbhvjnn39Uu3btq07bDwAAAADXMwI2AAAAAAAG4HYjAAAAAAAGIGADAAAAAGAAAjYAAAAAAAYgYAMAAAAAYIDMXwoKAAAKVaNGjZSamprl+q5du2ry5MmSpN69eysyMlKdOnVyrXc4HHI4HG5tTCaTx/vmo6Oj1aVLF3Xt2jXbmux2u66cG9XHx8fjDRLt27fXpEmT1Lx5c9eyY8eOKSIiIttjSFK/fv00cuTIHG0LAIA3IWADAOCFtm/fLklq2LChli1bplq1aunkyZNq3bq1tm/fLn9/f9e2NpvNI4x36dJFe/fu9dhvrVq1tGrVKplMJkmS1WqVzWbLtp7jx4/rrrvu8lhuMpnUrVs3TZgwwbXMarXKarW6bVehQgX9888/OnTokNq1a6d//vnHbf2sWbMUHx+vqVOnZlsLAADeioANAEARNGvWLL311luuzz169HBbv2rVKo82f//9tx566CHZ7Xb5+eXuV4Dy5ct7hGJJGjRokAIDA3O1LwAArlc8gw0AQBH0xBNP6J9//tE///yjpk2b5qjN8ePHVbFixVyH66wkJiZq06ZNeuihhwzZHwAARR0BGwCAYuLnn39WeHi4YftbtGiR6tevr3r16hm2TwAAijICNgAARdCsWbNUp04d1alTR7/99lu229tsNn399de67777PNY5HA6lpaV5TIp2NUeOHNGsWbP07LPP5qpuAACuZwRsAACKGKvVqs6dO+uXX37J8RDxJUuWKCAgINOJyl588UXVr19fd955Z46Ob7fbNXbsWJlMJlWtWjXX9QMAcL1ikjMAALzMqVOn1K9fPzmdTtlsNg0YMEAmk0mpqakymUxq3769KlasqCeffFLt2rXLdn9Hjx7VtGnTNGnSJI9XaknSq6++6jFJ2tW88sorunjxojp37qyhQ4fqo48+ksViuWqbjz76SK+99prrc506dTLd7quvvlJYWJg2btyY43oAAPAWBGwAALxMaGiopk+fLrvdLpPJJB8fHwUEBKhkyZIKDg7ONCRnJSkpSUOGDNF9992nNm3aXFNddrtdr7zyirZu3ar58+crKChIgwYN0jPPPKM333zzqpOn9e3bV3379pUk3XHHHZo5c6YaN27sWh8dHa327dvrkUceuaYaAQAoTARsAAC8jI+Pj2rVquW2bO3atVq8eLF2796tkydPKjg4WFWrVlXHjh316KOPuoXVDKdOnVJsbKzKlSunsWPHXlNN58+f1zPPPKNTp05p3rx5KlWqlCTpnXfe0RNPPKGYmBhNnz5dwcHB13QcAACKMp7BBgDAy02aNEnjxo1TmzZt9PHHH+uXX37R0qVL1b9/f61Zs0YzZ85USEiIW5tvv/1WXbt2Va1atfT222/LbDZfUw1PPPGESpcurQULFqhcuXKu5UFBQZozZ46aNm0qX1/fazoGAABFHXewAQDwYklJSfrkk0/0+eefq1GjRq7lQUFBKl++vNq0aaOuXbtq+fLlevTRRyVJv//+u8aNG6fnn39eDz74oCF1vP322woNDc10ncViUWxsbJZt7Xa7nE6nx7K0tDS3ZRmzmWfw9fWVyWS6hqoBAChYBGwAAIoAf3//TJf7+Ph43J1u3Lix1q1bl2WbvMgqXOdE48aNZbVa3ZZFRUV5bPfjjz/q5Zdfdn2OjIx0+wwAgLcjYAMA4MVKliypXr16afDgwRo2bJhatmyp0NBQJScna+fOnfrwww916dIljzvVRobra7Vjx47CLgEAgAJBwAYAwMuNGTNGTZs21aJFizRp0iSdOXNGQUFBqlatmjp16qSHH35YJUuWzNO+LRbLNT+fndk+s3ttFwAA1yOT88qHogAAgFdzOBy5elUXAAAoGARsAAAAAAAMwOVvAAAAAAAMQMAGAAAAAMAABGwAAAAAAAxAwAYAAAAAwAAEbAAAAAAADEDABgAAAADAAARsAAAAAAAMQMAGAAAAAMAABGwAAAAAAAzw/wA4/xQxmz6UswAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "split metric Test Train\n", + "0 F1 Score 0.842573 0.878897\n", + "1 PR-AUC 0.955974 0.974105\n", + "2 ROC-AUC 0.986500 0.992645\n", + "3 재현율 0.934129 0.972138\n", + "4 정밀도 0.767363 0.801976\n", + "5 정확도 0.929896 0.944661" + ], + "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", + "
splitmetricTestTrain
0F1 Score0.8425730.878897
1PR-AUC0.9559740.974105
2ROC-AUC0.9865000.992645
3재현율0.9341290.972138
4정밀도0.7673630.801976
5정확도0.9298960.944661
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"plot_model_feature_importance(event_model_importance, f\\\"\\ubd88\\ub7c9 \\ud0d0\\uc9c0 \\ud53c\\ucc98 \\uc911\\uc694\\ub3c4 - {selected_event_model_name}\\\", top_n=25)\",\n \"rows\": 6,\n \"fields\": [\n {\n \"column\": \"metric\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 6,\n \"samples\": [\n \"F1 Score\",\n \"PR-AUC\",\n \"\\uc815\\ud655\\ub3c4\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.08187723811943914,\n \"min\": 0.7673625905411163,\n \"max\": 0.9865001903781169,\n \"num_unique_values\": 6,\n \"samples\": [\n 0.8425730994152046,\n 0.9559739814794836,\n 0.9298958333333334\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Train\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.07324130855606069,\n \"min\": 0.8019760790431617,\n \"max\": 0.9926450697410859,\n \"num_unique_values\": 6,\n \"samples\": [\n 0.8788966774947284,\n 0.9741047418313843,\n 0.9446614583333334\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "재현율(Recall): 0.9341\n", + "정밀도(Precision): 0.7674\n", + "F1 Score: 0.8426\n", + "PR-AUC: 0.9560\n", + "임계값(Threshold): 0.5025\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 지표 값\n", + "0 정확도(Accuracy) 0.929896\n", + "1 정밀도(Precision) 0.767363\n", + "2 재현율(Recall) 0.934129\n", + "3 F1 Score 0.842573\n", + "4 ROC-AUC 0.986500\n", + "5 PR-AUC 0.955974\n", + "6 오탐률(False Positive Rate) 0.071168\n", + "7 임계값(Threshold) 0.502521" + ], + "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", + "
지표값
0정확도(Accuracy)0.929896
1정밀도(Precision)0.767363
2재현율(Recall)0.934129
3F1 Score0.842573
4ROC-AUC0.986500
5PR-AUC0.955974
6오탐률(False Positive Rate)0.071168
7임계값(Threshold)0.502521
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"plot_model_feature_importance(event_model_importance, f\\\"\\ubd88\\ub7c9 \\ud0d0\\uc9c0 \\ud53c\\ucc98 \\uc911\\uc694\\ub3c4 - {selected_event_model_name}\\\", top_n=25)\",\n \"rows\": 8,\n \"fields\": [\n {\n \"column\": \"\\uc9c0\\ud45c\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 8,\n \"samples\": [\n \"\\uc815\\ubc00\\ub3c4(Precision)\",\n \"PR-AUC\",\n \"\\uc815\\ud655\\ub3c4(Accuracy)\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uac12\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.3152191025343723,\n \"min\": 0.07116788321167883,\n \"max\": 0.9865001903781169,\n \"num_unique_values\": 8,\n \"samples\": [\n 0.7673625905411163,\n 0.9559739814794836,\n 0.9298958333333334\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 예측 정상(0) 예측 불량(1)\n", + "실제 정상(0) 7126 546\n", + "실제 불량(1) 127 1801" + ], + "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", + "
예측 정상(0)예측 불량(1)
실제 정상(0)7126546
실제 불량(1)1271801
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"plot_model_feature_importance(event_model_importance, f\\\"\\ubd88\\ub7c9 \\ud0d0\\uc9c0 \\ud53c\\ucc98 \\uc911\\uc694\\ub3c4 - {selected_event_model_name}\\\", top_n=25)\",\n \"rows\": 2,\n \"fields\": [\n {\n \"column\": \"\\uc608\\uce21 \\uc815\\uc0c1(0)\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4949,\n \"min\": 127,\n \"max\": 7126,\n \"num_unique_values\": 2,\n \"samples\": [\n 127,\n 7126\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uc608\\uce21 \\ubd88\\ub7c9(1)\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 887,\n \"min\": 546,\n \"max\": 1801,\n \"num_unique_values\": 2,\n \"samples\": [\n 1801,\n 546\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc8AAAF/CAYAAAAvskJeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAASaxJREFUeJzt3XdUFFfDBvBnKUsRpCggIIoaI/YChpgQe4uxKxJ776hBxV5iLPFNNCpqohgsKYqIYDcxKppggogFWxK7FBFUOkrZ8v3hx8Zxd4FBcBd9fudwjjtzZ+auujx755aRKJVKJYiIiKjEDHRdASIiooqG4UlERCQSw5OIiEgkhicREZFIDE8iIiKRGJ5EREQiMTyJiIhEYngSERGJxPAkIiISieH5lnvy5Anc3Nzw7NkzrWV2796NcePGqW3/+uuvUa9ePbUfLy8vPH78WFVu9OjR2LdvX7F1uXLlCtzd3TWec+fOnapygYGBmDdvntrxSqUSMplM7edlMTEx6NixY7H10VcbN25U+/u5fv16kcdcu3ZN69/tiz9r1qzReHy3bt0E5eLj41X7mjZtirS0NADA8OHDERERodqXnZ2NBg0aCI51c3ODj4+P2jVGjx6N/fv3l+avpFSmTp2K5cuXiz7u22+/xaJFi8qhRlSRGOm6AqRbCoUCSqUSzZo1K7Kcl5eX2raZM2fCz89P7Xxt2rTBvXv3ULVqVQBAfn4+CgoKiq3LrVu3UKNGDezZs0dtn5HRf/9V8/LykJ+fr1YmMDAQ33zzjdp2qVSKwMBAtGrVSlUfTce/qEuXLrh3757W/R9++CG2bt1a5DmK8/DhQxw/fhxDhgwptmxkZKTq77B+/frYuHGjYH9ycjKSk5MBAFZWVmjRooVg/82bN+Hk5ISwsDBIJBKt1zE0NBS8ViqVkMvlCAsLg1wuBwBIJBJIpVIoFAoYGBggNzdX9SUlPz8feXl5quMtLCxw5coVvLgK6K1bt9CrVy+1a5fk30WM+fPnw8TERGvQOTs7o0qVKqLPK5fLS1zP/fv3o379+nj33Xc17j9z5gx2796NixcvIi0tDVKpFA4ODmjdujXmzp2rKnf+/HkMGjQIwPO//6pVq6JBgwbw9fVFkyZNVOUePnyItm3bwtzcHL///jssLCy01i0gIAAbN27EkCFDsHDhwhK9H/oPw5MAPG+NmZmZady3e/dunDx5Um27RCIRhFohY2Nj1S/aQr/88gvu3LkDCwsLTJ48WeN1lEoljI2NNZ6zJMaPH4/x48cLtqWlpeH999+HlZWVqHOFh4erAuHq1asYOXIkzp07p9ovlUpLVccX3b9/H1u3bi1ReEZHR5foCwgAVKtWTS08FQoFzMzMYGxsLKqOy5cvx969ezXuc3Nzw65du4o9x8uB/OL/s08++QS3bt1Sve7Zs6eo+hVFLpdrvPNQaPbs2WV2LW1CQ0PRp08ftfCUyWRYuHAhTpw4gWHDhmHixIlwcHBAbm4u7t+/jzt37qiVB4Bz585BqVTi0aNHCA4OxvDhw7F//37UqFFDVU6pVKJq1ao4cuQIBgwYoLFeCoUCoaGhqFmzZon/X5EQw/MtV9gKKSgogKWlpcYyRX24ClsmhRQKBfLz89V+YSYkJCA/P7/YEMvOzsbZs2cF58rLy0Pr1q1hampaovf0oiNHjqBevXpo0KCBqOPMzc3V/ly5cmXR1y8r06dPBwDEx8fjxx9/xNmzZ/Ho0SMYGRnByckJ7du3x6efflrmdVywYAEWLFiA/Px8/PPPP8jJyUH9+vVhbW1d4nMEBAQgJSUFBgbPe4nS09NVdzIOHz6sKjd06NAyrbs+W7VqFc6fP499+/bByclJsM/JyUl1l+Rlhf++VlZWWLBgAWJjY3H06FG1L439+/fHnj17tIbnmTNnYGZmhubNm5fBu3k7MTzfcpUrV0a1atW0flgBwMDAAMOHD1fbvmXLFqxZs0atleng4IBatWoJto0ZMwbe3t7F1icpKQmrVq1CQUEBDAwMYGpqikqVKsHDw0MQngcPHsTBgwcBPA/IOnXqqJ1LLpcjODi4RC270sjOzsaqVatw9OhR5OXlwdPTEwsWLICLi4uqzJYtW7Bz5048evQIVatWxeTJk+Ht7Y1GjRqpvpTUq1cPxsbGuHr1apHXu3fvHnx8fDB06FCsW7cOjo6OkMlkuHfvHjZv3gwfHx/s379fY6u48PZqQUFBsbdtX97/999/Y8qUKXBxcYGFhQViY2Ph5+eHPn36qMq8eFv/xf8rDx48wMaNG3H9+nW1L1RA+bY8i6Pptu7+/fsRGBiIuLg42NvbY8SIEcjJycGDBw/wxRdfqMoVFBRg5cqVOHLkCFJTU+Hs7Aw/Pz907doVALBp0yZV/3F0dDTmzp0LPz8/TJgwQfUFKDg4WC04xXJ1dUVSUpLa9o8//hibN2/GjRs3NN4yDgsLQ58+fYrsmqCiMTzfclKpFKdPny7VsTdu3MDYsWPV+j01uXr1KiwtLWFqaoq2bdtqLVe3bl2EhIQUe77u3btjxYoVqv43TXbs2AG5XI5+/foVez6xlEolJk+eDIVCgS1btqBy5crYsWMHRowYgaNHj0IqleLIkSP46aefsHr1atSuXRupqamq46OionDu3DksWbIEBw4cULXKihITEwNjY2P4+vqqtpmYmKBhw4aYNm0aunXrhvj4eI1fJOrWrYvExEQ0atSoyGv06NEDq1atEmxbuHAhfH190bt3bwBAYmIi+vbtCy8vL9jZ2QEAfv/9d1SpUkWt9Vj4BUFTcAK6bXm+fFs3IiIC8+bNw5w5c9C5c2c8fvwYn3/+OR4/fgxPT0/BsUeOHEGbNm2wYcMGODg44Ndff8XMmTPRoEED1KhRA6NHj8agQYMwfvx4dO/eHT169FDdrj5y5AgaN26Mxo0bv1L9lUol/vnnH41fOExNTdG9e3fs2bMH8+fPF+zLzMzEqVOnMGfOHK0DxKh4DM+3lEKhKFVfx8thpVAoVOfKzs5Geno6EhMTkZCQgISEBNUgh9TUVMTFxWntVwWet45e/GWmUCiQlZWFx48fIy4uDsbGxqoWjkQigYmJidZz3b59GwEBAWjTpk2p+1CLcvLkSdy8eRPHjx9X3dZdvHgxevTogcOHD6NPnz6IiYlBt27d4OHhAQCwtbVVHW9hYQFzc3MYGBiU+FZrmzZt8O2332L27Nno2bMnHBwcIJfLERcXh6CgIHh5eam1+As1bNgQ58+fV73Oy8tDkyZNcPr0aVSrVq3I6964cQPvv/++6rWzszOcnZ1x69YtVXgaGBho/Hsu/FLw7NkzmJmZITc3F+np6UhOTsadO3fg4eEhaKkXp1evXkhMTFS9Hj9+PMaOHVvi44sSFBSEQYMGqULcwcEB69evR4cOHdTKVqtWDQEBAarPwrBhw3Dq1Cn89ttvGD16NIyNjVX992ZmZoJ/42vXrhU7QK84KSkp2LBhAzIyMtC3b1+NZby9vTF69Gj4+/sLPrOHDh2Cu7s7HBwcXqkObzuG51tqy5YtGkemlsQff/wBe3t7NGzYEKtWrcL27dthamoKExMTmJmZoWrVqnB0dEStWrVUA1Rat25d7G1bNzc33Lp1S/WNvKCgAObm5rCzs0P16tXRvn17jaN+X5aSkoLx48djzJgxCAsLw88//4zBgweX6r1qc/r0aXTs2FHQNwoAnp6euHTpEvr06YP69etjy5YtGDBggNZQE8POzg7h4eEICwtDcHAwYmJiYGpqCnd3dwwePBhdu3ZVa8EWfrl5WeGtdm2DagwMDFTnatasGYKDg/HZZ58BeN4CTkhIgJubW7F1dnBwQM2aNdGiRQsolUoYGBjA0tIS9vb2qF27Nt555x1R4RkYGCj40iem77Uocrkcly5dErTqAWjt0mjSpInaHQ83NzfExcUVe62srCy1L0yRkZGqv99Cfn5+av9vPTw8UFBQgNzcXDg7O2Pbtm1aRww3atQIjo6O+O233/DJJ5+otoeHh2PkyJHF1pOKxvB8S2kamVpowIABGDx4sMbpBC8aMWIERowYUWZ1cnNzQ0xMDHJycmBkZARzc3Ott/u0SUhIwOjRo/HJJ5/A19cXnTp1wrBhw1ClShVVf1RZSExMxLlz53DkyBHB9ry8PFXA9+/fH2lpafDx8UHXrl0xefLkV/62b2VlhZEjR2LkyJGYOXMmatasiSlTpmgtP3bsWERGRmrd3759e43ba9WqhV9++QUAsGzZMkydOhXh4eGwsLBAWloavvzyS9jY2KjKa+tHlUqlOHbsGAoKCqBUKoscpdy5c2etUzoKlVdrKS0tDQUFBahevbravho1auDp06eCbZruoJiZmanmuxbF0tISWVlZgm2enp6CudDTp09HTk6OoIyxsTH27dsHmUyG5ORknDhxAkOGDMHmzZsF01Ve5O3tjT179qjC89atW4iLi6vQ85z1BcPzLff333/Dx8dHMA+voKAA169fx4IFCwA8n2M5bNiwEvVtAlDN/yvk6emp8ZeSJlKptNhpIJ06dUJ6erra9piYGEybNg39+/dX1bVevXrYvHkzJkyYgMePH5fp4KH+/ftj1KhRatsrVaoE4HmgjBs3Dn369MG6devQpUsXfPfdd0UOznrZoUOHMGPGjCLLbNiwQeP24OBgBAUFadynVCpVt1KLGkAEPA+P8PBwxMfH4+nTp6hdu7bg32jnzp2qW9Labt8+fPgQXbt2Ffw/e5mVlZXW+pa3lwe9vcjExEQtPLUp6v0VevfddxEVFSXYZmxsLPiMaOqSkEgkqjKurq7w9PSEqakpvvjiC4SGhmq8VmEfdnx8PFxcXBAWFoYePXqUyVSrtx3D8y1Xv359XL58ucgy+/btQ3BwsNb9eXl52LFjB3799VckJCQgIyMDUqkUdnZ2+PDDD+Hj44OGDRuWuE5Tp07FsWPHtP4iMjQ0xLRp0wT9cPfu3cPEiROxePFidO/eXVC+WbNm+PnnnxETE1PiOhTH3t4eGRkZJfpSYGdnh2XLlqFy5cpYuXKlahWd4kILeD4atVOnTqWq48u/gK9evYpdu3bh3LlzSEhIgFwuh4GBAapVq4ZmzZphwIABWoNdIpGgRo0auHr1Kr755hvExMTg8ePHePbsGWxtbVGrVi20bt0a69ev13gr1cXFBdeuXSuyvj4+Prh+/broaUVlwcbGBlKpFAkJCWr/pnfv3i2z28MA0LVrV3z77bf4559/SnTruyienp7Yvn271v2VK1dGp06dsHfvXkyZMgUHDhzAli1bXuma9ByX56NiFfWtHHgedidPnsS0adNw5MgRXLlyBX/++Sc2btyIatWqYdiwYYiOji7x9a5evYoNGzbg2rVrGn+GDx8umN4APP8m/uuvv6oFZ6E6depoXBKutDw9PXHixAk8evSoxMe0aNFCMNjFxMSk2EFbhQOjZDIZhgwZAqVSCRMTkxL9vOj06dMYOnQobG1tsWrVKvz111+4cuUKzp49i4CAANSqVQuTJ08ucnm8/fv3Y8yYMahWrRr+97//4dChQ4iMjMSPP/6IQYMG4c8//8Snn36KzMzMEv+d6AupVIoPPvgA4eHhgu3x8fGIjIwsdUut8N/uRe+88w769++PGTNmCJaxLI0rV67A0dGxyDLe3t4IDw/HqVOnULVqVdSvX/+VrknPseX5lktNTUWPHj2QkZGhtSVkZGSk8fYk8Pw21e+//469e/cKWgzGxsZwc3ODm5sb7t69i4iICLz33nslrpe5ubnWUbLm5uYaW6UvjmYtb926dUNQUBCGDRuGxYsXo27dunjy5Al+++03jB07FlKpFMePH0eVKlXg4uKCxMRErF+/Hm3atFGdw9HREY8ePcLp06fh6uoKMzMz2Nvba7xeXl4eLl++jPz8/FItFnH8+HF06NBB7RawVCpVTZvIzMzEiRMntPZ1HzhwAKNGjVLr565atSq8vLzg5eWFzp074+zZs+jSpYugTE5ODj755BOkpKRorWPlypVF3aEoiYKCArUwNzU11RiG06ZNw8CBA+Hi4oIBAwYgISEBc+fORZUqVYodkayNk5MTjh07htatWyM1NVX1GVmwYAH8/f3Rq1cvjBo1SjXtRyaT4e7du0hKStL4eczMzERBQQFSUlJw/PhxbN68WTD/VJOWLVvC1NQUS5cu1fo5JvEYnm+5lJQUPH36FFeuXCnRbcSXSSQStGvXDsuWLcOUKVPg5uYGS0tLFBQU4MGDBzhx4gROnTqFTZs2iTpvdna2YI3UFz19+rRUdS0tTf2wUqkUO3bswOrVqzFjxgxkZGTA2toa77//vmqQU2xsLH7++Wfk5OTAzs4OnTp1gr+/v+oc9vb2GD9+PGbNmgUDAwMsX75c6wCewj7knJycIqfoFNbt5b+fjh074rPPPsOGDRvQsWNHuLi4qKaOJCQk4NSpUwgPD1ebE/iibt26ISAgAPb29vjggw9UQV+4+lBoaCjkcrnGL0np6elISkrCpUuXipyuVJYMDQ0RGhqKsLAwwfaRI0dizpw5MDQ0FHxBa9CgAbZt24b//e9/2Lx5M+zt7TFy5Ej8/PPPglHeJiYmGsNX0/ZRo0bhs88+Q+fOndGiRQvVLVapVIp169bhxIkT2Lt3L7Zt24b09HRUqlQJTk5O6NSpk2CErKGhIfLz89GyZUsYGhrC2toajRo1wsaNGwVfyAqnx7z8xdPHxwfr169XmxMqlUqL/f9EmkmUJenhpjdWYcszNTW1yECSSCT49ddfNfbxvdjnGR8fj8zMTBgbG6v6PAcOHCiqH2vixImIiIjQ2udpZGSEmTNnlnq4fUxMDObMmYPjx4+X6nhdUCgU6NOnD/75559iy65YsULjwhDnz5/Hjh07cP78ecHtwqpVq6JFixYYMGAAPvrooyLPHRMTg/DwcMTExCAtLQ0ymQzm5uaoVasW2rZtiwEDBmhc5vHp06f4+OOP8fDhwyLP37ZtW2zevLnY91geLl68iJs3b+K9996DhYUF4uPjsXnzZlSqVAmrV6/WSZ1IfzE8qcy9PNqW9E9+fr5qtC1HXj7377//YsWKFao1fB0dHdGrVy+MHz9e9IL69OZjeBIREYnE5gEREZFIDE8iIiKRGJ5EREQivXVTVcya+xZfiOgtEv/HWl1XgUivVLUoPhrZ8iQiIhKJ4UlERCQSw5OIiEgkhicREZFIDE8iIiKRGJ5EREQiMTyJiIhEYngSERGJxPAkIiISieFJREQkEsOTiIhIJIYnERGRSAxPIiIikRieREREIjE8iYiIRGJ4EhERicTwJCIiEonhSUREJBLDk4iISCSGJxERkUgMTyIiIpEYnkRERCIxPImIiERieBIREYnE8CQiIhKJ4UlERCQSw5OIiEgkhicREZFIDE8iIiKRGJ5EREQiMTyJiIhEYngSERGJxPAkIiISieFJREQkEsOTiIhIJCNdV+BFOTk5iImJQVJSEjIzM1G5cmU4OjrCw8MDlSpV0nX1iIiIAOhJeEZFReH777/H33//jcaNG8PJyQmWlpZISkpCREQEZs+ejUaNGmH06NFo1aqVrqtLRERvOZ2GZ3JyMj7//HNYWlpiwoQJcHd3h0QiUSunUChw7tw5hISEYMeOHViyZAkcHBx0UGMiIiIdh+fGjRsxb948uLi4FFnOwMAAnp6e8PT0xN27d7FhwwYsXbr0NdWSiIhISKJUKpW6rsTrZNbcV9dVINIr8X+s1XUViPRKVYvi25V60ecJAFlZWfjjjz9w48YNZGRkQCKRwNLSEq6urmjVqhWqVaum6yoSEREB0IOpKgUFBVi0aBHatm2LvXv3IisrC1ZWVrC0tERWVhYOHDiAjz/+GHPnzkVeXp6uq0tERKT7lueqVavw6NEjnDhxAtbW1hrLpKWlYd68efjqq6+wcOHC11tBIiKil+i85Xn48GF89dVXWoMTAGxsbLBy5UocPXr09VWMiIhIC52Hp0wmg7m5ebHlLCwsIJPJXkONiIiIiqbz8HR3d0dQUFCx5YKCgtC8efPXUCMiIqKi6bzPc9GiRRgzZgwiIiLQoUMH1K5dG5UrV4ZSqURmZibu3r2L48ePIy0trUQhS0REVN70Yp6nTCbD6dOnERERgfv37yM1NRUymUw1VeWDDz5A9+7dIZVKX/lanOdJJMR5nkRCJZnnqRfh+ToxPImEGJ5EQiUJT532eS5cuBBxcXGijrl37x4WLFhQTjUiIiIqnk77PKdMmYIlS5bAzMwMPj4+aNmypday0dHR2LVrF/Ly8rB48eLXWEsiIiIhvbhtGxUVhaCgIFy7dg1NmjRB9erVYWFhgaysLCQmJiI2NhYNGzYsk0eS8bYtkRBv2xIJVbg+z+zsbJw/fx6JiYnIysqCpaUlnJ2d4e7uDgsLizK5BsOTSIjhSSRUoRaGB54vhNCmTRtdV4OIiKhIOl8k4UW7d+/WdRWIiIiKpVfhuX79el1XgYiIqFg6vW378OFDFBQUqF4rFArEx8erXjs4OEAqlSIrKwuXLl1C8+bNy6zvk4iIqLR0Gp6DBg1Cfn6+6rWBgQEGDhyoer1s2TI0atQI/fv3h62tLdLT0xEaGgpbW1tdVJeIiAiAno221WTt2rVQKpXw8/PDxo0bkZ+fDz8/v1Kfj6NtiYQ42pZISO9XGNImJycHCoUCABAREaFqjfr4+ODUqVM6rBkREZGehufcuXMRGhoKAEhPT0e1atUAAFWrVkVWVpYuq0ZERKR/4bl9+3YkJCSgT58+AJ73gxIREekTvVkk4fHjx1i7di1iY2MRFBQEY2NjAIBUKkVOTg4qVaqE3Nxc1XYiIiJd0Wl4Nm/eHLa2trCyssKNGzfg6emJXbt2CaajvPfeezh27Bj69OmDEydOwN3dXYc1JiIi0nF4njhxAsnJybh16xb279+PqKgobNq0CTNmzIBEIgEADB48GCNGjEB0dDR+//13BAUF6bLKRERE+jVVJTY2FrNmzULz5s2xcuVK1fa///4bkZGR8PLyQv369V/pGpyqQiTEqSpEQhXuqSoAkJWVBR8fH3h7e2PkyJFlfn6GJ5EQw5NIqMI9VQUALC0t8e233+LHH3/UdVVIi5g98+DsYC3YJoEEFuYmsH7/M8hkz+foGhhIsNq/P4b3bgXbVtPVzjN+QGsM/KQl6ta0R25eAX6JvIb5a/chPeuZoJzU2AhTh7aHT1cPONlbQSKRYHv4n5i3dl95vUWiVxZ78Tx8x42AuXklwfYOXT7GrHmL1cr/ceok5syYgolT/DBkxBjBvvz8fAT/tAO//XIYjx4lA0qge+9+8P1sZrm+B9JO78ITAFxdXbFw4UJdV4O08PBeobatq1dDLJjQTRWcZqbG+GHlKJgYG8HYyFDjeapVrYypy4Nx9dYDWFuaY+vyYfh20SAM8v+vX9tEaoRD3/niVlwK+n+2GfcfPIGRkQHsbSzL580RlRG5XA5HJ2eE7P+l2LJZWZn4NuAbeLz3PmQymWBfXl4e/CaPhUuNmvjfmg1wcq4OWUEB0tJSy6vqVAKcREllYqz3Rwjae0b1uttHjXDxehx8l+3SesySbw/h8o1EKBRKpGbkYNqKEHzSpjGMjP77bzllcDukpudg4pKduP/gCQBAJlPgwaOM8nszRK/Z+m++gveng2Fn76C2L2TnD7CyssbcRUvh5FwdAGBkbKyxLL0+Om15xsTECJ6q8rLGjRvDwsKCT1XRczUcbfBB89oYNmeratve3y7+/76SL+Kfmf0MUmMjmJtKkZmdCwAY0fsDjJi3vUzrS6RPoqP+RHzcfcxdtBTXr11R239w3158vvwrHdSMiqLT8Pzmm28gl8tVr69fv44GDRoAACQSCebOnQtnZ2c+VUXPjerrhT2/XkDOs/ziCxehR7sm+PPibVVw2ttaooajLXKe5WHfholwb1ATDx9nYnPI7/g+NLIsqk6kU8+ePcWar1bgy9XrVNPzXpT65DEeJiXB1MwcM6aMx9/XrqJKVTv0HTAQffr76KDGVEin4blz507Bay8vL+zevVuwbe3atejVq5fqqSo7dux4paeqUNkyMjLA8N6t0GfKt690nkpmUswb9zEmL/3vNm/1ajZ4mpuP7xYPxvx1+xB9+R4avuOIHV+OhJWFKVZvP/6q1ScqNxKJBKlPHmPIgF54nJICG9sqaN22PYaPGa8aRLRp/Vp06toNrrXqaDxHcvJDmJqaYuXSRZg0dToaNm6CO7duYfF8f+RkZ6kNLKLXRy/7POPi4pCUlASAT1XRd73bN0NiSjou/ZPwSudZNas//rx4Gyei/lFtMzMxhpWlGT7feBBnLtxGgUyOS/8kYPr/9mDasA6vWnWiclW/QSME7gjG9p17cej4H1j6v9W4fu0Kli6cCwC4EnsRF8+fw7CRY7WeIy8vDzk52Rg3aSqatfCAsbEU9eo3gJ//POz6cTv0bKbhW0WvwrNZs2YAgKVLl6pCkk9V0W9jvT9C0CveQh3n/RFaNKgB32XBgu1Pc/Mhk8lx5sJtwfao2Duws7GEvS1H3JL+MjUzQ+0678DIyAhGRkZ4p249fLFyNf44fRKPUpKxctlizFrwOYyKWK/b1NQUhoaGaNq8hWB746bNkJ6ehrTUJ+X9NkgLnU9V6datG6ytrTF+/Hhs2LABkZGRSEhIQP/+/QHwqSr6rF4tBzRzq46+U78r9Tk6fVAfs8d0QbsR3+BprrDP9P6DVBgZGcLIyAAFsv/6xg0NDaBQKJD1NLfU1yXSBRsbW1SubIXHj1KQlJiIGb7jBftzc5/BwNAQu37cjsDtO+Ho6Ay5XA65TI4XM1YhV0AikajNIaXXR+fhmZKSgsGDB2P27Nn46KOPcPHiRQQEBPCpKhXA2P5eCPnlfKkHCjV51xnfLx2GAX6BiEtSn7OWmpGDa7ce4JPWjRF67IJqe3tPN/x95yGe5WofqU2kjxLi45CdnQ2XGq44+ed5tf3LFs9DdZcaGDFmgmpbrTrvIPKPU+jY+WPVtnPRf8G1dh2Ympm9jmqTBjpv1pmammLw4ME4evQoHjx4gNq1a6tG3AL/PVUFAJ+qokfMTI0xqLsngvaW7pats701wgImYPrKEJy9fFdruVXbfsPK6X3Q+F1nAECrprWxyr8fvvj2UKmuS/S63Ll1E3du3YRSqYRMJsOli+cxZ8YUDBg0FBaWJe9yGDpiDDas+Ro3b/wDpVKJy5cuYN2qlRg7YUo51p6Ko/OWZyEbGxsEBQVh7Nix2LFjB4YPHw6AT1XRV307tcC/dx8WO1CoQCZHbr5MbXuvDk3haGeFDQsHYsPCgYJ9k7/YhbDjz+eJBh85B2tLM+xePRZVbSyQmJyOhesP4EDE5bJ7M0TlIDX1CdZ8tRwpKcmQGkvh6OyMQUNHousnPbUeIzUxgbFUKtjWpVsPZGVlYt7MaUhLS4W9fTVM8P0Mbdp3LO+3QEXQ+cLwXl5eiIz8r/WSkpICb29vfP/996hbty4APlWFqDxxYXgioZIsDK/z27Yvs7e3x4wZM/DVV/+tqFG/fn2MHTv2lYOTiIioLOg8PHftUl/7tGfPnjAwMEBqKhc+JiIi/aPzPk8XFxeN2zdv3vyaa0JERFQyOm95EhERVTQMTyIiIpEYnkRERCIxPImIiERieBIREYmk09G2sbGxyM8Xty6qsbGx6ukrREREuqDT8AwICBAdnlKplEv0ERGRTuk0PBmCRERUEek0PAMDA0vV8hw3blw51YiIiKh4Oh0wpGlN+q1bt+qgJkRERCWn86eqvOzFp6woFAqEhITAx8cHEomkTM7Pp6oQCfGpKkRCFeKpKsnJyUhPT1e9trW1BQDIZDL4+/vj4sWLZRacREREZUHnC8MPGzYMCQkJaN68OXr16oW9e/fizp07mD17Npo2bYr58+fruopEREQCOg/PnJwcRERE4NSpUzh8+DDWrFmDp0+fYtmyZejevbuuq0dERKRG57dtgecPwB4wYAC2b9+OgIAA1K1bF8eOHUNubq6uq0ZERKRGL8LzRR4eHggODoa9vT28vb0F/aFERET6QO/CEwAMDQ2xYMEC9OrVCxMmTEBeXp6uq0RERKSi8/D86quvtO4bM2YMmjdvjrCwsNdYIyIioqLp3TzP8sZ5nkRCnOdJJFQh5nkSERFVNDqdqhIdHa11bVt3d3fk5OTg5s2bUCqVqFu3Luzs7PDdd99h4sSJr7mmRERE/9FpeG7cuBEFBQVq2yUSCZYsWYJ58+ZBqVRCIpFAoVAgNDQU+/btY3gSEZFO6TQ8d+zYUeT+9PR0HDt2DADQoUMHAJoXkyciInqd9LrPk2vaEhGRPtK78AwMDMSFCxcAsJVJRET6Sa/C8/bt2/jhhx/g6uqq66oQERFppTfhef/+fUyaNAmLFi1SPZaMiIhIH+l0wNCKFStgY2MDhUKBXbt2wd/fH507d1bt19TnyX5QIiLSNZ2Gp62tLRITExEZGYlKlSqhXr16gv0v9nlmZ2dj7ty5XCieiIh0TqfhOWHCBACAQqHAwYMHMWbMGHz99ddo1aoVAGDSpEmqsqtXr8b9+/fxySef6KSuREREhfRqbdvY2FhMnjwZu3btgouLS7lcg2vbEglxbVsioQq3tm3Tpk0xdepUBAUF6boqREREWun0tq0mAwYMgFwu13U1iIiItNKrlmchQ0NDXVeBiIhIK70MTyIiIn3G8CQiIhKJ4UlERCQSw5OIiEgkhicREZFIDE8iIiKRGJ5EREQiMTyJiIhEKnV4fvnllyUql5+fX9pLEBER6aVShadcLscPP/xQbLlLly6hffv2DFAiInqjlNtt27i4OEybNg1+fn6QSqXldRkiIqLXrsQLwzdq1EiwYLtSqUT9+vVVr2fNmoU+ffogOjoa8fHx2LZtGyZOnIh+/fqVbY2JiIh0rMThefjw4SJvvzo6OiIhIQEBAQGIi4tDy5Yt+eBqIiJ6I5XLw7DT09OxadMmHDp0CN9//z3c3NzK+hKlxodhEwnxYdhEQjp7GLa1tTXmzJkDX19fjB49GikpKeVxGSIiIp0o8W3bxYsX48mTJ/jggw/Qs2dPWFhYqJWRyWT4/fffUdiYtbOzg7u7O5KTk2Fvb192tSYiItKhErc8Q0NDUb16dYSHh6Njx444cuSIWpns7Gxs27YNvr6+2Lp1K7Zv346EhASMGTOmTCtNRESkSyVuecrlckyfPh1SqRQnT57E/Pnz8eDBA0EwWltb48cff4Sbmxu+//57mJmZIS8vD02bNi2XyhMREelCiVueEolE9ef27dvjp59+wpYtW3D8+PEiy0okEsFrIiKiiq7ELc+X1alTBytXrsTcuXPRsmVLWFlZIT8/H5cuXQIAnD9/HiYmJsjIyGB4EhHRG6XU4QkA7dq1w3vvvYcNGzZg/vz5SE5OxooVK1CvXj2sWrUKwPOWZ48ePcqkskRERPqgxOGpbTrotGnT0K9fP0yYMAEuLi7Yt29fWdWNiIhIL5W4z/Po0aMa16itU6cO/P39BUv3ERERvclK3PKsVauW1n2DBw8uk8oQERFVBHwYNhERkUglbnkuX74cBQUFoi8glUoxb9480ccRERHpqxKHp52dXakeas1neRIR0ZumxOE5bty48qwHERFRhVHi8Pz888+Rl5cn+gImJib4/PPPRR9HRESkr0ocnq6urmq3bdesWYPPPvusyBWEjIxeaR2GMpd2boOuq0CkV2LvZ+i6CkR6paqFVbFlXulh2PXr18e1a9dgYPB80O7FixdhYWGBunXrlvaU5S5XpusaEOkXhieRkGed4sNT1FQVTTlb2OqMjo7GxIkTkZSUJOaUREREFY6oe6odOnSAoaEhPv74Y3h7e+PMmTOQSCTYunUrtmzZglWrVsHLy6u86kpERKQXRIXngwcP8MUXX+CPP/5Az5490a5dO9y6dQumpqYIDg5GzZo1y6ueREREekPUbVuJRILevXtj/fr1OHXqFBwcHHDv3j107dqVwUlERG+NUi/PZ2VlhdmzZ+PQoUM4dOgQpk2bhqdPn5Zl3YiIiPTSK69tW6NGDezcuRNKpRLjx48v1SpEREREFYmo8DQxMVFNS3mRqakp1q5dC0tLS/j5+Wl99icREdGbQFR4Xrx4UeuiBwYGBli7di0cHR2Rk5NTJpUjIiLSR6+0SEJFxEUSiIS4SAKRUEkWSSjxVJUjR44U2Z/ZoUMHJCYm4t9//wUAuLm5oV69evD19cWGDVwSj4iI3hwlDs89e/ZoXRjewMAATZs2xbBhw+Dq6gqFQoGkpCScOXMGx48fL7PKEhER6YMSh+e2bduKLZOTk4OQkBAAQKNGjUpfKyIiIj32ylNVXlTU01WIiIjeFK8cnjt37kRaWhoAzQvHExERvWleKTzPnTuHNWvWMDSJiOitUurwTEhIwPTp0zF37lzY2tqWZZ2IiIj0WonDMyMjAwqFAgBw+vRpDBgwAD4+Pujbt6+qDPs8iYjobVCi0bZyuRzvv/8+jIyMYG9vr3o0mbe3d5HHcZ1bIiJ6E5UoPA0NDXHmzBk8ePAAsbGx2LNnD7777jvUq1cPTZo00XhM1apV0bRpUzg6OpZphYmIiHSt1Mvz7dy5E6tXr8bmzZvh4eEB4Hk/aPXq1QEAT58+RVpaGmxsbGBubl52NX5FXJ6PSIjL8xEJlenyfC8bNGgQLC0tMXnyZOzbtw+Ojo6q4AQAc3NzvQpNIiKisvJKU1V69OiBnj174ujRo2VVHyIiIr3Hp6oQveV425ZIqCS3bct0eT4iIqK3AcOTiIhIJIYnERGRSAxPIiIikRieREREIjE8iYiIRGJ4EhERicTwJCIiEonhSUREJBLDk4iISKRSLwxfHu7cuYOoqCgkJSUhIyMDVlZWcHR0hKenJ+rUqaPr6hEREQHQg/CUy+UIDw/Htm3bYGxsDHd3dzg5OaFGjRrIyMjArVu3sGvXLigUCowYMQJ9+vSBkZHOq01ERG8xnabQ9evXsXLlSri7uyMwMBDOzs5ay8bHx2PPnj0YMWIE5s+fj/r167/GmhIREf1Hp+H522+/YePGjbC0tCy2rIuLC6ZPn4709HRs27aN4UlERDrDR5IRveX4SDIiIT6SjIiIqBwwPImIiERieBIREYmk8zkfTZs2hVwuL7acUqmEiYkJLly48BpqRUREpJ3Ow7Nfv36Ii4vDkiVLii1rbGz8GmpERERUNJ2PtlUoFJg8eTIaNWqEyZMnl/v1ONqWSIijbYmEKsRoWwMDA6xZswa1a9fWdVWIiIhKROctz9eNLU8iIbY8iYQqRMuTiIiootFpeC5cuBBxcXGijrl37x4WLFhQTjUiIiIqnk5H206ZMgVLliyBmZkZfHx80LJlS61lo6OjsWvXLuTl5WHx4sWvsZZERERCetHnGRUVhaCgIFy7dg1NmjRB9erVYWFhgaysLCQmJiI2NhYNGzbE6NGj0apVq1e6Fvs8iYTY50kkVJI+T70Iz0LZ2dk4f/48EhMTkZWVBUtLSzg7O8Pd3R0WFhZlcg2GJ5EQw5NIqMKF5+vA8CQSYngSCVWY0bYFBQU4dOgQAOD27dv4999/dVwjIiIi7fQiPLOzs7F582YAwIULF3D27Fkd14iIiEg7nYZncnIyHjx4gOTkZMhkMiQlJSEjIwMZGRl48OABcnJyAADPnj3DX3/9hczMTF1Wl4iICICO+zxbt26NgoICaKqCRCLB0KFDMXz4cPTt2xdGRkbIyclBSEgI7O3tS31N9nkSCbHPk0iowg4Yevr0KQDA3NwcP/30E+7cuYNFixYhMDAQWVlZmDFjRqnPzfAkEmJ4EglVmAFDL9uxYwfCw8MBAKdOnYK3tzcAoH///jh9+rQuq0ZERKT753kmJSUhMTERAFCzZk3Y2dnB0dER165dA/C8X9TV1RUAYGtri+zsbF1VlYiICIAehGfv3r1RvXp1yGQyKBQKHDx4ENWrV8fJkycBAPn5+XwINhER6RWdh6epqSn27t0LAPDy8gIAVKtWDWlpaQAAGxsbPHnyBA4ODpDJZDA0NNRZXYmIiAA96POUSCRq26ytrZGbmwsAaNasGSIjIwEAZ8+eRYMGDV5r/YiIiF6m85anJqampqrw7NevH4YPH47r16/j5MmTWLlypY5rR0REbzudtzxfpFAooFAoUFBQgPz8fABA3bp1ERAQABMTEyxZsgSenp46riUREb3tdN7yNDc3V/3Z2toaDRs2BAC0adNGtd3DwwMeHh6vvW5ERESa6N0iCYUtTqlUWi7n5yIJREJcJIFIqCSLJOi85fmy8gpNej3S09Pw2ZTJMDc3x7ebv1dtz8zMxI5tQThx/BgeP3oEK2tr9Os/ACNHj1UNGjt0cD9WLl+qds7c3FyMGDUGvlM/e11vg6hUsjLTsW6pP0xNzTFz6TrBvpSkRIT+8B3+vhwDmUwGF9d30HvgaDRo1lJVRqlU4mDIdpw8EobcZ09Rs/a7GDpxJqrXrKN2rUfJD7B6kR/cGjfHCN855f7eSEiv+jwLDRkyRNdVoFKIj4vDyKGDYWxsDJlM2MTPysqEuXklfLc5CJFRMVi34TuE7tmN4J0/q8p079ELkVExaj/vvlsPTZo2e83vhkic5KQELPcfDyMjY8jkwv//OVmZWD5rHKq71sHqrfuwYecvaNW2C1Z/Ph2JcXdU5Q6F7MCl6Egs/mYrvg3+DR+064qv5k9BTpbwoRh3blzHyrmTYFG5MuQy3k7TBb0Mz3v37mndV3hbl/RPaEgwPpvhj+49eqntc3aujtFjx8HRyQkA8M47dTFuwiQc/+3XIs957eoVPHnyBF4ftS6XOhOVlYgjYfAZ5YsP23dT23ftUjQsrazR02ckpCamMDQ0QruP+6BBUw9cjvkLAKCQy/FL+E6M9VsEmyp2MDAwQJsuvfBug6Y4E3FUcL7jh/Zg0uzlaNC0pdq16PXQ6W1bPz8/KBQK1eu6devC19dXUGblypW4efMmPvroI4wYMQLdu3fHsWPHXndVqQT8Zs4CAOwPDytReQsLy2KXWwzZvQt9+vWHgYFefs8jUvl09FQAwB+/HVLbZ1PVHhlpT5CXmwsTU1MAgEwmQ0pSAtp36wsAuPnPFVhYWcOxek3BsS1atcGZk0fQuaePatu46YsBALHnzpTLe6Hi6fQ3Urt27dC2bVtER0ejTZs2+PHHH9XKHDlyBN7e3ti9ezcAqN0OpIor4uRxfFREizIrKwvHj/2KPn37v8ZaEZW9uvWboF7D5ghYPguZGWnIycrE+uWzUb1mHTR77/nKasmJ8XB6KTgBoJpzDSTcu/26q0zF0Gl49uzZE3369IG5uTn69u0LMzMztTIWFhbo2rWroIVKFd/ff1/H76dOYcjwEVrLHNgfDnePlnCoVu31VYyonEycvRTVXd/BzFF9MWtsf9g5OGHSnGWqAXNZGWkwr2SpdlwlC0tkv9TnSbqnd6Nt6c337NkzLJw3G34z/GFtbaO1XOju532oRG+CX/cF4/yZCPTwGQEDAwOcOBQKcwtL9B40BgYGBpDLZVBCfeagUqmEhlVMScf0NjynTZsGPZuCSmVk0YK5aNS4Cfr299Za5lz0WTx9+pQDheiNcObkUUQcDcfitdtgWdkaANC6cw/8b54vpCYm6O49HOaVLPE0O0vt2Kc52RpbpKRbejsKo7A/lN4sG9atQUpyMuYvWFxkuT0hwejTrz+fokNvhJg/I9C+W19VcAKAZWVr9Px0JGLORAB43reZlBindmxSwn04OLm8rqpSCeltePbu3Rt9+/bVdTWoDIWF7sGvvxzF2vUbYVzEYhhPHj/G6YiTHChEbwxjYymyMtLVtmemp8HQ6Pnzius2aILUR8l4EH9PUOZC1Gk0av7ea6gliaG34amNpkeYkf7780wkAtZ9g/XfboKNjW2RZcPDQuH5fisOFKI3RqeeA/DbwRCcPLwX+fl5UMjluBzzF/b+uEk1VcXE1Axden2K79cuRXrqYyiVSpw+dgD/XL6Adh/30fE7oJfptM9z8uTJkMvlePLkCSZMmKBxzl9hv2dmZiYWLFhQ7LxA0j2pVKq2zOKekGBkZWZhyMABwsISCcL2H4K9vYNqU9jePZi/8PPXUFOismdkbAxjY+H//7r1m2DOio3YH7wVYT9vgUIhh2N1V4yaMg8tvdqryvUdMg74WYLF04YjL/cZnGvWgf/y9ahsrfkLp7GxFEbGXNJUF3S6MPyJEydU8zYlEgmcnJzQqFEjeHl5qR6AvX//fvTq1Qt//fUX7ty5g9q1a6NVq1alviYXhicS4sLwREIlWRhe756qAkAQnmWN4UkkxPAkEipJeOpln+fw4cN1XQUiIiKt9LLlWZ7Y8iQSYsuTSKjCtjyJiIj0GcOTiIhIJIYnERGRSAxPIiIikXS6SEJsbCzy8/NFHWNsbIxmzZqVT4WIiIhKQKfhGRAQIDo8pVIpgoKCyqlGRERExeNUFaK3HKeqEAmVZKqKTluegYGBpWp5jhs3rpxqREREVDydDhjS1OjdunWrDmpCRERUcnp32/bFdW0VCgVCQkLg4+NTZo8i421bIiHetiUSqhArDCUnJyM9PV312tb2+aN3ZDIZ/P39cfHiRT7Dk4iI9IpO+zwBYNiwYUhISEDz5s3Rq1cv7N27F3fu3MHs2bPRtGlTzJ8/X9dVJCIiEtB5eObk5CAiIgKnTp3C4cOHsWbNGjx9+hTLli1D9+7ddV09IiIiNTq/bQsA9vb2GDBgALZv346AgADUrVsXx44dQ25urq6rRkREpEYvwvNFHh4eCA4Ohr29Pby9vQX9oURERPpA78ITAAwNDbFgwQL06tULEyZMQF5enq6rREREpKLz8Pzqq6+07hszZgyaN2+OsLCw11gjIiKioundPM/yxnmeREKc50kkVCHmeRIREVU0Op2qEh0drXVtW3d3d+Tk5ODmzZtQKpWoW7cu7Ozs8N1332HixImvuaZERET/0Wl4bty4EQUFBWrbJRIJlixZgnnz5kGpVEIikUChUCA0NBT79u1jeBIRkU7pNDx37NhR5P709HQcO3YMANChQwcAmheTJyIiep30us+Ta9oSEZE+0rvwDAwMxIULFwCwlUlERPpJr8Lz9u3b+OGHH+Dq6qrrqhAREWmlN+F5//59TJo0CYsWLVI9loyIiEgf6XTA0IoVK2BjYwOFQoFdu3bB398fnTt3Vu3X1OfJflAiItI1nYanra0tEhMTERkZiUqVKqFevXqC/S/2eWZnZ2Pu3LlcKJ6IiHROL5bnUygUOHjwIL7++mt8/fXXaNWqFQBg37596N27NwAgMjIS9+/fR82aNeHl5VXqa3F5PiIhLs9HJFSS5fn0IjwLxcbGYvLkydi1axdcXFzK5RoMTyIhhieRUIVb27Zp06aYOnUqgoKCdF0VIiIirfSq5VlILpfD0NCwXM7NlieREFueREIVruVZqLyCk4iIqCzoZXgSERHpM4YnERGRSAxPIiIikRieREREIjE8iYiIRGJ4EhERicTwJCIiEonhSUREJBLDk4iISCSGJxERkUgMTyIiIpEYnkRERCIxPImIiERieBIREYnE8CQiIhKJ4UlERCQSw5OIiEgkhicREZFIDE8iIiKRGJ5EREQiMTyJiIhEYngSERGJxPAkIiISieFJREQkEsOTiIhIJIYnERGRSAxPIiIikRieREREIjE8iYiIRJIolUqlritBRERUkbDlSUREJBLDk4iISCSGJxERkUgMTyIiIpEYnkRERCIxPImIiERieBIREYnE8CQiIhKJ4UlERCQSw5OIiEgkhicREZFIDE8iIiKRGJ5EREQiMTzfUl26dEFycjIuXryIUaNGaS03bdo0eHp6qn6WLFlS5nUZOHAgzp07p3FfamoqmjdvrnFfu3bt8ODBA437kpOTsWDBghLXYdGiRXj48GGJy9Ob53V9Jo4fP45JkyZp3b9//3589tlnos5Z6KOPPtL6/1jsZ2Lt2rW4du1aqerxNjDSdQWo/AQGBmLnzp2Qy+Xw8vLCggULUKlSJQBAQUEBCgoKkJ+fj4KCAq3nWLduXamvHx8fj08//VSwLTc3F3Z2dvjll19U2+RyudY6PHz4EDY2Nhr3FVX3JUuWYNasWarXycnJWLJkCc6fPw8jIyN069YN/v7+kEqlAIAxY8bg888/x6ZNm0S9R6pYdP2ZAACZTAa5XK51v1wuh0KhUNv+8ccfIycnR7AtLy8PYWFhcHZ2BvD8MyGTyTSe9+XPROG1li9fjtDQUFy+fFmwb9SoUZg8eTK2bt0KY2PjEr23twnD8w21f/9+7N27F+Hh4TAzM8O4ceMwe/ZsbNiwoUTHT506FefPn9e4z8LCAvPmzUObNm2KPIeLiwvOnDkj2Pbzzz/j4MGDJXsTAG7duoXKlSuXuDwA/PXXXzAzM4OrqyuA578Ux4wZg27dumHdunV4+vQpZs+ejWXLluGLL74AANSoUQMWFhb466+/0KpVK1HXo4pBHz4ThaKiotC+fXuN+3JycuDp6am2/ejRo2rb+vbti8TERFV4AkBmZiZSU1NhYWGh+nL48mcCAJ49ewY/Pz8UFBRoDNzKlSujRYsW2LdvH7y9vUv0vt4mDM831I4dO+Dn56dqtS1ZsgRdu3ZVfWCLu0UZEBCgtu3PP//Ed999BysrKzRt2lR0ndLS0hAQEICVK1eW+JgDBw7gxo0bSElJgb29fYmOCQoKwtixY1WvT58+jUqVKmHixIkAACsrK3z55Zdo3749ZsyYASsrKwCAj48PNm3axPB8Q+nLZ0IikcDT0xOBgYEa9+/duxenT58u0bk0hZ6fnx+MjY0xbtw49OzZE4D6ZwIAIiIi0KhRI/Tu3RudO3fWeH5vb2+MGzeO4akBw/MNlJ+fj7///hvvv/++alutWrXg6uoKf39/dOzYUeu33pfPc+nSJZw6dQq//PILkpKSMG7cOIwdOxYWFhai6pSbm4vJkyfDy8sL7dq1w+TJk3Hp0iUAQEZGhsZjYmNjERUVBU9PT6xbtw7Lly9XK+Pj4wNDQ0P4+vpi4MCByM7OxtWrV9GyZUtVmYiICLX3a2Njg2bNmiEyMhKffPIJAMDd3R3Xr19Hdna26PdH+k2fPhNOTk6IiYlB69atNe5/9uwZhgwZora9W7duSE1NhaGhoWqblZUVatasKSgXFBSE6tWrq15r+kwUng8AEhIStNa1evXqMDIywu3bt1GnTp3i39xbhOH5BkpLS4ORkRGsra0F252dnfHs2bNijw8JCUF4eDhSUlLQpEkTtG3bFgMHDsSVK1cQFRWFIUOGIDc3F126dIGfn1+x50tJScH06dNhbm6Oixcv4o8//sDGjRtV+wcMGKB2TFZWFvz9/TF06FBMmjQJn376KbZv344RI0YIyu3evVvwyyMmJgZNmzaFgcF/Y+Hu37+Pdu3aqV2jVq1auHHjhio8DQwM0KRJE8TExKBt27bFvi+qOPTpM9G4cWNcuHBBVP3z8/Nx+/ZtXL16tdj+xyNHjsDGxgbNmzfHO++8o/EzIYaHhweioqIYni9heL6BJBIJFAoFlEolJBKJartMJoOdnV2xx3t6eqJVq1ZwcXERbHdxcVF9W83NzUV2dnaR51EqlTh48CBWrVqFkSNHYuTIkbh27RpmzJgBZ2dnLFy4UNAHU+jevXuYOHEimjZtipkzZ8LQ0BBbt27FxIkTERMTg5UrV2r9lv9y/w/wfMSupn5TS0tLpKenC7Y5OTlpHcFLFZc+fCYCAwOxY8cOUfWuWbMmdu7cqXpdOJApNzcX6enpSE5ORkJCAhITE1VfLJ89ewapVKq6pavpMyEGPxOaMTzfQLa2tpBIJHj48CEcHR1V2+Pj4zFz5kxIpVKN/Tvx8fEYOHAglEqlqOsFBgaiYcOGatvHjx8PuVyOwMBAuLm5AQAaNmyIAwcOYM+ePVq/Qf/www/o168fRo8erfpF5+DggODgYISFhcHU1FRrXbKysmBpaSnYJpPJtL6nF3+RAs8HSWRmZmp/s1Qh6cNnYty4cRg3bpxa2bCwMJw6dUpjn2ohqVSKNm3aoFevXjAxMYGJiQlMTU1hY2ODatWqCe6+9OvXT3DbVtNnQozKlSvj/v37pT7+TcXwfAMZGRmhWbNmOHXqFAYOHAgAuHz5MurVq6eaiqGpf8fFxQWRkZFlVo8vv/wSVapUUdsulUoxePBg1eu5c+finXfeUb1etGiRxvNJpVLB1JelS5eiWrVqgjKWlpZITk5W25aVlaV2vszMTLUWaUZGBhwcHIp4V1QR6ctn4lVoG2D0oqFDh6rdmtb0mRAjIyND9Ij3twHD8w01duxYzJ07Fx4eHqhcuTKWLFmChQsXvtY6vBic//zzD3766SdER0cjLy8PSqUSVlZWaN++PYYMGaL1m3Fxx5mYmAjKOzs7q41UdHV1xZ07d9TOfffuXfTo0UOw7cGDB+zvfEPpw2cCAPbt26dxPnHXrl0BPB/g061bN8ybN0/j8Tdv3kRoaChiY2ORmpoKqVQKBwcHtG3bFiNGjFDr0tD0mRDjwYMHgi+39BzD8w3Vpk0bzJs3D7NnzwYATJo0Cc2aNSvRscePH1fNf9REoVDA2NgYR48eLfIWaqHr169j5MiR8Pf3x5w5c1Qf7gcPHmD37t3o378/Dhw4oJoy8irHubu7Y/bs2VAoFKoBEh988AFCQkIEt8zS0tJw6dIlrFixQrVNLpcjNjYW33zzTQn+lqii0ZfPRO/evdG7d2+t+48ePYqQkBCN+2JiYjBlyhRMnz4dI0aMQJUqVVBQUIB79+4hNDQUffv2RXh4uGrhB0DzZ0KMc+fOCe4U0XMMzzdY9+7d0b17d9HHdezYER07diyyjLu7O548eVKigQiRkZFo164d+vfvL9ju5OQEPz8//P7777h06ZLaBPPSHGdpaYlGjRohOjpaNS2he/fu2LRpEzZt2oQxY8YgJycHc+fORefOneHk5KQ69ty5c2jUqBGnqbzB9OEz8eeff2L69Ola77YYGBhoHIEOACdOnEDXrl0F8y6lUikaNmyIhg0bolu3brh06RI+/PBD1X5Nn4mSio+Ph1wuZ8tTA4YnlYpEIinxIAovLy9s27YNBw8eRMeOHWFmZgYAePToEUJCQpCenq5x/drSHjd69GgEBwerflGYmJhg69atWLp0KVq1agVDQ0N07dpV1QIpFBISUuSapkRFKeln4u7du2jfvr3grkdJvf/++1i0aBHat2+P999/XzXo7smTJ9i7dy+ys7M1Dt57+TPxImNjY7Xuj0IhISEYOXKk6Hq+DRiebykjIyMYGxurfspTgwYNEBQUhB9//BHr169Hfn4+gOffiNu1a4c9e/ZoHJBQ2uM++OAD/PDDD7hz5w5q164N4PnAj6IGXNy9exc5OTmCb+z0dnldn4latWph7dq1iIqK0lrGwMAAhw4dUrsF3KZNG6xcuRK7du3CkiVLIJPJIJFIYGFhgdatW2PPnj1qA4YAzZ+JQg4ODrh48aLaMenp6Th//jymTJlSujf6hpMoxY7BJgJw8OBBdO7cWes3Vl1LTk7GunXrSvztfv78+fD19RVMYyAS4037THzzzTfo0qWLxpYsMTyJiIhE4/M8iYiIRGJ4EhERicTwJCIiEonhSUREJBLDk4iISCSGJ1EFEhUVhR49eqBZs2YYPny4YM3e1NRUNG3aFMDzaQkvP/y4UFpaGtzc3FCvXj3VT1HLr925c0dQtvCnQYMGgkX87927x2kN9NbgIglEFURcXBwmTZqERYsWoUOHDti9ezfGjBmD/fv3w9LSEnK5HLm5uQCeP/ex8M8vkslksLS0RExMDBQKhWq7kZGR2rMuC9WuXRuXL19W2/7NN98gPj5e9To/P1/1DEmiNx3Dk6iC2LFjBzp06KBaVHzMmDH4/fffERYWhuHDhxd7fExMTJEtTCMjIwwePFjj0zw0Tfw/f/48+vTpU/I3QPQGYXgSVRBnzpzB1KlTBdu6du2KJUuWlGjVGA8PD/z7779q2xMSErB27VqcO3cOH3/8cYnqcvLkScTHx6Nnz55q+wpbn4aGhhpbskRvAvZ5ElUQCQkJcHV1FWx79913YW5ujn///VfUQ5tlMhlOnz6NadOmoWvXrrCzs8Phw4c1LrT/stu3b2PevHlYsGCBxieDFD7hozQLnxNVFGx5ElUABQUFKCgoEDynEQCsra3x9OnTYvsalUolbt68iYsXL+Ls2bOIjIxEzZo10bhxY9SqVQt79+5FYmIimjRpgnr16gme2PGiiIgIzJkzB6NHj1Z7kHghTa1bojcNw5OoAih80kdmZqZge3p6OkxNTWFkVPRH+caNG5gyZQqaNGmC9957D/7+/oJF8J88eYJz587h0qVLiIqKQosWLQThefv2baxbtw5nz57FF198gS5dupTtGySqYBieRBWEi4sLbt++jcaNG6u2/fvvv6hSpUqRxxUUFMDV1RUHDx4UbM/Ly1P92cLCAu3atUO7du1U22QyGYyMjPDTTz/h66+/Rv/+/fHLL7/AxsamjN4RUcXF8CSqID788EOcPHlSNdoWAI4ePYrExETUq1dP63Hdu3fHvXv3RF/Py8sLQUFB6NSpE7p06QI7O7siyzs5OWHWrFmir0NUETE8iSqIYcOGoVevXti3bx+6dOmCH374ARcuXMCePXvQpEkTPHr0CF5eXmrH/frrr690XQcHBwBAfHw87O3tVdNW0tLSYGFhobq9Gx8fz6kr9NbgaFuiCqJGjRr49ttvsWXLFnh4eODIkSPYvHkzmjRpUqLjCwoKkJeXV+TPiwsnvMzX1xeXLl1SvZ46dSpOnz6tej1z5kxER0eX+v0RVSRseRJVIK1atcLhw4dLdWz79u2RkpJSZBmpVIpt27bBw8ND4/5hw4YJXhcuzpCWloa4uDjBikNEbzKGJ9Fb4o8//ii2zLBhw/Dvv/9qDc/AwEDVvrFjx6q2b968GS1btsS2bdvQuXNn1KxZs2wqTaSneNuWiFSMjY2hVCq17jc1NUWlSpVQqVIlGBoaAgCCg4Nx8OBBrFq1CpMmTcLQoUNx8eLF11VlIp1gy5PoDWFoaAipVArgeQhqWo/2VUgkEmRlZammuOTk5GD//v2IiYnB999/D1tbWwwZMgSmpqbw9fXFiRMnYGpqWqZ1INIXEmVRXzOJ6K0ydepUtGnTBv369VPbN2vWLBw4cEDVMrW0tMTWrVvh4OCgGpFbKC8vr8zDm0ifMDyJiIhEYp8nERGRSAxPIiIikRieREREIjE8iYiIRGJ4EhERicTwJCIiEonhSUREJBLDk4iISKT/AzTGQ1/dNBuVAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABicAAAGACAYAAADGeLGUAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAjQ9JREFUeJzs3XlcVOX7//H3sMrmLqSCCpKSpmZqJlm4Zm7lllb6UUuTFMvUFu1LWZbmlmlli+ZWZpq5L7lgpqUtUrmVOxjghhsIiizD/P7wxyQBCgizwOv5ePT4fLzPds3czMx17uuc+xhMJpNJAAAAAAAAAAAAFuJg7QAAAAAAAAAAAEDpQnECAAAAAAAAAABYFMUJAAAAAAAAAABgURQnAAAAAAAAAACARVGcAAAAAAAAAAAAFkVxAgAAAAAAAAAAWBTFCQAAAAAAAAAAYFEUJwAAAAAAAAAAgEVRnAAAAAAAAAAAABZFcQLIpwsXLigoKEgpKSl5rrN06VINGTIkR/vUqVNVt27dHP+1bNlS58+fN683aNAgrVq16pax7N+/X02aNMl1n4sXLzavN3v2bL322ms5tjeZTMrIyMjx339FRkaqXbt2t4wHAAAUHLmF/duzZ48ee+wxSdKlS5fUsGHDXNe79957c/TTjYxGoxo0aKCzZ8/muv3mzZv10ksv6eGHH9a9996ru+++W8HBwerfv78+/fRTXb58uWhfGACgRCHnAGCrnKwdAGAvMjMzZTKZdM8999x0vf+ebErSSy+9pJEjR+bYX0hIiE6cOKHKlStLktLS0pSenn7LWI4dO6YaNWpo2bJlOZY5Of37sU5NTVVaWlqOdWbPnq3p06fnaHdxcdHs2bPVokULczy5bX+jDh066MSJE3kuf+CBBzRv3ryb7uNWzpw5o4iICPXr1++m6/3555964oknzP92d3dXjRo19MQTT6hPnz5ycLhejw0PD8/23pUpU0YNGzbUK6+8ogYNGhQ4vkGDBmn37t3asmWLfHx8cizfs2ePBg8erMjIyFy3X7BggX788UfNnTs3x7Ldu3dr0aJF+uOPP3Tx4kVJUtWqVfXaa6+pTZs2BY4VAGA7yC1yZ0u5xaxZs/TBBx9ka3N2dtYbb7yh3r17KzU1VampqZKkjIwM8///r127dsloNJr/feN7Kl0faMmrr6ZMmaI1a9boueee0+DBg+Xt7S1HR0clJCTo8OHDWrhwoVauXKmVK1fK3d09X68fAFC6kHPkzpZyjjVr1ujll1/O0V6rVi1t2rQpW1tcXJxCQ0Pl5+enTz/99LbiA6yN4gRQQJGRkXJzc8t12dKlS/X999/naDcYDDlOQqXrJ7c3nqhK0saNGxUVFSVPT0+FhYXlehyTySRnZ+dc95kfoaGhCg0NzdZ26dIl3X///SpXrlyB9rVy5UrzVQoHDhzQ008/rd27d5uXu7i4FCrGG/3zzz+aN2/eLX/M09LS5OLiop07d0qS0tPTdeDAAY0bN06nTp3S6NGjJV0fPOjRo4fGjh2rzMxMXbhwQatWrdJTTz2l5cuXq06dOvmOLSYmRnv37lW9evW0evXqXK80uXHgIq+4/5s0mUwmTZo0SStXrtTAgQP13HPPycfHR6mpqTp+/Lg5AQQA2D9yi+xsKbcYOnSoBg8enK2tXbt2cnR0vOUxEhISdP/998tkMuW5jrOzsw4cOHDT/axbt07jxo1T+/bts7WXK1dONWvWVJs2bdSkSRP9/fffatq06S3jAgCUXuQc2dlSzpGRkaFatWrlKNr89306cOCAhg4dqvLly+erGATYOooTQD4ZDAZJ1we8vby8cl3nZj8MJpMp2w93Zmam0tLScpzcxsXFKS0t7ZY/qsnJyfr111+z7Ss1NVUPPfSQypQpk6/XdKMNGzaobt26qlevXoG2u/EKvaz/X7Zs2QIfvyjdePyQkBC98sorCg8P14svvmh+v52dnc3rlS9fXqNHj9bRo0e1evXqXK9WyMvy5cvVpUsX3Xvvvfrkk09yLU4Uxvz587Vp0yYtX75cfn5+2ZZVrVq1SI4BALAucovc2VJu4eDgIFdXV/O/Dx06pAsXLqh169a33LZ8+fLat2/fTYsTWX8DN9OsWTN98803CgoKypETXLlyRYsWLZKbm5vuvPPOW+4LAFA6kXPkzpZyDul6P93s+NeuXVNoaKjGjRunw4cPa8+ePZYLDigmFCeAfCpbtqzuuOMO8y2CuXFwcNCAAQNytM+ZM0fvv/9+jqsKfHx85O/vn61t8ODBevzxx28Zz+nTpzVt2jSlp6fLwcFBZcqUkYeHh5o2bZrtx3zt2rVau3atpOs/2LVr186xL6PRqCVLltyykl9YycnJmjZtmr777julpqaqefPmCg8Pz3aCPWfOHC1evFjnzp1T5cqVFRYWpscff1x33323OUmqW7duvq4w/K+6devqypUrSkpKUvny5fNcz9/fX7Gxsfner9Fo1IoVKzRnzhz5+/vr7bff1t69e9WoUaMCxfdfiYmJ+uijj/T+++/nGIQAAJQc5BaFZ63c4rvvvlPLli1VsWLFfK2fdcVlcnKyIiIidPLkSVWvXl3t2rWTp6dnvvbx7rvvav78+RoxYoQSEhJUuXJlOTo66tKlS0pPT1fz5s21bNmyAl8tCgAoPcg5Cs/a4xk3KlOmjNavX6/y5cvr8OHDt/3aAFtAcQLIJxcXF23fvr1Q2x45ckTPPvtsjnkac3PgwAF5eXmpTJkyatWqVZ7r3Xnnnfrmm29uub8uXbpo4sSJMhgMed6SuHDhQhmNRvXs2fOW+ysok8mksLAwZWZmas6cOSpbtqwWLlyogQMH6rvvvpOLi4s2bNigRYsW6b333lNAQID52QqS9Msvv2j37t166623tGbNGvNzIwri1KlT8vLyuuUVEAcPHlT9+vXzvd/t27frjjvuUFBQkKTr7/WKFStuuzjxww8/qHz58goJCbmt/QAAbBu5ReFYK7dITEzU119/rQ8//LBA8R46dEgDBw6Ug4ODatasqdjYWL377ruaO3euLl68qGefffam27u4uJinsEhLS9Ply5dlNBrl6ekpDw+PAsUCACidyDkKxxbGM/7rZhdcAvaI4gRwC5mZmYWax++/P56ZmZnmfSUnJyshIUEnT55UXFyc4uLi9NRTT0mSLl68qJiYmDzngZSuX9GQNS9i1r6TkpJ0/vx5xcTEyNnZ2fwgK4PBkG06gv86fvy4PvjgA4WEhBR6zseb+f7773X06FFFRESYb5McN26cunbtqvXr16t79+6KjIxUp06dzPMk33g1oqenp9zd3eXg4FDg2yuNRqN+//13jRs3Tv369cszETh16pRmz56t6OhoTZs2TdL1h1Z17do121QMs2fP1r333mv+97fffqvevXub/92rVy8NHDhQ//d//3dbc1MeOnRId999d6G3BwDYNnKL22Ot3OLTTz9VYmKiUlJSsrVHR0erbt26eW6X9byIN954Q87OzsrIyNCECRP0f//3f1q9erUOHz6sjIyMbBdIxMfH66GHHrrplFB5GT16dJFNMwkAsG/kHLfHmuMZQGlBcQK4hTlz5mj69OmF2vbHH3+Ut7e36tevr2nTpmnBggUqU6aMXF1d5ebmpsqVK6tq1ary9/eXs7OzJOmhhx665W2QQUFBOnbsmBo0aCDp+tyQ7u7uqlKlinx9fdWmTRvzj/nNxMfHKzQ0VIMHD9aKFSv01VdfqW/fvoV6rXnZvn272rVrl20uR0lq3ry59uzZo+7du+uuu+7SnDlz1Lt37xy3hRZUWlqamjZtKqPRqJSUFPn4+OiZZ57R//73v2zrrVixQhs2bFB6erquXbum2rVr6+uvvzY/aLpKlSpatWpVtkEBb29v8/8/d+6cfv/9d3MxQ5Lq168vX19fRUREqFOnToV+DUlJSXnOAwoAsH/kFrfH0rmFdP3KxxUrVmjUqFGaPHmygoODzYM2tWrV0po1a3T+/Hm1adMmx7bx8fEaOXKkuT+cnJzUqVMnbdiwQRkZGbp06ZIyMzOzbePt7a2//vorWx7SsGFDrV69OtvrefjhhzV+/Hjdf//95rb8PKwbAFA6kHPcHkvnHP/884+5yJGlW7duCg8Pv639AraM4gRwC1m30eemd+/e6tu3rx577LGb7mPgwIEaOHBgkcUUFBSkyMhIXblyRU5OTnJ3dy/wiWhcXJwGDRqkzp07a/jw4Wrfvr369++vSpUq6ZFHHimyWE+ePKndu3drw4YN2dpTU1PNCUevXr106dIl9enTR4888ojCwsLk4+NTqOM5Oztr1apVkqRy5crlOcjfoUMHjRw5UgaDQceOHdNLL72U7UoGR0dHVa9ePc/jrFy5Uh07dsyRpPTq1UsrVqy4reKEp6enTp06VejtAQC2jdzi9lg6t4iLi9PIkSM1fvx4dejQQX/99ZfGjRund999V9K/V3XmddfkY489punTp2vcuHEKDAxUdHS0pk+frp49e2r//v2aPn16rndI5Pb+Ozg45LgyNLc2AAAkco7bZemco3r16lqwYEG2Np4phZKOLBbIp4MHD6pPnz7ZTh7T09P1999/m6vYTk5O6t+/f77mYpSu375441RDzZs3l6+vb762dXFxueXUQe3bt1dCQkKO9sjISI0YMUK9evUyx1q3bl199tlneu6553T+/PkifZhUr1699Mwzz+Roz5on2WAwaMiQIerevbtmzpypDh066JNPPrnpw7ryYjAY8vUeenh4mNerXr26atasqa+//vqW8z5nWb58ueLi4rR8+fJs7SaTSZmZmTp79qw5IXFycpLRaJTRaMw16UpLSzNfaSJdn39zy5Yt+YoDAGC/yC0Kz1K5RVRUlJ555hn17dtXHTp0kCRNmDBBjz/+uD744AM1b978lvt4/vnn5erqqrCwMJ05c0Z33HGHHn/8cT333HNydHTUl19+mWNapxt16tRJsbGxMhqNeuyxx2QwGMzL0tLSNGTIEPn6+urbb7/N90O2AQClCzlH4VlyPMPJySnf7yFQUlCcAPLprrvu0r59+266zqpVq7RkyZI8l6empmrhwoXatGmT4uLilJiYKBcXF1WpUkUPPPCA+vTpU6AHMr/wwgvavHlznvMROzo6asSIEdlu9T9x4oSGDh2qcePGqUuXLtnWv+eee/TVV18pMjIy3zHcire3txITE/P1A1ulShW98847Klu2rCZNmqTVq1dLUraT8OLyzDPPaOLEiRowYMAtk6TffvtNLi4uWrNmTa7LJ06cqDVr1pgLHd7e3jIajYqLi1PNmjVzrB8bG6s77rjD/O9WrVrprbfe0q5duxQcHHwbrwoAYMvILQrHUrnF2bNn1a9fPw0dOjTb9JBeXl6aM2eOPv3003zF6+joqKFDh2ro0KF5XqhwM/+9WvO/jEaj7rvvPsXExKhevXoF2jcAoHQg5ygcexnPAOwZxQmgCBmNxpsuf+GFF5SYmKgRI0aofv36Klu2rFJTUxUXF6fvv/9e/fv31yeffKL77rsvX8c7cOCAPvroI7Vq1SrX5e+9956OHTuWra1WrVratGlTtoc03ah27dqqXbt2vo6fH82bN9ebb76pc+fOqUqVKvna5t5779U333xj/rerq2uhHuJVEB06dNC0adO0YsUKPfHEEzddd9myZercuXOe71O3bt306aefmosTfn5+CggI0Jdffpljrsj4+Hht3rxZU6dONbdVqlRJQ4YMUXh4uBYtWqRq1ard5qsDANgrcoucLJVbeHt7a9asWWrcuHGOZX5+fpowYYJ+/fXXfB3/0KFD+uijj/TRRx/lujxr4OLGK1Dzy2AwFGo7AABuRM6Rk72MZwD2jOIEkE8XL15U165dlZiYmGfl28nJKdfb/aTr0/3s2LFDy5cvz3ZVm7Ozs4KCghQUFKTo6Ght27Yt3z/mkuTu7p7nPMPu7u65XoWQ1w95cejUqZPmzp2r/v37a9y4cbrzzjt14cIFbdmyRc8++6xcXFwUERGhSpUqyc/PTydPntSHH36okJAQ8z6qVq2qc+fOafv27apVq5bc3NyyPZy6KDg6Oqp///6aO3euHn/88TyvakxKStLmzZvNV0Hkpm3btnr99de1b98+NWzYUJL0xhtvKDQ0VC4uLurVq5fKlSun/fv3a8qUKbrvvvvUtm3bbPsYNmyY4uPj1aNHDz3zzDMKCQlRlSpVlJaWpujoaFWsWFF169YtujcAAGBx5BaFY6ncwmAw5FqYKIzExMSbXrHq6OioHTt25DpH9YsvvqiIiIg8/0YMBoOqVq2qGjVqFEmsAICSh5yjcOxlPAOwZxQngHyKj4/X1atXtX///kLdlmcwGNS6dWu98847ev755xUUFCQvLy+lp6fr1KlT2rp1q3744Yd8TxGQJTk5Wampqbkuu3r1qkVvIcxt3kgXFxctXLhQ7733nkaPHq3ExESVL19e999/v7kAsHfvXn311Ve6cuWKqlSpovbt2+vll18278Pb21uhoaF65ZVX5ODgoAkTJqhNmzY5ju/q6pqvB0K6uLjkul6vXr308ccfa8uWLXk+ROu7775T7dq1VatWrTz37+7urrZt22rNmjXm4kSLFi307bffatasWRo4cKCSkpJUo0YNPfHEE3riiSdy9JODg4PGjx+vhx9+WEuXLtUXX3yhS5cuycHBQf7+/nr11VcpTgCAnSO3uDVr5xZFxcHBQRkZGUpPT8/z/atUqZJMJlOO5X///bc+/vhjPfTQQ8UWHwCgZCPnuDVr5xyurq63nGL6Ro6Ojvka/wBsncGU1+RuALLJutLg4sWLN/2BNBgM2rRpU65zEt44R2NsbKwuX74sZ2dn8xyNTz75ZIHmCh46dKi2bduW5xyNTk5Oeumll/T000/ne583ioyM1JgxYxQREVGo7QEAQN7ILezfnj17FB4ernXr1unSpUtq1aqV9u7dm2O9s2fPqnv37rpw4cJN99erVy9NmDAhW9uIESO0ZcuWW8YyePBgjRo1qmAvAABQKpBzALBVFCcAK8rMzGSOYAAAUGTILQAAgCWQcwAoCnyLAFbEDzkA3J5Lly7pqaee0uDBg/O1fmRkpHr37q1mzZqpffv2Wrp0aTFHCFgWuQUAALAEcg4ARcGmvkkYYAAAAPkVExOjvn37ytnZWRkZGflaPywsTGFhYdq9e7c+++wzff7551q3bp0FogUAAAAAADeymeIEAwwAAKAglixZopdfflmPPfZYvtZftGiR+vTpo5CQEElSQECAwsPDNW/evOIMEwAAAAAA5MJmihMMMAAAgIJ45ZVX1Lp163yvv23bNrVt2zZbW3BwsKKiohQfH1/U4QEAAAAAgJtwsnYAWV555RVJ0ooVK/K1/rZt2zRt2rRsbcHBwRoxYoTi4+Pl7e1d4Bj+/PNPmUwmOTs7F3hbAACsLT09XQaDQY0bN7Z2KDbHaDQqNjZWAQEB2dqdnZ3l6+uro0ePkjsAAEol8gfLI38AANizoswdbKY4URDFNcBgMpnM/wEAYG/4/cpbQkKCJMnLyyvHMi8vLyUmJhZqv1l5Q1pa2u2EBwAAShHGHQAA9qwof8PssjhRXAMMzs7OSktLU3p6+u2EBwCA1XAFXu4yMjLMAwEGgyHbsttJrJydnWUymRQYGHi7IQIAYBXHjh3L8duI4pWVrzVo0MDKkQAAUHD79+8vsn3ZZXGiuAYYpOtJAgMMAAB7dOzYMWuHYLOyLmhISkpS2bJlsy3Lra0gDAaD3N3dbys+AACshcIEAACwFrssTjDAAABATgwu5M3d3V3e3t6Kjo5Wo0aNzO3p6emKi4tTzZo1rRgdAAAAAAClj4O1AyiMGwcYbsQAAwAAyEtwcLAiIiKyte3cuVPe3t7y8/OzUlQAAAAAAJROdlmckBhgAAAANzdy5Ej99ttv5n8PGjRIS5cu1fbt2yVJUVFRmjhxokJDQ60VIgAAAAAApZbdFCcYYAAAALlxcXGRi4tLjvaoqChdunTJ/O86depoxowZmjFjhpo0aaLBgwerb9++6tWrlyXDBQAAAAAAssFnThR0gGHq1KkaNWqUypUrpwEDBjDAAABAKdOlSxd16dIlR/vq1atztAUHB2vlypWWCAsAAAAAANyEzRUnGGAAAAAAAAAAAKBks5tpnQAAAAAAAAAAQMlAcQIAAAAAAAAAAFgUxQkAAAAAAAAAAGBRFCduQ2ZmprVDKLF4bwEAAFBQ5JDFh/cWsB5TptHaIZRIvK8AYH0290Bse+Lg4KCPlv6gk+cSrB1KiVK9SnkN79PK2mEAAADAzjg4OGj21lk6demktUMpUapVqK4hbcOsHQZQahkcHHX6u3eVdjHG2qGUGC4Va6hqx7HWDgMASj2KE7fp5LkEnTh1wdphAAAAAJB06tJJxZw/Ye0wAKBIpV2MUWr8MWuHAQBAkWJaJwAAAAAAAAAAYFEUJwAAAAAAAAAAgEVRnAAAALAQHihbfHhvAQAAAMC+8MwJAAAAC+FhvcWjOB/Wm5mZKQcHrucpDry3AAAAQOlGcQIAAMCCeFivfaGgVDyKs6AEADcTGRmpKVOmKDo6WuXLl9fgwYPVp0+fm26zZMkSLV68WKdPn5aXl5c6dOig559/Xu7u7haKGgCAkoniBAAAAHATFJQAoGSIiYlRWFiYpkyZopCQEEVFRSk0NFQeHh7q0qVLrtvMnj1ba9as0Xvvvae6desqNjZWL7/8sl5//XW99957Fn4FAACULNxHDQAAAAAASrxFixapT58+CgkJkSQFBAQoPDxc8+bNy3Ob1atX68UXX1TdunUlSX5+fnrttde0bds2i8QMAEBJRnECpQYPyiw+vLcAAAAAbN22bdvUtm3bbG3BwcGKiopSfHx8rtvccccdio2NzdYWFRWlWrVqFVeYAACUGkzrhFLDwcFBHy39QSfPJVg7lBKlepXyGt6nlbXDAAAAAIA8GY1GxcbGKiAgIFu7s7OzfH19dfToUXl7e+fYbsSIEQoNDZWPj486deqkiIgITZs2TR9++OFtxWMymXT16tVbrmcwGOTm5nZbx0LeUlJSZDKZrB0GANgVk8kkg8FQJPuiOIFS5eS5BJ04dcHaYQAAAAAALCghIUGS5OXllWOZl5eXEhMTc92uYcOGmj9/voYOHarp06fr2rVrmjt3rnmap8JKT0/XwYMHb7mem5ub6tWrd1vHQt6io6OVkpJi7TAAwO64uLgUyX4oTgCwWZmZmXJwYPa54sB7CwAAgNIkIyNDJpMp16s9b3blfExMjN58803deeed6tq1q9avX6+xY8dq4sSJCgoKKnQ8zs7OCgwMvOV6RXVlKnLn7+/PnRMAUEDHjh0rsn1RnABgs5iKq3gwFRcAAABKm6w7JpKSklS2bNlsy3Jrk67f3RAaGqonn3xS/fv3lyR17dpV3377rQYPHqwNGzbkul1+GAwGubu7F2pbFB2mzAKAgivKwjnFCQA2jam4AAAAANwud3d3eXt7Kzo6Wo0aNTK3p6enKy4uTjVr1syxzfHjx3Xu3Dn973//y9beq1cvLViwQH/++adCQkKKPXYAAEoq5vQAAAAAAAAlXnBwsCIiIrK17dy5U97e3vLz88uxvqurq65du6YrV65ka8/MzFRCQoKcnZ2LNV4AAEo6ihMAAAAAAKDEGzRokJYuXart27dLkqKiojRx4kSFhoZKkoxGowYOHKioqChJ159H0LJlSz333HM6fvy4JOncuXMaO3asypYtq6ZNm1rnhQAAUEIwrRMAAAAAACjx6tSpoxkzZmjq1KkaNWqUypUrpwEDBqhXr16Srj80OyoqSsnJyeZtZs6cqXnz5iksLEznz59X2bJlFRISoi+++EIuLi7WeikAAJQIFCcAAAAAAECpEBwcrJUrV+a6zNXVVTt27MjRNnToUA0dOtQS4QEAUKowrRMAAAAAAAAAALAoihMAAAAAAKvIzMy0dgglFu8tYB2mTKO1QyixeG+BkodpnQAAAAAAVuHg4KDZW2fp1KWT1g6lRKlWobqGtA2zdhhAqWRwcNTp795V2sUYa4dSorhUrKGqHcdaOwwARYziBAAAAADAak5dOqmY8yesHQYAFJm0izFKjT9m7TAAwOYxrRMAAAAAAAAAALAoihMAAAAAAAAAAMCiKE4AAAAAAAAAAACLojgBAAAAAAAAAAAsiuIEAAAAAAAAAACwKIoTAAAAAAAAAEolU6bR2iGUSLyvyA8nawcAAAAAAAAAANZgcHDU6e/eVdrFGGuHUmK4VKyhqh3HWjsM2AGKEwAAAAAAAABKrbSLMUqNP2btMIBSh2mdAAAAAAAAAACARVGcAAAAdisyMlK9e/dWs2bN1L59ey1duvSW2yxZskSPPvqomjVrpjZt2mjy5Mm6evWqBaIFAAAAAABZbKo4wQADAADIr5iYGIWFhSksLEy7d+/WZ599ps8//1zr1q3Lc5vZs2dr0aJFmjp1qnbv3q2FCxfqzz//1Ouvv27ByAEAAAAAgM0UJxhgAAAABbFo0SL16dNHISEhkqSAgACFh4dr3rx5eW6zevVqvfjii6pbt64kyc/PT6+99pq2bdtmkZgBAAAAAMB1NlOcYIABAAAUxLZt29S2bdtsbcHBwYqKilJ8fHyu29xxxx2KjY3N1hYVFaVatWoVV5gAAAAAACAXTtYOIMu2bds0bdq0bG3BwcEaMWKE4uPj5e3tnWMbBhgAACidjEajYmNjFRAQkK3d2dlZvr6+Onr0aK65w4gRIxQaGiofHx916tRJERERmjZtmj788MNCx2IymfI1paTBYJCbm1uhj4NbS0lJkclkKrL90WfFryj7jP4qfnzG7E9++sxkMslgMFgoIgAAgH/ZRHGCAQbkhpNV+8LJqv0p6j6D9ZWmwYWEhARJkpeXV45lXl5eSkxMzHW7hg0bav78+Ro6dKimT5+ua9euae7cuea7MAsjPT1dBw8evOV6bm5uqlevXqGPg1uLjo5WSkpKke2PPit+Rdln9Ffx4zNmf/LbZy4uLhaIBgAAIDubKE4wwIDccLJqXzhZtT9F3WewDaVlcCEjI0MmkynXgszNim4xMTF68803deedd6pr165av369xo4dq4kTJyooKKhQsTg7OyswMPCW65WWwpE1+fv7F3mhHMWrKPuM/ip+fMbsT3767NixYxaKBgAAIDubKE4wwIDccLJqXzhZtT9F3WewvtI0uJB1QUNSUpLKli2bbVlubdL1CxBCQ0P15JNPqn///pKkrl276ttvv9XgwYO1YcOGXLe7FYPBIHd390K8ChQ17rizP/SZfaG/7E9++oy8GwAAWItNFCcYYEBuOPmxL/SX/aHPSp7SNLjg7u4ub29vRUdHq1GjRub29PR0xcXFqWbNmjm2OX78uM6dO6f//e9/2dp79eqlBQsW6M8//1RISEixxw4AAAAAACQHawcgZR9guFFhBxjKly+vP//8s1hjBgAA1hUcHKyIiIhsbTt37pS3t7f8/PxyrO/q6qpr167pypUr2dozMzOVkJAgZ2fnYo0XAAAAAAD8yyaKExIDDAAAoGAGDRqkpUuXavv27ZKkqKgoTZw4UaGhoZIko9GogQMHKioqStL1qcxatmyp5557TsePH5cknTt3TmPHjlXZsmXVtGlT67wQAAAAAABKIZspTjDAAAAACqJOnTqaMWOGZsyYoSZNmmjw4MHq27evevXqJen6M62ioqKUnJxs3mbmzJl64IEHFBYWpqZNm6pPnz5yd3fXF198UWoeJg4AAAAAgC2wiWdOSP8OMEydOlWjRo1SuXLlNGDAgFsOMMybN09hYWE6f/68ypYtq5CQEAYYAAAoJYKDg7Vy5cpcl7m6umrHjh052oYOHaqhQ4daIjwAAAAAAJAHmylOSAwwAAAAAAAAAABQGtjMtE4AAAAAAAAAAKB0oDgBAAAAAAAAAAAsiuIEAAAAAAAAAACwKIoTAAAAAAAAAADAoihOAAAAAAAAAAAAi6I4AQAAAAAAAAAALIriBAAAAAAAAAAAsCiKEwAAAAAAAAAAwKIoTgAAAAAAAAAAAIuiOAEAAAAAAAAAACyK4gQAAAAAAAAAALAoihMAAAAAAAAAAMCiKE4AAAAAAAAAAACLojgBAAAAAAAAAAAsiuIEAAAAAAAAAACwKIoTAAAAAAAAAADAoihOAAAAAAAAAAAAi6I4AQAAAAAASoXIyEj17t1bzZo1U/v27bV06dJbbpOZmanFixerZ8+eat68uZo0aaJRo0ZZIFoAAEo2J2sHAAAAAAAAUNxiYmIUFhamKVOmKCQkRFFRUQoNDZWHh4e6dOmS6zYmk0mjRo3StWvXNHnyZAUGBspoNOrs2bMWjh4AgJKHOycAAAAAAECJt2jRIvXp00chISGSpICAAIWHh2vevHl5brNhwwbFxsbqo48+UmBgoCTJ0dFR1apVs0jMAACUZBQnAAAAAABAibdt2za1bds2W1twcLCioqIUHx+f6zbLli3ToEGD5OTExBMAABQ1fl0BAAAAAECJZjQaFRsbq4CAgGztzs7O8vX11dGjR+Xt7Z1tmclk0p49e/Tiiy/qxRdf1K+//qqyZcuqW7duGjx4sJydnQsdj8lk0tWrV2+5nsFgkJubW6GPg5tLSUmRyWQqsv3RX8WPPrMvRd1fsA0mk0kGg6FI9kVxAgAAAAAAlGgJCQmSJC8vrxzLvLy8lJiYmKP90qVLSklJ0aRJkzRkyBBNnjxZp0+f1quvvqozZ87orbfeKnQ86enpOnjw4C3Xc3NzU7169Qp9HNxcdHS0UlJSimx/9Ffxo8/sS1H3F2yHi4tLkeyH4gQAAAAAACjRMjIyZDKZcr3aM6+relNTUyVJPXv2VJs2bSRJtWrV0qRJk9S5c2eNHj1aZcuWLVQ8zs7O5mdY3ExRXZmK3Pn7+xf5VfgoXvSZfSnq/oJtOHbsWJHti+IEAAAAAAAo0bLumEhKSspRUMitTZLKlCkjSbr//vuztfv7+8vLy0vR0dFq1KhRoeIxGAxyd3cv1LYoOkznY3/oM/tCf5VMRVnU44HYAAAAAACgRHN3d5e3t7eio6OztaenpysuLk41a9bMsU2FChXk7u5uvoPiRpmZmfL09Cy2eAEAKA0oTgAAAAAAgBIvODhYERER2dp27twpb29v+fn55brNfffdp++//z5b24EDByRJNWrUKJ5AAQAoJShOAAAAAACAEm/QoEFaunSptm/fLkmKiorSxIkTFRoaKkkyGo0aOHCgoqKizNsMHjxYc+bM0S+//CJJOnLkiMaMGaOwsDA5Oztb/kUAAFCC8MwJAAAAAABQ4tWpU0czZszQ1KlTNWrUKJUrV04DBgxQr169JF1/aHZUVJSSk5PN2zRr1kzjx4/X+PHjdfr0aVWoUEH9+vXTwIEDrfQqAAAoOShOAACKTGZmphwcuCmvqPG+AgAAFI3g4GCtXLky12Wurq7asWNHjvaOHTuqY8eOxR0aAAClDsUJAECRcXBw0EdLf9DJcwnWDqXEqF6lvIb3aWXtMAAAAAAAAIoUxQkAQJE6eS5BJ05dsHYYAAAAAAAAsGHMEQEAAAAAAAAAACyK4gQAAAAAAAAAALAoihMAAAAAAAAAAMCieOYEAAAAAACwSRkZGVq3bp327t2r+Ph4TZw4UeXKlTMvc3R0lMFgsHKUAACgMLhzAgAA2K3IyEj17t1bzZo1U/v27bV06dJbbpOZmanFixerZ8+eat68uZo0aaJRo0ZZIFoAAFAQsbGxeuSRRzRv3jw5Ojrqp59+0pUrV8zLZ8+erVdffdWKEQIAgNthU3dOREZGasqUKYqOjlb58uU1ePBg9enT56bbZGZmasmSJVq+fLni4uKUkZGhkJAQTZ8+3UJRAwAAa4iJiVFYWJimTJmikJAQRUVFKTQ0VB4eHurSpUuu25hMJo0aNUrXrl3T5MmTFRgYKKPRqLNnz1o4egAAcCsTJkzQQw89pDfeeEOStHr16mzL27Vrp8GDB1sjNAAAUARspjjBAAMAACiIRYsWqU+fPgoJCZEkBQQEKDw8XDNnzswzd9iwYYNiY2O1dOlSOTldT4McHR1VrVo1i8UNAADy59dff81RkLhR5cqVdenSJQtGBAAAilKBp3X666+/dPLkyXyte+rUKR0+fDhf6+Y1wDBv3rw8t8kaYPjoo48UGBgoiQEGAABKi23btqlt27bZ2oKDgxUVFaX4+Phct1m2bJkGDRpkLkwAAADb5erqqqSkpDyXHz161Pz8CQAAYH8KfGb+yiuv6KWXXlL16tVvue6RI0f08ccf65tvvrnlutu2bdO0adOytQUHB2vEiBGKj4+Xt7d3jm0YYAAAoHQyGo2KjY1VQEBAtnZnZ2f5+vrq6NGjOXIHk8mkPXv26MUXX9SLL76oX3/9VWXLllW3bt00ePBgOTs7FyoWk8mkq1ev3nI9g8EgNze3Qh0D+ZOSkiKTyVRk+6PPil9R9hn9Vfz4jNmf/PSZyWSy2QdKP/LII5oyZYpmz54tV1fXbMsuXLig8ePHq3Xr1laKDgAA3K4Cj+rHxMQoKCgoX+vWrVtXR48eveV6DDAgN5ys2hdOVu0PfWZf7H1woaglJCRIkry8vHIs8/LyUmJiYo72S5cuKSUlRZMmTdKQIUM0efJknT59Wq+++qrOnDmjt956q1CxpKen6+DBg7dcz83NTfXq1SvUMZA/0dHRSklJKbL90WfFryj7jP4qfnzG7E9++8zFxcUC0RTcyy+/rGHDhqlt27Zq27at0tLSNG/ePCUkJGjr1q3y9fXVqFGjrB0mAAAopAIXJ4xGo8qUKZOvdcuUKaP09PRbrscAA3LDyap94WTV/tBn9sXeBxeKWkZGhkwmU64FmbyKOKmpqZKknj17qk2bNpKkWrVqadKkSercubNGjx6tsmXLFjgWZ2dn8/SSN1NaCkfW5O/vX+RFVxSvouwz+qv48RmzP/nps2PHjlkomoLz8PDQwoULtXXrVm3fvl1NmzZVdHS0fHx89Oabb6pjx46lJvcBAKAkKnBxokKFCrp48aIqVKhwy3UvXbqUr5N8BhiQG05W7Qsnq/aHPrMv9j64UNSyLmhISkrK8XufW5sk88UV999/f7Z2f39/eXl5KTo6Wo0aNSpwLAaDQe7u7gXeDkWPu7fsD31mX+gv+5OfPrPlHO7HH39U06ZNzXdOAACAkqXAxYkGDRpo165dql279i3X/eWXX9SgQYNbrscAA3LDyY99ob/sD31mX+x9cKGoubu7y9vbO8fvfXp6uuLi4lSzZs0c21SoUEHu7u7mCxxulJmZKU9Pz2KNGQAAFMwLL7ygLVu2kLcCAFBCORR0g169eunzzz/PdaqlG12+fFmff/65unfvfst93jjAcCMGGAAAQF6Cg4MVERGRrW3nzp3y9vaWn59frtvcd999+v7777O1HThwQJJUo0aN4gkUAAAUSt26dfM17TIAALBPBS5OtGvXTvfee68GDhyo48eP57rOiRMnNHDgQAUFBemRRx7J134ZYAAAAAUxaNAgLV26VNu3b5ckRUVFaeLEiQoNDZV0/TlZAwcOVFRUlHmbwYMHa86cOfrll18kSUeOHNGYMWMUFhYmZ2dny78IAACQp+nTp2vJkiWaN2+eoqKidO3aNWuHBAAAilCBp3WSpClTpmjSpEl67LHHdO+996pBgwby8vJSUlKS/vrrL0VGRurRRx/VuHHj8r3PQYMGqV+/fmratKlCQkJyHWAYNGiQ3njjDQUEBEi6PsAwbNgwNWzYUPfffz8DDAAAlCJ16tTRjBkzNHXqVI0aNUrlypXTgAED1KtXL0nXn2kVFRWl5ORk8zbNmjXT+PHjNX78eJ0+fVoVKlRQv379NHDgQCu9CgAAkJeePXsqIyNDW7du1dSpU3MsN5lMcnJyMl+kCAAA7EuhihPOzs56/fXX1a9fP23cuFEHDx5UcnKyPD091aRJE40dO1Z169Yt0D4ZYAAAoOTZvHmzMjIyCrSNq6trvh96GRwcrJUrV+a5nx07duRo79ixozp27FigmAAAgOWtWrXqlnmEk1OhhjUAAIANuK1fcX9/fw0dOrSoYmGAAQCAEmbatGkFLk6UKVMm38UJAABQcvn4+Fg7BAAAUIy4xAAAABSbzZs3WzsEAABg52JjYxUREaGYmBgZDAbVqlVLnTt3VqVKlawdGgAAuA0FLk68+eabSk1NzXO5s7OzqlatqtatWysoKOi2ggMAAAAAAKXX9OnTNXfuXAUEBCgwMFCSFBkZqffff1/PPvushg0bZuUIAQBAYRW4OOHi4iKTyZTn8rS0NO3atUuzZs3SE088ofDw8NsKEAAA2K/ifuYEAAAoub744gutWrVKX3zxhZo0aZJt2e7duzV8+HBVrlxZvXv3tlKEAADgdhS4OPHaa6/la72DBw/queeeU6NGjdS1a9cCBwYAAOwfz5wAAACFtWTJEo0bNy5HYUKSmjVrpnHjxumTTz6hOAEAgJ0qtmdO3HXXXXrllVf0xRdfUJwAAKCU4pkTAACgsGJjY9W4ceM8lzdv3lxjxoyxYEQAAKAoORTnzu+77z5FRUUV5yEAAAAAAEAJVLFiRcXExOS5PCYmRuXLl7dcQAAAoEgV250TkpSamipXV9fiPAQAALAz165d0759+3TmzBllZmbmWG40GtWzZ08rRAYAAGzJww8/rDfeeEOLFy+Wp6dntmXJycmaNGmSOnfubKXoAADA7SrW4sTGjRtVr1694jwEAACwI/v379fQoUN15coVeXt7Ky4uTnfccYcuXLig1NRU1alTRzVq1KA4AQAANGLECA0ePFht27bVo48+qsDAQEnSsWPHtGbNGtWpU0cvvPCClaMEAACFVSzFibS0NC1evFgffvihFixYUByHAAAAdmjSpElq3769xo4dKxcXFzVv3lzz5s1TzZo1tWPHDo0fP16DBg2ydpgAAMAGeHp66quvvtLy5csVERGhn376SQaDQTVq1ND48ePVoUMHa4cIAABuQ4GLE926dVNaWlqey1NTU3X27Fl5eHho/PjxN314FQAAKF0OHz6sKVOmyMXFRZLk7u6uxMRESdJDDz2kl156SVOmTNHixYutGSYAALARjo6O6t27t3r37m3tUAAAQBErcHFiyJAhSk1NzXuHTk7y9vZW48aNzQMPAAAAkmQwGGQ0Gs3/9vHx0dGjR9WwYUNJ0r333quxY8daKzwAAGBD3nzzTT3++OOqX79+rsv//vtvLVy4UJMnT7ZwZAAAoCgUuDjRqVOn4ogDAACUArVr19ahQ4dUo0YNSdeLEatXrzY/Y+Lw4cPy9va2ZogAAMBGrF+/XkOGDMlzeYUKFbR582aKEwBQipgyjTI4OFo7jBLJGu9tsT4Q+/z581q3bp0GDhxYnIcBAAB24tlnn9WPP/6ohx9+WJI0YMAA9ejRQz179lTt2rX1ww8/aNiwYVaOEgAA2IKUlBSVKVMmz+Wurq5KT0+3YEQAAGszODjq9HfvKu1ijLVDKVFcKtZQ1Y6Wn8WgyIsT6enp2rp1q1asWKFdu3apYcOGFCcAAIAkqW3btmrbtq353z4+PlqxYoW+/fZbnT9/Xm+88Ya6dOlixQgBAICtqFGjhvbv36+QkJBcl+/du5c7LgGgFEq7GKPU+GPWDgNFoMiKE/v27dOKFSv03XffycfHR507d9brr78uPz+/ojoEAAAogXx8fBQWFmbtMAAAgI3p1auXpk2bpoYNG6pChQrZlsXFxWncuHHq3r27laIDAAC367aKE+fOndPq1au1cuVKJSYm6rHHHtPVq1c1c+ZM+fv7F1WMAACghOjevbv+7//+T02bNs11eWRkpP7v//5PmzZtsnBkAADA1gwcOFB79+5V+/bt1aNHDwUGBspoNOrvv//WmjVr1KRJEy5wAADAjhW4OJGWlqaIiAitWLFCv/32m4KDg/Xiiy+qdevWcnJy0pdfflkccQIAgBIgKipKtWrVynN5rVq1dPr0acsFBAAAbJaDg4Nmzpyp7777TuvXr9dPP/0kSQoICNDEiRPVqVMnGQwGK0cJAAAKq8DFidatW8vT01M9evTQhAkT5OPjUxxxAQCAEshgMCgjIyPP5Uaj0YLRAAAAe9CxY0d17NjR2mEAAIAi5lDQDcqVKydJcnJykqura5EHBAAASq6goCDt2LEjz+UbN25kakgAAJCnhIQE7du3T5cuXbJ2KAAA4DYVuDixYcMGvfXWWzp48KDatWunUaNG6ZdffimO2AAAQAnz7LPP6r333jNPy3CjdevWadq0aRowYIAVIgMAALZg5cqV+uuvv3JdtmzZMoWEhKhPnz568MEHNXv2bAtHBwAAilKhHoh9//336/7779fly5e1Zs0aTZo0SSkpKerdu7dMJhNzPgIAgFy1bdtWL7zwgoYOHaratWurdu3ayszM1N9//62TJ09q2LBh6tGjh7XDBAAAVvLJJ59oypQpOdojIiI0ceJETZ8+XQ899JB+//13jRkzRtWrV1fnzp2tECkAALhdBb5z4kZly5ZVv379tGrVKr333nuKiYmRq6urJkyYoPXr1+vq1atFFScAACgh+vbtq4iICHXv3l1eXl4qV66c+vbtqy1btmjYsGHWDg8AAFjR6dOnVatWrWxtycnJeuutt/TKK6+obdu2cnZ21v33368xY8Zo4cKF1gkUAADctkLdOZGbu+++W3fffbfGjh2rjRs3avHixQoPD1dISIhmzJhRVIcBAAAlgI+PD9M3AQCAHMqXL6/ExESVL1/e3DZr1ix5e3vrySefzLZu48aNdfz4cQtHCAAAispt3TmRmzJlyqhbt2766quvtHz5ctWsWbOoDwEAAOxYRkaGVq1apbfeekvDhw9XYmJitmUmk8mK0QEAAGtq0qSJ1q5da/737t279eWXX+qtt97KsW5qamqB9x8ZGanevXurWbNmat++vZYuXZrvbY1Go3r27KmGDRsW+LgAACCnIrlz4uzZs/Lx8cnRHhAQoJEjRxbFIQAAQAkQGxurp59+Wu7u7rrvvvv0448/6sqVKypXrpwkafbs2Tpx4kSuc00DAICSb/jw4Xrqqad04sQJeXt7a8mSJXrxxRd1991351j3999/L9AFkTExMQoLC9OUKVMUEhKiqKgohYaGysPDQ126dLnl9nPnzlXVqlV18ODBAr0mAACQuyK5c+LRRx/V6dOni2JXAACgBJswYYIeeughrVmzRuHh4XJxccm2vF27dvrll1+sFB0AALC2wMBAff3113JyctLx48cVHh6uwYMH57quk5NTnstys2jRIvXp00chISGSrl9QGR4ernnz5t1y2+joaK1atUojRozI9/EAAMDNFcmdE5mZmUzBAAAAbunXX3/V6tWr81xeuXJlXbp0yYIRAQAAW1O7dm1NmjTplut17dq1QPvdtm2bpk2blq0tODhYI0aMUHx8vLy9vXPdzmQyKTw8XK+99prc3NwKdEwAAJC3IilOGAyGotgNAAAo4VxdXZWUlJTn8qNHj5qneAIAACgqRqNRsbGxCggIyNbu7OwsX19fHT16NM/ixOLFi1W9enW1bNlScXFxRRKPyWTS1atXb7mewWCgIFKMUlJSivRiW/qr+NFn9oX+sj/56TOTyVRk9YAiKU5w1wQAAMiPRx55RFOmTNHs2bPl6uqabdmFCxc0fvx4tW7d2krRAQCAkiohIUGS5OXllWOZl5eXEhMTc93u5MmTmj9/vpYtW1ak8aSnp+fr2RVubm6qV69ekR4b/4qOjlZKSkqR7Y/+Kn70mX2hv+xPfvvsv1M0F1aRFCdmz56tKlWqFMWuAABACfbyyy9r2LBhatu2rdq2bau0tDTNmzdPCQkJ2rp1q3x9fTVq1ChrhwkAAEqYjIwMmUymXK/2vNkFl2+88YZGjBihChUqFGk8zs7OCgwMvOV6zFRRvPz9/Yv8qm4UL/rMvtBf9ic/fXbs2LEiO16RFCcaN26c57K//vpL9evXL4rDAAAAO+fh4aGFCxdq69at2r59u5o2baro6Gj5+PjozTffVMeOHYvsCgwAAIAsWXdMJCUlqWzZstmW5dYmSWvWrJGDg0OBn22RHwaDQe7u7kW+XxQM08PYH/rMvtBf9ic/fVaURaJCFScuXryozZs3KyYmRjVq1FCPHj1yDCTs3LlTn376qfbu3at9+/YVSbAAAMC+paSkyM3NzXznxH/t3r1bc+fO1aeffmqF6AAAQEnl7u4ub29vRUdHq1GjRub29PR0xcXFqWbNmjm2OXjwoCIjI9W0aVNzW2ZmpoxGo5o2bap27drl68HdAAAgdwUuTsTExOjxxx+Xj4+P/P39tW3bNi1ZskQLFy5UuXLltHHjRs2ePVsnTpxQz549NXHixOKIGwAA2AmTyaQZM2Zo+fLlunDhgipVqqQxY8aoS5cu5nW+//57zZ49W3/99Ze6detmvWABAECJFRwcrIiIiGzFiZ07d8rb21t+fn451n/11Vf16quvZmuLi4vTww8/rMjIyGKPFwCAkq7AxYl3331X7dq104QJEyRJRqNRI0eO1PDhw3Xu3DmlpKSoX79+euKJJ3J90BQAAChdFi1apNWrV+uNN95QQECA/vrrL7399ttycXHRtWvXNGfOHJ07d05PPvmkZs2apUqVKlk7ZAAAUAINGjRI/fr1U9OmTRUSEqKoqChNnDhRoaGhkq6PbwwaNMicswAAgOJV4OLEb7/9pq+++sr8b0dHR40YMUKdO3fW22+/re7du8vJqUgeZQEAAEqAL7/8Uq+88ooefvhhSVJgYKAMBoNGjBihGjVqaMCAAerRo4fKlClj5UgBAEBJVqdOHc2YMUNTp07VqFGjVK5cOQ0YMEC9evWSdP2h2VFRUUpOTs5zH87OznJ1dbVUyAAAlGgFriJcuXJFVatWzdZWu3Ztubi46MEHH6QwAQAAsjl58qSaNGmSra19+/Z65ZVX9NVXX6ly5cpWigwAANiad955RxkZGfle38nJSeHh4flePzg4WCtXrsx1maurq3bs2HHT7X18fPTnn3/m+3gAACBvDgXdwGAwyNHRMUe7q6urMjMziyQoAABQchiNRnl4eGRrc3Nzk6enp9LS0m5r35GRkerdu7eaNWum9u3ba+nSpQWKq2fPnmrYsOFtxQAAAIrO5s2b9dtvvyk1NTVf/127ds3aIQMAgEIq8G0OJpNJCxYsyHEbY1pamr7++muVLVs2+wGcnPT000/fcr+RkZGaMmWKoqOjVb58eQ0ePFh9+vTJV0xGo1G9e/fW0aNHtW/fvvy/GAAAUOwMBkOu7Q4ODnkuy4+YmBiFhYVpypQp5nmjQ0ND5eHhke1h23mZO3euqlatqoMHDxY6BgAAULQ+/fRTDR48WI8//rjuvfdea4cDAACKUYGLEy1atNCvv/6ao71hw4bas2dPjvYyZcrcsjjB4AIAACWXyWTSAw88kKM9NTVVHTp0yFGgcHR01B9//HHL/S5atEh9+vRRSEiIJCkgIEDh4eGaOXPmLfOH6OhorVq1SjNnztT3339fgFcDAACKU7169TRp0iQ9//zz+u6773JcAAkAAEqOAhcn5s+fX+RBMLgAAEDJtXjx4gLNHZ3fh0xu27ZN06ZNy9YWHBysESNGKD4+Xt7e3rluZzKZFB4ertdee01ubm75jgsAAFjGQw89pG+//ZbCBAAAJVyhnl79zTff6Msvv9Tp06dVvXp1DRgwQD169Ch0EAwuAABQchXHlAxGo1GxsbEKCAjI1u7s7CxfX18dPXo0z/xh8eLFql69ulq2bKm4uLjbjsVkMunq1au3XM9gMJCvFLOUlBSZTKYi2x99VvyKss/or+LHZ8z+5KfPTCbTbU2zWFyqVq1q7RAAAEAxK3Bx4rvvvtO0adM0ZMgQ1a1bVydPntTkyZPl4uKSrymY/suWBhckBhhsCSer9oWTVftDn9kXex5cKA4JCQmSJC8vrxzLvLy8lJiYmOt2J0+e1Pz587Vs2bIiiyU9PT1fU0u6ubmpXr16RXZc5BQdHa2UlJQi2x99VvyKss/or+LHZ8z+5LfPXFxcLBANAABAdgUuTixcuFBvvvmmOnXqZG7z9vbW1KlTC1WcsKXBBYkBBlvCyap94WTV/tBn9oXBhewyMjJkMplyLcjcrIjzxhtvaMSIEapQoUKRxeLs7KzAwMBbrldaCkfW5O/vX+RFVxSvouwz+qv48RmzP/nps2PHjlkomvwZNGiQPvnkkxw5zYIFC/TEE0+oTJkyVooMAAAUtQIXJ6KionTfffdla2vZsqWGDx+ua9euFThRsKXBBYkBBlvCyap94WTV/tBn9sUeBxeKU9ZFDUlJSTnmo86tTZLWrFkjBwcHde3atUhjMRgMcnd3L9J9onC4e8v+0Gf2hf6yP/npM1vL4Xbt2qW0tLQcxYmPP/5YDz/8sKpVq2alyAAAQFErcHEiKSkpRwHCxcVFrq6uunTpUoHnhbSlwQWJAQZbwsmPfaG/7A99Zl/scXChOLm7u8vb21vR0dFq1KiRuT09PV1xcXGqWbNmjm0OHjyoyMhINW3a1NyWmZkpo9Gopk2bql27dpo0aZJF4gcAALnL62KMoryoBgAA2IZCPRA7N87OzoXajsEFAABQGMHBwYqIiMiWP+zcuVPe3t7y8/PLsf6rr76qV199NVtbXFycHn74YUVGRhZ7vAAAAAAA4F8FLk6YTCb16tVLDg4O2dqTk5M1YMAAOTll36Wjo6PWrl17030yuAAAAApq0KBB6tevn5o2baqQkBBFRUVp4sSJCg0NlSQZjUYNGjRIb7zxhgICAqwcLQAAyI+87gQ1GAyl6i5RAABKgwIXJ9577z2lpaXle31XV9dbrsPgAgAAKKg6depoxowZmjp1qkaNGqVy5cppwIAB6tWrl6Trz7WKiopScnJynvtwdnbOV64CAAAsw2Qy6YUXXpCjo2O29qtXr+qVV17JdZrpWbNmWTJEAABQRApcnOjcuXORB8HgAgAAKIzg4GCtXLky12Wurq7asWPHTbf38fHRn3/+WRyhAQCAQnjxxReVkZGRo/3GmRZu9N8HZwMAAPtRZM+cuF0MLgAAAAAAULo999xz1g4BAABYiMOtVwEAAAAAAAAAACg6FCcAAAAAAAAAAIBFUZwAAAAAAAAAAAAWRXECAAAAAAAAAABYFMUJAAAAAAAAAABgURQnAAAAAAAAAACARVGcAAAAAAAAAAAAFkVxAgAAAAAAAAAAWBTFCQAAAAAAAAAAYFEUJwAAAAAAAAAAgEVRnAAAAAAAAAAAABZFcQIAAAAAAAAAAFgUxQkAAAAAAAAAAGBRFCcAAAAAAAAAAIBFUZwAAAAAAAAAAAAWRXECAAAAAAAAAABYFMUJAAAAAAAAAABgURQnAAAAAAAAAACARVGcAAAAAAAAAAAAFkVxAgAAAAAAAAAAWBTFCQAAAAAAAAAAYFEUJwAAAAAAAAAAgEVRnAAAAAAAAAAAABZFcQIAAAAAAAAAAFgUxQkAAAAAAAAAAGBRFCcAAAAAAAAAAIBFUZwAAAAAAAAAAAAWRXECAAAAAAAAAABYFMUJAAAAAAAAAABgURQnAAAAAAAAAACARVGcAAAAAAAApUJkZKR69+6tZs2aqX379lq6dOlN1//xxx8VGhqq4OBg3X///Ro0aJCOHTtmoWgBACjZKE4AAAAAAIASLyYmRmFhYQoLC9Pu3bv12Wef6fPPP9e6devy3CY2Nlb9+/fX999/rx07dqhBgwYaMmSIrl69asHIAQAomShOAAAAAACAEm/RokXq06ePQkJCJEkBAQEKDw/XvHnz8tzmqaee0gMPPKAyZcrIxcVFI0aMkCTt37/fIjEDAFCSUZwAAAAAAAAl3rZt29S2bdtsbcHBwYqKilJ8fHy+9mEwGOTh4aHk5OTiCBEAgFLFydoBAAAAAAAAFCej0ajY2FgFBARka3d2dpavr6+OHj0qb2/vW+7nxIkTOnXqlJo1a3Zb8ZhMpnxNDWUwGOTm5nZbx0LeUlJSZDKZimx/9Ffxo8/sC/1lf/LTZyaTSQaDoUiOR3ECAAAAAACUaAkJCZIkLy+vHMu8vLyUmJiYr/1Mnz5dffv2VdmyZW8rnvT0dB08ePCW67m5ualevXq3dSzkLTo6WikpKUW2P/qr+NFn9oX+sj/57TMXF5ciOR7FCQAAYLciIyM1ZcoURUdHq3z58ho8eLD69OmT5/o//vijFi1apP379yszM1P169fX2LFjFRgYaMGoAQCApWVkZMhkMuV6tWd+r+pdtWqVjhw5okmTJt12PM7OzvnKP4rqylTkzt/fv8iv6kbxos/sC/1lf/LTZ8eOHSuy49lUcYIBBgAAkF8xMTEKCwvTlClTFBISoqioKIWGhsrDw0NdunTJdZvY2Fj1799fTZo0kYODgz7++GMNGTJE69atk7u7u4VfAQAAsJSsOyaSkpJy3PWQW9t/HThwQFOnTtXChQuLJGcwGAzkHjaA6WHsD31mX+gv+5OfPivKIpHNPBA7a4AhLCxMu3fv1meffabPP/9c69aty3ObrAGG77//Xjt27FCDBg00ZMiQfM3bCAAA7NuiRYvUp08fhYSESJICAgIUHh6uefPm5bnNU089pQceeEBlypSRi4uLRowYIUnav3+/RWIGAADW4e7uLm9vb0VHR2drT09PV1xcnGrWrJnntqdPn1ZYWJjefvttLoYEAKAI2UxxggEGAABQENu2bVPbtm2ztQUHBysqKkrx8fH52ofBYJCHh4eSk5OLI0QAAGBDgoODFRERka1t586d8vb2lp+fX67bJCUl6dlnn9XTTz+tNm3aWCJMAABKDZuZ1mnbtm2aNm1atrbg4GCNGDFC8fHx8vb2vuU+GGAAAKB0MBqNio2NVUBAQLZ2Z2dn+fr66ujRo/nKHU6cOKFTp06pWbNmhY7FZDLl665Ng8HAbc3FLCUlpcjntKXPildR9hn9Vfz4jNmf/PRZbs9gKKkGDRqkfv36qWnTpuYpISdOnKjQ0FBJ1/OLQYMG6Y033lBAQIAyMjI0fPhwNWvWTAMHDrRu8AAAlEA2UZxggAG54WTVvnCyan/oM/vC4EJ2CQkJkv6dP/pGXl5eSkxMzNd+pk+frr59+95ynumbSU9P18GDB2+5npubm+rVq1fo4+DWoqOjlZKSUmT7o8+KX1H2Gf1V/PiM2Z/89pmLi4sForG+OnXqaMaMGZo6dapGjRqlcuXKacCAAerVq5ek6w/NjoqKMl/weOzYMf3yyy/av3+/1q5dm21f3bp1U3h4uMVfAwAAJYlNFCcYYEBuOFm1L5ys2h/6zL4wuJBdRkaGTCZTrgWZ/BbdVq1apSNHjmjSpEm3FYuzs3O+5p8uLYUja/L39y/yoiuKV1H2Gf1V/PiM2Z/89NmxY8csFI1tCA4O1sqVK3Nd5urqqh07dpj/HRQUpMOHD1sqNAAASh2bKE4wwIDccLJqXzhZtT/0mX1hcCG7rAsakpKSclyUkFvbfx04cEBTp07VwoUL5e7ufluxGAyG294HigZ3b9kf+sy+0F/2Jz99Rg4HAACsxSaKEwwwIDec/NgX+sv+0Gf2hcGF7Nzd3eXt7a3o6Gg1atTI3J6enq64uDjVrFkzz21Pnz6tsLAwvf322/m6IAEAAAAAABQ9B2sHIGUfYLgRAwwAACAvwcHBioiIyNa2c+dOeXt7y8/PL9dtkpKS9Oyzz+rpp59WmzZtLBEmAAAAAADIhU0UJyQGGAAAQMEMGjRIS5cu1fbt2yVJUVFRmjhxokJDQyVJRqNRAwcOVFRUlKTr00gOHz5czZo108CBA60VNgAAAAAAkA0VJxhgAAAABVGnTh3NmDFDM2bMUJMmTTR48GD17dtXvXr1knQ9V4iKilJycrKk68/k+OWXX7R69Wo1bdo023/vvPOONV8KAAAAAACljk08c0L6d4Bh6tSpGjVqlMqVK6cBAwbccoBh//79Wrt2bbZ9devWTeHh4RZ/DQAAwLKCg4O1cuXKXJe5urpqx44d5n8HBQXp8OHDlgoNAAAAAADchM0UJyQGGAAAAAAAAAAAKA1sZlonAAAAAAAAAABQOlCcAAAAAAAAAAAAFkVxAgAAAAAAAAAAWBTFCQAAAAAAAAAAYFEUJwAAAAAAAAAAgEVRnAAAAAAAAAAAABZFcQIAAAAAAAAAAFgUxQkAAAAAAAAAAGBRFCcAAAAAAAAAAIBFUZwAAAAAAAAAAAAWRXECAAAAAAAAAABYFMUJAAAAAAAAAABgURQnAAAAAAAAAACARVGcAAAAAAAAAAAAFkVxAgAAAAAAAAAAWBTFCQAAAAAAAAAAYFEUJwAAAAAAAAAAgEVRnAAAAAAAAAAAABZFcQIAAAAAAAAAAFgUxQkAAAAAAAAAAGBRFCcAAAAAAAAAAIBFUZwAAAAAAAAAAAAWRXECAAAAAAAAAABYFMUJAAAAAAAAAABgURQnAAAAAAAAAACARVGcAAAAAAAAAAAAFkVxAgAAAAAAAAAAWBTFCQAAAAAAAAAAYFEUJwAAAAAAAAAAgEVRnAAAAAAAAAAAABZFcQIAAAAAAAAAAFgUxQkAAAAAAAAAAGBRFCcAAAAAAAAAAIBFUZwAAAAAAAAAAAAWRXECAAAAAAAAAABYFMUJAAAAAAAAAABgUTZVnIiMjFTv3r3VrFkztW/fXkuXLr3lNhEREeratauaNWumrl27KiIiwgKRAgAAW0DuAAAACoLcAQAA2+Fk7QCyxMTEKCwsTFOmTFFISIiioqIUGhoqDw8PdenSJddtfv/9d7355pv6+OOP1bBhQ+3Zs0fDhg1ThQoV1KRJEwu/AgAAYEnkDgAAoCDIHQAAsC02c+fEokWL1KdPH4WEhEiSAgICFB4ernnz5uW5zbx58/T888+rYcOGkqR77rlHYWFhWrBggSVCBgAAVkTuAAAACoLcAQAA22IzxYlt27apbdu22dqCg4MVFRWl+Pj4HOunpaVp586dObZp166ddu7cqfT09GKNFwAAWBe5AwAAKAhyBwAAbItNTOtkNBoVGxurgICAbO3Ozs7y9fXV0aNH5e3tnW3Z2bNn5ezsrMqVK2dr9/Hxkclk0smTJ1WrVq0CxZGeni6TyaR9+/bla32DwaAuTasrw1i1QMfBzTk5Omj//v0ymUxFul/6q3gUV39J9Flxoc/sS0H6Kz09XQaDwQJRWZ895w4P1+isDF9jgY6Dm3NycCzW7zX6rOgVV5/RX8WDz5j9KUiflZb8wVZyB6lw+YPxzqdkCsgo8LGQu6uOTrpcjN9r9FfRo8/sC/1lfwrSZ0WZO9hEcSIhIUGS5OXllWOZl5eXEhMTc7RfunQp1/Vvts2tZL2pBXlzy3qUKfBxkD/FkSDTX8WnuE5o6LPiQ5/Zl/z0l8FgKBWDC5J95w5ebmULfBzkT3H9/dNnxac4+oz+Kj58xuwP+cO/bCV3kAqXPzi6lS/UsXBzxfW3T38VH/rMvtBf9sfSuYNNFCcyMjJkMplkMplyvLC8qjU3u30yt/3kR+PGjQu8DQAAsDxyBwAAUBC2kjtI5A8AAGSxiWdOZF2JkJSUlGNZUlKSypbNeSVN2bJldfny5Vz3l5ycnOfVDQAAwP6ROwAAgIIgdwAAwPbYRHHC3d1d3t7eio6Oztaenp6uuLg41axZM8c2fn5+unr1qs6fP5+t/cyZM0pPT1f16tWLNWYAAGA95A4AAKAgyB0AALA9NlGckKTg4GBFRERka9u5c6e8vb3l5+eXY/0yZcro3nvvzbHN1q1b1bRpU7m4uBRrvAAAwLrIHQAAQEGQOwAAYFtspjgxaNAgLV26VNu3b5ckRUVFaeLEiQoNDZUkGY1GDRw4UFFRUeZtnnvuOX344Yfat2+fJGnv3r366KOPNGTIEMu/AAAAYFHkDgAAoCDIHQAAsC0GU15PfrKCXbt2aerUqYqJiVG5cuU0YMAADRgwQJKUmpqq9u3b66OPPlLDhg3N26xbt06zZs1SfHy8qlSpouHDh6tLly7WegkAAMCCyB0AAEBBkDsAAGA7bKo4AQAAAAAAAAAASj6bmdYJAAAAAAAAAACUDhQnAAAAAAAAAACARVGcAAAAAAAAAAAAFkVxAgAAAAAAAAAAWBTFCQAAAAAAAAAAYFEUJwAAAAAAAAAAgEVRnECRMxqN1g4BAADYEXIHAABQEOQOAFAyUJxAkXN0dJQkXb582cqRACWDyWSydggAUKzIHYCiRe4AoKQjdwCKFrkDrIXiBIrc3r171bJlS3388cdKS0uzdjjIxdmzZ3Xs2DFrh4F8MhgMSk5O5vMEoMQid7B95A72hdwBQElH7mAfyB/sB7kDrIXiBArEZDIpMzPzpuv88ccfunLlihITE80/QlRgbcuqVas0ZcoUSdLFixetHA1uZdu2bXrttdfk7Oxs7VBgwzIzM7m9HTaJ3KFkIHewL+QOyA9yB9gqcoeSg/zBfpA7ID+KI3egOIECMRgMcnD498/mxh//rD/OsmXLqnz58vLw8ND+/fvN28E6cvviePDBB3XgwAF17dpVo0aNUmJiopWiQ24yMzOzJeOtW7fWhQsXNGHCBHXu3FmHDh2yYnSwNVmfbwcHBzk6OspoNOrPP/8k+YfNIHewP+QO9ofcAQVB7gBbR+5gn8gf7Au5AwqiOHMHihPIU25XHURFRemFF17Q8uXLJWX/8c+a89HNzU0PPvig0tLSdOLECeaAtLKsLw7pep8uX75cgwcPVkZGhho1aqQFCxaoXLlyVo4SksyJgYODgzkZv3jxosaMGaPff/9dP/30kwYOHKigoCCuCoJZ1uc7ISFBo0aNUrNmzTR58mQNHz5cf/zxh5WjQ2lD7lAykDvYD3IHFAa5A2wJuUPJQf5gH8gdUBjFmTtQnEA2N94+eWMCkNV26NAhbd68Wd98841+/vnnXPexZ88e1alTR8HBwTp16pSOHDli3jcs78CBAxo9erS6du2qP/74Q61bt9b27ds1fvx4xcXFSZIyMjKsHCUkmRODvXv36qWXXtKXX34pk8mknj17asaMGapTp446deokiauCSqqrV69q3759uc7zaTQac729/fz583riiSe0du1aVahQQZs3b9aSJUtUs2ZNLVy4kO9gFDtyh5KH3MF+kDuA3AH2iNyhZCJ/sA/kDrC13IHiBLLJun3y4sWLWrJkidasWaOEhATzl1eLFi1UtWpVBQQEaPXq1dq+fbt526wfmWrVqmnPnj168MEHZTKZ9Pfff5v3jaJnNBrznO8tMjJSr7zyiqpVq6YZM2aofv36qlixopydnXXPPfcoLi5OsbGxcnJyIomzoLz6LCUlRW+88YZGjhyp8uXLq1mzZqpQoYKaNWumRx55RImJidq1a9ct51+F/Vq5cqX27t2ba9Lu6OgoBwcHJSUlKSUlxdxeuXJlOTs7a8qUKWrXrp0qV64sSXr22WdVpkwZbd68WRInaig+5A72h9zB/pA7IC/kDrBH5A72ifzBvpA7IC+2ljs4FfJ1oAQwmUw5frjXr1+vL7/8UtHR0WrSpInS09P19ddfa/To0WratKkqVKige+65Rw4ODnrooYf0ySefyNfXV7Vr1zbf4uPu7i4fHx95eHioZs2aioqK0tmzZ+Xj42ONl1niZb3vqampOnXqlPz9/SVdT9o2b96sPn36aMCAATm2u+OOO9SwYUOtXLlSL7zwgjIzM837QvHKep8zMjLk5PTv1/CZM2d0+PBhbdmyJVtfZK3XqFEjRUZGqkWLFvL09LR43Cg+Wd/Hffv2zXPZunXrtHDhQiUkJKhevXpq0aKFunTpIk9PT3Xu3FmXLl1S9erVzdv5+vqqQYMG2rZtm4xGI59vFAlyh5KB3MH+kDvgv8gdYC/IHUoO8gf7Qu6A/7LV3IE7J0qZzMxMcxXrvwnCnj17NHHiRNWtW1e//vqrPv74Y7377ruqV6+ePvnkE/N63bp1U0REhDp06KAHHnhA7733ns6fP2/e39GjR+Xm5iZJatCggS5dumR+kA4V8qK3e/duPf3002rdurXefvttjRo1SlFRUXJyctLp06d18eJFHThwINdtO3XqpK1bt0riChNLioiI0DPPPKOnnnpK7777rvnzcebMGfn4+Oivv/7Ktn5WItG+fXsdPnxYp0+ftnjMKF43+/wZDAZt3rxZX3zxhf73v/9p5cqVatasmTZu3KgJEyZIuv63cfXqVZ05c8a8nYuLi3me0F27dkniOxiFQ+5Q8pA72B9yB/wXuQNsGblDyUT+YF/IHfBftpo7UJwoZRwcHGQwGHT8+HHNmjUr2/yNVatWVbt27cwPKEpNTVXlypXVqlUrXb58Wenp6ZKk4OBgOTo6avv27Xr++efl5OSkjz76SBcuXJB0vWp2+PBhSVLTpk3l4uJi/hLkR6jgbpzv7b8f8HPnzmnu3Llq2rSpfvjhB4WHhysjI0Nvv/22oqKi9Morr+jMmTOaPHmynn76aQ0aNEhfffWVeX/333+/MjMztWfPHvMttLh9RqMxzy/jBQsW6KOPPlKrVq00ceJEnT59Wu+++67WrVun++67T76+vnrhhRc0ZcoUjR49WmvWrFFiYqKk60l3mTJldPDgQXMfcqulffvvfI4mk0mXL1/Wd999p9jYWEnSpUuXtGDBAnXv3l2PPvqoPD091a9fP4WHh2vjxo3au3evKlWqpMDAQO3YsSPbrZk1atSQv7+/duzYYfHXhpKD3MH+kDvYH3IH5Be5A+wBuYN9In+wL+QOyC9bzx34RigFsv4Ar169qvnz5+uRRx7RwIEDdfz4cfOXjyRVqVJFd999t3799VclJCTI1dVVkrRs2TI9+OCDcnZ2ltFolLOzszp27Ki5c+dKkkaMGCEHBwe99957kq7/kTds2FDp6emqWLGiateurdjYWJ04ccKyL9wO5fbDkjXf2+XLl3MsX7RokS5fvqywsDC5uLgoICBAEydOlL+/vz7//HP5+flp8uTJmjlzpoYMGaKePXvq008/1axZs2Q0GuXp6almzZrpww8/1LJly/Tuu+9a6qWWSFmfNUdHRxkMhhw/4MePH9eGDRs0cuRI9e/fX4GBgXrvvffUpUsXTZw4UY6OjnrxxRe1aNEiBQQEqG7duvr888/17rvv6ujRo5KuJ3Xbt2/X7t27tWPHjjyvTIF9yPp8X7x4UT///LMMBoPOnz+vzz77zNy3JpNJx48fV9u2bSX9m1gEBgaqTZs2mjNnjiSpc+fO2rVrl/mETfr3e33v3r1KSEjgRA35Ru5gP8gd7Bu5AwqK3AG2itzBvpA/2C9yBxSUrecOFCdKgayq9IwZM/THH39o7Nix+vHHHzV9+nS1adMm23p169aVh4eH9u3bp+TkZL322ms6dOiQatSoofj4ePPcYT179tQff/yhtLQ01a5dWyNGjNC+ffv0ww8/6K+//pLBYJCzs7Mk6Z577tGZM2fMT27Hv7Zs2aLXX39dX375pU6ePGn+AGclAhkZGVqyZIkee+wxDRgwQG+99ZbWr18vSbp27ZouXLig1q1bZ9unp6enWrVqpVOnTunPP/+UJHl5ealFixbq1KmTXnjhBW3YsMHcl88//7z8/f21fPlyBQYGWuql263t27dr+fLlOnfuXLZ2k8kkBwcHpaWl6YsvvtCAAQP03nvvmR8KJElnz57V6dOnFRISYr7V2cnJSY8//rgcHBy0atUqubi4yNfXV7169dKQIUP0zjvv6MqVK+YHvD366KOqV6+eRo8erY8++siczMO2ZWZmZruyIOsz/vPPP+uJJ55Qp06dtGbNGqWnpysgIEBBQUE6ePCgkpOTlZiYqHvuuUcHDx6UpGxXGnXr1s38Oe/atauSk5Oz3Z5rMBgUFBSkFi1aKCkpyRIvFSUEuYPtInewP+QOKAxyB9gbcgfbRv5gX8gdUBj2mjvwQOwSJreHTUnS5MmTdfz4cb3zzjuqWrWqpOtVMBcXl2zb+fn56c4771RYWJg8PT1Vr1499erVS8uXL9fnn3+uadOmKSgoSPXq1ZOfn5+++eYb9evXT+XKldPIkSO1c+dO/f7776pQoYL52E2aNJGzs7MaNGhgmTfBxp09e1azZs3Spk2bVL16dXXo0EHbtm3TDz/8oCFDhqh58+bmdb/++mtt3rxZw4YNMz9Aavz48XJzc1ObNm10+vRp3Xnnneb1s/qxWrVqKl++vHkeuKyETZIuXLige+65x/ygmgoVKmjs2LE8kOomDh06pM8//1y7du3SHXfcoWrVqumLL77Q008/rW7duikzM1MODg46e/asRo0aJUdHR3Xv3l2JiYkaP368Tpw4oWeeeUYGg0H+/v6Ki4uTr6+vTCaT+WFgHTp00KZNm7LtT5KqVaumqKgoBQUFSZIqVqyop59+Wr1795aXl5c13xYUgIODg7lPT506Zf4e/uabb9SqVSs999xzkv5NHoKDg7V+/XqdPXtWXl5e8vT0VExMjKTrP/xZ3/POzs6qV6+e4uPj5e3trUaNGmn9+vVq2bKl+fv9rrvu0l133WXR1wv7Qu5g+8gd7A+5A24XuQNsGbmDfSB/sC/kDrhd9po7UJwoYf6bIJhMJl26dEkHDhzQsGHDVLVqVfMXkIODgzIyMuTk5GTerkKFCmrUqJF+/vlnff755/L29pYkDRkyRKNHj9Znn32mSZMmydXVVY899pg5SZCkNm3ayNfXV1999ZUCAgLMx3F2dlaTJk0s+0bYkKwf7az/3blzp3799VeFh4era9eukq7fFrV06VKtXbtWzZs3l8Fg0NmzZ/XZZ5/p/fffV7NmzSRJw4YNU0ZGhtauXas6deooODhYmzZt0oABA7IdMzAwUIcOHTJ/8ezatUu7du1SRESEHBwcNGXKlGwJAclB3hISEvR///d/SktL05YtW+Th4aGMjAwtWrRI06dPV7du3czrLliwQH5+fpo0aZK5LTAwUB9//LF5Dr7y5csrKirKnCRkvfdBQUHm2+ISEhJ0/vx5bdmyRevXr9d9992ngIAA8z4dHBxIEGxYbidrp06d0pw5c7Rx40Z16NBBo0eP1uHDh5Wamqru3bvn2MdDDz2kb7/9Vvv371e3bt1Uo0YN7d69W61bt5avr6/5+3X16tXy8PAwf1c/9dRT+u2333I9Wbwx+QRuRO5ge8gd7Bu5AwqK3AH2htzBNpE/2C9yBxRUScodyDRKkIyMDO3cuVORkZHmNoPBoP379+v8+fNq0aKF0tPT5eDgYP4jdnK6Xp86ceKEEhISJEkBAQGqVauWtm7dKun6A6okadCgQfrpp5/Mf3yPPvqojh8/rlOnTpmPX7duXW3atElPPPEEiez/ZzAYlJGRYX7fGjdurHr16unq1auSpLS0NPn6+iojI0Ply5c334K1d+9e1a9f33y7Y1Z7t27dVKZMGW3atEk9evTQiRMntG3bNvOxJOm3335Tenq6uX9PnTql48eP66WXXtKGDRt09913W+4NsCPXrl3T8uXLtWHDBvO8jZ6enmrfvr0qV64sDw8PpaWlycnJSU8++aSuXLmis2fPmv/WIyMjde+990qSUlJSJEktW7Y0z89Xt25dubq6mh8SlPVZlKTly5ebr/KJi4vThAkT9Msvv+ill17Sm2++me0KFNgek8kko9EoKfvJmslkUnp6umbPnq2rV69q4cKFevPNN+Xl5SUfHx+ZTCZNnz5du3bt0tGjR3Xu3DllZmaqfPnyCgwM1J49e5ScnKwnn3xSJpNJr7/+uv788085ODho3bp1io+P1zPPPGM+XuPGjRUaGprr3wvfycgNuYNtInewH+QOKCxyB9grcgfbRf5gH8gdUFglNXfgW9yOpKWlScr9wUWSlJycrD/++EO//vqrMjIyzPN/GY1GVapUSVevXpWzs7M5QYiJidE777yjBx98UE8//bR5jrpq1aqpbt26+vnnnyX9W9k2GAxyd3dXfHy8eb1mzZpp9+7dkmTet5+fX/G9CXYmLS1NERERmjx5srnN399f3t7e2r9/vy5evCgXFxdlZGTozz//VL169cw/6g4ODjp69KgqVKggo9Fobq9Ro4YqVqyoc+fOqUKFCurXr5/mzZunmTNnKikpSfv27dOnn36qfv36mZOLXr166ZNPPlG7du0s/ybYgR07dujpp5/Wgw8+qJUrV+r8+fNKT0+XJDk5OemBBx5QVFSUDh06ZL5lbdmyZWrWrJk8PDwkSWfOnFH16tXNPxBubm7m/T/88MM6deqULl68qH79+unHH3/U7NmzzQ8K2rhxo8qVK2eew/Ouu+7S/Pnz9eWXX2abnxW25cbvYoPBIEdHR5lMJm3cuFE//vij0tPTzd+1mzZt0uTJk1WnTh3zNn5+fho9erS8vb21du1aDR8+XKNHjzY/5K9du3Y6ceKEDh06JG9vb73++uuqXr26PvzwQ7Vu3VqfffaZunTpkuPWdZPJlOfvBEofcgf7Q+5gH8gdUBjkDrAH5A72ifzB9pE7oDBKQ+7AtE524MKFC5oxY4YCAwM1YMAA8y0yWQ/CyVK+fHklJCRo8+bN+vTTTzVq1CjVr19fFy9eVPXq1XXmzBkFBATIYDDo6NGjGjNmjOrUqaNp06bp119/1cGDB2UymVS2bFnVq1dPv/zyi06cOKFatWpJkr744gt17dpVvr6+5jkDP//8c/MPl5Tz9s7SzsXFRZUrV9alS5e0YMECJScnq3///rrvvvu0Zs0a7d+/X8nJyXr//ffl6OioS5cumecFbNmypc6cOaPY2Fhz4pV1O2xmZqbOnz8vSQoNDVWNGjW0ceNG/e9//9Ply5fVs2dPPf7449Z86Xbjm2++0YYNG/TQQw/pww8/lKenp9LS0szJgCTVqlVLQUFB2r59u4KCgvTll19q0aJF5gcBeXp6qlKlSsrMzNS1a9dybG80GnX33Xfrn3/+UePGjTV69Gh99dVX+vnnn3XixAk5Oztr2LBh5lsouVrBtmWdaP33+2758uWaPHmyfH195e3trdmzZ2vGjBmqXbu2XF1dtWDBAoWEhKh69epKS0uTp6enAgMDNXr0aPPfzNatW/X+++/rgQceUPPmzTV//nwdPHhQDRo0kLe3t9555x3FxMTI1dVVPj4+ucbH9zAkcgd7Ru5g+8gdUFDkDrAH5A72jfzBtpE7oKBKU+5AccIOuLq6ytvbW3/++acGDBhg/uP87x/C66+/rh9//FE1a9bUSy+9pMcee0zS9Tnl1q1bp9jYWPOX0J133qnly5ebtz116pSioqK0f/9+NWzYULVq1ZKvr6++/vprValSRV9//bUCAgL07LPPSvr3qoasH6vSeCtlbj8EBoPB/F4YjUYlJibqww8/1L59+/Tjjz9qzJgxKlu2rBo1aqQVK1Zo+PDhqlu3rvr06aOAgADNnz9fGzdu1PDhw9W8eXM1bdpUH3/8sd59911JMidk//zzj2rWrCnpel906dJFnTt31unTp1WtWjULvxP24+LFi7p06ZJq164tSdqyZYuWLFmi0aNH64EHHpCU+wPbPD091bZtW40fP17z589XxYoV1aZNGx08eFB9+/bV6NGj1alTJ9WpU0f79u1T48aNdffdd+vq1atyd3fX4cOHdeLECdWvX1/S9SsaHn74Yf3888+qUKGC+aFTsA9Z371Hjx7Vb7/9pr59+yopKUkrVqzQxIkT1a5dOyUlJenll1/Wxx9/rNdee01vvvmmVq1apd9++00HDx7UPffcowceeEC9evWS9O9nu23btpowYYLOnDkjR0dHBQYGKi4uTqmpqXJ1dZV0/QomSdkebAb8F7mDbSJ3sD/kDigK5A6wB+QOtov8wb6QO6AolKbcoXR+s9sZT09PNWjQQBcuXFBMTIwcHBx07Ngxffjhh1q1apX5dsfXX39dP/zwgzp27Ki///7bvP3dd9+tSpUq6ffffzc/+CbrVs1r165JkurXry+TyaRffvlFklS1alXVqlVLS5cu1b59+/TOO+9ozpw52R6Ok6U0JQipqalauHChHnvsMX3xxRfmuRul6z/UDg4OSkpKUlpamhwdHZWQkCBfX1/1799fXbp0MT+ApnLlyrrrrrvUqVMnffXVV3r22WfVtm1bLVy4UAEBAfrss88kSSNHjlR0dLRef/11nTt3TtL12/pSUlKyzfcmXf/iIjnIXdatZqNHjzbPaSpJ33//vUJCQvTAAw+Y13F0dFRGRoY54ZOuv7dNmjRR9erV9c4772jDhg169dVXNWvWLPXp00dLlizR2bNn1b17dzk5OWnGjBm6dOmS3N3dzZ+rxx57LFvyIUktWrQgQbBhud2imJGRoZ9//lk///yzXnvtNcXFxSkzM1Pff/+9MjMzdf/990uSvLy89Nprr+nIkSPatGmTWrVqpRkzZig8PFwrVqxQgwYNNHXqVO3bt0/Sv9+jq1atUkBAgO655x5J1x9EN3bsWJUtWzZHLFm3dAK5IXewHeQO9oncAYVB7gB7Ru5gW8gf7A+5AwqD3IHihE3LesiJdP1hUVWrVtXXX3+t999/X3379tXx48e1adMmPffcc8rMzDR/AXl7e+v8+fOKjo42b//YY4/pyJEjWrRokaTrt/xlZmaqTJkykqTq1asrPT1dHh4eMhqNKlOmjJ544gnt2bNHH3zwgVq0aCFJ5of1lDYXL17UhAkT1KZNG0VEROjJJ59Ux44dzR/s9PR0LVmyRD169FDfvn01fvx4nT17VgEBAXrrrbcUEhKixMRE/fbbb+Z93nPPPUpJSTE/pMhkMsnR0VFdu3bViRMnlJGRocaNG+vNN9/UP//8o//7v//TAw88oMWLF2vgwIGqUqUKc8Pmk8Fg0Pnz5+Xk5KQmTZpIuv7wpz/++EOPP/64+UqFrPfTycnJfKtrVhLu7e2te++9V7t27ZL0b4Ldq1cvxcfHKzY2VtWrV9crr7yi5ORkjRw5UqGhobrvvvt0+vRp9ezZM1s8sF25PWDq4sWLkqSDBw9q6dKl+vDDDzV8+HC9+uqrcnBwkJOTk1JSUuTp6amzZ8/qww8/1ODBg/XPP//Iy8vLPB9j1apVVaFCBT3zzDMKCgrSTz/9pOTkZI0ePVqNGzfW3Llz1aNHD/MJmZeXl6S85/wF/ovcwXaQO9g3cgcUBLkD7Bm5g20hf7Bf5A4oCHKHfzGtkxUkJSVp4cKF6tOnj6pUqWJuz3rqetZtNjdWpipXrqy7775bixYt0l133aXvv/9eHh4eysjIUKdOnbRgwQJzNbt27doqV66cfvnlF/n7+0uSHnzwQbm6umrs2LE6f/687rvvPjVq1EiXL1/WkiVL9PPPP6tx48Zq2bKl+bjlypWTdL1i5+DgYP6vNMn68fjuu++Ulpamb775RtWrV8+2Tlpamt555x1FRUXpmWeeUUhIiF599VXNmTNHQ4cOVaVKlVSxYkX5+Pjo999/13333SdJuvfee7VmzRodOXJEDz74oDlh+/HHHxUUFKSrV6+qbNmyCgoK0vz583X8+HFVqFAh298MPzY5bdy4UStWrNCzzz6rZs2amecpvXTpkg4fPmxOEtzd3ZWenq7U1FQZDAbzbcLp6elatmyZVq5cqRMnTujRRx/V66+/Lnd3d7Vu3VrTp083J9gZGRmqWLGirly5Yr6SpUKFClqwYIGOHj2qQ4cO6a233tIdd9xhzbcEBZT1HfjLL7+oXLlyWrlypf755x999tlnqlatmmrWrKnIyEi1bNlSGRkZcnR0lJ+fn5KSktS5c2dduHBBTZs21VtvvWU+wfqvPXv2yGAwqEOHDnJ3d1erVq30wgsvmG+Z/i8+6yB3sB/kDvaH3AG3i9wBtojcwb6QP9gXcgfcLnKHf1GcsIKrV6/Kz89Pbm5u2doNBoM5QThy5IiqV6+uDh06aOXKlapSpYruuusuXblyRXfeeac8PDzMD8R5+umntXr1aj366KOqXLmyqlWrJn9/f/3999/mL0iTyaTmzZtr4cKFmj17trZs2aJ169bpn3/+UYsWLTR79mzzfHj/deODp0obg8GgY8eOafbs2Zo6daqqV69urm7emMS1a9dOzZo1M/dpkyZNtHLlSrVt21YtWrRQtWrVFBgYqF27dpn7zd3dXXXr1tWxY8d05coVlSlTRsePH9fhw4fVuXPnbLdTOTo6qk6dOpZ98Xbq3nvv1YkTJ/T8889rzJgx6tKli6Tr8zw+/PDD5vVOnz6tRo0a6fjx4/L395eDg4MSEhI0btw4nT17Vn379pXJZNKaNWuUkJCg8uXL66677pKHh4e2bt2q9u3by8nJSV988YXq169vvkXZYDCoTJkyatCggRo0aGCttwH5kNe8tRs2bNC7774rZ2dntW7dWuvWrTP/SFeqVEmNGjXSsmXLFBUVpTvvvFPS9ZOqgIAAubm5af369dn2d/HiRVWsWFGXL1/WnDlzFBERoYsXL2rAgAGqUaOGHBwc1LVrV3NMWVcyATcid7Af5A72h9wB+UXuAHtC7mBfyB/sC7kD8ovc4dZK97e/lfj4+JgfGnWj1NRULViwQF988YU8PT3VqlUrnT9/Xt9995369+8vPz8/tWjRwnybT9aP0aOPPqo5c+boyJEjqly5ssqUKaPAwEDt27dPhw4dUv369XX16lV5enrKz89Pb7/9tiTp5MmT2SrxWbf/lMarFG5m/vz56tSpk/mqg/9+eJ2cnBQcHKzMzEzNnj1by5Ytk4ODgwwGg/lBXx4eHvL391dkZKQiIyPVqlUrSVKzZs20Z88evffeezp58qQOHTqk3r17q02bNpZ+mSWGt7e3nnvuOVWvXl1ffvmldu/erRdeeEEXLlwwX5UjXf8cOjk56cSJE+a28uXLa8qUKeYHAB08eFCbNm3Sjh079Oijj6pSpUpq0aKF1qxZozJlymjWrFm6cuWKRo4cqUqVKln6peI/8vugpqyTpxu/67ISvMuXL+vLL7/UqFGjzPO0BgUFacKECVq7dq26du2qGjVqqGnTpvrhhx/MSULVqlXVrl07LViwIMfxVq1apS5dusjb21tlypTRc889l+tvAN+/uBlyB/tC7mBfyB1KL3IHlGTkDvaH/MF+kDuUXuQORc+2oimB/vrrL/388895Lr9xPq+dO3dq69atmjlzpjZt2qSQkBA1adJECxculHS9cta8eXNFR0crOTnZ/AAdDw8PNWjQQN9//71SU1MlSXXr1lXlypU1ceJEDR06VJMnT8523MzMTHOCYDQalZmZKYPBYHN/oLbAYDDI09NTUu5zX2bN+7Z27Vr9/vvvCg8P16ZNm9S/f3/99ttvOn/+vKTrT7qvXr26Nm3aJEn6888/1bBhQ1WoUEEnTpzQww8/rB9//FGjR4+Wh4eH5V5gCdW1a1e9++67cnV11WOPPaZ9+/apV69e5uWVK1dWYGCgjhw5osOHD0u6fpusq6ur0tLSlJmZKR8fH/n7++v777+XdD0xv//++7VlyxZNnz5dXbp00fLly0nobEDWj3xWgvDrr7/ql19+UUpKinl5lqx11qxZowULFujChQvmKxR27dqltLQ0NW3a1Lz+448/rv/973/m7+I77rhDDRo00O+//25ex8XFxXzLfI8ePfTBBx/o1VdfVYsWLbRnzx6lp6dLksLCwswJgtFozBYXt0ojC7mD/SN3sE/kDqULuQNKEnKHkoH8wf6QO5Qu5A7Fg1+EYrZu3Tpt2rRJly5dytaempqqRYsWac6cOZKkK1euaMuWLapdu7b5jzM4OFiTJ09WfHy8/v77bzk7OyswMFBOTk766aefJP37g9W9e3dFRkaaf4wqVqyosLAwNW3aVI0bN9bLL7+c7fg3JgP/reThXyaTSVevXlWVKlXyvBVLks6ePatly5apQYMGCgkJkSQ1bNhQP//8s44fPy7pep+0a9dOUVFRatmypcaPH6+LFy/q9ddf1+LFi9W3b1/zw8VQNGrXrq033nhD3bt31/79+7VlyxadOXPGvLxt27ZydHTUrFmzJMn8/ru4uMjBwUEVK1aUg4ODPD09lZycLIPBoKZNm+rXX3/VypUr1a9fP/rMRhgMBh09elTjx49XcHCwxo4dqy+++EI9evTQyZMns/0A//zzz+arDf744w+NHDlSS5YskSQlJyfLZDLJz88v2wnBoEGD9NdffykpKUmenp4KCgpSSkqK9uzZI+l6gilJ06dP1/Dhw3X27FlVqFBBX3/9tT744INsV4tl7dfR0dEmEwNYH7mDfSN3sG/kDqUHuQNKEnIH+0f+YL/IHUoPcofiwS9DMevatasuX76sI0eOSPr3j8NgMOjatWv65ZdfJEkeHh46dOiQ+ccl6yFVvr6+euSRRzR//nxJUvXq1RUYGKjt27dLkpydnSVJrVq10rlz57R3717zsT09PTVy5EgNGTIk2xyCyD+DwaA6deooNjZWGRkZea5nNBp16tQpPfnkk+a2uLg4lS9fXn///bcuXLggSapTp44mTpyoefPmaeXKlapYsaK5D1H0svrM09NTtWrV0vHjxzV8+HDFxMRIkgIDAzVs2DBFR0fr+eef19q1a3Xs2DFduHBB8+bNU48ePfT777+rc+fOcnd3lySVKVMm222asA1HjhxR165dlZmZqfnz5+v777/X9OnTdffdd+vTTz9VVFSUJCk9PV3r169Xx44dtWLFCs2cOVNPPPGEPvvsM128eFGtWrXS33//reTkZPMJgdFoVPny5VWzZk0tXbpUklSzZk3VqFFDW7dulfTvVRGVK1dWmzZtNGHCBI0ZM0a1atUy3/aZhZMy3Aq5g30jd7Bv5A6lB7kDShJyB/tH/mC/yB1KD3KH4mE/kdqpO++8U5mZmTp06JCkf/84XFxcdM899ygjI8N8+6Wvr6+2bdsm6fofZda6Xbp0Mf8hent7q0GDBjp16pROnz4tg8Fgrpy99tpruT4I57+38KBgOnfurN9++02nTp3KdXlmZqaqVasmNzc3LV682PxlsHv3bj344INKSEhQYmKief3atWvzgCkLcXJyUlpamvbs2aOXXnpJY8aMUVBQkIYMGaLt27fr2rVr8vPz0+eff67atWtrxYoV+uCDD/Tkk09q586dGjZsmJYsWaIWLVrY1Rd7SZOf76+AgABVqVJFXbt2Vd26dXXt2jWVKVNG//vf/5ScnKwDBw5Iuv5Ash07duiJJ56QdP0koFOnTipfvrwWL16sihUr6s4779TixYslyTyX5OXLl+Xq6mr+jr7jjjtUp04dHTlyRBkZGbnON5n13cut6ygocgf7R+5gv8gdSgZyB5Q25A4lA/mDfSJ3KBnIHazHPqO2I87OzmrcuLGioqJ0+vRpSdf/cCTJz89PtWrVMs8r99hjjykiIkLS9S+3LI6Ojrp69aoiIyMlSbVq1ZKTk1OOqxg6d+4sPz+/HDHYwy08tszPz09ly5bVxo0bzQmZdL06fuPtls8884z++usvPfXUU2revLmuXr2qV155RWPHjlVAQIC1wi/1UlNTFRMTo5o1a8rd3V3vvPOOunXrpg8++EBTpkxRYmKifHx89OKLL2r+/PkaNWqU1q1bp7lz56pdu3bWDr/UO3LkSK7fXyaTKdsVRU5OTurUqZNmzJgh6d8rCho0aKDTp0+rSpUqkq7P3+nh4SE3NzdduXJFM2fOVNeuXRUbGysfHx85ODiof//+Wrp0qY4fP27+fB89elROTk46f/684uPj5eLios6dO+uDDz7I9n19I757UVjkDvaP3MG+kTvYN3IHlEbkDiUD+YP9Inewb+QO1kVxwgLatGmjS5cuma9iyPqjqVy5sho1aqRDhw7p6tWrateunVxdXfX1118rIyPDvN7OnTvl4uKiLVu2SLp+W89LL71kfrjJjX+EuT00Cbfv+eef1+7duzVz5kxzm5OTkxwcHHT06FFNmzZNtWrV0rRp0zRgwACtXr1a7777ripWrJhrZROWs23bNnl7e+vOO+80J3jPPfecxo0bp7179+qjjz4yr5uZmalatWoxn6ONOHbsmD777DPFxsbmWGYwGMw/zv/884+k63Pg/vnnn0pKSjKfPO3Zs0fx8fGqUKGCpOvz7AYGBurRRx9Vu3btdOjQIY0ZM0aRkZF6/PHHJV1/EFW7du0UGhqqefPmafLkyRo3bpxatmyp5s2bm49bsWJFubq6coUYigW5g/0jd7Bf5A72i9wBpRm5Q8lA/mCfyB3sF7mD9eVedkGR8vX1laurqw4fPqyHHnpIjo6OMplMcnR0VJ06deTi4qJt27apc+fOGjlypNauXauff/5Zw4cP19q1axUdHa3nnntObm5ukq7PE3nXXXfleix7vYXH1jVs2FDDhg3TBx98oA4dOqhTp05ycnLSxo0bdfbsWT388MMKCAiQp6enOnbsaO1wcYP4+Hjdcccdkv598JTJZFLDhg01d+5clS9f3rwunx/r+u+D3/z9/fXee+/luu7p06c1d+5cbdy4UXfffbcmT56soKAg1axZU1u3blW3bt30008/6cMPP1TLli0VFBQkSapSpYp8fX114cIFffXVV9lOsrJugS5XrpzGjBmjtm3bavv27TIajZo5c6Z++uknXblyRRUrVswWi71fpQDbRO5g/8gd7Be5g/0gdwD+Re5QMpA/2CdyB/tB7mB7DKaSXHqxIevXr9dPP/2kwYMHq3bt2jIajXJ0dNSFCxf0+eefKyEhQe+++66MRqNOnDihNWvWaMeOHbrrrrvUo0cPvf/++xo+fLhatGhh7ZdSqmVkZOinn37SqVOndPz4cbVo0YJb8Gxct27dFBoaqo4dO2b7Ecqakw+26b8Jw42uXLmi119/XU5OTho0aJDq1q1rXjZ//nxNnz5dPj4+MplMevDBB7V+/XrNnDlT9913n5ycnPTjjz9q1qxZevbZZ9W2bVvztsuWLZO3t7dCQkJkMpl04cIFXbhwQRcvXtTChQt14cIFTZs2TTVr1iz21w9I5A4lBbmD/SF3sE/kDgC5Q0lC/mBfyB3sE7mDbeDOCQtp0aKFNm7cqL///lu1a9c2t1eqVEn33HOPZs+erZMnT6p69ery9/dX//79NXDgQMXGxmrevHmqX7++mjdvbsVXAOn67ZStWrWydhjIp0uXLqlp06bmz9yNPzokCLYnNTVV77//voYMGZLtKoG9e/fKZDLpnnvukSStWLFC0dHRWr58eY5EolOnTvrggw80ZswYc/Jep04dff755zp48KAGDRqkBx98UFFRUXr77be1YcMGOTg46KefflLt2rU1ZswYSdf/PuLj4/XBBx/o3Llz6t69u/r06WO+bROwBHKHkoHcwb6QO9gXcgcgO3KHkoP8wX6QO9gXcgfbQ3HCQipWrKhKlSrpxIkTkq4/sOTgwYP68ssvdccdd6hDhw5KTk6WJF29elURERH67LPP5O7urscff1xPPvkkt34BBVShQgWFh4dbOwzo5lckSNevKHF1dVV0dLTWrl2r4OBgnT9/Xi1atNDKlSuVkJCgGTNmKC0tTbt379bTTz8tBweHHFei+Pj4qH79+jpw4IDatWunjIwMPfXUU/L29taMGTPk4OCgp59+WgMGDNADDzygiIgIpaSk6Kuvvsrx8LjAwEBNnz5d7u7uxfa+ADdD7gBYHrmD7SB3AAqO3AGwPHIH20HuYJ8oTlhQh//X3t3HVFn+cRz/3OfAOSC4gTgnqSkPRSaULdw0JZ9IG+oS5go3WQ9uzPKhspw5Z7jcKmeSc+Qm5tQ2wtpsK43QzVw0I1erDCEwgUwLc4mFoHLgPuf3Bz9uJbBftz8753B4v/7i3Oe+r3MdGJwP+17X/Z09WyUlJVq9erVOnDihS5cuacqUKcrOztaoUaOs86KjozV16lRlZmYqLi4ugDMGgP/fihUrtHDhwh7bw03TlCSraZthGGpqalJnZ6feeOMNjRgxQitWrJAkTZw4USUlJWpqalJ8fLzq6uqUkZFhjdPdKKpbbm6uXnvtNT333HPWc5mZmYqKitLy5csVGxur+fPnKzk5WcnJydZ1Pp9PXq/XmpPL5aJJGQKO7ABgICI7ADeP7ABgICI79F+UxP3o3nvv1dWrV3X58mWtWbNGFRUVevXVV62A4PV6rXOHDx9OQADQr3X/TXvmmWd63bfW6XTK6XSqpaVFR48elSQVFhYqNjZWQ4cO1Z49e5SVlSWpayXB4MGDdeTIEUnSlClTdPjw4R7jXd8+adq0aero6NC3334rqet+rVLXNve9e/dq/vz5vebZvRKiOyAAwYLsAGAgITsA/z+yA4CBhOzQ/9EQO8A6OzvlcDjYOglgQPnuu++0ZcsWVVdXa8aMGVq3bp2io6MlSevXr5fb7daaNWskSa2trdq9e7dOnjyprVu36uuvv9ZTTz2lTz75RCNGjOgxbnfTv/z8fEVERGjr1q00IUPIITsAGIjIDsDNIzsAGIjIDv0Dn0wBYJqmtbUoLCyMgAAg5Fy/IqtbS0uL9fWBAwc0btw4ffXVV9q4caMVECRp5syZ+vzzz63H0dHRSktL0++//66TJ08qPT1dkydPVkFBgUpLSyV1NSF78803tX37dklSQUGBVq9eLYkmZAgNZAcAoY7sANxaZAcAoY7sEBr4dAqA7m1FABBKrv8HqPufn+7Hb731lp5++mlJUl1dnaqqqvTkk0/2Oc6ECRMUHh6uyspK61hiYqLi4+N16NAhSdKGDRv0wAMPaN++fVqwYIFmzZqlxsZGTZ06VZI0YsSIXqsbgP6M7AAgFJEdgH8P2QFAKCI7hB5u6wQAuKWuXr2qpqYmVVRUKCUlRRMnTlRDQ4Oys7N1+PBhDR06VAsXLlRCQoIyMjKUnJysiIiIHg36Nm/erHPnzmnTpk2SpPb2dr333nuqqKjQ22+/3eO1amtrNX78eH+/TQAAcIuQHQAAgB1kh9DBzgkAwC3x6aefKjc3Vzk5OSoqKtKuXbvU0NAgj8ejxMREDR8+XB999JGkrhUIY8aMUWVlpZYvX661a9dq1apV1lhz5szRl19+2WP8sWPH6vLly6qpqbGORUREWAHBNM0+t3UCAIDgRHYAAAB2kB1CDzsnAAD/iGmacjgcMgyjV7Onuro6rVu3TpmZmVq0aJEOHTqkoqIijR49Whs2bNBtt92mHTt26MCBA/rwww+t6zwej1wul3744QctXrxYBQUFmj17tiQpLy9PbrdbVVVVWr58uR599FG1tbUpNjbW7+8dAADYR3YAAAB2kB0GHnZOAAD+EafTKcMw1Nzc3KvZ086dOzVkyBDl5+dr0KBBmj9/vl5//XW1traqvr5ekpSbm6tTp05Zj6Wu5nymaWrs2LEaM2aMqqurrec2bdqkrKwsFRYWatGiRXK5XIqNjRU1dQAA+geyAwAAsIPsMPCEBXoCAIDAq66uVktLiyZNmtTn8x6PR6WlpSotLZXb7VZqaqrS09OVnZ0tj8ejqKgoqxGU1+uVw+FQenq6EhMT9eOPP2r8+PEaPHiw0tLS9MEHH2jVqlXWigiHw6GysjJFREQoKyvLes3hw4crJyen11z+GlAAAID/kR0AAIAdZAf0hZ0TAAAdOHBABw8e1MWLF/t8vrS0VIcPH9aaNWtUXFys0aNHa8uWLdq/f79cLpc6OzvlcDjU1tYmh8Mh0zQlSXfddZe++eYbnT9/XpK0aNEilZeXS+pqNvXiiy/q/vvv19atW5WVlaWUlJRer839HAEACD5kBwAAYAfZAX2hOAEA0Lx589TS0qKTJ09KUo8tjE1NTdq2bZteeOEFTZ06VcOGDVN+fr7y8vJUXl6uxsZG3XPPPaqvr9e5c+ckXftgnzBhgo4ePaqzZ89KkubOnatffvlFx44d06BBgzRz5ky9//77Ki8v14IFC/pcneBw8FEFAECwITsAAAA7yA7oC995AIDuuOMOeb1e1dbWSuq5hfHUqVNKS0vTyJEjJV0LAA8//LBiY2P18ccfa8aMGfrzzz915MgRSVJ4eLgk6eDBg+ro6ND58+et4LF+/XrFx8dLkrKyspSUlCSfz2etegAAAMGP7AAAAOwgO6Av9JwAACg8PFz33XefGhoa1NTUpPj4eHV2diosLEwXLlxQe3u73G63pK4GVZI0bNgw3X777Tpz5ozi4uI0b9487dq1Sx6PR7m5uTp+/Lj++OMPTZ8+XY2NjTIMQz6fT7m5uT1e2+fzyTAMa1wAABD8yA4AAMAOsgP6ws4JAIAkacaMGbp48WKvVQwPPvigqqqqrPs3SpJpmnK5XLpw4YLCwrrq3Dk5OVq6dKl+/fVX5ebmqrCwUOPGjZPb7VZCQkKPMa+/nyONpgAA6J/IDgAAwA6yA/6K4gQAQJI0cuRIud1u1dXVyTRNOZ1OmaapIUOGKDU1VXv37tWlS5ckXVvFUF9fb22llLq2XK5cuVL79u3Tu+++q0uXLiksLExz587t8VrczxEAgP6P7AAAAOwgO+Cv+CkBACR1rSSYNm2aTp8+rZ9++knStZUGS5Ys0ZkzZ/Tyyy/rt99+kyS988478vl8WrJkSY9x9u/fr7y8PGVmZqqmpkb5+fmKjIzs0ewKAAD0f2QHAABgB9kBf2X4+KkBAP6rublZBQUFmjVrlubNm2etZJCks2fPau3atXK73Tpx4oRGjhypZ599VpMnT7YCgGEYqq+v1/nz5zVp0qRAvhUAAOAHZAcAAGAH2QHXoyE2AMAyZMgQxcXFWSsYnE6namtrVVxcrIceekh79uzRqVOnNHToUMXExFjXXX//xqSkJCUlJfl55gAAIBDIDgAAwA6yA67HzgkAQA+VlZUqKSlRVFSUTpw4oba2Nk2cOFFLly7VqFGjrPO8Xq98Pp+1wgEAAAxMZAcAAGAH2QHdKE4AAHq4fPmyVqxYocjISD322GOaMmVKoKcEAACCGNkBAADYQXZAN4oTAID/yTRNGYYhh8MR6KkAAIB+gOwAAADsIDsMTBQnAAB9Mk1Tktg+CQAA/hGyAwAAsIPsAIoTAAAAAAAAAADAr9gnAwAAAAAAAAAA/IriBAAAAAAAAAAA8CuKEwAAAAAAAAAAwK8oTgAAAAAAAAAAAL+iOAEAAAAAAAAAAPwqLNATANB/VVVV6YknnlBra+sNzzEMQxkZGdqxY4d1LDs7WzU1NT3Oczgc+uKLLxQbG6vdu3eroaFBr7zyijZu3Kjo6GgtXbr0X3sfAADAP8gOAADALvIDELooTgC4aXV1dUpISFBpaakMw+jznGPHjun555+3HpumqZqaGpWVlWn06NHWccMw5HQ6JUkej0cej0eS1N7eLpfL9S++CwAA4C9kBwAAYBf5AQhdFCcA3DSfz6fIyEiFh4ff8JyoqCh5vd4e10iS2+1WWBh/ggAAGEjIDgAAwC7yAxC6+O0EEBQmTZqk5uZm63F2dnYAZwMAAIId2QEAANhFfgCCC8UJAEHhs88+s1Y27Ny5Uz///HOAZwQAAIIZ2QEAANhFfgCCC8UJAH7lcDgkSa2trWptbdWVK1fU3Nys06dP6+zZs3r88cfZcgkAACxkBwAAYBf5Aegf+C0EcNMMw9CVK1fU0dFxw6ZUbW1tViiQugJCenq6HnnkERmGIZfLpZiYGCUnJ+vOO+9UR0eHv6YPAAD8jOwAAADsIj8AoYviBICblpycrPr6eqWmpt7wHMMwNG3atB7HSkpK1NnZecNVCoMHD1ZMTMwtnCkAAAgGZAcAAGAX+QEIXYav+0ZrAHAL5OTkaPHixZozZ84tGe/48eMKDw/X3XfffUvGAwAAwYXsAAAA7CI/AKGBnRMAAqaoqEjbtm3723PcbrcKCwsJCAAAgOwAAABsIz8AwYviBICAWbZsmZYtW/a356xcuVLff/+9pk+f7qdZAQCAYEV2AAAAdpEfgOBFcQKAbT6fT6Zp3vB5r9erzs7OXscNw5DT6fw3pwYAAIIQ2QEAANhFfgBCHz0nANhWXFyszZs3277OMAxVVFRo2LBhkqSysjK99NJLam9vv+E1kZGR2rJlS6/GVgAAoP8gOwAAALvID0DoozgBIGCKiopUW1uroqKiQE8FAAD0A2QHAABgF/kBCF7c1glAwCQmJmr79u1KSUn52/MSEhJUXl7up1kBAIBgRXYAAAB2kR+A4MXOCQAAAAAAAAAA4FeOQE8AAAAAAAAAAAAMLBQnAAAAAAAAAACAX1GcAAAAAAAAAAAAfkVxAgAAAAAAAAAA+BXFCQAAAAAAAAAA4FcUJwAAAAAAAAAAgF9RnAAAAAAAAAAAAH5FcQIAAAAAAAAAAPgVxQkAAAAAAAAAAOBXFCcAAAAAAAAAAIBf/Qf1Mood0hybSQAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " feature importance importance_ratio\n", + "0 cycle_time_sec 734.0 0.119156\n", + "1 paint_thermal_std_temp 699.0 0.113474\n", + "2 station_delay_sec 678.0 0.110065\n", + "3 queue_length 505.0 0.081981\n", + "4 processing_time_sec 372.0 0.060390\n", + "5 vibration_peak 356.0 0.057792\n", + "6 equipment_idle_time_sec 334.0 0.054221\n", + "7 vibration_acceleration_g 327.0 0.053084\n", + "8 max_temperature 247.0 0.040097\n", + "9 vibration_score 209.0 0.033929\n", + "10 thermal_score 195.0 0.031656\n", + "11 throughput_per_min 194.0 0.031494\n", + "12 current_max_ampere 177.0 0.028734\n", + "13 min_temperature 165.0 0.026786\n", + "14 current_min_ampere 162.0 0.026299\n", + "15 paint_thickness_value 159.0 0.025812\n", + "16 current_rms_ampere 154.0 0.025000\n", + "17 robot_frequency_hz 136.0 0.022078\n", + "18 process_code_BODY 64.0 0.010390\n", + "19 avg_temperature 43.0 0.006981\n", + "20 paint_image_position_LEFT 34.0 0.005519\n", + "21 robot_vibration_score 31.0 0.005032\n", + "22 wip_count 27.0 0.004383\n", + "23 vibration_rms 26.0 0.004221\n", + "24 waiting_time_sec 17.0 0.002760" + ], + "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", + " \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", + "
featureimportanceimportance_ratio
0cycle_time_sec734.00.119156
1paint_thermal_std_temp699.00.113474
2station_delay_sec678.00.110065
3queue_length505.00.081981
4processing_time_sec372.00.060390
5vibration_peak356.00.057792
6equipment_idle_time_sec334.00.054221
7vibration_acceleration_g327.00.053084
8max_temperature247.00.040097
9vibration_score209.00.033929
10thermal_score195.00.031656
11throughput_per_min194.00.031494
12current_max_ampere177.00.028734
13min_temperature165.00.026786
14current_min_ampere162.00.026299
15paint_thickness_value159.00.025812
16current_rms_ampere154.00.025000
17robot_frequency_hz136.00.022078
18process_code_BODY64.00.010390
19avg_temperature43.00.006981
20paint_image_position_LEFT34.00.005519
21robot_vibration_score31.00.005032
22wip_count27.00.004383
23vibration_rms26.00.004221
24waiting_time_sec17.00.002760
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"plot_model_feature_importance(event_model_importance, f\\\"\\ubd88\\ub7c9 \\ud0d0\\uc9c0 \\ud53c\\ucc98 \\uc911\\uc694\\ub3c4 - {selected_event_model_name}\\\", top_n=25)\",\n \"rows\": 25,\n \"fields\": [\n {\n \"column\": \"feature\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 25,\n \"samples\": [\n \"max_temperature\",\n \"current_rms_ampere\",\n \"cycle_time_sec\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"importance\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 214.70794116659962,\n \"min\": 17.0,\n \"max\": 734.0,\n \"num_unique_values\": 25,\n \"samples\": [\n 247.0,\n 154.0,\n 734.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"importance_ratio\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.03485518525431811,\n \"min\": 0.00275974025974026,\n \"max\": 0.11915584415584415,\n \"num_unique_values\": 25,\n \"samples\": [\n 0.0400974025974026,\n 0.025,\n 0.11915584415584415\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + } + ], + "source": [ + "print(\"불량 탐지 모델별 평가 지표\")\n", + "display(event_model_result_table)\n", + "\n", + "event_confusion_tables_by_model = {}\n", + "event_train_confusion_tables_by_model = {}\n", + "event_confusion_metric_rows = []\n", + "\n", + "for model_name in event_model_comparison[\"model_name\"]:\n", + " threshold = float(event_model_comparison.loc[event_model_comparison[\"model_name\"] == model_name, \"threshold\"].iloc[0])\n", + " train_proba = event_train_proba_by_model[model_name]\n", + " test_proba = event_test_proba_by_model[model_name]\n", + " train_metrics = compute_metrics(y_event_train, train_proba, threshold)\n", + " test_metrics = compute_metrics(y_event_test, test_proba, threshold)\n", + " event_train_confusion_tables_by_model[model_name] = confusion_matrix_table(train_metrics)\n", + " event_confusion_tables_by_model[model_name] = confusion_matrix_table(test_metrics)\n", + " event_confusion_metric_rows.append({\n", + " \"model_name\": model_name,\n", + " \"threshold\": threshold,\n", + " **{f\"train_{k}\": v for k, v in train_metrics.items()},\n", + " **{f\"test_{k}\": v for k, v in test_metrics.items()},\n", + " })\n", + " print(f\"\\n[{model_name}] Train/Test 혼동행렬\")\n", + " print(f\"Train FP={train_metrics['fp']} FN={train_metrics['fn']} | Test FP={test_metrics['fp']} FN={test_metrics['fn']}\")\n", + " display(pd.DataFrame([\n", + " {\"split\": \"Train\", **train_metrics},\n", + " {\"split\": \"Test\", **test_metrics},\n", + " ]))\n", + "\n", + "event_confusion_metrics_by_model = pd.DataFrame(event_confusion_metric_rows)\n", + "\n", + "fig, axes = plt.subplots(len(event_model_comparison), 2, figsize=(10, max(4, len(event_model_comparison) * 3.2)))\n", + "axes = np.array(axes).reshape(len(event_model_comparison), 2)\n", + "for row_idx, model_name in enumerate(event_model_comparison[\"model_name\"]):\n", + " sns.heatmap(event_train_confusion_tables_by_model[model_name], annot=True, fmt=\"d\", cmap=\"Blues\", ax=axes[row_idx, 0], cbar=False, annot_kws={\"size\": 10})\n", + " axes[row_idx, 0].set_title(f\"{model_name} Train 혼동행렬\")\n", + " axes[row_idx, 0].set_xlabel(\"예측값\")\n", + " axes[row_idx, 0].set_ylabel(\"실제값\")\n", + " sns.heatmap(event_confusion_tables_by_model[model_name], annot=True, fmt=\"d\", cmap=\"Oranges\", ax=axes[row_idx, 1], cbar=False, annot_kws={\"size\": 10})\n", + " axes[row_idx, 1].set_title(f\"{model_name} Test 혼동행렬\")\n", + " axes[row_idx, 1].set_xlabel(\"예측값\")\n", + " axes[row_idx, 1].set_ylabel(\"실제값\")\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "event_train_proba = event_train_proba_by_model[selected_event_model_name]\n", + "event_test_proba = event_test_proba_by_model[selected_event_model_name]\n", + "event_test_pred = (event_test_proba >= selected_event_threshold).astype(int)\n", + "print(f\"선택 모델: {selected_event_model_name}\")\n", + "print(classification_report(y_event_test, event_test_pred, target_names=CLASS_NAMES, digits=4, zero_division=0))\n", + "\n", + "event_train_metrics, event_test_metrics = plot_train_test_confusion(\n", + " y_event_train,\n", + " event_train_proba,\n", + " y_event_test,\n", + " event_test_proba,\n", + " selected_event_threshold,\n", + " f\"불량 탐지 - {selected_event_model_name}\",\n", + ")\n", + "plot_train_test_metric_comparison(event_train_metrics, event_test_metrics, f\"불량 탐지 Train/Test 성능 비교 - {selected_event_model_name}\")\n", + "\n", + "event_metric_summary_table, event_confusion_matrix_table = display_confusion_matrix_report(\n", + " y_event_test, event_test_proba, selected_event_threshold, title=f\"불량 탐지 Test 혼동행렬 - {selected_event_model_name}\"\n", + ")\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(16, 4))\n", + "sns.barplot(data=event_model_comparison, x=\"model_name\", y=\"test_pr_auc\", ax=axes[0], color=\"#4C78A8\")\n", + "axes[0].set_title(\"불량 탐지 Test PR-AUC\")\n", + "axes[0].set_xlabel(\"모델\")\n", + "axes[0].set_ylabel(\"PR-AUC\")\n", + "axes[0].tick_params(axis=\"x\", rotation=20)\n", + "sns.barplot(data=event_model_comparison, x=\"model_name\", y=\"test_recall\", ax=axes[1], color=\"#59A14F\")\n", + "axes[1].set_title(\"불량 탐지 Test 재현율\")\n", + "axes[1].set_xlabel(\"모델\")\n", + "axes[1].set_ylabel(\"Recall\")\n", + "axes[1].tick_params(axis=\"x\", rotation=20)\n", + "sns.barplot(data=event_model_comparison, x=\"model_name\", y=\"test_f1\", ax=axes[2], color=\"#F28E2B\")\n", + "axes[2].set_title(\"불량 탐지 Test F1\")\n", + "axes[2].set_xlabel(\"모델\")\n", + "axes[2].set_ylabel(\"F1 Score\")\n", + "axes[2].tick_params(axis=\"x\", rotation=20)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "plot_probability_distribution(y_event_test, event_test_proba, selected_event_threshold, f\"불량 탐지 Test 예측 확률 분포 - {selected_event_model_name}\")\n", + "plot_pr_roc_curves(y_event_test, event_test_proba_by_model, \"불량 탐지 Test\")\n", + "\n", + "event_model_importance = model_feature_importance(selected_event_model)\n", + "plot_model_feature_importance(event_model_importance, f\"불량 탐지 피처 중요도 - {selected_event_model_name}\", top_n=25)" + ] + }, + { + "cell_type": "markdown", + "id": "1e8109dd", + "metadata": { + "id": "1e8109dd" + }, + "source": [ + "## 5. SHAP 불량 원인 분석" + ] + }, + { + "cell_type": "markdown", + "id": "4128b9ca", + "metadata": { + "id": "4128b9ca" + }, + "source": [ + "**셀 설명**\n", + "\n", + "선택된 불량 탐지 모델의 SHAP 중요도를 계산해 어떤 feature가 예측에 크게 기여했는지 확인합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4eb9351a", + "metadata": { + "id": "4eb9351a", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "a7fe2815-ba54-4daf-823b-ee5a1624f915" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " feature mean_abs_shap\n", + "0 vibration_acceleration_g 1.142834\n", + "1 cycle_time_sec 0.966047\n", + "2 vibration_peak 0.894833\n", + "3 process_code_BODY 0.701656\n", + "4 current_max_ampere 0.434145\n", + "5 current_rms_ampere 0.372167\n", + "6 station_delay_sec 0.360060\n", + "7 processing_time_sec 0.318584\n", + "8 paint_thermal_std_temp 0.279638\n", + "9 queue_length 0.257782\n", + "10 equipment_idle_time_sec 0.226875\n", + "11 current_min_ampere 0.196916\n", + "12 throughput_per_min 0.130066\n", + "13 equipment_type_ROBOT_ARM 0.098666\n", + "14 vibration_rms 0.092616\n", + "15 max_temperature 0.077381\n", + "16 vibration_score 0.069712\n", + "17 robot_frequency_hz 0.066810\n", + "18 thermal_score 0.056834\n", + "19 robot_amplitude 0.031175\n", + "20 min_temperature 0.028765\n", + "21 paint_image_position_LEFT 0.026563\n", + "22 paint_thickness_value 0.023652\n", + "23 avg_temperature 0.011191\n", + "24 robot_vibration_score 0.010973\n", + "25 robot_axis_J3 0.009231\n", + "26 waiting_time_sec 0.008450\n", + "27 paint_image_position_RIGHT 0.004459\n", + "28 equipment_type_CONVEYOR 0.004237\n", + "29 wip_count 0.004029" + ], + "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", + " \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", + "
featuremean_abs_shap
0vibration_acceleration_g1.142834
1cycle_time_sec0.966047
2vibration_peak0.894833
3process_code_BODY0.701656
4current_max_ampere0.434145
5current_rms_ampere0.372167
6station_delay_sec0.360060
7processing_time_sec0.318584
8paint_thermal_std_temp0.279638
9queue_length0.257782
10equipment_idle_time_sec0.226875
11current_min_ampere0.196916
12throughput_per_min0.130066
13equipment_type_ROBOT_ARM0.098666
14vibration_rms0.092616
15max_temperature0.077381
16vibration_score0.069712
17robot_frequency_hz0.066810
18thermal_score0.056834
19robot_amplitude0.031175
20min_temperature0.028765
21paint_image_position_LEFT0.026563
22paint_thickness_value0.023652
23avg_temperature0.011191
24robot_vibration_score0.010973
25robot_axis_J30.009231
26waiting_time_sec0.008450
27paint_image_position_RIGHT0.004459
28equipment_type_CONVEYOR0.004237
29wip_count0.004029
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"plt\",\n \"rows\": 30,\n \"fields\": [\n {\n \"column\": \"feature\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 30,\n \"samples\": [\n \"paint_image_position_RIGHT\",\n \"max_temperature\",\n \"avg_temperature\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"mean_abs_shap\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.31032572028034117,\n \"min\": 0.004029154253983199,\n \"max\": 1.1428337501387382,\n \"num_unique_values\": 30,\n \"samples\": [\n 0.004459415345444113,\n 0.07738062643329328,\n 0.011191022166631485\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " row_index defect_probability risk_grade \\\n", + "97 7585 0.999328 HIGH \n", + "81 1793 0.999281 HIGH \n", + "123 1593 0.999256 HIGH \n", + "332 4265 0.999209 HIGH \n", + "128 2165 0.999164 HIGH \n", + "253 457 0.999110 HIGH \n", + "383 7169 0.999089 HIGH \n", + "316 2701 0.999051 HIGH \n", + "377 2373 0.998991 HIGH \n", + "483 3653 0.998952 HIGH \n", + "119 6301 0.998894 HIGH \n", + "34 921 0.998822 HIGH \n", + "391 7261 0.998773 HIGH \n", + "216 1145 0.998758 HIGH \n", + "139 2149 0.998725 HIGH \n", + "191 9377 0.998722 HIGH \n", + "468 8336 0.998642 HIGH \n", + "336 8453 0.998461 HIGH \n", + "315 765 0.998423 HIGH \n", + "21 6805 0.998357 HIGH \n", + "\n", + " top_features \n", + "97 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "81 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "123 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "332 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "128 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "253 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "383 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "316 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "377 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "483 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "119 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "34 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "391 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "216 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "139 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "191 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "468 [{'feature': 'vibration_acceleration_g', 'shap... \n", + "336 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "315 [{'feature': 'vibration_peak', 'shap_value': 9... \n", + "21 [{'feature': 'vibration_peak', 'shap_value': 9... " + ], + "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", + " \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", + "
row_indexdefect_probabilityrisk_gradetop_features
9775850.999328HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
8117930.999281HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
12315930.999256HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
33242650.999209HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
12821650.999164HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
2534570.999110HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
38371690.999089HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
31627010.999051HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
37723730.998991HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
48336530.998952HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
11963010.998894HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
349210.998822HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
39172610.998773HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
21611450.998758HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
13921490.998725HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
19193770.998722HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
46883360.998642HIGH[{'feature': 'vibration_acceleration_g', 'shap...
33684530.998461HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
3157650.998423HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
2168050.998357HIGH[{'feature': 'vibration_peak', 'shap_value': 9...
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"plt\",\n \"rows\": 20,\n \"fields\": [\n {\n \"column\": \"row_index\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 3039,\n \"min\": 457,\n \"max\": 9377,\n \"num_unique_values\": 20,\n \"samples\": [\n 7585,\n 8453,\n 9377\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"defect_probability\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0002919588618330555,\n \"min\": 0.9983565997587882,\n \"max\": 0.9993277041630241,\n \"num_unique_values\": 20,\n \"samples\": [\n 0.9993277041630241,\n 0.9984614822540115,\n 0.9987215551588507\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"risk_grade\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"HIGH\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"top_features\",\n \"properties\": {\n \"dtype\": \"object\",\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "def transformed_feature_names(pipeline):\n", + " return pipeline.named_steps[\"preprocess\"].get_feature_names_out().tolist()\n", + "\n", + "\n", + "def compute_shap_importance(pipeline, X, sample_size=500):\n", + " X_sample = X.sample(min(sample_size, len(X)), random_state=RANDOM_STATE)\n", + " preprocessor = pipeline.named_steps[\"preprocess\"]\n", + " model = pipeline.named_steps[\"model\"]\n", + " X_transformed = preprocessor.transform(X_sample)\n", + " feature_names = transformed_feature_names(pipeline)\n", + " try:\n", + " explainer = shap.TreeExplainer(model)\n", + " raw_values = explainer.shap_values(X_transformed, check_additivity=False)\n", + " if isinstance(raw_values, list):\n", + " shap_matrix = np.asarray(raw_values[1])\n", + " elif getattr(raw_values, \"ndim\", 0) == 3:\n", + " shap_matrix = np.asarray(raw_values[:, :, 1])\n", + " else:\n", + " shap_matrix = np.asarray(raw_values)\n", + " except Exception as exc:\n", + " print(\"TreeExplainer 실패, model-agnostic Explainer로 대체:\", exc)\n", + " background = preprocessor.transform(X.sample(min(100, len(X)), random_state=RANDOM_STATE))\n", + " explainer = shap.Explainer(lambda data: model.predict_proba(data)[:, 1], background)\n", + " shap_matrix = np.asarray(explainer(X_transformed, max_evals=min(2 * X_transformed.shape[1] + 1, 1000)).values)\n", + " importance = pd.DataFrame({\"feature\": feature_names, \"mean_abs_shap\": np.abs(shap_matrix).mean(axis=0)}).sort_values(\"mean_abs_shap\", ascending=False).reset_index(drop=True)\n", + " sample_proba = predict_positive_proba(pipeline, X_sample)\n", + " examples = []\n", + " for row_pos, row_idx in enumerate(X_sample.index):\n", + " abs_values = np.abs(shap_matrix[row_pos])\n", + " top_idx = abs_values.argsort()[::-1][:5]\n", + " examples.append({\"row_index\": int(row_idx), \"defect_probability\": float(sample_proba[row_pos]), \"risk_grade\": risk_grade(float(sample_proba[row_pos])), \"top_features\": [{\"feature\": feature_names[i], \"shap_value\": float(shap_matrix[row_pos, i]), \"abs_shap\": float(abs_values[i])} for i in top_idx]})\n", + " return importance, pd.DataFrame(examples)\n", + "\n", + "\n", + "event_shap_importance, event_shap_examples = compute_shap_importance(selected_event_model, X_event_test)\n", + "display(event_shap_importance.head(30))\n", + "display(event_shap_examples.sort_values(\"defect_probability\", ascending=False).head(20))\n", + "plt.figure(figsize=(9, 7))\n", + "sns.barplot(data=event_shap_importance.head(25), x=\"mean_abs_shap\", y=\"feature\", color=\"#4C78A8\")\n", + "plt.title(f\"불량 탐지 SHAP 중요도 - {selected_event_model_name}\")\n", + "plt.xlabel(\"평균 |SHAP|\")\n", + "plt.ylabel(\"Feature\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "68650205", + "metadata": { + "id": "68650205" + }, + "source": [ + "## 6. 공정 간 불량 전이 예측 모델링" + ] + }, + { + "cell_type": "markdown", + "id": "869a1fcd", + "metadata": { + "id": "869a1fcd" + }, + "source": [ + "**셀 설명**\n", + "\n", + "PRESS->BODY, BODY->PAINT, PAINT->ASSEMBLY 흐름별로 다음 공정 불량 가능성을 예측합니다. 실제 운영에서 이미 관측된 source 공정의 정답 라벨은 과도한 지름길이 될 수 있어 기본 feature에서 제외합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "39c90ef0", + "metadata": { + "id": "39c90ef0", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "ef77ad51-049c-4614-e865-3e2cf2610684" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "공정 전이 예측 정답 유출 방지 제외 컬럼: ['source_defect_yn']\n", + "공정 전이 예측 단일 feature 예측력 상위 10개\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " feature single_feature_auc\n", + "4 source_current_rms_ampere 0.521400\n", + "5 source_vibration_score 0.521281\n", + "1 source_station_delay_sec 0.517898\n", + "2 source_queue_length 0.504349\n", + "6 source_thermal_score 0.503262\n", + "0 source_cycle_time_sec 0.503251\n", + "3 source_wip_count 0.502044" + ], + "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", + "
featuresingle_feature_auc
4source_current_rms_ampere0.521400
5source_vibration_score0.521281
1source_station_delay_sec0.517898
2source_queue_length0.504349
6source_thermal_score0.503262
0source_cycle_time_sec0.503251
3source_wip_count0.502044
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 7,\n \"fields\": [\n {\n \"column\": \"feature\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 7,\n \"samples\": [\n \"source_current_rms_ampere\",\n \"source_vibration_score\",\n \"source_cycle_time_sec\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"single_feature_auc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.009165577515941305,\n \"min\": 0.502044399948169,\n \"max\": 0.5214003968035711,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.5214003968035711,\n 0.521281370206187,\n 0.5032511497246327\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "공정 전이 예측 feature 수: 7\n", + "공정 전이 예측 feature: ['source_cycle_time_sec', 'source_station_delay_sec', 'source_queue_length', 'source_wip_count', 'source_current_rms_ampere', 'source_vibration_score', 'source_thermal_score']\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " split label count ratio\n", + "0 Train 정상 22634 0.785903\n", + "1 Train 불량 6166 0.214097\n", + "2 Test 정상 5708 0.792778\n", + "3 Test 불량 1492 0.207222" + ], + "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", + "
splitlabelcountratio
0Train정상226340.785903
1Train불량61660.214097
2Test정상57080.792778
3Test불량14920.207222
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 4,\n \"fields\": [\n {\n \"column\": \"split\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 2,\n \"samples\": [\n \"Test\",\n \"Train\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"label\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 2,\n \"samples\": [\n \"\\ubd88\\ub7c9\",\n \"\\uc815\\uc0c1\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"count\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 9329,\n \"min\": 1492,\n \"max\": 22634,\n \"num_unique_values\": 4,\n \"samples\": [\n 6166,\n 1492\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"ratio\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.33412495217761795,\n \"min\": 0.20722222222222222,\n \"max\": 0.7927777777777778,\n \"num_unique_values\": 4,\n \"samples\": [\n 0.21409722222222222,\n 0.20722222222222222\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "target_defect_yn 정상 비율 전이 양성 비율\n", + "source_process_code target_process_code \n", + "BODY PAINT 0.779792 0.220208\n", + "PAINT ASSEMBLY 0.793438 0.206563\n", + "PRESS BODY 0.784479 0.215521" + ], + "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", + "
target_defect_yn정상 비율전이 양성 비율
source_process_codetarget_process_code
BODYPAINT0.7797920.220208
PAINTASSEMBLY0.7934380.206563
PRESSBODY0.7844790.215521
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 3,\n \"fields\": [\n {\n \"column\": \"\\uc815\\uc0c1 \\ube44\\uc728\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.006933411374427258,\n \"min\": 0.7797916666666667,\n \"max\": 0.7934375,\n \"num_unique_values\": 3,\n \"samples\": [\n 0.7797916666666667,\n 0.7934375,\n 0.7844791666666666\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uc804\\uc774 \\uc591\\uc131 \\ube44\\uc728\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.006933411374427237,\n \"min\": 0.2065625,\n \"max\": 0.22020833333333334,\n \"num_unique_values\": 3,\n \"samples\": [\n 0.22020833333333334,\n 0.2065625,\n 0.21552083333333333\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "[press_to_body] lightweight CV tuning: 3 trials x 3 folds\n", + " trial 1: CV PR-AUC=0.2900, Recall=0.9990, F1=0.3569, elapsed=1.0s\n", + " trial 2: CV PR-AUC=0.2825, Recall=0.9927, F1=0.3573, elapsed=1.0s\n", + " trial 3: CV PR-AUC=0.2841, Recall=0.9976, F1=0.3568, elapsed=1.0s\n", + "재현율(Recall): 0.6833\n", + "정밀도(Precision): 0.2580\n", + "F1 Score: 0.3745\n", + "PR-AUC: 0.3004\n", + "임계값(Threshold): 0.4377\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 지표 값\n", + "0 정확도(Accuracy) 0.504583\n", + "1 정밀도(Precision) 0.257971\n", + "2 재현율(Recall) 0.683301\n", + "3 F1 Score 0.374540\n", + "4 ROC-AUC 0.591590\n", + "5 PR-AUC 0.300385\n", + "6 오탐률(False Positive Rate) 0.544971\n", + "7 임계값(Threshold) 0.437682" + ], + "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", + "
지표값
0정확도(Accuracy)0.504583
1정밀도(Precision)0.257971
2재현율(Recall)0.683301
3F1 Score0.374540
4ROC-AUC0.591590
5PR-AUC0.300385
6오탐률(False Positive Rate)0.544971
7임계값(Threshold)0.437682
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 8,\n \"fields\": [\n {\n \"column\": \"\\uc9c0\\ud45c\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 8,\n \"samples\": [\n \"\\uc815\\ubc00\\ub3c4(Precision)\",\n \"PR-AUC\",\n \"\\uc815\\ud655\\ub3c4(Accuracy)\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uac12\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.1466059283015766,\n \"min\": 0.2579710144927536,\n \"max\": 0.6833013435700576,\n \"num_unique_values\": 8,\n \"samples\": [\n 0.2579710144927536,\n 0.30038480436139636,\n 0.5045833333333334\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 예측 정상(0) 예측 불량(1)\n", + "실제 정상(0) 855 1024\n", + "실제 불량(1) 165 356" + ], + "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", + "
예측 정상(0)예측 불량(1)
실제 정상(0)8551024
실제 불량(1)165356
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 2,\n \"fields\": [\n {\n \"column\": \"\\uc608\\uce21 \\uc815\\uc0c1(0)\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 487,\n \"min\": 165,\n \"max\": 855,\n \"num_unique_values\": 2,\n \"samples\": [\n 165,\n 855\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uc608\\uce21 \\ubd88\\ub7c9(1)\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 472,\n \"min\": 356,\n \"max\": 1024,\n \"num_unique_values\": 2,\n \"samples\": [\n 356,\n 1024\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "[body_to_paint] lightweight CV tuning: 3 trials x 3 folds\n", + " trial 1: CV PR-AUC=0.2841, Recall=0.9995, F1=0.3617, elapsed=0.8s\n", + " trial 2: CV PR-AUC=0.2739, Recall=0.9915, F1=0.3632, elapsed=1.0s\n", + " trial 3: CV PR-AUC=0.2789, Recall=1.0000, F1=0.3613, elapsed=1.1s\n", + "재현율(Recall): 0.6341\n", + "정밀도(Precision): 0.2513\n", + "F1 Score: 0.3600\n", + "PR-AUC: 0.2951\n", + "임계값(Threshold): 0.4447\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 지표 값\n", + "0 정확도(Accuracy) 0.499167\n", + "1 정밀도(Precision) 0.251301\n", + "2 재현율(Recall) 0.634146\n", + "3 F1 Score 0.359957\n", + "4 ROC-AUC 0.581338\n", + "5 PR-AUC 0.295122\n", + "6 오탐률(False Positive Rate) 0.539368\n", + "7 임계값(Threshold) 0.444744" + ], + "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", + "
지표값
0정확도(Accuracy)0.499167
1정밀도(Precision)0.251301
2재현율(Recall)0.634146
3F1 Score0.359957
4ROC-AUC0.581338
5PR-AUC0.295122
6오탐률(False Positive Rate)0.539368
7임계값(Threshold)0.444744
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 8,\n \"fields\": [\n {\n \"column\": \"\\uc9c0\\ud45c\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 8,\n \"samples\": [\n \"\\uc815\\ubc00\\ub3c4(Precision)\",\n \"PR-AUC\",\n \"\\uc815\\ud655\\ub3c4(Accuracy)\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uac12\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.1379253812244167,\n \"min\": 0.2513011152416357,\n \"max\": 0.6341463414634146,\n \"num_unique_values\": 8,\n \"samples\": [\n 0.2513011152416357,\n 0.2951224353443143,\n 0.49916666666666665\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 예측 정상(0) 예측 불량(1)\n", + "실제 정상(0) 860 1007\n", + "실제 불량(1) 195 338" + ], + "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", + "
예측 정상(0)예측 불량(1)
실제 정상(0)8601007
실제 불량(1)195338
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 2,\n \"fields\": [\n {\n \"column\": \"\\uc608\\uce21 \\uc815\\uc0c1(0)\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 470,\n \"min\": 195,\n \"max\": 860,\n \"num_unique_values\": 2,\n \"samples\": [\n 195,\n 860\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uc608\\uce21 \\ubd88\\ub7c9(1)\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 473,\n \"min\": 338,\n \"max\": 1007,\n \"num_unique_values\": 2,\n \"samples\": [\n 338,\n 1007\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "[paint_to_assembly] lightweight CV tuning: 3 trials x 3 folds\n", + " trial 1: CV PR-AUC=0.2310, Recall=0.9960, F1=0.3445, elapsed=1.6s\n", + " trial 2: CV PR-AUC=0.2256, Recall=0.9965, F1=0.3447, elapsed=1.0s\n", + " trial 3: CV PR-AUC=0.2247, Recall=0.9950, F1=0.3446, elapsed=1.1s\n", + "재현율(Recall): 0.5776\n", + "정밀도(Precision): 0.1856\n", + "F1 Score: 0.2810\n", + "PR-AUC: 0.1844\n", + "임계값(Threshold): 0.4600\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 지표 값\n", + "0 정확도(Accuracy) 0.460417\n", + "1 정밀도(Precision) 0.185620\n", + "2 재현율(Recall) 0.577626\n", + "3 F1 Score 0.280955\n", + "4 ROC-AUC 0.507275\n", + "5 PR-AUC 0.184449\n", + "6 오탐률(False Positive Rate) 0.565749\n", + "7 임계값(Threshold) 0.460019" + ], + "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", + "
지표값
0정확도(Accuracy)0.460417
1정밀도(Precision)0.185620
2재현율(Recall)0.577626
3F1 Score0.280955
4ROC-AUC0.507275
5PR-AUC0.184449
6오탐률(False Positive Rate)0.565749
7임계값(Threshold)0.460019
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 8,\n \"fields\": [\n {\n \"column\": \"\\uc9c0\\ud45c\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 8,\n \"samples\": [\n \"\\uc815\\ubc00\\ub3c4(Precision)\",\n \"PR-AUC\",\n \"\\uc815\\ud655\\ub3c4(Accuracy)\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uac12\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.16226774661737187,\n \"min\": 0.18444886094472468,\n \"max\": 0.5776255707762558,\n \"num_unique_values\": 8,\n \"samples\": [\n 0.18561995597945707,\n 0.18444886094472468,\n 0.46041666666666664\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 예측 정상(0) 예측 불량(1)\n", + "실제 정상(0) 852 1110\n", + "실제 불량(1) 185 253" + ], + "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", + "
예측 정상(0)예측 불량(1)
실제 정상(0)8521110
실제 불량(1)185253
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 2,\n \"fields\": [\n {\n \"column\": \"\\uc608\\uce21 \\uc815\\uc0c1(0)\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 471,\n \"min\": 185,\n \"max\": 852,\n \"num_unique_values\": 2,\n \"samples\": [\n 185,\n 852\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"\\uc608\\uce21 \\ubd88\\ub7c9(1)\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 605,\n \"min\": 253,\n \"max\": 1110,\n \"num_unique_values\": 2,\n \"samples\": [\n 253,\n 1110\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " model_key trial_no cv_pr_auc cv_recall cv_precision cv_f1 \\\n", + "0 body_to_paint 1 0.284062 0.999527 0.220817 0.361722 \n", + "1 body_to_paint 3 0.278926 1.000000 0.220507 0.361337 \n", + "2 body_to_paint 2 0.273898 0.991489 0.222351 0.363213 \n", + "3 paint_to_assembly 1 0.230985 0.995966 0.208272 0.344501 \n", + "4 paint_to_assembly 2 0.225575 0.996470 0.208419 0.344734 \n", + "5 paint_to_assembly 3 0.224656 0.994957 0.208365 0.344569 \n", + "6 press_to_body 1 0.290033 0.999033 0.217283 0.356935 \n", + "7 press_to_body 3 0.284147 0.997584 0.217244 0.356788 \n", + "8 press_to_body 2 0.282452 0.992749 0.217845 0.357285 \n", + "\n", + " cv_accuracy cv_threshold elapsed_sec \\\n", + "0 0.223229 0.143963 0.842512 \n", + "1 0.221562 0.091514 1.105790 \n", + "2 0.234271 0.115225 1.001900 \n", + "3 0.217083 0.202340 1.578503 \n", + "4 0.217500 0.134790 1.047794 \n", + "5 0.218125 0.161553 1.124835 \n", + "6 0.224167 0.180116 0.991396 \n", + "7 0.224792 0.137241 1.006999 \n", + "8 0.230208 0.134730 1.049339 \n", + "\n", + " params \n", + "0 {'model__subsample': 0.95, 'model__reg_lambda'... \n", + "1 {'model__subsample': 0.95, 'model__reg_lambda'... \n", + "2 {'model__subsample': 0.85, 'model__reg_lambda'... \n", + "3 {'model__subsample': 0.95, 'model__reg_lambda'... \n", + "4 {'model__subsample': 0.85, 'model__reg_lambda'... \n", + "5 {'model__subsample': 0.95, 'model__reg_lambda'... \n", + "6 {'model__subsample': 0.95, 'model__reg_lambda'... \n", + "7 {'model__subsample': 0.95, 'model__reg_lambda'... \n", + "8 {'model__subsample': 0.85, 'model__reg_lambda'... " + ], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
model_keytrial_nocv_pr_auccv_recallcv_precisioncv_f1cv_accuracycv_thresholdelapsed_secparams
0body_to_paint10.2840620.9995270.2208170.3617220.2232290.1439630.842512{'model__subsample': 0.95, 'model__reg_lambda'...
1body_to_paint30.2789261.0000000.2205070.3613370.2215620.0915141.105790{'model__subsample': 0.95, 'model__reg_lambda'...
2body_to_paint20.2738980.9914890.2223510.3632130.2342710.1152251.001900{'model__subsample': 0.85, 'model__reg_lambda'...
3paint_to_assembly10.2309850.9959660.2082720.3445010.2170830.2023401.578503{'model__subsample': 0.95, 'model__reg_lambda'...
4paint_to_assembly20.2255750.9964700.2084190.3447340.2175000.1347901.047794{'model__subsample': 0.85, 'model__reg_lambda'...
5paint_to_assembly30.2246560.9949570.2083650.3445690.2181250.1615531.124835{'model__subsample': 0.95, 'model__reg_lambda'...
6press_to_body10.2900330.9990330.2172830.3569350.2241670.1801160.991396{'model__subsample': 0.95, 'model__reg_lambda'...
7press_to_body30.2841470.9975840.2172440.3567880.2247920.1372411.006999{'model__subsample': 0.95, 'model__reg_lambda'...
8press_to_body20.2824520.9927490.2178450.3572850.2302080.1347301.049339{'model__subsample': 0.85, 'model__reg_lambda'...
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 9,\n \"fields\": [\n {\n \"column\": \"model_key\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"body_to_paint\",\n \"paint_to_assembly\",\n \"press_to_body\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"trial_no\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 1,\n \"max\": 3,\n \"num_unique_values\": 3,\n \"samples\": [\n 1,\n 3,\n 2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cv_pr_auc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.027976767265469934,\n \"min\": 0.22465572302386438,\n \"max\": 0.2900332269689014,\n \"num_unique_values\": 9,\n \"samples\": [\n 0.28414655115768744,\n 0.27892640272244773,\n 0.22465572302386438\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cv_recall\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0029747637757056057,\n \"min\": 0.9914886900924135,\n \"max\": 1.0,\n \"num_unique_values\": 9,\n \"samples\": [\n 0.9975838399136183,\n 1.0,\n 0.9949571356530509\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cv_precision\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.005755485400928011,\n \"min\": 0.20827177445390943,\n \"max\": 0.22235076641076557,\n \"num_unique_values\": 9,\n \"samples\": [\n 0.21724362717005827,\n 0.22050717954035523,\n 0.20836486496247122\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cv_f1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.007807718156739475,\n \"min\": 0.34450062427592715,\n \"max\": 0.36321282487417433,\n \"num_unique_values\": 9,\n \"samples\": [\n 0.3567881011983085,\n 0.36133685499954254,\n 0.34456939290932215\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cv_accuracy\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.005841465685439465,\n \"min\": 0.21708333333333332,\n \"max\": 0.23427083333333334,\n \"num_unique_values\": 9,\n \"samples\": [\n 0.2247916666666667,\n 0.2215625,\n 0.21812499999999999\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cv_threshold\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.03318883313675992,\n \"min\": 0.09151424755806108,\n \"max\": 0.2023403245121107,\n \"num_unique_values\": 9,\n \"samples\": [\n 0.13724086496235352,\n 0.09151424755806108,\n 0.16155269022850893\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"elapsed_sec\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.20271419904406385,\n \"min\": 0.8425116259995775,\n \"max\": 1.578503302000172,\n \"num_unique_values\": 9,\n \"samples\": [\n 1.0069991109999137,\n 1.1057903700002498,\n 1.1248353730002236\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"params\",\n \"properties\": {\n \"dtype\": \"object\",\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 모델 키 소스 공정 타깃 공정 \\\n", + "0 press_to_body PRESS BODY \n", + "1 body_to_paint BODY PAINT \n", + "2 paint_to_assembly PAINT ASSEMBLY \n", + "\n", + " 선택 파라미터 train_threshold \\\n", + "0 {'model__subsample': 0.95, 'model__reg_lambda'... 0.437682 \n", + "1 {'model__subsample': 0.95, 'model__reg_lambda'... 0.444744 \n", + "2 {'model__subsample': 0.95, 'model__reg_lambda'... 0.460019 \n", + "\n", + " train_pr_auc train_roc_auc Train 정확도 Train 정밀도 Train 재현율 Train F1 \\\n", + "0 0.491504 0.796379 0.605833 0.342342 0.899952 0.496004 \n", + "1 0.496058 0.784340 0.604688 0.344611 0.881741 0.495547 \n", + "2 0.492547 0.794082 0.590521 0.322845 0.895108 0.474535 \n", + "\n", + " train_false_positive_rate train_tn train_fp train_fn train_tp \\\n", + "0 0.474970 3954 3577 207 1862 \n", + "1 0.473551 3941 3545 250 1864 \n", + "2 0.488775 3894 3723 208 1775 \n", + "\n", + " 임계값 Test PR-AUC test_roc_auc Test 정확도 Test 정밀도 Test 재현율 \\\n", + "0 0.437682 0.300385 0.591590 0.504583 0.257971 0.683301 \n", + "1 0.444744 0.295122 0.581338 0.499167 0.251301 0.634146 \n", + "2 0.460019 0.184449 0.507275 0.460417 0.185620 0.577626 \n", + "\n", + " Test F1 Test 오탐률 test_tn test_fp test_fn test_tp \n", + "0 0.374540 0.544971 855 1024 165 356 \n", + "1 0.359957 0.539368 860 1007 195 338 \n", + "2 0.280955 0.565749 852 1110 185 253 " + ], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
모델 키소스 공정타깃 공정선택 파라미터train_thresholdtrain_pr_auctrain_roc_aucTrain 정확도Train 정밀도Train 재현율Train F1train_false_positive_ratetrain_tntrain_fptrain_fntrain_tp임계값Test PR-AUCtest_roc_aucTest 정확도Test 정밀도Test 재현율Test F1Test 오탐률test_tntest_fptest_fntest_tp
0press_to_bodyPRESSBODY{'model__subsample': 0.95, 'model__reg_lambda'...0.4376820.4915040.7963790.6058330.3423420.8999520.4960040.4749703954357720718620.4376820.3003850.5915900.5045830.2579710.6833010.3745400.5449718551024165356
1body_to_paintBODYPAINT{'model__subsample': 0.95, 'model__reg_lambda'...0.4447440.4960580.7843400.6046880.3446110.8817410.4955470.4735513941354525018640.4447440.2951220.5813380.4991670.2513010.6341460.3599570.5393688601007195338
2paint_to_assemblyPAINTASSEMBLY{'model__subsample': 0.95, 'model__reg_lambda'...0.4600190.4925470.7940820.5905210.3228450.8951080.4745350.4887753894372320817750.4600190.1844490.5072750.4604170.1856200.5776260.2809550.5657498521110185253
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "split metric Test Train\n", + "0 F1 Score 0.374540 0.496004\n", + "1 PR-AUC 0.300385 0.491504\n", + "2 ROC-AUC 0.591590 0.796379\n", + "3 재현율 0.683301 0.899952\n", + "4 정밀도 0.257971 0.342342\n", + "5 정확도 0.504583 0.605833" + ], + "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", + "
splitmetricTestTrain
0F1 Score0.3745400.496004
1PR-AUC0.3003850.491504
2ROC-AUC0.5915900.796379
3재현율0.6833010.899952
4정밀도0.2579710.342342
5정확도0.5045830.605833
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 6,\n \"fields\": [\n {\n \"column\": \"metric\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 6,\n \"samples\": [\n \"F1 Score\",\n \"PR-AUC\",\n \"\\uc815\\ud655\\ub3c4\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.16875133953319638,\n \"min\": 0.2579710144927536,\n \"max\": 0.6833013435700576,\n \"num_unique_values\": 6,\n \"samples\": [\n 0.3745397159389795,\n 0.30038480436139636,\n 0.5045833333333334\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Train\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.20850551628710484,\n \"min\": 0.34234234234234234,\n \"max\": 0.8999516674722088,\n \"num_unique_values\": 6,\n \"samples\": [\n 0.4960042621204049,\n 0.4915044099356285,\n 0.6058333333333333\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " feature importance importance_ratio\n", + "0 source_thermal_score 1026.0 0.212863\n", + "1 source_vibration_score 1001.0 0.207676\n", + "2 source_current_rms_ampere 998.0 0.207054\n", + "3 source_cycle_time_sec 984.0 0.204149\n", + "4 source_wip_count 346.0 0.071784\n", + "5 source_queue_length 285.0 0.059129\n", + "6 source_station_delay_sec 180.0 0.037344" + ], + "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", + "
featureimportanceimportance_ratio
0source_thermal_score1026.00.212863
1source_vibration_score1001.00.207676
2source_current_rms_ampere998.00.207054
3source_cycle_time_sec984.00.204149
4source_wip_count346.00.071784
5source_queue_length285.00.059129
6source_station_delay_sec180.00.037344
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 7,\n \"fields\": [\n {\n \"column\": \"feature\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 7,\n \"samples\": [\n \"source_thermal_score\",\n \"source_vibration_score\",\n \"source_queue_length\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"importance\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 394.41173796886295,\n \"min\": 180.0,\n \"max\": 1026.0,\n \"num_unique_values\": 7,\n \"samples\": [\n 1026.0,\n 1001.0,\n 285.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"importance_ratio\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.08182816140432843,\n \"min\": 0.03734439834024896,\n \"max\": 0.21286307053941908,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.21286307053941908,\n 0.20767634854771785,\n 0.05912863070539419\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "split metric Test Train\n", + "0 F1 Score 0.359957 0.495547\n", + "1 PR-AUC 0.295122 0.496058\n", + "2 ROC-AUC 0.581338 0.784340\n", + "3 재현율 0.634146 0.881741\n", + "4 정밀도 0.251301 0.344611\n", + "5 정확도 0.499167 0.604688" + ], + "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", + "
splitmetricTestTrain
0F1 Score0.3599570.495547
1PR-AUC0.2951220.496058
2ROC-AUC0.5813380.784340
3재현율0.6341460.881741
4정밀도0.2513010.344611
5정확도0.4991670.604688
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 6,\n \"fields\": [\n {\n \"column\": \"metric\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 6,\n \"samples\": [\n \"F1 Score\",\n \"PR-AUC\",\n \"\\uc815\\ud655\\ub3c4\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.15755227989013074,\n \"min\": 0.2513011152416357,\n \"max\": 0.6341463414634146,\n \"num_unique_values\": 6,\n \"samples\": [\n 0.3599574014909478,\n 0.2951224353443143,\n 0.49916666666666665\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Train\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.20015544891453493,\n \"min\": 0.344610833795526,\n \"max\": 0.8817407757805109,\n \"num_unique_values\": 6,\n \"samples\": [\n 0.49554698923301876,\n 0.49605769687838186,\n 0.6046875\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " feature importance importance_ratio\n", + "0 source_vibration_score 1073.0 0.221969\n", + "1 source_thermal_score 1006.0 0.208109\n", + "2 source_current_rms_ampere 1001.0 0.207075\n", + "3 source_cycle_time_sec 944.0 0.195283\n", + "4 source_wip_count 331.0 0.068473\n", + "5 source_queue_length 315.0 0.065163\n", + "6 source_station_delay_sec 164.0 0.033926" + ], + "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", + "
featureimportanceimportance_ratio
0source_vibration_score1073.00.221969
1source_thermal_score1006.00.208109
2source_current_rms_ampere1001.00.207075
3source_cycle_time_sec944.00.195283
4source_wip_count331.00.068473
5source_queue_length315.00.065163
6source_station_delay_sec164.00.033926
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 7,\n \"fields\": [\n {\n \"column\": \"feature\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 7,\n \"samples\": [\n \"source_vibration_score\",\n \"source_thermal_score\",\n \"source_queue_length\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"importance\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 398.74003943373816,\n \"min\": 164.0,\n \"max\": 1073.0,\n \"num_unique_values\": 7,\n \"samples\": [\n 1073.0,\n 1006.0,\n 315.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"importance_ratio\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.08248656173639597,\n \"min\": 0.03392635498551924,\n \"max\": 0.22196938353330575,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.22196938353330575,\n 0.20810922631361192,\n 0.06516342573438147\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "split metric Test Train\n", + "0 F1 Score 0.280955 0.474535\n", + "1 PR-AUC 0.184449 0.492547\n", + "2 ROC-AUC 0.507275 0.794082\n", + "3 재현율 0.577626 0.895108\n", + "4 정밀도 0.185620 0.322845\n", + "5 정확도 0.460417 0.590521" + ], + "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", + "
splitmetricTestTrain
0F1 Score0.2809550.474535
1PR-AUC0.1844490.492547
2ROC-AUC0.5072750.794082
3재현율0.5776260.895108
4정밀도0.1856200.322845
5정확도0.4604170.590521
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 6,\n \"fields\": [\n {\n \"column\": \"metric\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 6,\n \"samples\": [\n \"F1 Score\",\n \"PR-AUC\",\n \"\\uc815\\ud655\\ub3c4\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Test\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.17110755703355043,\n \"min\": 0.18444886094472468,\n \"max\": 0.5776255707762558,\n \"num_unique_values\": 6,\n \"samples\": [\n 0.2809550249861188,\n 0.18444886094472468,\n 0.46041666666666664\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Train\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.2139139139784951,\n \"min\": 0.32284467078937795,\n \"max\": 0.8951084215834594,\n \"num_unique_values\": 6,\n \"samples\": [\n 0.47453548990776634,\n 0.4925466309387107,\n 0.5905208333333334\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " feature importance importance_ratio\n", + "0 source_thermal_score 1032.0 0.216035\n", + "1 source_cycle_time_sec 1008.0 0.211011\n", + "2 source_vibration_score 956.0 0.200126\n", + "3 source_current_rms_ampere 867.0 0.181495\n", + "4 source_wip_count 398.0 0.083316\n", + "5 source_queue_length 332.0 0.069500\n", + "6 source_station_delay_sec 184.0 0.038518" + ], + "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", + "
featureimportanceimportance_ratio
0source_thermal_score1032.00.216035
1source_cycle_time_sec1008.00.211011
2source_vibration_score956.00.200126
3source_current_rms_ampere867.00.181495
4source_wip_count398.00.083316
5source_queue_length332.00.069500
6source_station_delay_sec184.00.038518
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 7,\n \"fields\": [\n {\n \"column\": \"feature\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 7,\n \"samples\": [\n \"source_thermal_score\",\n \"source_cycle_time_sec\",\n \"source_queue_length\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"importance\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 362.6834511172046,\n \"min\": 184.0,\n \"max\": 1032.0,\n \"num_unique_values\": 7,\n \"samples\": [\n 1032.0,\n 1008.0,\n 332.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"importance_ratio\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.07592284930232458,\n \"min\": 0.03851789826250785,\n \"max\": 0.2160351685158049,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.2160351685158049,\n 0.21101109482939084,\n 0.0694996859953946\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + " car_master_id source_event_id target_event_id \\\n", + "1816 11417 EVT-20260618-045665 EVT-20260618-045666 \n", + "1805 11406 EVT-20260618-045621 EVT-20260618-045622 \n", + "355 9956 EVT-20260617-039821 EVT-20260617-039822 \n", + "348 9949 EVT-20260617-039793 EVT-20260617-039794 \n", + "4730 11931 EVT-20260618-047722 EVT-20260618-047723 \n", + "2470 9671 EVT-20260617-038682 EVT-20260617-038683 \n", + "224 9825 EVT-20260617-039297 EVT-20260617-039298 \n", + "56 9657 EVT-20260617-038625 EVT-20260617-038626 \n", + "35 9636 EVT-20260617-038541 EVT-20260617-038542 \n", + "43 9644 EVT-20260617-038573 EVT-20260617-038574 \n", + "6953 11754 EVT-20260618-047015 EVT-20260618-047016 \n", + "3530 10731 EVT-20260617-042922 EVT-20260617-042923 \n", + "1949 11550 EVT-20260618-046197 EVT-20260618-046198 \n", + "1783 11384 EVT-20260617-045533 EVT-20260617-045534 \n", + "2053 11654 EVT-20260618-046613 EVT-20260618-046614 \n", + "1320 10921 EVT-20260617-043681 EVT-20260617-043682 \n", + "230 9831 EVT-20260617-039321 EVT-20260617-039322 \n", + "1845 11446 EVT-20260618-045781 EVT-20260618-045782 \n", + "1477 11078 EVT-20260617-044309 EVT-20260617-044310 \n", + "2376 11977 EVT-20260618-047905 EVT-20260618-047906 \n", + "1180 10781 EVT-20260617-043121 EVT-20260617-043122 \n", + "1563 11164 EVT-20260617-044653 EVT-20260617-044654 \n", + "110 9711 EVT-20260617-038841 EVT-20260617-038842 \n", + "2206 11807 EVT-20260618-047225 EVT-20260618-047226 \n", + "2215 11816 EVT-20260618-047261 EVT-20260618-047262 \n", + "2000 11601 EVT-20260618-046401 EVT-20260618-046402 \n", + "2323 11924 EVT-20260618-047693 EVT-20260618-047694 \n", + "8 9609 EVT-20260617-038433 EVT-20260617-038434 \n", + "2046 11647 EVT-20260618-046585 EVT-20260618-046586 \n", + "1136 10737 EVT-20260617-042945 EVT-20260617-042946 \n", + "\n", + " source_process_code target_process_code model_key \\\n", + "1816 PRESS BODY press_to_body \n", + "1805 PRESS BODY press_to_body \n", + "355 PRESS BODY press_to_body \n", + "348 PRESS BODY press_to_body \n", + "4730 BODY PAINT body_to_paint \n", + "2470 BODY PAINT body_to_paint \n", + "224 PRESS BODY press_to_body \n", + "56 PRESS BODY press_to_body \n", + "35 PRESS BODY press_to_body \n", + "43 PRESS BODY press_to_body \n", + "6953 PAINT ASSEMBLY paint_to_assembly \n", + "3530 BODY PAINT body_to_paint \n", + "1949 PRESS BODY press_to_body \n", + "1783 PRESS BODY press_to_body \n", + "2053 PRESS BODY press_to_body \n", + "1320 PRESS BODY press_to_body \n", + "230 PRESS BODY press_to_body \n", + "1845 PRESS BODY press_to_body \n", + "1477 PRESS BODY press_to_body \n", + "2376 PRESS BODY press_to_body \n", + "1180 PRESS BODY press_to_body \n", + "1563 PRESS BODY press_to_body \n", + "110 PRESS BODY press_to_body \n", + "2206 PRESS BODY press_to_body \n", + "2215 PRESS BODY press_to_body \n", + "2000 PRESS BODY press_to_body \n", + "2323 PRESS BODY press_to_body \n", + "8 PRESS BODY press_to_body \n", + "2046 PRESS BODY press_to_body \n", + "1136 PRESS BODY press_to_body \n", + "\n", + " target_defect_probability threshold predicted_target_defect_yn \\\n", + "1816 0.816156 0.437682 1 \n", + "1805 0.814475 0.437682 1 \n", + "355 0.796522 0.437682 1 \n", + "348 0.795205 0.437682 1 \n", + "4730 0.790645 0.444744 1 \n", + "2470 0.788088 0.444744 1 \n", + "224 0.778944 0.437682 1 \n", + "56 0.773686 0.437682 1 \n", + "35 0.772719 0.437682 1 \n", + "43 0.769506 0.437682 1 \n", + "6953 0.768398 0.460019 1 \n", + "3530 0.768384 0.444744 1 \n", + "1949 0.765838 0.437682 1 \n", + "1783 0.765786 0.437682 1 \n", + "2053 0.762853 0.437682 1 \n", + "1320 0.762076 0.437682 1 \n", + "230 0.761371 0.437682 1 \n", + "1845 0.760902 0.437682 1 \n", + "1477 0.760856 0.437682 1 \n", + "2376 0.759724 0.437682 1 \n", + "1180 0.759612 0.437682 1 \n", + "1563 0.756723 0.437682 1 \n", + "110 0.756505 0.437682 1 \n", + "2206 0.756009 0.437682 1 \n", + "2215 0.755675 0.437682 1 \n", + "2000 0.754770 0.437682 1 \n", + "2323 0.754285 0.437682 1 \n", + "8 0.754089 0.437682 1 \n", + "2046 0.754072 0.437682 1 \n", + "1136 0.753669 0.437682 1 \n", + "\n", + " risk_grade target_actual_yn \n", + "1816 HIGH 0 \n", + "1805 HIGH 1 \n", + "355 HIGH 0 \n", + "348 HIGH 0 \n", + "4730 HIGH 0 \n", + "2470 HIGH 1 \n", + "224 HIGH 1 \n", + "56 HIGH 1 \n", + "35 HIGH 1 \n", + "43 HIGH 0 \n", + "6953 HIGH 0 \n", + "3530 HIGH 1 \n", + "1949 HIGH 0 \n", + "1783 HIGH 0 \n", + "2053 HIGH 1 \n", + "1320 HIGH 0 \n", + "230 HIGH 1 \n", + "1845 HIGH 1 \n", + "1477 HIGH 1 \n", + "2376 HIGH 0 \n", + "1180 HIGH 1 \n", + "1563 HIGH 0 \n", + "110 HIGH 1 \n", + "2206 HIGH 1 \n", + "2215 HIGH 1 \n", + "2000 HIGH 0 \n", + "2323 HIGH 1 \n", + "8 HIGH 0 \n", + "2046 HIGH 1 \n", + "1136 HIGH 0 " + ], + "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", + " \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", + " \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", + " \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", + "
car_master_idsource_event_idtarget_event_idsource_process_codetarget_process_codemodel_keytarget_defect_probabilitythresholdpredicted_target_defect_ynrisk_gradetarget_actual_yn
181611417EVT-20260618-045665EVT-20260618-045666PRESSBODYpress_to_body0.8161560.4376821HIGH0
180511406EVT-20260618-045621EVT-20260618-045622PRESSBODYpress_to_body0.8144750.4376821HIGH1
3559956EVT-20260617-039821EVT-20260617-039822PRESSBODYpress_to_body0.7965220.4376821HIGH0
3489949EVT-20260617-039793EVT-20260617-039794PRESSBODYpress_to_body0.7952050.4376821HIGH0
473011931EVT-20260618-047722EVT-20260618-047723BODYPAINTbody_to_paint0.7906450.4447441HIGH0
24709671EVT-20260617-038682EVT-20260617-038683BODYPAINTbody_to_paint0.7880880.4447441HIGH1
2249825EVT-20260617-039297EVT-20260617-039298PRESSBODYpress_to_body0.7789440.4376821HIGH1
569657EVT-20260617-038625EVT-20260617-038626PRESSBODYpress_to_body0.7736860.4376821HIGH1
359636EVT-20260617-038541EVT-20260617-038542PRESSBODYpress_to_body0.7727190.4376821HIGH1
439644EVT-20260617-038573EVT-20260617-038574PRESSBODYpress_to_body0.7695060.4376821HIGH0
695311754EVT-20260618-047015EVT-20260618-047016PAINTASSEMBLYpaint_to_assembly0.7683980.4600191HIGH0
353010731EVT-20260617-042922EVT-20260617-042923BODYPAINTbody_to_paint0.7683840.4447441HIGH1
194911550EVT-20260618-046197EVT-20260618-046198PRESSBODYpress_to_body0.7658380.4376821HIGH0
178311384EVT-20260617-045533EVT-20260617-045534PRESSBODYpress_to_body0.7657860.4376821HIGH0
205311654EVT-20260618-046613EVT-20260618-046614PRESSBODYpress_to_body0.7628530.4376821HIGH1
132010921EVT-20260617-043681EVT-20260617-043682PRESSBODYpress_to_body0.7620760.4376821HIGH0
2309831EVT-20260617-039321EVT-20260617-039322PRESSBODYpress_to_body0.7613710.4376821HIGH1
184511446EVT-20260618-045781EVT-20260618-045782PRESSBODYpress_to_body0.7609020.4376821HIGH1
147711078EVT-20260617-044309EVT-20260617-044310PRESSBODYpress_to_body0.7608560.4376821HIGH1
237611977EVT-20260618-047905EVT-20260618-047906PRESSBODYpress_to_body0.7597240.4376821HIGH0
118010781EVT-20260617-043121EVT-20260617-043122PRESSBODYpress_to_body0.7596120.4376821HIGH1
156311164EVT-20260617-044653EVT-20260617-044654PRESSBODYpress_to_body0.7567230.4376821HIGH0
1109711EVT-20260617-038841EVT-20260617-038842PRESSBODYpress_to_body0.7565050.4376821HIGH1
220611807EVT-20260618-047225EVT-20260618-047226PRESSBODYpress_to_body0.7560090.4376821HIGH1
221511816EVT-20260618-047261EVT-20260618-047262PRESSBODYpress_to_body0.7556750.4376821HIGH1
200011601EVT-20260618-046401EVT-20260618-046402PRESSBODYpress_to_body0.7547700.4376821HIGH0
232311924EVT-20260618-047693EVT-20260618-047694PRESSBODYpress_to_body0.7542850.4376821HIGH1
89609EVT-20260617-038433EVT-20260617-038434PRESSBODYpress_to_body0.7540890.4376821HIGH0
204611647EVT-20260618-046585EVT-20260618-046586PRESSBODYpress_to_body0.7540720.4376821HIGH1
113610737EVT-20260617-042945EVT-20260617-042946PRESSBODYpress_to_body0.7536690.4376821HIGH0
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" display(transition_predictions\",\n \"rows\": 30,\n \"fields\": [\n {\n \"column\": \"car_master_id\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 877,\n \"min\": 9609,\n \"max\": 11977,\n \"num_unique_values\": 30,\n \"samples\": [\n 9609,\n 10921,\n 11807\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_event_id\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 30,\n \"samples\": [\n \"EVT-20260617-038433\",\n \"EVT-20260617-043681\",\n \"EVT-20260618-047225\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"target_event_id\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 30,\n \"samples\": [\n \"EVT-20260617-038434\",\n \"EVT-20260617-043682\",\n \"EVT-20260618-047226\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_process_code\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"PRESS\",\n \"BODY\",\n \"PAINT\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"target_process_code\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"BODY\",\n \"PAINT\",\n \"ASSEMBLY\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"model_key\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"press_to_body\",\n \"body_to_paint\",\n \"paint_to_assembly\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"target_defect_probability\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.01753503589531774,\n \"min\": 0.7536693059130332,\n \"max\": 0.8161559491328145,\n \"num_unique_values\": 30,\n \"samples\": [\n 0.7540887936375358,\n 0.7620758999081632,\n 0.7560090861583946\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"threshold\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0044929554442605995,\n \"min\": 0.4376819769807411,\n \"max\": 0.46001877207080666,\n \"num_unique_values\": 3,\n \"samples\": [\n 0.4376819769807411,\n 0.44474415478457285,\n 0.46001877207080666\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"predicted_target_defect_yn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 1,\n \"max\": 1,\n \"num_unique_values\": 1,\n \"samples\": [\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"risk_grade\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"HIGH\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"target_actual_yn\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 1,\n \"num_unique_values\": 2,\n \"samples\": [\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + } + ], + "source": [ + "TRANSFER_TARGET = \"target_defect_yn\"\n", + "TRANSFER_LEAKAGE_COLS = [\n", + " TRANSFER_TARGET,\n", + " \"source_defect_yn\",\n", + " \"target_defect_reason\",\n", + " \"target_event_json\",\n", + " \"target_defect_probability\",\n", + " \"predicted_target_defect_yn\",\n", + " \"target_actual_yn\",\n", + "]\n", + "TRANSFER_EXCLUDE_COLS = [\n", + " \"car_master_id\",\n", + " \"source_event_id\",\n", + " \"target_event_id\",\n", + " \"source_process_code\",\n", + " \"target_process_code\",\n", + " \"source_event_json\",\n", + " \"dataset_split\",\n", + "] + TRANSFER_LEAKAGE_COLS\n", + "\n", + "transition_feature_cols = select_model_features(\n", + " transfer_train_raw,\n", + " TRANSFER_TARGET,\n", + " TRANSFER_EXCLUDE_COLS,\n", + " TRANSFER_LEAKAGE_COLS,\n", + " context=\"공정 전이 예측\",\n", + ")\n", + "transition_feature_cols = drop_suspicious_features(transfer_train_raw, TRANSFER_TARGET, transition_feature_cols, context=\"공정 전이 예측\")\n", + "ensure_feature_columns_exist(transfer_test_raw, transition_feature_cols, context=\"공정 전이 예측\")\n", + "print(\"공정 전이 예측 feature 수:\", len(transition_feature_cols))\n", + "print(\"공정 전이 예측 feature:\", transition_feature_cols)\n", + "\n", + "plot_class_distribution(transfer_train_raw, transfer_test_raw, TRANSFER_TARGET, \"공정 전이 예측\")\n", + "display(pd.crosstab([transfer_train_raw[\"source_process_code\"], transfer_train_raw[\"target_process_code\"]], transfer_train_raw[TRANSFER_TARGET], normalize=\"index\").rename(columns={0: \"정상 비율\", 1: \"전이 양성 비율\"}))\n", + "plot_feature_distribution_grid(transfer_train_raw, transition_feature_cols, TRANSFER_TARGET, \"공정 전이 예측 주요 feature 분포\", max_features=12)\n", + "plot_numeric_correlation_heatmap(transfer_train_raw, transition_feature_cols, \"공정 전이 예측 수치형 feature 상관관계\", max_features=12)\n", + "\n", + "\n", + "TRANSITION_PARAM_DISTRIBUTIONS = {\n", + " \"model__n_estimators\": [160, 220, 280],\n", + " \"model__learning_rate\": [0.035, 0.045, 0.06],\n", + " \"model__num_leaves\": [11, 15, 23],\n", + " \"model__min_child_samples\": [40, 60, 90],\n", + " \"model__subsample\": [0.75, 0.85, 0.95],\n", + " \"model__colsample_bytree\": [0.70, 0.80, 0.90],\n", + " \"model__reg_lambda\": [4.0, 8.0, 12.0],\n", + "}\n", + "\n", + "\n", + "def make_transition_model(train_df: pd.DataFrame, feature_cols: list[str], scale_pos_weight: float):\n", + " return Pipeline([\n", + " (\"preprocess\", make_preprocessor(train_df, feature_cols, scale_numeric=False)),\n", + " (\"model\", lgb.LGBMClassifier(\n", + " objective=\"binary\",\n", + " n_estimators=220,\n", + " learning_rate=0.045,\n", + " num_leaves=15,\n", + " min_child_samples=60,\n", + " subsample=0.85,\n", + " colsample_bytree=0.75,\n", + " reg_lambda=8.0,\n", + " scale_pos_weight=scale_pos_weight,\n", + " random_state=RANDOM_STATE,\n", + " n_jobs=-1,\n", + " verbosity=-1,\n", + " )),\n", + " ])\n", + "\n", + "\n", + "def tune_transition_model_cv(model_key: str, train_flow: pd.DataFrame, feature_cols: list[str], target_col: str, scale_pos_weight: float):\n", + " X = train_flow[feature_cols]\n", + " y = train_flow[target_col].astype(int)\n", + " X_tune, y_tune = make_tuning_sample(X, y, MAX_TUNING_ROWS)\n", + " candidates = sample_param_candidates(TRANSITION_PARAM_DISTRIBUTIONS, TUNING_TRIALS_PER_MODEL, RANDOM_STATE)\n", + " cv = StratifiedKFold(n_splits=CV_FOLDS, shuffle=True, random_state=RANDOM_STATE)\n", + " rows = []\n", + " best_row = None\n", + " best_score = (-np.inf, -np.inf, -np.inf)\n", + " print(f\"\\n[{model_key}] lightweight CV tuning: {len(candidates)} trials x {CV_FOLDS} folds\")\n", + " for trial_no, params in enumerate(candidates, start=1):\n", + " fold_metrics = []\n", + " started_at = time.perf_counter()\n", + " for train_idx, valid_idx in cv.split(X_tune, y_tune):\n", + " X_fold_train = X_tune.iloc[train_idx]\n", + " y_fold_train = y_tune.iloc[train_idx]\n", + " X_fold_valid = X_tune.iloc[valid_idx]\n", + " y_fold_valid = y_tune.iloc[valid_idx]\n", + " estimator = make_transition_model(train_flow, feature_cols, scale_pos_weight)\n", + " estimator.set_params(**params)\n", + " estimator.fit(X_fold_train, y_fold_train)\n", + " valid_proba = predict_positive_proba(estimator, X_fold_valid)\n", + " threshold = find_recall_priority_threshold(y_fold_valid, valid_proba, min_recall=0.60, min_precision=0.20)\n", + " fold_metrics.append(compute_metrics(y_fold_valid, valid_proba, threshold))\n", + " elapsed_sec = time.perf_counter() - started_at\n", + " row = {\n", + " \"model_key\": model_key,\n", + " \"trial_no\": trial_no,\n", + " \"params\": params,\n", + " \"cv_pr_auc\": float(np.mean([m[\"pr_auc\"] for m in fold_metrics])),\n", + " \"cv_recall\": float(np.mean([m[\"recall\"] for m in fold_metrics])),\n", + " \"cv_precision\": float(np.mean([m[\"precision\"] for m in fold_metrics])),\n", + " \"cv_f1\": float(np.mean([m[\"f1\"] for m in fold_metrics])),\n", + " \"cv_accuracy\": float(np.mean([m[\"accuracy\"] for m in fold_metrics])),\n", + " \"cv_threshold\": float(np.mean([m[\"threshold\"] for m in fold_metrics])),\n", + " \"elapsed_sec\": elapsed_sec,\n", + " }\n", + " rows.append(row)\n", + " score = (row[\"cv_pr_auc\"], row[\"cv_recall\"], row[\"cv_f1\"])\n", + " if score > best_score:\n", + " best_score = score\n", + " best_row = row\n", + " print(f\" trial {trial_no}: CV PR-AUC={row['cv_pr_auc']:.4f}, Recall={row['cv_recall']:.4f}, F1={row['cv_f1']:.4f}, elapsed={elapsed_sec:.1f}s\")\n", + " return best_row, rows\n", + "\n", + "\n", + "transition_models = {}\n", + "transition_metadata = {}\n", + "transition_metric_rows = []\n", + "transition_cv_rows = []\n", + "transition_prediction_frames = []\n", + "transition_confusion_tables = {}\n", + "transition_train_confusion_tables = {}\n", + "transition_proba_by_model = {}\n", + "transition_train_proba_by_model = {}\n", + "transition_y_true_by_model = {}\n", + "transition_y_train_by_model = {}\n", + "\n", + "for source_process, target_process in TRANSFER_FLOW_ORDER:\n", + " model_key = f\"{source_process.lower()}_to_{target_process.lower()}\"\n", + " train_flow = transfer_train_raw[(transfer_train_raw[\"source_process_code\"] == source_process) & (transfer_train_raw[\"target_process_code\"] == target_process)].copy()\n", + " test_flow = transfer_test_raw[(transfer_test_raw[\"source_process_code\"] == source_process) & (transfer_test_raw[\"target_process_code\"] == target_process)].copy()\n", + " if train_flow.empty or test_flow.empty:\n", + " print(f\"{model_key}: 학습 또는 테스트 데이터가 없어 건너뜁니다.\")\n", + " continue\n", + " X_train_flow = train_flow[transition_feature_cols]\n", + " y_train_flow = train_flow[TRANSFER_TARGET].astype(int)\n", + " X_test_flow = test_flow[transition_feature_cols]\n", + " y_test_flow = test_flow[TRANSFER_TARGET].astype(int)\n", + " if y_train_flow.nunique() < 2 or y_test_flow.nunique() < 2:\n", + " print(f\"{model_key}: 한 클래스만 존재해 건너뜁니다.\")\n", + " continue\n", + " spw = scale_pos_weight_for(y_train_flow)\n", + " best_params = {}\n", + " if ENABLE_HYPERPARAMETER_TUNING:\n", + " best_row, rows = tune_transition_model_cv(model_key, train_flow, transition_feature_cols, TRANSFER_TARGET, spw)\n", + " transition_cv_rows.extend(rows)\n", + " best_params = best_row[\"params\"] if best_row else {}\n", + " flow_model = make_transition_model(train_flow, transition_feature_cols, spw)\n", + " flow_model.set_params(**best_params)\n", + " flow_model.fit(X_train_flow, y_train_flow)\n", + " train_proba = predict_positive_proba(flow_model, X_train_flow)\n", + " test_proba = predict_positive_proba(flow_model, X_test_flow)\n", + " threshold = find_recall_priority_threshold(y_train_flow, train_proba, min_recall=0.60, min_precision=0.20)\n", + " train_metrics = compute_metrics(y_train_flow, train_proba, threshold)\n", + " test_metrics = compute_metrics(y_test_flow, test_proba, threshold)\n", + " _, cm_table = display_confusion_matrix_report(y_test_flow, test_proba, threshold, title=f\"공정 전이 Test 혼동행렬 - {source_process} -> {target_process}\")\n", + " transition_models[model_key] = flow_model\n", + " transition_train_confusion_tables[model_key] = confusion_matrix_table(train_metrics)\n", + " transition_confusion_tables[model_key] = cm_table\n", + " transition_train_proba_by_model[model_key] = train_proba\n", + " transition_proba_by_model[model_key] = test_proba\n", + " transition_y_train_by_model[model_key] = y_train_flow\n", + " transition_y_true_by_model[model_key] = y_test_flow\n", + " transition_metadata[model_key] = {\"source_process_code\": source_process, \"target_process_code\": target_process, \"threshold\": threshold, \"feature_columns\": transition_feature_cols, \"scale_pos_weight\": spw, \"best_params\": best_params}\n", + " transition_metric_rows.append({\n", + " \"model_key\": model_key,\n", + " \"source_process_code\": source_process,\n", + " \"target_process_code\": target_process,\n", + " \"best_params\": best_params,\n", + " **{f\"train_{k}\": v for k, v in train_metrics.items()},\n", + " **{f\"test_{k}\": v for k, v in test_metrics.items()},\n", + " })\n", + " pred_frame = test_flow[[\"car_master_id\", \"source_event_id\", \"target_event_id\", \"source_process_code\", \"target_process_code\"]].copy()\n", + " pred_frame[\"model_key\"] = model_key\n", + " pred_frame[\"target_defect_probability\"] = test_proba\n", + " pred_frame[\"threshold\"] = threshold\n", + " pred_frame[\"predicted_target_defect_yn\"] = (test_proba >= threshold).astype(int)\n", + " pred_frame[\"risk_grade\"] = pred_frame[\"target_defect_probability\"].map(risk_grade)\n", + " pred_frame[\"target_actual_yn\"] = y_test_flow.to_numpy()\n", + " transition_prediction_frames.append(pred_frame)\n", + "\n", + "transition_cv_results = pd.DataFrame(transition_cv_rows)\n", + "if not transition_cv_results.empty:\n", + " display(\n", + " transition_cv_results.sort_values([\"model_key\", \"cv_pr_auc\", \"cv_recall\", \"cv_f1\"], ascending=[True, False, False, False])\n", + " [[\"model_key\", \"trial_no\", \"cv_pr_auc\", \"cv_recall\", \"cv_precision\", \"cv_f1\", \"cv_accuracy\", \"cv_threshold\", \"elapsed_sec\", \"params\"]]\n", + " .reset_index(drop=True)\n", + " )\n", + "\n", + "transition_model_metrics = pd.DataFrame(transition_metric_rows).sort_values([\"test_pr_auc\", \"test_recall\", \"test_f1\"], ascending=False).reset_index(drop=True) if transition_metric_rows else pd.DataFrame()\n", + "transition_predictions = pd.concat(transition_prediction_frames, ignore_index=True) if transition_prediction_frames else pd.DataFrame()\n", + "if not transition_model_metrics.empty:\n", + " display(transition_model_metrics.rename(columns={\n", + " \"model_key\": \"모델 키\",\n", + " \"source_process_code\": \"소스 공정\",\n", + " \"target_process_code\": \"타깃 공정\",\n", + " \"best_params\": \"선택 파라미터\",\n", + " \"train_f1\": \"Train F1\",\n", + " \"test_f1\": \"Test F1\",\n", + " \"train_recall\": \"Train 재현율\",\n", + " \"test_recall\": \"Test 재현율\",\n", + " \"train_precision\": \"Train 정밀도\",\n", + " \"test_precision\": \"Test 정밀도\",\n", + " \"train_accuracy\": \"Train 정확도\",\n", + " \"test_accuracy\": \"Test 정확도\",\n", + " \"test_pr_auc\": \"Test PR-AUC\",\n", + " \"test_false_positive_rate\": \"Test 오탐률\",\n", + " \"test_threshold\": \"임계값\",\n", + " }))\n", + " fig, axes = plt.subplots(1, 3, figsize=(16, 4))\n", + " sns.barplot(data=transition_model_metrics, x=\"model_key\", y=\"test_pr_auc\", ax=axes[0], color=\"#4C78A8\")\n", + " axes[0].set_title(\"전이 예측 Test PR-AUC\")\n", + " axes[0].set_xlabel(\"모델\")\n", + " axes[0].set_ylabel(\"PR-AUC\")\n", + " axes[0].tick_params(axis=\"x\", rotation=20)\n", + " sns.barplot(data=transition_model_metrics, x=\"model_key\", y=\"test_recall\", ax=axes[1], color=\"#59A14F\")\n", + " axes[1].set_title(\"전이 예측 Test 재현율\")\n", + " axes[1].set_xlabel(\"모델\")\n", + " axes[1].set_ylabel(\"Recall\")\n", + " axes[1].tick_params(axis=\"x\", rotation=20)\n", + " sns.barplot(data=transition_model_metrics, x=\"model_key\", y=\"test_f1\", ax=axes[2], color=\"#F28E2B\")\n", + " axes[2].set_title(\"전이 예측 Test F1\")\n", + " axes[2].set_xlabel(\"모델\")\n", + " axes[2].set_ylabel(\"F1 Score\")\n", + " axes[2].tick_params(axis=\"x\", rotation=20)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + " for model_key in transition_model_metrics[\"model_key\"]:\n", + " threshold = transition_metadata[model_key][\"threshold\"]\n", + " train_metrics, test_metrics = plot_train_test_confusion(\n", + " transition_y_train_by_model[model_key],\n", + " transition_train_proba_by_model[model_key],\n", + " transition_y_true_by_model[model_key],\n", + " transition_proba_by_model[model_key],\n", + " threshold,\n", + " f\"공정 전이 - {model_key}\",\n", + " )\n", + " plot_train_test_metric_comparison(train_metrics, test_metrics, f\"공정 전이 Train/Test 성능 비교 - {model_key}\")\n", + " plot_probability_distribution(transition_y_true_by_model[model_key], transition_proba_by_model[model_key], threshold, f\"공정 전이 Test 예측 확률 분포 - {model_key}\")\n", + " importance = model_feature_importance(transition_models[model_key])\n", + " plot_model_feature_importance(importance, f\"공정 전이 피처 중요도 - {model_key}\", top_n=15)\n", + "\n", + "if not transition_predictions.empty:\n", + " display(transition_predictions.sort_values(\"target_defect_probability\", ascending=False).head(30))" + ] + }, + { + "cell_type": "markdown", + "id": "5f314dd3", + "metadata": { + "id": "5f314dd3" + }, + "source": [ + "## 7. SHAP 기반 전이 위험 분석 및 Kafka 분석 이벤트" + ] + }, + { + "cell_type": "markdown", + "id": "cc8bfdea", + "metadata": { + "id": "cc8bfdea" + }, + "source": [ + "**셀 설명**\n", + "\n", + "전이 예측 모델별 SHAP 중요도를 계산하고, 화면/API에서 사용할 수 있는 분석 이벤트 형태로 변환합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5d86cf73", + "metadata": { + "id": "5d86cf73", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "6c12488b-54ee-40e2-f39a-9ceefd51da77" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " feature mean_abs_shap model_key \\\n", + "0 source_cycle_time_sec 0.194787 press_to_body \n", + "1 source_current_rms_ampere 0.177804 press_to_body \n", + "2 source_queue_length 0.157906 press_to_body \n", + "3 source_vibration_score 0.097177 press_to_body \n", + "4 source_thermal_score 0.091699 press_to_body \n", + "5 source_wip_count 0.053012 press_to_body \n", + "6 source_station_delay_sec 0.036352 press_to_body \n", + "7 source_cycle_time_sec 0.189979 body_to_paint \n", + "8 source_vibration_score 0.175717 body_to_paint \n", + "9 source_thermal_score 0.099140 body_to_paint \n", + "10 source_current_rms_ampere 0.097832 body_to_paint \n", + "11 source_queue_length 0.076991 body_to_paint \n", + "12 source_wip_count 0.034891 body_to_paint \n", + "13 source_station_delay_sec 0.029957 body_to_paint \n", + "14 source_cycle_time_sec 0.210911 paint_to_assembly \n", + "15 source_vibration_score 0.129053 paint_to_assembly \n", + "16 source_thermal_score 0.079522 paint_to_assembly \n", + "17 source_current_rms_ampere 0.073281 paint_to_assembly \n", + "18 source_queue_length 0.040449 paint_to_assembly \n", + "19 source_station_delay_sec 0.035959 paint_to_assembly \n", + "20 source_wip_count 0.035648 paint_to_assembly \n", + "\n", + " source_process_code target_process_code \n", + "0 PRESS BODY \n", + "1 PRESS BODY \n", + "2 PRESS BODY \n", + "3 PRESS BODY \n", + "4 PRESS BODY \n", + "5 PRESS BODY \n", + "6 PRESS BODY \n", + "7 BODY PAINT \n", + "8 BODY PAINT \n", + "9 BODY PAINT \n", + "10 BODY PAINT \n", + "11 BODY PAINT \n", + "12 BODY PAINT \n", + "13 BODY PAINT \n", + "14 PAINT ASSEMBLY \n", + "15 PAINT ASSEMBLY \n", + "16 PAINT ASSEMBLY \n", + "17 PAINT ASSEMBLY \n", + "18 PAINT ASSEMBLY \n", + "19 PAINT ASSEMBLY \n", + "20 PAINT ASSEMBLY " + ], + "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", + " \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", + "
featuremean_abs_shapmodel_keysource_process_codetarget_process_code
0source_cycle_time_sec0.194787press_to_bodyPRESSBODY
1source_current_rms_ampere0.177804press_to_bodyPRESSBODY
2source_queue_length0.157906press_to_bodyPRESSBODY
3source_vibration_score0.097177press_to_bodyPRESSBODY
4source_thermal_score0.091699press_to_bodyPRESSBODY
5source_wip_count0.053012press_to_bodyPRESSBODY
6source_station_delay_sec0.036352press_to_bodyPRESSBODY
7source_cycle_time_sec0.189979body_to_paintBODYPAINT
8source_vibration_score0.175717body_to_paintBODYPAINT
9source_thermal_score0.099140body_to_paintBODYPAINT
10source_current_rms_ampere0.097832body_to_paintBODYPAINT
11source_queue_length0.076991body_to_paintBODYPAINT
12source_wip_count0.034891body_to_paintBODYPAINT
13source_station_delay_sec0.029957body_to_paintBODYPAINT
14source_cycle_time_sec0.210911paint_to_assemblyPAINTASSEMBLY
15source_vibration_score0.129053paint_to_assemblyPAINTASSEMBLY
16source_thermal_score0.079522paint_to_assemblyPAINTASSEMBLY
17source_current_rms_ampere0.073281paint_to_assemblyPAINTASSEMBLY
18source_queue_length0.040449paint_to_assemblyPAINTASSEMBLY
19source_station_delay_sec0.035959paint_to_assemblyPAINTASSEMBLY
20source_wip_count0.035648paint_to_assemblyPAINTASSEMBLY
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"print(json\",\n \"rows\": 21,\n \"fields\": [\n {\n \"column\": \"feature\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 7,\n \"samples\": [\n \"source_cycle_time_sec\",\n \"source_current_rms_ampere\",\n \"source_wip_count\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"mean_abs_shap\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.06094596169059344,\n \"min\": 0.029957444152210865,\n \"max\": 0.2109112074173861,\n \"num_unique_values\": 21,\n \"samples\": [\n 0.1947872792830002,\n 0.0732806481984165,\n 0.12905330235372311\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"model_key\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"press_to_body\",\n \"body_to_paint\",\n \"paint_to_assembly\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"source_process_code\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"PRESS\",\n \"BODY\",\n \"PAINT\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"target_process_code\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"BODY\",\n \"PAINT\",\n \"ASSEMBLY\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "kafka event examples: 500\n", + "[\n", + " {\n", + " \"eventType\": \"DEFECT_TRANSFER_PREDICTION\",\n", + " \"carMasterId\": 11417,\n", + " \"sourceEventId\": \"EVT-20260618-045665\",\n", + " \"targetEventId\": \"EVT-20260618-045666\",\n", + " \"sourceProcessCode\": \"PRESS\",\n", + " \"targetProcessCode\": \"BODY\",\n", + " \"targetDefectProbability\": 0.8161559491328145,\n", + " \"threshold\": 0.4376819769807411,\n", + " \"predictedTargetDefectYn\": 1,\n", + " \"riskGrade\": \"HIGH\",\n", + " \"mainCause\": \"source_cycle_time_sec\",\n", + " \"modelKey\": \"press_to_body\",\n", + " \"predictedAt\": \"2026-06-27T06:42:38.645689+00:00\"\n", + " },\n", + " {\n", + " \"eventType\": \"DEFECT_TRANSFER_PREDICTION\",\n", + " \"carMasterId\": 11406,\n", + " \"sourceEventId\": \"EVT-20260618-045621\",\n", + " \"targetEventId\": \"EVT-20260618-045622\",\n", + " \"sourceProcessCode\": \"PRESS\",\n", + " \"targetProcessCode\": \"BODY\",\n", + " \"targetDefectProbability\": 0.81447506053072,\n", + " \"threshold\": 0.4376819769807411,\n", + " \"predictedTargetDefectYn\": 1,\n", + " \"riskGrade\": \"HIGH\",\n", + " \"mainCause\": \"source_cycle_time_sec\",\n", + " \"modelKey\": \"press_to_body\",\n", + " \"predictedAt\": \"2026-06-27T06:42:38.645689+00:00\"\n", + " },\n", + " {\n", + " \"eventType\": \"DEFECT_TRANSFER_PREDICTION\",\n", + " \"carMasterId\": 9956,\n", + " \"sourceEventId\": \"EVT-20260617-039821\",\n", + " \"targetEventId\": \"EVT-20260617-039822\",\n", + " \"sourceProcessCode\": \"PRESS\",\n", + " \"targetProcessCode\": \"BODY\",\n", + " \"targetDefectProbability\": 0.7965217595386686,\n", + " \"threshold\": 0.4376819769807411,\n", + " \"predictedTargetDefectYn\": 1,\n", + " \"riskGrade\": \"HIGH\",\n", + " \"mainCause\": \"source_cycle_time_sec\",\n", + " \"modelKey\": \"press_to_body\",\n", + " \"predictedAt\": \"2026-06-27T06:42:38.645689+00:00\"\n", + " }\n", + "]\n" + ] + } + ], + "source": [ + "transition_shap_importance_rows = []\n", + "for model_key, model in transition_models.items():\n", + " meta = transition_metadata[model_key]\n", + " flow_test = transfer_test_raw[(transfer_test_raw[\"source_process_code\"] == meta[\"source_process_code\"]) & (transfer_test_raw[\"target_process_code\"] == meta[\"target_process_code\"])]\n", + " importance, _ = compute_shap_importance(model, flow_test[transition_feature_cols], sample_size=500)\n", + " importance[\"model_key\"] = model_key\n", + " importance[\"source_process_code\"] = meta[\"source_process_code\"]\n", + " importance[\"target_process_code\"] = meta[\"target_process_code\"]\n", + " transition_shap_importance_rows.append(importance)\n", + "\n", + "transition_shap_importance = pd.concat(transition_shap_importance_rows, ignore_index=True) if transition_shap_importance_rows else pd.DataFrame()\n", + "global_top_cause = {}\n", + "if not transition_shap_importance.empty:\n", + " global_top_cause = transition_shap_importance.sort_values([\"model_key\", \"mean_abs_shap\"], ascending=[True, False]).groupby(\"model_key\").first()[\"feature\"].to_dict()\n", + " display(transition_shap_importance.groupby(\"model_key\").head(10))\n", + " plt.figure(figsize=(9, 7))\n", + " sns.barplot(data=transition_shap_importance.groupby(\"model_key\").head(8), x=\"mean_abs_shap\", y=\"feature\", hue=\"model_key\")\n", + " plt.title(\"공정 전이 예측 SHAP 중요도\")\n", + " plt.xlabel(\"평균 |SHAP|\")\n", + " plt.ylabel(\"Feature\")\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "predicted_at = datetime.now(timezone.utc).isoformat()\n", + "if not transition_predictions.empty:\n", + " transition_predictions[\"main_cause\"] = transition_predictions[\"model_key\"].map(global_top_cause).fillna(\"not_available\")\n", + " transition_predictions[\"predicted_at\"] = predicted_at\n", + "\n", + "kafka_analysis_events = []\n", + "for _, row in transition_predictions.sort_values(\"target_defect_probability\", ascending=False).head(500).iterrows():\n", + " kafka_analysis_events.append({\n", + " \"eventType\": \"DEFECT_TRANSFER_PREDICTION\",\n", + " \"carMasterId\": int(row[\"car_master_id\"]),\n", + " \"sourceEventId\": str(row[\"source_event_id\"]),\n", + " \"targetEventId\": str(row[\"target_event_id\"]),\n", + " \"sourceProcessCode\": str(row[\"source_process_code\"]),\n", + " \"targetProcessCode\": str(row[\"target_process_code\"]),\n", + " \"targetDefectProbability\": float(row[\"target_defect_probability\"]),\n", + " \"threshold\": float(row[\"threshold\"]),\n", + " \"predictedTargetDefectYn\": int(row[\"predicted_target_defect_yn\"]),\n", + " \"riskGrade\": str(row[\"risk_grade\"]),\n", + " \"mainCause\": str(row[\"main_cause\"]),\n", + " \"modelKey\": str(row[\"model_key\"]),\n", + " \"predictedAt\": predicted_at,\n", + " })\n", + "print(\"kafka event examples:\", len(kafka_analysis_events))\n", + "print(json.dumps(kafka_analysis_events[:3], ensure_ascii=False, indent=2))" + ] + }, + { + "cell_type": "markdown", + "id": "e76d4d4f", + "metadata": { + "id": "e76d4d4f" + }, + "source": [ + "## 8. 모델/분석 산출물 저장" + ] + }, + { + "cell_type": "markdown", + "id": "2497b13c", + "metadata": { + "id": "2497b13c" + }, + "source": [ + "**셀 설명**\n", + "\n", + "학습된 모델, feature 목록, metric, 혼동행렬, SHAP 결과, 전이 모델 metadata를 파일로 저장합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5083f196", + "metadata": { + "id": "5083f196", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "50efd52e-ec17-4533-e478-4a33e4211bac" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content/drive/MyDrive/defect_transfer_outputs/selected_defect_detector.joblib\n", + "/content/drive/MyDrive/defect_transfer_outputs/defect_model_features.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/defect_model_metrics.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/defect_model_comparison.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/defect_model_cv_results.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/defect_model_confusion_matrix.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/defect_model_confusion_matrices_by_model.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/defect_shap_importance.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/defect_model_feature_importance.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/adjacent_transfer_models.joblib\n", + "/content/drive/MyDrive/defect_transfer_outputs/adjacent_transfer_model_metadata.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/adjacent_transfer_model_metrics.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/adjacent_transfer_confusion_matrices.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/adjacent_transfer_train_confusion_matrices.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/adjacent_transfer_shap_importance.json\n", + "/content/drive/MyDrive/defect_transfer_outputs/defect_transfer_kafka_analysis_events.jsonl\n", + "/content/drive/MyDrive/defect_transfer_outputs/event_json_inference_schema.json\n" + ] + } + ], + "source": [ + "def to_builtin(value):\n", + " if isinstance(value, dict):\n", + " return {k: to_builtin(v) for k, v in value.items()}\n", + " if isinstance(value, list):\n", + " return [to_builtin(v) for v in value]\n", + " if isinstance(value, (np.integer,)):\n", + " return int(value)\n", + " if isinstance(value, (np.floating,)):\n", + " return float(value)\n", + " if isinstance(value, pd.DataFrame):\n", + " return value.to_dict(orient=\"records\")\n", + " return value\n", + "\n", + "\n", + "selected_model_path = OUTPUT_DIR / \"selected_defect_detector.joblib\"\n", + "candidate_models_path = OUTPUT_DIR / \"candidate_defect_models.joblib\"\n", + "feature_path = OUTPUT_DIR / \"defect_model_features.json\"\n", + "metrics_path = OUTPUT_DIR / \"defect_model_metrics.json\"\n", + "comparison_path = OUTPUT_DIR / \"defect_model_comparison.json\"\n", + "cv_results_path = OUTPUT_DIR / \"defect_model_cv_results.json\"\n", + "confusion_matrix_path = OUTPUT_DIR / \"defect_model_confusion_matrix.json\"\n", + "all_confusion_matrices_path = OUTPUT_DIR / \"defect_model_confusion_matrices_by_model.json\"\n", + "train_confusion_matrices_path = OUTPUT_DIR / \"defect_model_train_confusion_matrices_by_model.json\"\n", + "shap_importance_path = OUTPUT_DIR / \"defect_shap_importance.json\"\n", + "feature_importance_path = OUTPUT_DIR / \"defect_model_feature_importance.json\"\n", + "transition_models_path = OUTPUT_DIR / \"adjacent_transfer_models.joblib\"\n", + "transition_metadata_path = OUTPUT_DIR / \"adjacent_transfer_model_metadata.json\"\n", + "transition_metrics_path = OUTPUT_DIR / \"adjacent_transfer_model_metrics.json\"\n", + "transition_confusion_path = OUTPUT_DIR / \"adjacent_transfer_confusion_matrices.json\"\n", + "transition_train_confusion_path = OUTPUT_DIR / \"adjacent_transfer_train_confusion_matrices.json\"\n", + "transition_shap_path = OUTPUT_DIR / \"adjacent_transfer_shap_importance.json\"\n", + "transition_cv_results_path = OUTPUT_DIR / \"adjacent_transfer_cv_results.json\"\n", + "kafka_events_path = OUTPUT_DIR / \"defect_transfer_kafka_analysis_events.jsonl\"\n", + "schema_path = OUTPUT_DIR / \"event_json_inference_schema.json\"\n", + "\n", + "joblib.dump(selected_event_model, selected_model_path)\n", + "joblib.dump(event_candidate_models, candidate_models_path)\n", + "joblib.dump(transition_models, transition_models_path)\n", + "feature_path.write_text(json.dumps(event_feature_cols, ensure_ascii=False, indent=2), encoding=\"utf-8\")\n", + "metrics_payload = {\n", + " \"selected_model_name\": selected_event_model_name,\n", + " \"threshold\": selected_event_threshold,\n", + " \"train_metrics\": compute_metrics(y_event_train, event_train_proba, selected_event_threshold),\n", + " \"test_metrics\": compute_metrics(y_event_test, event_test_proba, selected_event_threshold),\n", + " \"train_rows\": int(len(defect_train)),\n", + " \"test_rows\": int(len(defect_test)),\n", + " \"positive_ratio_train\": float(y_event_train.mean()),\n", + " \"created_at\": datetime.now(timezone.utc).isoformat(),\n", + "}\n", + "metrics_path.write_text(json.dumps(to_builtin(metrics_payload), ensure_ascii=False, indent=2), encoding=\"utf-8\")\n", + "comparison_path.write_text(event_model_comparison.to_json(orient=\"records\", force_ascii=False, indent=2), encoding=\"utf-8\")\n", + "if \"event_cv_results\" in globals() and not event_cv_results.empty:\n", + " cv_results_path.write_text(event_cv_results.to_json(orient=\"records\", force_ascii=False, indent=2), encoding=\"utf-8\")\n", + "if \"transition_cv_results\" in globals() and not transition_cv_results.empty:\n", + " transition_cv_results_path.write_text(transition_cv_results.to_json(orient=\"records\", force_ascii=False, indent=2), encoding=\"utf-8\")\n", + "confusion_matrix_path.write_text(event_confusion_matrix_table.to_json(orient=\"split\", force_ascii=False, indent=2), encoding=\"utf-8\")\n", + "if \"event_confusion_tables_by_model\" in globals():\n", + " all_confusion_matrices_path.write_text(json.dumps({key: table.to_dict(orient=\"split\") for key, table in event_confusion_tables_by_model.items()}, ensure_ascii=False, indent=2), encoding=\"utf-8\")\n", + "if \"event_train_confusion_tables_by_model\" in globals():\n", + " train_confusion_matrices_path.write_text(json.dumps({key: table.to_dict(orient=\"split\") for key, table in event_train_confusion_tables_by_model.items()}, ensure_ascii=False, indent=2), encoding=\"utf-8\")\n", + "shap_importance_path.write_text(event_shap_importance.to_json(orient=\"records\", force_ascii=False, indent=2), encoding=\"utf-8\")\n", + "feature_importance_path.write_text(event_model_importance.to_json(orient=\"records\", force_ascii=False, indent=2), encoding=\"utf-8\")\n", + "transition_metadata_path.write_text(json.dumps(to_builtin(transition_metadata), ensure_ascii=False, indent=2), encoding=\"utf-8\")\n", + "transition_metrics_path.write_text(transition_model_metrics.to_json(orient=\"records\", force_ascii=False, indent=2), encoding=\"utf-8\")\n", + "transition_confusion_path.write_text(json.dumps({key: table.to_dict(orient=\"split\") for key, table in transition_confusion_tables.items()}, ensure_ascii=False, indent=2), encoding=\"utf-8\")\n", + "transition_train_confusion_path.write_text(json.dumps({key: table.to_dict(orient=\"split\") for key, table in transition_train_confusion_tables.items()}, ensure_ascii=False, indent=2), encoding=\"utf-8\")\n", + "transition_shap_path.write_text(transition_shap_importance.to_json(orient=\"records\", force_ascii=False, indent=2), encoding=\"utf-8\")\n", + "with open(kafka_events_path, \"w\", encoding=\"utf-8\") as f:\n", + " for event in kafka_analysis_events:\n", + " f.write(json.dumps(to_builtin(event), ensure_ascii=False) + \"\\n\")\n", + "schema_payload = {\"event_model\": {\"target_column\": EVENT_TARGET, \"feature_columns\": event_feature_cols, \"source_train_csv\": str(DEFECT_TRAIN_PATH), \"source_test_csv\": str(DEFECT_TEST_PATH)}, \"transition_model\": {\"target_column\": TRANSFER_TARGET, \"feature_columns\": transition_feature_cols, \"source_train_csv\": str(TRANSFER_TRAIN_PATH), \"source_test_csv\": str(TRANSFER_TEST_PATH)}}\n", + "schema_path.write_text(json.dumps(schema_payload, ensure_ascii=False, indent=2), encoding=\"utf-8\")\n", + "\n", + "for path in [\n", + " selected_model_path,\n", + " feature_path,\n", + " metrics_path,\n", + " comparison_path,\n", + " cv_results_path,\n", + " confusion_matrix_path,\n", + " all_confusion_matrices_path,\n", + " shap_importance_path,\n", + " feature_importance_path,\n", + " transition_models_path,\n", + " transition_metadata_path,\n", + " transition_metrics_path,\n", + " transition_confusion_path,\n", + " transition_train_confusion_path,\n", + " transition_shap_path,\n", + " kafka_events_path,\n", + " schema_path,\n", + "]:\n", + " if path.exists():\n", + " print(path)" + ] + }, + { + "cell_type": "markdown", + "id": "20844247", + "metadata": { + "id": "20844247" + }, + "source": [ + "## 운영/API에서 우선 사용할 파일\n", + "\n", + "불량 탐지 API:\n", + "- selected_defect_detector.joblib\n", + "- defect_model_features.json\n", + "- defect_model_metrics.json\n", + "- event_json_inference_schema.json\n", + "\n", + "전이 예측 API:\n", + "- adjacent_transfer_models.joblib\n", + "- adjacent_transfer_model_metadata.json\n", + "\n", + "SHAP/분석:\n", + "- defect_shap_importance.json\n", + "- adjacent_transfer_shap_importance.json\n", + "- defect_transfer_kafka_analysis_events.jsonl" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "pygments_lexer": "ipython3" + }, + "colab": { + "provenance": [] + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/app/repository/__init__.py b/app/repository/__init__.py index ccee955..6418e44 100644 --- a/app/repository/__init__.py +++ b/app/repository/__init__.py @@ -1,2 +1,30 @@ """Database repository package.""" +from app.repository.car_master_repository import CarMasterRepository +from app.repository.defect_transfer_prediction_repository import ( + DefectTransferPredictionRepository, +) +from app.repository.equipment_repository import EquipmentRepository +from app.repository.manufacturing_event_repository import ( + ManufacturingEventRepository, +) +from app.repository.manufacturing_event_template_repository import ( + ManufacturingEventTemplateRepository, +) +from app.repository.manufacturing_generation_job_repository import ( + ManufacturingGenerationJobRepository, +) +from app.repository.sampledb_repository import SampleDbRepository +from app.repository.sampledb_schema_manager import SampleDbSchemaManager + +__all__ = [ + "CarMasterRepository", + "DefectTransferPredictionRepository", + "EquipmentRepository", + "ManufacturingEventRepository", + "ManufacturingEventTemplateRepository", + "ManufacturingGenerationJobRepository", + "SampleDbRepository", + "SampleDbSchemaManager", +] + diff --git a/app/repository/bottleneck_analysis_repository.py b/app/repository/bottleneck_analysis_repository.py index 49eed34..20143d2 100644 --- a/app/repository/bottleneck_analysis_repository.py +++ b/app/repository/bottleneck_analysis_repository.py @@ -1,178 +1,676 @@ +from __future__ import annotations + +import json from collections.abc import Iterable +from datetime import date as DateType +from datetime import datetime from typing import Any +from app.repository.sampledb_schema import manufacturing_event_json from app.utils.database_utils import mysql_connect_args_for_seoul class BottleneckAnalysisRepository: - """병목 분석 결과를 DB에 저장하고 조회하는 저장소 계층""" + """병목 분석 결과를 저장하고 sampledb.manufacturing_event_json 원천 이벤트를 읽는다.""" - def __init__(self, database_url: str) -> None: - """MySQL 연결을 초기화하고 테이블 스키마를 보장한다.""" + def __init__( + self, + database_url: str, + *, + event_database_url: str | None = None, + ) -> None: self.database_url = database_url + self.event_database_url = event_database_url or database_url self.engine: Any | None = None + self.event_engine: Any | None = None self.table: Any | None = None - self.product_process_history_table: Any | None = None self.metadata: Any | None = None self._init_sqlalchemy() self.ensure_schema() def ensure_schema(self) -> None: - """병목 분석 결과 테이블과 조회용 인덱스를 생성""" + """병목 결과 테이블이 없거나 구조가 다르면 DB 스키마를 맞춘다.""" + # 병목 결과 테이블이 없거나 컬럼이 다르면 여기서 맞춘다. self.metadata.create_all(self.engine) + self._align_result_schema() def replace_results( self, rows: Iterable[dict[str, Any]], - detected_at: str, + detected_at: Any, *, start_rank: int, end_rank: int, ) -> None: - """요청 순위 구간 교체""" - payload = [{**row, "detected_at": detected_at} for row in rows] - self._validate_product_process_history_ids(payload) + """계산된 병목 순위 결과를 detected_at 스냅샷으로 저장한다.""" + payload = [ + { + key: value + for key, value in {**row, "detected_at": detected_at}.items() + if key != "id" + } + for row in rows + ] + if not payload: + return + + # 새 분석 결과를 한 번에 저장한다. + with self.engine.begin() as conn: + conn.execute(self.table.insert(), payload) + def prune_results_after_rank(self, max_rank: int) -> None: + """현재 날짜의 병목 결과 중 상위 순위만 남기고 나머지를 삭제한다.""" + from sqlalchemy import func with self.engine.begin() as conn: - # 요청한 rank 범위만 갱신 conn.execute( - self.table.delete().where( - self.table.c.rank_no.between(start_rank, end_rank), - ), + self.table.delete() + .where(self.table.c.rank_no > max_rank) + .where(func.date(self.table.c.detected_at) == func.current_date()) ) - if payload: - conn.execute(self.table.insert(), payload) - def list_results(self, *, cursor: int, size: int) -> list[dict[str, Any]]: - """요청 순위 페이지 조회""" - from sqlalchemy import select + def list_results( + self, + *, + cursor: int, + size: int, + analysis_date: DateType | None = None, + ) -> list[dict[str, Any]]: + """지정한 날짜의 최신 병목 스냅샷을 기준으로 결과 목록을 반환한다.""" + # detected_at 스냅샷 기준으로 같은 날짜의 병목 결과만 읽는다. + snapshot_detected_at = self._latest_snapshot_detected_at(analysis_date) + if snapshot_detected_at is None: + return [] - start_rank = cursor * size + 1 - end_rank = start_rank + size - 1 + from sqlalchemy import select - query = select(self.table) query = ( - # 같은 순위가 있어도 조회 순서가 흔들리지 않도록 보조 정렬 - query.where(self.table.c.rank_no.between(start_rank, end_rank)) - .order_by(self.table.c.rank_no.asc(), self.table.c.id.asc()) - .limit(size) + select( + self.table.c.id, + self.table.c.manufacturing_event_id, + self.table.c.car_master_id, + self.table.c.process_code, + self.table.c.equipment_code, + self.table.c.rank_no, + self.table.c.avg_delay_time, + self.table.c.affected_vehicle_count, + self.table.c.risk_score, + self.table.c.detected_at, + ) + .where(self.table.c.detected_at == snapshot_detected_at) + .order_by( + self.table.c.rank_no.asc(), + self.table.c.id.asc(), + ) ) with self.engine.connect() as conn: - return [dict(row) for row in conn.execute(query).mappings()] + rows = [dict(row) for row in conn.execute(query).mappings()] + + deduped = self._dedupe_rows(rows) + offset = cursor * size + return deduped[offset : offset + size] + + def count_results( + self, + *, + analysis_date: DateType | None = None, + ) -> int: + """지정한 날짜의 최신 병목 결과 건수를 반환한다.""" + # 조회 기준 날짜의 결과 건수를 세어 페이지네이션 여부를 판단한다. + snapshot_detected_at = self._latest_snapshot_detected_at(analysis_date) + if snapshot_detected_at is None: + return 0 - def count_results(self) -> int: - """저장된 병목 분석 결과 수를 반환""" from sqlalchemy import func, select - query = select(func.count()).select_from(self.table) + query = ( + select(func.count()) + .select_from(self.table) + .where(self.table.c.detected_at == snapshot_detected_at) + ) with self.engine.connect() as conn: - return int(conn.execute(query).scalar_one()) + raw_count = int(conn.execute(query).scalar_one()) - def list_product_process_histories(self) -> list[dict[str, Any]]: - """분석에 사용할 product_process_history 전체를 조회""" - from sqlalchemy import select + if raw_count <= 0: + return 0 + + return len(self.list_results(cursor=0, size=raw_count)) + + def delete_results_by_date(self, analysis_date: DateType) -> int: + """병목 결과 테이블에서 특정 날짜 스냅샷을 제거한다.""" + from sqlalchemy import func + + with self.engine.begin() as conn: + result = conn.execute( + self.table.delete().where(func.date(self.table.c.detected_at) == analysis_date), + ) + return int(result.rowcount or 0) + + def list_manufacturing_event_histories( + self, + *, + analysis_date: DateType | None = None, + ) -> list[dict[str, Any]]: + """병목 분석용 원천 이벤트를 sampledb에서 읽어온다.""" + # 병목 분석 대상 원천 이벤트를 sampledb에서 읽는다. + from sqlalchemy import select, func query = ( select( - self.product_process_history_table.c.id, - self.product_process_history_table.c.manufacturing_event_id, - self.product_process_history_table.c.car_master_id, - self.product_process_history_table.c.process_code, - self.product_process_history_table.c.equipment_code, - self.product_process_history_table.c.station_code, - self.product_process_history_table.c.process_time, - self.product_process_history_table.c.waiting_time, + manufacturing_event_json.c.id, + manufacturing_event_json.c.car_master_id, + manufacturing_event_json.c.process_code, + manufacturing_event_json.c.equipment_id, + manufacturing_event_json.c.event_time, + manufacturing_event_json.c.event_json, ) - .order_by(self.product_process_history_table.c.id.asc()) + .where(manufacturing_event_json.c.dispatch_status == "SENT") + .where(manufacturing_event_json.c.is_sent.is_(True)) + .where( + func.date(manufacturing_event_json.c.event_time) + == (analysis_date or func.current_date()) + ) + .order_by(manufacturing_event_json.c.id.asc()) + ) + with self.event_engine.connect() as conn: + rows = conn.execute(query).mappings() + return [ + self._to_bottleneck_history(row) + for row in rows + ] + + def list_pending_manufacturing_event_histories( + self, + *, + analysis_date: DateType | None = None, + ) -> list[dict[str, Any]]: + """아직 병목 분석이 끝나지 않은 원천 이벤트만 가져온다.""" + # 아직 병목 분석이 끝나지 않은 원천 이벤트만 다시 가져온다. + from sqlalchemy import select, func + + query = ( + select( + manufacturing_event_json.c.id, + manufacturing_event_json.c.car_master_id, + manufacturing_event_json.c.process_code, + manufacturing_event_json.c.equipment_id, + manufacturing_event_json.c.event_time, + manufacturing_event_json.c.event_json, + ) + .where(manufacturing_event_json.c.dispatch_status == "SENT") + .where(manufacturing_event_json.c.is_sent.is_(True)) + .where(manufacturing_event_json.c.bottleneck_analysis_done.is_(False)) + .where( + func.date(manufacturing_event_json.c.event_time) + == (analysis_date or func.current_date()) + ) + .order_by(manufacturing_event_json.c.id.asc()) + ) + with self.event_engine.connect() as conn: + rows = conn.execute(query).mappings() + return [ + self._to_bottleneck_history(row) + for row in rows + ] + + def list_date_options(self) -> list[dict[str, Any]]: + """dateOptions 표시용으로 detected_at 날짜와 대표 event_id를 묶어 반환한다.""" + # 날짜 선택 UI용으로 detected_at 기준 옵션을 만든다. + from sqlalchemy import func, select + + query = ( + select( + func.date(self.table.c.detected_at).label("date"), + func.min(self.table.c.manufacturing_event_id).label( + "sample_manufacturing_event_id", + ), + ) + .where(self.table.c.detected_at.is_not(None)) + .group_by(func.date(self.table.c.detected_at)) + .order_by(func.date(self.table.c.detected_at).desc()) ) with self.engine.connect() as conn: - return [dict(row) for row in conn.execute(query).mappings()] + date_rows = [dict(row) for row in conn.execute(query).mappings()] - def _validate_product_process_history_ids(self, rows: list[dict[str, Any]]) -> None: - """병목 결과의 product_process_history_id가 실제 공정 이력 PK인지 검증""" - history_ids = { - int(row["product_process_history_id"]) - for row in rows - if row.get("product_process_history_id") is not None - } - if not history_ids: - return + sample_event_ids = sorted( + { + int(row["sample_manufacturing_event_id"]) + for row in date_rows + if row.get("sample_manufacturing_event_id") is not None + }, + ) + event_id_by_id: dict[int, str] = {} + if sample_event_ids: + event_query = select( + manufacturing_event_json.c.id, + manufacturing_event_json.c.event_id, + ).where(manufacturing_event_json.c.id.in_(sample_event_ids)) + with self.event_engine.connect() as conn: + for event_row in conn.execute(event_query).mappings(): + event_id_by_id[int(event_row["id"])] = str(event_row["event_id"]) - from sqlalchemy import select + return [ + { + "date": row["date"], + "sample_event_id": ( + event_id_by_id.get(int(row["sample_manufacturing_event_id"])) + if row.get("sample_manufacturing_event_id") is not None + else None + ), + } + for row in date_rows + ] + + def _event_ids_for_today(self) -> list[int]: + """오늘 날짜로 들어온 병목 대상 이벤트 id 목록을 조회한다.""" + from sqlalchemy import func, select - query = select(self.product_process_history_table.c.id).where( - self.product_process_history_table.c.id.in_(history_ids), + query = ( + select(manufacturing_event_json.c.id) + .where(manufacturing_event_json.c.dispatch_status == "SENT") + .where(manufacturing_event_json.c.is_sent.is_(True)) + .where(func.date(manufacturing_event_json.c.event_time) == func.current_date()) ) + with self.event_engine.connect() as conn: + return [int(row[0]) for row in conn.execute(query).all()] + + def _latest_snapshot_detected_at( + self, + analysis_date: DateType | None = None, + ) -> datetime | None: + from sqlalchemy import func, select + + query = select(func.max(self.table.c.detected_at)) + if analysis_date is not None: + query = query.where(func.date(self.table.c.detected_at) == analysis_date) with self.engine.connect() as conn: - existing_ids = {int(row["id"]) for row in conn.execute(query).mappings()} + value = conn.execute(query).scalar_one() + return value + + def mark_bottleneck_analysis_done(self, event_ids: Iterable[int]) -> int: + event_ids = [int(event_id) for event_id in event_ids] + if not event_ids: + return 0 + + from sqlalchemy import func + + with self.event_engine.begin() as conn: + result = conn.execute( + manufacturing_event_json.update() + .where(manufacturing_event_json.c.id.in_(event_ids)) + .values( + bottleneck_analysis_done=True, + updated_at=func.current_timestamp(), + ), + ) + return int(result.rowcount or 0) + + def reset_bottleneck_analysis_done(self, event_ids: Iterable[int]) -> int: + event_ids = [int(event_id) for event_id in event_ids] + if not event_ids: + return 0 - missing_ids = sorted(history_ids - existing_ids) - if missing_ids: - raise ValueError( - f"Invalid product_process_history_id values: {missing_ids}", + from sqlalchemy import func + + with self.event_engine.begin() as conn: + result = conn.execute( + manufacturing_event_json.update() + .where(manufacturing_event_json.c.id.in_(event_ids)) + .values( + bottleneck_analysis_done=False, + updated_at=func.current_timestamp(), + ), ) + return int(result.rowcount or 0) + + def _to_bottleneck_history(self, row: dict[str, Any]) -> dict[str, Any]: + event_json = self._event_json_dict(row["event_json"]) + equipment = event_json.get("equipment", {}) + equipment_status = event_json.get("equipmentStatus", {}) + metrics = event_json.get("processMetrics", {}) + equipment_code = str( + equipment.get("equipmentCode") + or row.get("equipment_id") + or "UNKNOWN", + ) + process_data = event_json.get("processData", {}) + process_code = str(row["process_code"]) + operation_status = str( + equipment_status.get("operationStatus") or "", + ).upper() + process_time = self._safe_float(metrics.get("processingTimeSec")) + waiting_time = self._safe_float(metrics.get("waitingTimeSec")) + cycle_time = self._safe_float(metrics.get("cycleTimeSec")) + station_delay_time = self._safe_float(metrics.get("stationDelaySec")) + timestamp_delay_time = self._process_timestamp_delay( + process_data, + process_code, + ) + equipment_stop_delay_time = self._equipment_stop_delay( + equipment_status, + event_json, + row.get("event_time"), + ) + delay_time = ( + station_delay_time + if station_delay_time > 0 + else timestamp_delay_time + if timestamp_delay_time > 0 + else equipment_stop_delay_time + if operation_status in {"FAULT", "STOPPED", "ERROR", "DOWN"} + else 0.0 + ) + + return { + "id": int(row["id"]), + "manufacturing_event_id": int(row["id"]), + "car_master_id": row["car_master_id"], + "process_code": process_code, + "equipment_code": equipment_code, + "equipment_status": operation_status, + "station_key": equipment_code, + "process_time": process_time, + "waiting_time": waiting_time, + "cycle_time": cycle_time, + "delay_time": delay_time, + "queue_length": self._safe_float(metrics.get("queueLength")), + "wip_count": self._safe_float(metrics.get("wipCount")), + } + + @staticmethod + def _dedupe_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]: + if not rows: + return [] + + deduped: list[dict[str, Any]] = [] + seen_keys: set[tuple[str, str]] = set() + for row in sorted( + rows, + key=lambda item: ( + float(item.get("risk_score") or 0.0), + float(item.get("avg_delay_time") or 0.0), + int(item.get("affected_vehicle_count") or 0), + int(item.get("manufacturing_event_id") or 0), + int(item.get("car_master_id") or 0), + str(item.get("process_code") or "").strip().upper(), + str(item.get("equipment_code") or "").strip().upper(), + int(item.get("rank_no") or 0), + int(item.get("id") or 0), + ), + reverse=True, + ): + key = ( + str(row.get("process_code") or "").strip().upper(), + str(row.get("equipment_code") or "").strip().upper(), + ) + if key in seen_keys: + continue + seen_keys.add(key) + deduped.append(row) + + deduped.sort( + key=lambda item: ( + int(item.get("rank_no") or 0), + int(item.get("id") or 0), + ), + ) + return deduped + + @staticmethod + def _event_json_dict(value: Any) -> dict[str, Any]: + if isinstance(value, dict): + return value + if isinstance(value, str): + return json.loads(value) + return {} + + @staticmethod + def _safe_float(value: Any) -> float: + if value is None: + return 0.0 + return float(value) + + @classmethod + def _process_timestamp_delay( + cls, + process_data: Any, + process_code: str, + ) -> float: + if not isinstance(process_data, dict): + return 0.0 + + candidates = [ + process_code, + process_code.lower(), + process_code.upper(), + ] + for key in candidates: + value = process_data.get(key) + if isinstance(value, dict): + return cls._safe_float(value.get("timestampDelaySec")) + return 0.0 + + @classmethod + def _equipment_stop_delay( + cls, + equipment_status: dict[str, Any], + event_json: dict[str, Any], + event_time_value: Any, + ) -> float: + status_changed_at = cls._parse_datetime( + equipment_status.get("statusChangedTime"), + ) + event_time = cls._parse_datetime( + event_time_value, + ) or cls._parse_datetime( + cls._nested_value(event_json, "event", "eventTime"), + ) + if status_changed_at is None: + return 0.0 + + last_normal_time = cls._parse_datetime( + equipment_status.get("lastNormalTime"), + ) + + if event_time is not None and event_time > status_changed_at: + return (event_time - status_changed_at).total_seconds() + + if last_normal_time is not None: + return max((status_changed_at - last_normal_time).total_seconds(), 0.0) + + if event_time is None: + event_time = datetime.now() + else: + return 30.0 + + return max((event_time - status_changed_at).total_seconds(), 0.0) + + @staticmethod + def _parse_datetime(value: Any) -> Any | None: + if value is None: + return None + if hasattr(value, "isoformat") and hasattr(value, "tzinfo"): + return value.replace(tzinfo=None) + text = str(value).strip() + if not text: + return None + try: + return datetime.fromisoformat( + text.replace("Z", "+00:00"), + ).replace(tzinfo=None) + except ValueError: + return None + + @staticmethod + def _nested_value(payload: dict[str, Any], *path: str) -> Any: + current: Any = payload + for key in path: + if not isinstance(current, dict): + return None + current = current.get(key) + return current def _init_sqlalchemy(self) -> None: - """MySQL 연결을 위한 SQLAlchemy 엔진과 테이블 메타데이터를 구성""" try: - from sqlalchemy import BigInteger, Column, DateTime, Double, Float, ForeignKey - from sqlalchemy import Index, Integer, MetaData, String, Table + from sqlalchemy import BigInteger, Column, DateTime, Double, Enum + from sqlalchemy import Index, Integer, MetaData, String, Table, func from sqlalchemy import create_engine except ModuleNotFoundError as exc: raise RuntimeError( - "외부 DB를 사용하려면 requirements.txt의 sqlalchemy, pymysql 패키지가 필요합니다.", + "SQLAlchemy and PyMySQL are required for bottleneck analysis storage.", ) from exc self.metadata = MetaData() - self.product_process_history_table = Table( - "product_process_history", + process_code_enum = Enum("PRESS", "BODY", "PAINT", "ASSEMBLY") + self.table = Table( + "bottleneck_analysis_result", self.metadata, Column("id", BigInteger, primary_key=True, autoincrement=True), - # sampledb manufacturing_event.id에 대한 논리 참조이며 DB 간 FK는 두지 않음 Column("manufacturing_event_id", BigInteger), - # sampledb car_master.id에 대한 논리 참조이며 DB 간 FK는 두지 않음 Column("car_master_id", BigInteger), - Column("process_code", String(20), nullable=False), - Column("equipment_code", String(50), nullable=False), - Column("station_code", String(50), nullable=False), - Column("lot_code", String(50)), - Column("started_at", DateTime, nullable=False), - Column("ended_at", DateTime, nullable=False), - Column("process_time", Double), - Column("waiting_time", Double), - Column("result_status", String(20), nullable=False), - Column("sequence_no", Integer, nullable=False), - Column("previous_process_code", String(20)), - Column("created_at", DateTime, nullable=False), - Index("idx_product_process_history_event_id", "manufacturing_event_id"), - Index("idx_product_process_history_car_master_id", "car_master_id"), - Index("idx_product_process_history_process_code", "process_code"), - ) - # SQLAlchemy Core 테이블 정의를 사용해 MySQL DDL/CRUD를 DB 방언에 맞게 생성 - self.table = Table( - "bottleneck_analysis_result", - self.metadata, - Column("id", Integer, primary_key=True, autoincrement=True), - Column("product_process_history_id", BigInteger, ForeignKey("product_process_history.id")), - Column("manufacturing_event_id", Integer), - Column("car_master_id", Integer), - Column("process_code", String(64), nullable=False), - Column("equipment_code", String(64), nullable=False), - Column("station_code", String(64), nullable=False), - Column("rank_no", Integer, nullable=False), - Column("avg_delay_time", Float, nullable=False), - Column("affected_vehicle_count", Integer, nullable=False), - Column("risk_score", Float, nullable=False), - Column("detected_at", String(64), nullable=False), + Column("process_code", process_code_enum), + Column("equipment_code", String(50)), + Column("rank_no", Integer), + Column("avg_delay_time", Double), + Column("affected_vehicle_count", Integer), + Column("risk_score", Double), + Column("detected_at", DateTime), + Column("created_at", DateTime, nullable=False, server_default=func.current_timestamp()), + Column( + "updated_at", + DateTime, + nullable=False, + server_default=func.current_timestamp(), + server_onupdate=func.current_timestamp(), + ), Index("idx_bottleneck_analysis_result_rank", "rank_no"), - Index("idx_bottleneck_analysis_result_history_id", "product_process_history_id"), ) self.engine = create_engine( self.database_url, - # MySQL 세션 함수(now 등)를 서비스 기준 타임존과 맞춤 connect_args=mysql_connect_args_for_seoul(self.database_url), pool_pre_ping=True, future=True, ) + self.event_engine = create_engine( + self.event_database_url, + connect_args=mysql_connect_args_for_seoul(self.event_database_url), + pool_pre_ping=True, + future=True, + ) + + def _align_result_schema(self) -> None: + if self.engine.dialect.name != "mysql": + return + + from sqlalchemy import inspect, text + + table_name = "bottleneck_analysis_result" + inspector = inspect(self.engine) + if not inspector.has_table(table_name): + return + + columns = { + column["name"] + for column in inspector.get_columns(table_name) + } + expected_columns = { + "manufacturing_event_id": "BIGINT NULL", + "car_master_id": "BIGINT NULL", + "process_code": "ENUM('PRESS','BODY','PAINT','ASSEMBLY') NULL", + "equipment_code": "VARCHAR(50) NULL", + "rank_no": "INT NULL", + "avg_delay_time": "DOUBLE NULL", + "affected_vehicle_count": "INT NULL", + "risk_score": "DOUBLE NULL", + "detected_at": "DATETIME NULL", + "created_at": "DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP", + "updated_at": ( + "DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP " + "ON UPDATE CURRENT_TIMESTAMP" + ), + } + removed_columns = ("product_process_history_id", "station_code") + + with self.engine.begin() as conn: + for column_name in removed_columns: + if column_name not in columns: + continue + self._drop_column_constraints(conn, inspector, table_name, column_name) + conn.execute( + text( + f"ALTER TABLE {table_name} " + f"DROP COLUMN {column_name}", + ), + ) + columns.remove(column_name) + + for column_name, definition in expected_columns.items(): + if column_name not in columns: + conn.execute( + text( + f"ALTER TABLE {table_name} " + f"ADD COLUMN {column_name} {definition}", + ), + ) + columns.add(column_name) + + conn.execute( + text( + f"ALTER TABLE {table_name} " + "MODIFY COLUMN id BIGINT NOT NULL AUTO_INCREMENT", + ), + ) + if "detected_at" in columns: + conn.execute( + text( + f"UPDATE {table_name} " + "SET detected_at = STR_TO_DATE(" + "LEFT(SUBSTRING_INDEX(REPLACE(detected_at, 'T', ' '), '+', 1), 19), " + "'%Y-%m-%d %H:%i:%s'" + ") " + "WHERE detected_at IS NOT NULL " + "AND CAST(detected_at AS CHAR) LIKE '%T%'", + ), + ) + conn.execute( + text( + f"UPDATE {table_name} " + "SET created_at = COALESCE(created_at, detected_at, CURRENT_TIMESTAMP), " + "updated_at = COALESCE(updated_at, detected_at, CURRENT_TIMESTAMP)", + ), + ) + + for column_name, definition in expected_columns.items(): + conn.execute( + text( + f"ALTER TABLE {table_name} " + f"MODIFY COLUMN {column_name} {definition}", + ), + ) + + @staticmethod + def _drop_column_constraints( + conn: Any, + inspector: Any, + table_name: str, + column_name: str, + ) -> None: + from sqlalchemy import text + + for foreign_key in inspector.get_foreign_keys(table_name): + if column_name in foreign_key.get("constrained_columns", []): + conn.execute( + text( + f"ALTER TABLE {table_name} " + f"DROP FOREIGN KEY {foreign_key['name']}", + ), + ) + + index_names = { + index["name"] + for index in inspector.get_indexes(table_name) + if column_name in index.get("column_names", []) + } + for index_name in index_names: + conn.execute(text(f"DROP INDEX {index_name} ON {table_name}")) diff --git a/app/repository/car_master_repository.py b/app/repository/car_master_repository.py new file mode 100644 index 0000000..ef15d11 --- /dev/null +++ b/app/repository/car_master_repository.py @@ -0,0 +1,84 @@ +from __future__ import annotations + +from datetime import date +from typing import Any + +from sqlalchemy import func, select + +from app.repository.sampledb_schema import car_master + + +class CarMasterRepository: + """기존 car_master 차량을 제조 이벤트의 carMasterId로 매핑한다.""" + + def __init__(self, engine: Any) -> None: + self.engine = engine + + def get_existing_map(self, count: int) -> dict[str, int]: + with self.engine.connect() as conn: + rows = list( + conn.execute( + select(car_master.c.id, car_master.c.vehicle_id) + .order_by(car_master.c.id.asc()) + .limit(count), + ).mappings(), + ) + return self._map_first_rows(rows, count) + + def get_map_by_production_date( + self, + production_date: date, + *, + limit: int | None = None, + ) -> dict[str, int]: + """vehicle_id의 생산일자에 해당하는 차량을 id 순서로 반환한다.""" + pattern = f"%-{production_date:%Y%m%d}-%" + query = ( + select(car_master.c.id, car_master.c.vehicle_id) + .where(car_master.c.vehicle_id.like(pattern)) + .order_by(car_master.c.id.asc()) + ) + if limit is not None: + query = query.limit(limit) + + with self.engine.connect() as conn: + rows = list(conn.execute(query).mappings()) + + if not rows: + raise RuntimeError( + f"{production_date.isoformat()} 생산 차량이 car_master에 없습니다.", + ) + if limit is not None and len(rows) < limit: + raise RuntimeError( + "요청한 차량 수보다 해당 날짜의 car_master가 부족합니다: " + f"date={production_date.isoformat()}, required={limit}, " + f"actual={len(rows)}", + ) + return { + str(row["vehicle_id"]): int(row["id"]) + for row in rows + } + + def count_by_production_date(self, production_date: date) -> int: + """vehicle_id 생산일자 기준 차량 수를 반환한다.""" + pattern = f"%-{production_date:%Y%m%d}-%" + query = select(func.count()).select_from(car_master).where( + car_master.c.vehicle_id.like(pattern), + ) + with self.engine.connect() as conn: + return int(conn.execute(query).scalar_one()) + + @staticmethod + def _map_first_rows(rows: list[Any], count: int) -> dict[str, int]: + if len(rows) < count: + raise RuntimeError( + f"car_master row가 부족합니다: required={count}, actual={len(rows)}", + ) + if int(rows[0]["id"]) != 1: + raise RuntimeError( + "제조 이벤트는 car_master.id=1부터 생성되어야 합니다.", + ) + return { + str(row["vehicle_id"]): int(row["id"]) + for row in rows[:count] + } diff --git a/app/repository/defect_transfer_prediction_repository.py b/app/repository/defect_transfer_prediction_repository.py new file mode 100644 index 0000000..245dac4 --- /dev/null +++ b/app/repository/defect_transfer_prediction_repository.py @@ -0,0 +1,765 @@ +from __future__ import annotations + +import json +from datetime import date, datetime +from typing import Any + +from app.repository.sampledb_schema import car_master, equipment, manufacturing_event_json +from app.utils.database_utils import mysql_connect_args_for_seoul +from app.utils.process_label_utils import NEXT_PROCESS, equipment_code_for_car_process + + +class DefectTransferPredictionRepository: + """불량 전이 예측 결과를 main_db에 저장하고 sampledb 원천 이벤트를 읽는다.""" + + def __init__( + self, + database_url: str, + *, + event_database_url: str, + ) -> None: + self.database_url = database_url + self.event_database_url = event_database_url + self.engine: Any | None = None + self.event_engine: Any | None = None + self.table: Any | None = None + self.metadata: Any | None = None + + self._init_sqlalchemy() + self.ensure_schema() + + def ensure_schema(self) -> None: + """불량 전이 결과 테이블의 스키마를 DB에 맞게 생성하거나 보정한다.""" + self.metadata.create_all(self.engine) + self._align_result_schema() + + def replace_prediction_result( + self, + *, + event_id: str, + car_master_id: int, + source_process_code: str, + target_process_code: str | None, + current_defect_probability: float, + target_defect_probability: float | None, + predicted_defect_process: str | None, + expected_occurrence_step: int | None, + risk_grade: str, + causes: list[dict[str, Any]], + predicted_at: datetime, + ) -> int: + """하나의 제조 이벤트에 대한 예측 결과를 최신 값으로 다시 저장한다.""" + """하나의 제조 이벤트에 대한 예측 결과를 최신 값으로 다시 저장한다.""" + # 하나의 제조 이벤트에 대해 예측 결과 1건만 유지한다. + manufacturing_event_id = self._manufacturing_event_id(event_id) + main_causes = self._normalize_main_causes(causes) + cause_rows = causes or [ + { + "message": "no main cause available", + "impact": 0.0, + }, + ] + top_cause = cause_rows[0] if cause_rows else {} + row = { + "manufacturing_event_id": manufacturing_event_id, + "car_master_id": car_master_id, + "source_process_code": source_process_code, + "target_process_code": target_process_code, + "current_defect_probability": current_defect_probability, + "target_defect_probability": target_defect_probability, + "predicted_defect_process": predicted_defect_process, + "expected_occurrence_step": expected_occurrence_step, + "risk_grade": risk_grade, + "main_causes": main_causes, + "influence_score": float(top_cause.get("impact") or 0.0), + "predicted_at": predicted_at, + } + + with self.engine.begin() as conn: + conn.execute( + self.table.delete().where( + self.table.c.manufacturing_event_id == manufacturing_event_id, + ), + ) + if self.engine.dialect.name != "mysql": + from sqlalchemy import func, select + + next_id = int(conn.execute(select(func.max(self.table.c.id))).scalar() or 0) + row = {**row, "id": next_id + 1} + conn.execute(self.table.insert(), [row]) + return 1 + + def has_prediction_for_event(self, event_id: str) -> bool: + """이미 해당 이벤트의 예측 결과가 저장되어 있는지 확인한다.""" + manufacturing_event_id = self._manufacturing_event_id(event_id) + if manufacturing_event_id is None: + return False + + from sqlalchemy import func, select + + query = ( + select(func.count()) + .select_from(self.table) + .where(self.table.c.manufacturing_event_id == manufacturing_event_id) + ) + with self.engine.connect() as conn: + return int(conn.execute(query).scalar_one()) > 0 + + def list_prediction_page( + self, + *, + cursor: int, + size: int, + analysis_date: date | None = None, + ) -> tuple[list[dict[str, Any]], bool]: + """차량별 최신 예측 결과를 모아 목록 페이지를 만든다.""" + # 차량별 최신 예측만 추려서 목록 페이지를 만든다. + rows = self._all_prediction_rows(analysis_date=analysis_date) + latest_by_car: dict[int, dict[str, Any]] = {} + for row in rows: + car_id = int(row["car_master_id"]) + if car_id not in latest_by_car: + latest_by_car[car_id] = row + + items = [ + row + for row in latest_by_car.values() + if self._result_probability(row) > 0 + ] + items.sort( + key=lambda row: ( + float(row.get("target_defect_probability") or 0.0), + float(row.get("current_defect_probability") or 0.0), + row.get("predicted_at") or datetime.min, + int(row.get("id") or 0), + ), + reverse=True, + ) + self._attach_vehicle_ids(items) + self._attach_process_equipment_codes(items) + + offset = cursor * size + page = items[offset : offset + size] + return page, len(items) > offset + size + + def list_prediction_rows( + self, + *, + analysis_date: date | None = None, + car_master_id: int | None = None, + ) -> list[dict[str, Any]]: + """조건에 맞는 불량 전이 결과 원본 row를 모두 반환한다.""" + return self._all_prediction_rows( + car_master_id=car_master_id, + analysis_date=analysis_date, + ) + + def list_cause_page( + self, + *, + vehicle_id: str | None, + cursor: int, + size: int, + analysis_date: date | None = None, + ) -> tuple[dict[str, Any] | None, list[dict[str, Any]], bool]: + """대표 원인 1개와 상세 원인 리스트를 함께 반환한다.""" + # 대표 원인 1개와 상세 원인 목록을 같은 이벤트 묶음으로 반환한다. + car_master_id = self._car_master_id(vehicle_id) if vehicle_id else None + rows = self._all_prediction_rows( + car_master_id=car_master_id, + analysis_date=analysis_date, + ) + if not rows: + return None, [], False + + latest_event_id = rows[0].get("manufacturing_event_id") + latest_rows = [ + row + for row in rows + if row.get("manufacturing_event_id") == latest_event_id + ] + latest_rows.sort( + key=lambda row: ( + float(row.get("influence_score") or 0.0), + int(row.get("id") or 0), + ), + reverse=True, + ) + self._attach_vehicle_ids(latest_rows) + self._attach_process_equipment_codes(latest_rows) + + offset = cursor * size + page = latest_rows[offset : offset + size] + return latest_rows[0], page, len(latest_rows) > offset + size + + def list_date_options(self, *, vehicle_id: str | None = None) -> list[dict[str, Any]]: + """predicted_at 기준으로 날짜 선택 옵션을 생성한다.""" + # 날짜 선택용 옵션은 predicted_at 기준으로 만든다. + from sqlalchemy import func, select + + car_master_id = self._car_master_id(vehicle_id) if vehicle_id else None + + query = ( + select( + func.date(self.table.c.predicted_at).label("date"), + func.min(self.table.c.manufacturing_event_id).label( + "sample_manufacturing_event_id", + ), + ) + .where(self.table.c.predicted_at.is_not(None)) + .group_by(func.date(self.table.c.predicted_at)) + .order_by(func.date(self.table.c.predicted_at).desc()) + ) + if car_master_id is not None: + query = query.where(self.table.c.car_master_id == car_master_id) + with self.engine.connect() as conn: + date_rows = [dict(row) for row in conn.execute(query).mappings()] + + sample_event_ids = sorted( + { + int(row["sample_manufacturing_event_id"]) + for row in date_rows + if row.get("sample_manufacturing_event_id") is not None + }, + ) + event_id_by_id: dict[int, str] = {} + if sample_event_ids: + event_query = select( + manufacturing_event_json.c.id, + manufacturing_event_json.c.event_id, + ).where(manufacturing_event_json.c.id.in_(sample_event_ids)) + with self.event_engine.connect() as conn: + for event_row in conn.execute(event_query).mappings(): + event_id_by_id[int(event_row["id"])] = str(event_row["event_id"]) + + return [ + { + "date": row["date"], + "sample_event_id": ( + event_id_by_id.get(int(row["sample_manufacturing_event_id"])) + if row.get("sample_manufacturing_event_id") is not None + else None + ), + } + for row in date_rows + ] + + def diagnostics(self) -> dict[str, Any]: + """원천 이벤트와 예측 결과의 현재 적재 상태를 점검한다.""" + # 원천 이벤트, 예측 결과, 최신 상태를 한 번에 점검한다. + from sqlalchemy import distinct, func, select + + with self.event_engine.connect() as conn: + source_event_count = int( + conn.execute(select(func.count()).select_from(manufacturing_event_json)).scalar() + or 0, + ) + sent_event_count = int( + conn.execute( + select(func.count()) + .select_from(manufacturing_event_json) + .where(manufacturing_event_json.c.dispatch_status == "SENT") + .where(manufacturing_event_json.c.is_sent.is_(True)), + ).scalar() + or 0, + ) + latest_source_event = conn.execute( + select( + manufacturing_event_json.c.id, + manufacturing_event_json.c.event_id, + manufacturing_event_json.c.car_master_id, + manufacturing_event_json.c.process_code, + manufacturing_event_json.c.is_sent, + manufacturing_event_json.c.created_at, + ).order_by(manufacturing_event_json.c.id.desc()), + ).mappings().first() + + all_rows = self._all_prediction_rows() + latest_by_car: dict[int, dict[str, Any]] = {} + for row in all_rows: + car_id = int(row["car_master_id"]) + if car_id not in latest_by_car: + latest_by_car[car_id] = row + + visible_latest_rows = [ + row + for row in latest_by_car.values() + if self._result_probability(row) > 0 + ] + + with self.engine.connect() as conn: + result_count = int( + conn.execute(select(func.count()).select_from(self.table)).scalar() or 0, + ) + result_car_count = int( + conn.execute( + select(func.count(distinct(self.table.c.car_master_id))), + ).scalar() + or 0, + ) + null_event_link_count = int( + conn.execute( + select(func.count()) + .select_from(self.table) + .where(self.table.c.manufacturing_event_id.is_(None)), + ).scalar() + or 0, + ) + latest_prediction = conn.execute( + select( + self.table.c.id, + self.table.c.manufacturing_event_id, + self.table.c.car_master_id, + self.table.c.source_process_code, + self.table.c.target_process_code, + self.table.c.current_defect_probability, + self.table.c.target_defect_probability, + self.table.c.risk_grade, + self.table.c.predicted_at, + ).order_by(self.table.c.predicted_at.desc(), self.table.c.id.desc()), + ).mappings().first() + + return { + "sourceEventCount": source_event_count, + "sentSourceEventCount": sent_event_count, + "predictionResultRowCount": result_count, + "predictionResultCarCount": result_car_count, + "visiblePredictionCarCount": len(visible_latest_rows), + "nullManufacturingEventLinkCount": null_event_link_count, + "latestSourceEvent": self._json_ready_row(latest_source_event), + "latestPredictionResult": self._json_ready_row(latest_prediction), + } + + def delete_predictions_by_date(self, analysis_date: date) -> int: + from sqlalchemy import func + + with self.engine.begin() as conn: + result = conn.execute( + self.table.delete().where(func.date(self.table.c.predicted_at) == analysis_date), + ) + return int(result.rowcount or 0) + + def _all_prediction_rows( + self, + *, + car_master_id: int | None = None, + analysis_date: date | None = None, + ) -> list[dict[str, Any]]: + """필요한 조건에 맞는 예측 결과 원본 row를 조회한다.""" + from sqlalchemy import func, select + + query = select(self.table) + if car_master_id is not None: + query = query.where(self.table.c.car_master_id == car_master_id) + if analysis_date is not None: + query = query.where(func.date(self.table.c.predicted_at) == analysis_date) + query = query.order_by( + self.table.c.predicted_at.desc(), + self.table.c.id.desc(), + ) + with self.engine.connect() as conn: + return [dict(row) for row in conn.execute(query).mappings()] + + def list_prediction_source_events( + self, + *, + analysis_date: date | None = None, + car_master_id: int | None = None, + ) -> list[dict[str, Any]]: + from sqlalchemy import func, select + + query = ( + select( + manufacturing_event_json.c.id, + manufacturing_event_json.c.event_id, + manufacturing_event_json.c.event_time, + manufacturing_event_json.c.car_master_id, + manufacturing_event_json.c.process_code, + manufacturing_event_json.c.event_json, + ) + .where(manufacturing_event_json.c.dispatch_status == "SENT") + .where(manufacturing_event_json.c.is_sent.is_(True)) + ) + if analysis_date is None: + query = query.where(func.date(manufacturing_event_json.c.event_time) == func.current_date()) + else: + query = query.where(func.date(manufacturing_event_json.c.event_time) == analysis_date) + if car_master_id is not None: + query = query.where(manufacturing_event_json.c.car_master_id == car_master_id) + query = query.order_by(manufacturing_event_json.c.id.asc()) + with self.event_engine.connect() as conn: + return [dict(row) for row in conn.execute(query).mappings()] + + def delete_source_analysis_done_flags( + self, + *, + event_ids: list[int], + column_name: str, + ) -> int: + if not event_ids: + return 0 + + from sqlalchemy import func + + if column_name not in {"bottleneck_analysis_done", "defect_transfer_analysis_done"}: + raise ValueError(f"Unsupported analysis flag column: {column_name}") + + with self.event_engine.begin() as conn: + result = conn.execute( + manufacturing_event_json.update() + .where(manufacturing_event_json.c.id.in_(event_ids)) + .values(**{column_name: False, "updated_at": func.current_timestamp()}), + ) + return int(result.rowcount or 0) + + @staticmethod + def _json_ready_row(row: Any | None) -> dict[str, Any] | None: + if row is None: + return None + return { + key: value.isoformat() if isinstance(value, datetime) else value + for key, value in dict(row).items() + } + + def _manufacturing_event_id(self, event_id: str) -> int | None: + from sqlalchemy import select + + query = select(manufacturing_event_json.c.id).where( + manufacturing_event_json.c.event_id == event_id, + ) + with self.event_engine.connect() as conn: + value = conn.execute(query).scalar() + return int(value) if value is not None else None + + def _car_master_id(self, vehicle_id: str | None) -> int | None: + if not vehicle_id: + return None + from sqlalchemy import select + + query = select(car_master.c.id).where(car_master.c.vehicle_id == vehicle_id) + with self.event_engine.connect() as conn: + value = conn.execute(query).scalar() + return int(value) if value is not None else None + + def _prediction_event_ids( + self, + *, + car_master_id: int | None = None, + analysis_date: date | None = None, + ) -> list[int]: + """분석 대상 manufacturing_event_json id를 필터링해서 반환한다.""" + from sqlalchemy import func, select + + query = ( + select(manufacturing_event_json.c.id) + .where(manufacturing_event_json.c.dispatch_status == "SENT") + .where(manufacturing_event_json.c.is_sent.is_(True)) + ) + if analysis_date is None: + query = query.where(func.date(manufacturing_event_json.c.event_time) == func.current_date()) + else: + query = query.where(func.date(manufacturing_event_json.c.event_time) == analysis_date) + if car_master_id is not None: + query = query.where(manufacturing_event_json.c.car_master_id == car_master_id) + with self.event_engine.connect() as conn: + return [int(row[0]) for row in conn.execute(query).all()] + + @staticmethod + def _normalize_probability(value: Any) -> float: + """확률값이 0~1 또는 0~100 형태여도 화면용 소수로 맞춘다.""" + if value is None: + return 0.0 + normalized = float(value) + if abs(normalized) > 1.0: + normalized /= 100.0 + return round(normalized, 4) + + @classmethod + def _result_probability(cls, row: dict[str, Any]) -> float: + """현재 화면에서 사용할 대표 확률값을 선택한다.""" + value = row.get("current_defect_probability") + if value is None: + value = row.get("target_defect_probability") + if value is None: + value = row.get("defect_probability") + if value is None: + return 0.0 + return cls._normalize_probability(value) + + def _attach_process_equipment_codes(self, rows: list[dict[str, Any]]) -> None: + """화면 표시에 필요한 공정명과 설비 코드를 보강한다.""" + if not rows: + return + from sqlalchemy import select + + event_ids = { + int(row["manufacturing_event_id"]) + for row in rows + if row.get("manufacturing_event_id") is not None + } + source_equipment_by_event: dict[int, str] = {} + if event_ids: + query = ( + select( + manufacturing_event_json.c.id, + equipment.c.equipment_code, + ) + .select_from( + manufacturing_event_json.join( + equipment, + equipment.c.id == manufacturing_event_json.c.equipment_id, + ), + ) + .where(manufacturing_event_json.c.id.in_(event_ids)) + ) + with self.event_engine.connect() as conn: + for event_row in conn.execute(query).mappings(): + source_equipment_by_event[int(event_row["id"])] = str( + event_row["equipment_code"], + ) + + target_keys: set[tuple[int, str]] = set() + for row in rows: + target_code = self._target_process_code(row) + if target_code: + target_keys.add((int(row["car_master_id"]), target_code)) + + target_equipment_by_key: dict[tuple[int, str], str] = {} + if target_keys: + car_ids = sorted({car_id for car_id, _ in target_keys}) + query = ( + select( + manufacturing_event_json.c.car_master_id, + manufacturing_event_json.c.process_code, + equipment.c.equipment_code, + manufacturing_event_json.c.id, + ) + .select_from( + manufacturing_event_json.join( + equipment, + equipment.c.id == manufacturing_event_json.c.equipment_id, + ), + ) + .where(manufacturing_event_json.c.car_master_id.in_(car_ids)) + .order_by( + manufacturing_event_json.c.car_master_id, + manufacturing_event_json.c.process_code, + manufacturing_event_json.c.id.desc(), + ) + ) + with self.event_engine.connect() as conn: + for event_row in conn.execute(query).mappings(): + key = ( + int(event_row["car_master_id"]), + str(event_row["process_code"]).strip().upper(), + ) + if key in target_keys and key not in target_equipment_by_key: + target_equipment_by_key[key] = str(event_row["equipment_code"]) + + for row in rows: + event_id = row.get("manufacturing_event_id") + row["source_equipment_code"] = ( + source_equipment_by_event.get(int(event_id)) + if event_id is not None + else None + ) + + car_id = int(row["car_master_id"]) + source_code = str(row.get("source_process_code") or "").strip().upper() + if not row["source_equipment_code"] and source_code: + row["source_equipment_code"] = equipment_code_for_car_process( + car_master_id=car_id, + process_code=source_code, + ) + + target_code = self._target_process_code(row) + if target_code: + row["target_equipment_code"] = target_equipment_by_key.get( + (car_id, target_code), + equipment_code_for_car_process( + car_master_id=car_id, + process_code=target_code, + ), + ) + else: + row["target_equipment_code"] = None + + @staticmethod + def _target_process_code(row: dict[str, Any]) -> str | None: + target_code = row.get("target_process_code") + if target_code: + return str(target_code).strip().upper() + source = str(row.get("source_process_code") or "").strip().upper() + return NEXT_PROCESS.get(source) + + def _attach_vehicle_ids(self, rows: list[dict[str, Any]]) -> None: + """manufacturing_event_id를 기반으로 vehicle_id를 붙인다.""" + if not rows: + return + from sqlalchemy import select + + car_ids = sorted({int(row["car_master_id"]) for row in rows}) + query = select(car_master.c.id, car_master.c.vehicle_id).where( + car_master.c.id.in_(car_ids), + ) + with self.event_engine.connect() as conn: + vehicle_by_id = { + int(row["id"]): str(row["vehicle_id"]) + for row in conn.execute(query).mappings() + } + for row in rows: + row["vehicle_id"] = vehicle_by_id.get( + int(row["car_master_id"]), + f"VIN-{int(row['car_master_id']):06d}", + ) + + def _init_sqlalchemy(self) -> None: + """예측 결과 저장소의 SQLAlchemy 테이블과 엔진을 준비한다.""" + try: + from sqlalchemy import BigInteger, Column, DateTime, Double, Enum, JSON + from sqlalchemy import Index, Integer, MetaData, String, Table, func + from sqlalchemy import create_engine + except ModuleNotFoundError as exc: + raise RuntimeError( + "SQLAlchemy and PyMySQL are required for defect transfer result storage.", + ) from exc + + self.metadata = MetaData() + process_code_enum = Enum("PRESS", "BODY", "PAINT", "ASSEMBLY") + self.table = Table( + "defect_transfer_prediction_result", + self.metadata, + Column("id", BigInteger, primary_key=True, autoincrement=True), + Column("manufacturing_event_id", BigInteger), + Column("car_master_id", BigInteger), + Column("source_process_code", process_code_enum), + Column("target_process_code", process_code_enum), + Column("current_defect_probability", Double), + Column("target_defect_probability", Double), + Column("predicted_defect_process", String(50)), + Column("expected_occurrence_step", Integer), + Column("risk_grade", String(20)), + Column("main_causes", JSON), + Column("influence_score", Double), + Column("predicted_at", DateTime, nullable=False), + Column("created_at", DateTime, nullable=False, server_default=func.current_timestamp()), + Column( + "updated_at", + DateTime, + nullable=False, + server_default=func.current_timestamp(), + server_onupdate=func.current_timestamp(), + ), + Index("idx_defect_transfer_car_predicted", "car_master_id", "predicted_at"), + Index("idx_defect_transfer_event", "manufacturing_event_id"), + ) + self.engine = create_engine( + self.database_url, + connect_args=mysql_connect_args_for_seoul(self.database_url), + pool_pre_ping=True, + future=True, + ) + self.event_engine = create_engine( + self.event_database_url, + connect_args=mysql_connect_args_for_seoul(self.event_database_url), + pool_pre_ping=True, + future=True, + ) + + def _align_result_schema(self) -> None: + """기존 결과 테이블과 현재 코드의 컬럼 구조를 맞춘다.""" + if self.engine.dialect.name != "mysql": + return + + from sqlalchemy import inspect, text + + table_name = "defect_transfer_prediction_result" + inspector = inspect(self.engine) + if not inspector.has_table(table_name): + return + + columns = {column["name"] for column in inspector.get_columns(table_name)} + expected_columns = { + "manufacturing_event_id": "BIGINT NULL", + "car_master_id": "BIGINT NULL", + "source_process_code": "ENUM('PRESS','BODY','PAINT','ASSEMBLY') NULL", + "target_process_code": "ENUM('PRESS','BODY','PAINT','ASSEMBLY') NULL", + "current_defect_probability": "DOUBLE NULL", + "target_defect_probability": "DOUBLE NULL", + "predicted_defect_process": "VARCHAR(50) NULL", + "expected_occurrence_step": "INT NULL", + "risk_grade": "VARCHAR(20) NULL", + "main_causes": "JSON NULL", + "influence_score": "DOUBLE NULL", + "predicted_at": "DATETIME NOT NULL", + "created_at": "DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP", + "updated_at": ( + "DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP " + "ON UPDATE CURRENT_TIMESTAMP" + ), + } + removed_columns = ("main_cause",) + with self.engine.begin() as conn: + for column_name in removed_columns: + if column_name not in columns: + continue + conn.execute( + text( + f"ALTER TABLE {table_name} " + f"DROP COLUMN {column_name}", + ), + ) + columns.remove(column_name) + + for column_name, definition in expected_columns.items(): + if column_name not in columns: + conn.execute( + text( + f"ALTER TABLE {table_name} " + f"ADD COLUMN {column_name} {definition}", + ), + ) + columns.add(column_name) + + conn.execute( + text( + f"ALTER TABLE {table_name} " + "MODIFY COLUMN id BIGINT NOT NULL AUTO_INCREMENT", + ), + ) + for column_name, definition in expected_columns.items(): + conn.execute( + text( + f"ALTER TABLE {table_name} " + f"MODIFY COLUMN {column_name} {definition}", + ), + ) + + @staticmethod + def _normalize_main_causes(causes: list[dict[str, Any]]) -> list[dict[str, Any]]: + """상위 원인 목록을 저장용 간단한 구조로 정리한다.""" + normalized: list[dict[str, Any]] = [] + for cause in causes[:5]: + message = str(cause.get("message") or cause.get("label") or "").strip() + if not message: + continue + try: + impact = float(cause.get("impact") or 0.0) + except (TypeError, ValueError): + impact = 0.0 + normalized.append( + { + "message": message, + "impact": impact, + }, + ) + + if normalized: + return normalized + + return [ + { + "message": "no main cause available", + "impact": 0.0, + }, + ] diff --git a/app/repository/equipment_repository.py b/app/repository/equipment_repository.py new file mode 100644 index 0000000..6cf9ffd --- /dev/null +++ b/app/repository/equipment_repository.py @@ -0,0 +1,79 @@ +from __future__ import annotations + +from typing import Any + +from sqlalchemy import func, select +from sqlalchemy.dialects.mysql import insert + +from app.repository.sampledb_schema import equipment + + +DEFAULT_EQUIPMENT_ROWS: list[dict[str, Any]] = [ + { + "process_code": process_code, + "equipment_code": f"EQ_{process_code}_{index:03d}", + "equipment_name": f"{equipment_name_prefix} {index}호", + "equipment_type": equipment_type, + "current_status": "RUNNING", + } + for process_code, equipment_type, equipment_name_prefix in ( + ("PRESS", "HYDRAULIC_PRESS", "프레스 유압모터"), + ("BODY", "ROBOT_ARM", "차체 용접 로봇"), + ("PAINT", "CAMERA", "도장 열화상 카메라"), + ("ASSEMBLY", "CONVEYOR", "의장 조립 컨베이어"), + ) + for index in range(1, 6) +] + + +class EquipmentRepository: + """equipment 마스터 데이터의 초기화와 조회를 담당한다.""" + + def __init__(self, engine: Any) -> None: + self.engine = engine + + def seed_defaults(self) -> None: + with self.engine.begin() as conn: + if self.engine.dialect.name == "mysql": + statement = insert(equipment).values(DEFAULT_EQUIPMENT_ROWS) + statement = statement.on_duplicate_key_update( + equipment_name=statement.inserted.equipment_name, + process_code=statement.inserted.process_code, + equipment_type=statement.inserted.equipment_type, + current_status=statement.inserted.current_status, + ) + conn.execute(statement) + return + + existing_codes = { + row["equipment_code"] + for row in conn.execute(select(equipment.c.equipment_code)).mappings() + } + rows = [ + row + for row in DEFAULT_EQUIPMENT_ROWS + if row["equipment_code"] not in existing_codes + ] + if rows: + next_id = int( + conn.execute(select(func.max(equipment.c.id))).scalar() or 0, + ) + rows = [ + {**row, "id": next_id + index} + for index, row in enumerate(rows, 1) + ] + conn.execute(equipment.insert(), rows) + + def get_map(self) -> dict[str, dict[str, Any]]: + query = select( + equipment.c.id, + equipment.c.process_code, + equipment.c.equipment_code, + equipment.c.equipment_name, + equipment.c.equipment_type, + ) + with self.engine.connect() as conn: + return { + row["equipment_code"]: dict(row) + for row in conn.execute(query).mappings() + } diff --git a/app/repository/manufacturing_event_repository.py b/app/repository/manufacturing_event_repository.py new file mode 100644 index 0000000..fbcf645 --- /dev/null +++ b/app/repository/manufacturing_event_repository.py @@ -0,0 +1,344 @@ +from __future__ import annotations + +import copy +import logging +import time +from collections.abc import Iterable +from datetime import date, datetime +from typing import Any + +from sqlalchemy import func, select +from sqlalchemy.exc import OperationalError + +from app.data_generation.manufacturing_event_json_builder import ( + initial_dispatch_status, + normalize_event_json, +) +from app.repository.sampledb_schema import manufacturing_event_json + + +logger = logging.getLogger(__name__) +MYSQL_LOCK_RETRY_ERROR_CODES = {1205, 1213} +MYSQL_LOCK_RETRY_DELAYS_SEC = (0.2, 0.5, 1.0, 2.0, 4.0) + + +class ManufacturingEventRepository: + """manufacturing_event_json 원천 이벤트의 저장과 조회를 담당한다.""" + + def __init__(self, engine: Any) -> None: + self.engine = engine + + def count_between(self, start_date: date, end_date: date) -> int: + event_date_key = func.substr(manufacturing_event_json.c.event_id, 5, 8) + query = select(func.count()).select_from(manufacturing_event_json).where( + event_date_key >= start_date.strftime("%Y%m%d"), + event_date_key <= end_date.strftime("%Y%m%d"), + ) + with self.engine.connect() as conn: + return int(conn.execute(query).scalar_one()) + + def insert_rows( + self, + rows: Iterable[dict[str, Any]], + *, + update_existing: bool = True, + ) -> int: + now = datetime.now() + payload = [] + for row in rows: + event_json = normalize_event_json(copy.deepcopy(row["event_json"])) + payload.append( + { + "event_id": row["event_id"], + "event_time": None, + "car_master_id": row["car_master_id"], + "process_code": row["process_code"], + "equipment_id": row["equipment_id"], + "event_json": event_json, + "dispatch_status": initial_dispatch_status( + str(row["process_code"]), + ), + "analysis_status": row.get("analysis_status", "NOT_ANALYZED"), + "bottleneck_analysis_done": _analysis_flag_value( + row.get("bottleneck_analysis_done", False), + ), + "defect_transfer_analysis_done": _analysis_flag_value( + row.get("defect_transfer_analysis_done", False), + ), + "is_sent": row.get("is_sent", False), + "retry_count": row.get("retry_count", 0), + "error_message": row.get("error_message"), + "updated_at": now, + }, + ) + if not payload: + return 0 + + # 동시 작업도 같은 event_id 순서로 행 잠금을 획득하도록 고정한다. + payload.sort(key=lambda row: str(row["event_id"])) + return self._insert_payload_with_retry( + payload, + update_existing=update_existing, + ) + + def insert_raw_rows( + self, + rows: Iterable[dict[str, Any]], + *, + update_existing: bool = True, + ) -> int: + now = datetime.now() + payload = [] + for row in rows: + event_json = normalize_event_json(copy.deepcopy(row["event_json"])) + payload.append( + { + "event_id": row["event_id"], + "event_time": row.get("event_time"), + "car_master_id": row["car_master_id"], + "process_code": row["process_code"], + "equipment_id": row["equipment_id"], + "event_json": event_json, + "dispatch_status": "SENT", + "bottleneck_analysis_done": _analysis_flag_value( + row.get("bottleneck_analysis_done", False), + ), + "defect_transfer_analysis_done": _analysis_flag_value( + row.get("defect_transfer_analysis_done", False), + ), + "is_sent": _is_true_flag(row.get("is_sent", True)), + "retry_count": row.get("retry_count", 0), + "error_message": row.get("error_message"), + "updated_at": now, + }, + ) + if not payload: + return 0 + + payload.sort(key=lambda row: str(row["event_id"])) + return self._insert_payload_with_retry( + payload, + update_existing=update_existing, + ) + + def _insert_payload_with_retry( + self, + payload: list[dict[str, Any]], + *, + update_existing: bool, + ) -> int: + attempts = len(MYSQL_LOCK_RETRY_DELAYS_SEC) + 1 + for attempt in range(attempts): + try: + return self._insert_payload_once( + payload, + update_existing=update_existing, + ) + except OperationalError as exc: + error_code = _mysql_error_code(exc) + can_retry = ( + self.engine.dialect.name == "mysql" + and error_code in MYSQL_LOCK_RETRY_ERROR_CODES + and attempt < attempts - 1 + ) + if not can_retry: + raise + + delay = MYSQL_LOCK_RETRY_DELAYS_SEC[attempt] + logger.warning( + "manufacturing_event_json chunk 저장 잠금 충돌 재시도: " + "error_code=%s attempt=%s/%s delay=%.1fs", + error_code, + attempt + 1, + attempts - 1, + delay, + ) + time.sleep(delay) + + raise RuntimeError("manufacturing_event_json chunk 저장 재시도에 실패했습니다.") + + def _insert_payload_once( + self, + payload: list[dict[str, Any]], + *, + update_existing: bool, + ) -> int: + with self.engine.begin() as conn: + event_ids = [row["event_id"] for row in payload] + existing_ids = { + row["event_id"] + for row in conn.execute( + select(manufacturing_event_json.c.event_id).where( + manufacturing_event_json.c.event_id.in_(event_ids), + ), + ).mappings() + } + existing_rows = { + row["event_id"]: row + for row in conn.execute( + select(manufacturing_event_json).where( + manufacturing_event_json.c.event_id.in_(event_ids), + ), + ).mappings() + } + + updated_rows = 0 + if update_existing: + for row in payload: + if row["event_id"] not in existing_ids: + continue + existing_row = existing_rows.get(row["event_id"]) + if existing_row is not None: + row = { + **row, + "analysis_status": existing_row.get( + "analysis_status", + row.get("analysis_status"), + ), + "bottleneck_analysis_done": existing_row.get( + "bottleneck_analysis_done", + row.get("bottleneck_analysis_done"), + ), + "defect_transfer_analysis_done": existing_row.get( + "defect_transfer_analysis_done", + row.get("defect_transfer_analysis_done"), + ), + } + result = conn.execute( + manufacturing_event_json.update() + .where( + manufacturing_event_json.c.event_id + == row["event_id"], + ) + .values(**row), + ) + updated_rows += int(result.rowcount or 0) + + new_rows = [ + row for row in payload if row["event_id"] not in existing_ids + ] + if new_rows and self.engine.dialect.name != "mysql": + next_id = int( + conn.execute( + select(func.max(manufacturing_event_json.c.id)), + ).scalar() + or 0, + ) + new_rows = [ + {**row, "id": next_id + index} + for index, row in enumerate(new_rows, 1) + ] + if new_rows: + conn.execute(manufacturing_event_json.insert(), new_rows) + return len(new_rows) + updated_rows + + def list_rows( + self, + *, + limit: int, + offset: int = 0, + start_date: date | None = None, + end_date: date | None = None, + process_code: str | None = None, + is_sent: bool | None = None, + ) -> list[dict[str, Any]]: + query = select(manufacturing_event_json) + event_date_key = func.substr(manufacturing_event_json.c.event_id, 5, 8) + if start_date: + query = query.where( + event_date_key >= start_date.strftime("%Y%m%d"), + ) + if end_date: + query = query.where( + event_date_key <= end_date.strftime("%Y%m%d"), + ) + if process_code: + query = query.where( + manufacturing_event_json.c.process_code == process_code, + ) + if is_sent is not None: + query = query.where(manufacturing_event_json.c.is_sent == is_sent) + + query = query.order_by( + manufacturing_event_json.c.event_id.asc(), + manufacturing_event_json.c.id.asc(), + ).offset(offset).limit(limit) + + with self.engine.connect() as conn: + return [dict(row) for row in conn.execute(query).mappings()] + + def get_analysis_flags(self, event_id: str) -> dict[str, bool] | None: + query = select( + manufacturing_event_json.c.event_id, + manufacturing_event_json.c.bottleneck_analysis_done, + manufacturing_event_json.c.defect_transfer_analysis_done, + ).where(manufacturing_event_json.c.event_id == event_id) + with self.engine.connect() as conn: + row = conn.execute(query).mappings().first() + if row is None: + return None + return { + "bottleneck_analysis_done": _is_true_flag( + row["bottleneck_analysis_done"], + ), + "defect_transfer_analysis_done": _is_true_flag( + row["defect_transfer_analysis_done"], + ), + } + + def is_bottleneck_analysis_done(self, event_id: str) -> bool: + query = select(manufacturing_event_json.c.bottleneck_analysis_done).where( + manufacturing_event_json.c.event_id == event_id, + ) + with self.engine.connect() as conn: + row = conn.execute(query).mappings().first() + return False if row is None else _is_true_flag(row["bottleneck_analysis_done"]) + + def is_defect_transfer_analysis_done(self, event_id: str) -> bool: + query = select(manufacturing_event_json.c.defect_transfer_analysis_done).where( + manufacturing_event_json.c.event_id == event_id, + ) + with self.engine.connect() as conn: + row = conn.execute(query).mappings().first() + return False if row is None else _is_true_flag(row["defect_transfer_analysis_done"]) + + def mark_bottleneck_analysis_done(self, event_id: str) -> int: + return self._mark_analysis_done( + event_id, + bottleneck_analysis_done=True, + ) + + def mark_defect_transfer_analysis_done(self, event_id: str) -> int: + return self._mark_analysis_done( + event_id, + defect_transfer_analysis_done=True, + ) + + def _mark_analysis_done(self, event_id: str, **values: Any) -> int: + from sqlalchemy import func + + with self.engine.begin() as conn: + result = conn.execute( + manufacturing_event_json.update() + .where(manufacturing_event_json.c.event_id == event_id) + .values(**values, updated_at=func.current_timestamp()), + ) + return int(result.rowcount or 0) + + +def _analysis_flag_value(value: Any) -> bool: + return _is_true_flag(value) + + +def _is_true_flag(value: Any) -> bool: + if isinstance(value, bool): + return value + if value is None: + return False + return str(value).strip().lower() == "true" + + +def _mysql_error_code(exc: OperationalError) -> int | None: + original = getattr(exc, "orig", None) + args = getattr(original, "args", ()) + return args[0] if args and isinstance(args[0], int) else None diff --git a/app/repository/manufacturing_event_template_repository.py b/app/repository/manufacturing_event_template_repository.py new file mode 100644 index 0000000..f660d99 --- /dev/null +++ b/app/repository/manufacturing_event_template_repository.py @@ -0,0 +1,119 @@ +from __future__ import annotations + +from collections.abc import Iterable +from typing import Any + +from sqlalchemy import func, select +from sqlalchemy.dialects.mysql import insert + +from app.repository.sampledb_schema import manufacturing_event_template + + +class ManufacturingEventTemplateRepository: + """manufacturing_event_template의 저장·조회·삭제를 담당한다.""" + + def __init__(self, engine: Any) -> None: + self.engine = engine + + def count(self, template_name: str) -> int: + query = select(func.count()).select_from( + manufacturing_event_template, + ).where( + manufacturing_event_template.c.template_name == template_name, + ) + with self.engine.connect() as conn: + return int(conn.execute(query).scalar_one()) + + def delete(self, template_name: str) -> int: + statement = manufacturing_event_template.delete().where( + manufacturing_event_template.c.template_name == template_name, + ) + with self.engine.begin() as conn: + result = conn.execute(statement) + return int(result.rowcount or 0) + + def insert_rows( + self, + rows: Iterable[dict[str, Any]], + *, + update_existing: bool = False, + ) -> int: + payload = list(rows) + if not payload: + return 0 + + with self.engine.begin() as conn: + if self.engine.dialect.name == "mysql": + statement = insert(manufacturing_event_template).values(payload) + if update_existing: + statement = statement.on_duplicate_key_update( + event_offset_us=statement.inserted.event_offset_us, + car_master_id=statement.inserted.car_master_id, + equipment_id=statement.inserted.equipment_id, + process_code=statement.inserted.process_code, + station_code=statement.inserted.station_code, + equipment_code=statement.inserted.equipment_code, + equipment_type=statement.inserted.equipment_type, + equipment_status=statement.inserted.equipment_status, + event_type=statement.inserted.event_type, + event_json=statement.inserted.event_json, + ) + else: + statement = statement.prefix_with("IGNORE") + result = conn.execute(statement) + return int(result.rowcount or 0) + + template_event_ids = [row["template_event_id"] for row in payload] + existing_ids = { + row["template_event_id"] + for row in conn.execute( + select( + manufacturing_event_template.c.template_event_id, + ).where( + manufacturing_event_template.c.template_event_id.in_( + template_event_ids, + ), + ), + ).mappings() + } + new_rows = [ + row + for row in payload + if row["template_event_id"] not in existing_ids + ] + if new_rows: + next_id = int( + conn.execute( + select(func.max(manufacturing_event_template.c.id)), + ).scalar() + or 0, + ) + new_rows = [ + {**row, "id": next_id + index} + for index, row in enumerate(new_rows, 1) + ] + conn.execute(manufacturing_event_template.insert(), new_rows) + return len(new_rows) + + def list_rows( + self, + *, + template_name: str, + limit: int, + offset: int = 0, + process_code: str | None = None, + ) -> list[dict[str, Any]]: + query = select(manufacturing_event_template).where( + manufacturing_event_template.c.template_name == template_name, + ) + if process_code: + query = query.where( + manufacturing_event_template.c.process_code == process_code, + ) + query = query.order_by( + manufacturing_event_template.c.event_offset_us.asc(), + manufacturing_event_template.c.id.asc(), + ).offset(offset).limit(limit) + + with self.engine.connect() as conn: + return [dict(row) for row in conn.execute(query).mappings()] diff --git a/app/repository/manufacturing_generation_job_repository.py b/app/repository/manufacturing_generation_job_repository.py new file mode 100644 index 0000000..2760f86 --- /dev/null +++ b/app/repository/manufacturing_generation_job_repository.py @@ -0,0 +1,189 @@ +from __future__ import annotations + +from contextlib import contextmanager +from datetime import datetime +from typing import Any, Iterator + +from sqlalchemy import func, select, text + +from app.repository.sampledb_schema import manufacturing_event_generation_job + + +MANUFACTURING_GENERATION_LOCK_NAME = "manufacturing_event_generation" + + +class ManufacturingGenerationJobRepository: + """제조 이벤트 비동기 job의 상태와 전역 실행 잠금을 관리한다.""" + + def __init__(self, engine: Any) -> None: + self.engine = engine + + @contextmanager + def execution_lock(self, timeout_seconds: int = 600) -> Iterator[bool]: + if self.engine.dialect.name != "mysql": + yield True + return + + with self.engine.connect() as conn: + acquired = ( + conn.execute( + text("SELECT GET_LOCK(:lock_name, :timeout_seconds)"), + { + "lock_name": MANUFACTURING_GENERATION_LOCK_NAME, + "timeout_seconds": timeout_seconds, + }, + ).scalar() + == 1 + ) + try: + yield acquired + finally: + if acquired: + conn.execute( + text("SELECT RELEASE_LOCK(:lock_name)"), + {"lock_name": MANUFACTURING_GENERATION_LOCK_NAME}, + ) + + def create( + self, + *, + job_id: str, + job_type: str, + request_json: dict[str, Any], + total_expected_events: int = 0, + ) -> dict[str, Any]: + now = datetime.now() + row = { + "job_id": job_id, + "job_type": job_type, + "status": "PENDING", + "request_json": request_json, + "total_expected_events": total_expected_events, + "generated_count": 0, + "affected_rows": 0, + "created_at": now, + "updated_at": now, + } + with self.engine.begin() as conn: + if self.engine.dialect.name != "mysql": + next_id = int( + conn.execute( + select(func.max(manufacturing_event_generation_job.c.id)), + ).scalar() + or 0, + ) + row = {**row, "id": next_id + 1} + conn.execute(manufacturing_event_generation_job.insert(), row) + return self.get(job_id) or {} + + def get(self, job_id: str) -> dict[str, Any] | None: + query = select(manufacturing_event_generation_job).where( + manufacturing_event_generation_job.c.job_id == job_id, + ) + with self.engine.connect() as conn: + row = conn.execute(query).mappings().first() + return _format_job_row(dict(row)) if row else None + + def list_resumable(self) -> list[dict[str, Any]]: + query = ( + select(manufacturing_event_generation_job) + .where( + manufacturing_event_generation_job.c.status.in_( + ["PENDING", "RUNNING"], + ), + ) + .order_by( + manufacturing_event_generation_job.c.created_at.asc(), + manufacturing_event_generation_job.c.id.asc(), + ) + ) + with self.engine.connect() as conn: + return [ + _format_job_row(dict(row)) + for row in conn.execute(query).mappings() + ] + + def mark_running(self, job_id: str) -> None: + now = datetime.now() + self._update( + job_id, + status="RUNNING", + started_at=now, + updated_at=now, + ) + + def update_progress( + self, + job_id: str, + progress: dict[str, Any], + ) -> None: + self._update( + job_id, + generated_count=int(progress.get("generatedCount", 0)), + affected_rows=int(progress.get("affectedRows", 0)), + total_expected_events=int(progress.get("totalExpectedEvents", 0)), + updated_at=datetime.now(), + ) + + def mark_succeeded( + self, + job_id: str, + result_json: dict[str, Any], + ) -> None: + now = datetime.now() + self._update( + job_id, + status="SUCCEEDED", + result_json=result_json, + error_message=None, + generated_count=int(result_json.get("generatedCount", 0)), + affected_rows=int(result_json.get("affectedRows", 0)), + total_expected_events=int( + result_json.get( + "totalExpectedEvents", + result_json.get( + "templateEventCount", + result_json.get("eventCount", 0), + ), + ), + ), + finished_at=now, + updated_at=now, + ) + + def mark_failed(self, job_id: str, error_message: str) -> None: + now = datetime.now() + self._update( + job_id, + status="FAILED", + error_message=error_message[:1000], + finished_at=now, + updated_at=now, + ) + + def _update(self, job_id: str, **values: Any) -> None: + statement = ( + manufacturing_event_generation_job.update() + .where(manufacturing_event_generation_job.c.job_id == job_id) + .values(**values) + ) + with self.engine.begin() as conn: + conn.execute(statement) + + +def _format_job_row(row: dict[str, Any]) -> dict[str, Any]: + return { + "jobId": row["job_id"], + "jobType": row["job_type"], + "status": row["status"], + "request": row["request_json"], + "result": row["result_json"], + "errorMessage": row["error_message"], + "totalExpectedEvents": int(row["total_expected_events"] or 0), + "generatedCount": int(row["generated_count"] or 0), + "affectedRows": int(row["affected_rows"] or 0), + "createdAt": row["created_at"], + "startedAt": row["started_at"], + "finishedAt": row["finished_at"], + "updatedAt": row["updated_at"], + } diff --git a/app/repository/quality_drive_detail_repository.py b/app/repository/quality_drive_detail_repository.py new file mode 100644 index 0000000..93b4630 --- /dev/null +++ b/app/repository/quality_drive_detail_repository.py @@ -0,0 +1,147 @@ +from sqlalchemy import text +import pandas as pd + +from app.db import main_engine +from app.kafka.consumer import create_consumer +from app.kafka.topics import QUALITY_INSPECTION_DRIVE_DETAIL +from app.kafka.options import DRIVE_DETAIL_GROUP + + +def calculate_drive_score(row): + score = 100 + + if float(row["throttle_position"]) > 90: + score -= 20 + + if float(row["brake_pressure"]) > 45: + score -= 20 + + if abs(float(row["steering_angle"])) > 40: + score -= 20 + + return round(score, 2) + + +def get_driving_pattern(row): + throttle = float(row["throttle_position"]) + brake = float(row["brake_pressure"]) + steering = abs(float(row["steering_angle"])) + + if throttle > 75: + return "RAPID_ACCEL" + + if brake > 35: + return "HARD_BRAKE" + + if steering > 40: + return "SHARP_TURN" + + return "NORMAL" + + +def run(stop_event): + + consumer = create_consumer( + topic=QUALITY_INSPECTION_DRIVE_DETAIL, + group_id=DRIVE_DETAIL_GROUP + ) + + detail_id = 1 + + try: + + while not stop_event.is_set(): + + # 1초마다 종료 신호 확인 + records = consumer.poll(timeout_ms=1000) + + if not records: + continue + + for _, messages in records.items(): + + for msg in messages: + + row = msg.value + + if not row.get("created_at"): + print( + f"폐기 차량 제외 : " + f"{row.get('vehicle_id')}" + ) + continue + + vehicle_id = row["vehicle_id"] + + exists = pd.read_sql( + text(""" + SELECT COUNT(*) AS cnt + FROM inspection_drive_detail + WHERE vehicle_id = :vehicle_id + """), + con=main_engine, + params={ + "vehicle_id": vehicle_id + } + ) + + if exists.iloc[0]["cnt"] > 0: + print(f"{vehicle_id} 이미 저장됨") + continue + + car_code = vehicle_id.split("-")[0] + + inspection_no = ( + f"DRIVE-{detail_id:05d}" + ) + + drive_score = calculate_drive_score(row) + driving_pattern = get_driving_pattern(row) + + if drive_score >= 80: + inspection_result = "NORMAL" + issue_message = "NORMAL" + else: + inspection_result = "WARNING" + issue_message = "ACCEL_ALERT" + + df = pd.DataFrame([{ + "car_code": car_code, + "inspection_no": inspection_no, + "vehicle_id": vehicle_id, + + "throttle_position": + round(float(row["throttle_position"]), 2), + + "brake_pressure": + round(float(row["brake_pressure"]), 2), + + "steering_angle": + round(float(row["steering_angle"]), 2), + + "drive_score": drive_score, + "inspection_result": inspection_result, + "driving_pattern": driving_pattern, + "issue_message": issue_message, + "created_at": row["created_at"] + }]) + + df.to_sql( + name="inspection_drive_detail", + con=main_engine, + if_exists="append", + index=False + ) + + detail_id += 1 + + except Exception as e: + print(f"오류 발생 : {e}") + + finally: + consumer.close() + + +if __name__ == "__main__": + import threading + run(threading.Event()) \ No newline at end of file diff --git a/app/repository/quality_process_repository.py b/app/repository/quality_process_repository.py new file mode 100644 index 0000000..1db3ef0 --- /dev/null +++ b/app/repository/quality_process_repository.py @@ -0,0 +1,121 @@ +from sqlalchemy import text +import pandas as pd + +from app.db import main_engine +from app.kafka.consumer import create_consumer +from app.kafka.topics import QUALITY_INSPECTION_PROCESS +from app.kafka.options import PROCESS_GROUP + + +def run(stop_event): + + consumer = create_consumer( + topic=QUALITY_INSPECTION_PROCESS, + group_id=PROCESS_GROUP + ) + + try: + + while not stop_event.is_set(): + + # 1초마다 종료 여부 확인 + records = consumer.poll(timeout_ms=1000) + + if not records: + continue + + for _, messages in records.items(): + + for msg in messages: + + row = msg.value + + if "process_name" not in row: + print("구버전 메시지 무시") + continue + + total_vehicle_count = row["total_vehicle_count"] + process_name = row["process_name"] + completed_count = row["completed_count"] + waiting_count = row["waiting_count"] + progress_rate = row["progress_rate"] + created_at = row["created_at"] + + # 같은 날짜 + 같은 공정 존재 여부 확인 + exists = pd.read_sql( + text(""" + SELECT COUNT(*) AS cnt + FROM inspection_process + WHERE process_name = :process_name + AND DATE(created_at) = DATE(:created_at) + """), + con=main_engine, + params={ + "process_name": process_name, + "created_at": created_at + } + ) + + if exists.iloc[0]["cnt"] > 0: + + # UPDATE + with main_engine.begin() as conn: + + conn.execute( + text(""" + UPDATE inspection_process + SET + completed_count = :completed_count, + waiting_count = :waiting_count, + progress_rate = :progress_rate, + process_status = :process_status + WHERE process_name = :process_name + AND DATE(created_at) = DATE(:created_at) + """), + { + "completed_count": completed_count, + "waiting_count": waiting_count, + "progress_rate": progress_rate, + "process_status": + "COMPLETE" + if progress_rate == 100 + else "RUNNING", + "process_name": process_name, + "created_at": created_at + } + ) + + else: + + # INSERT + df = pd.DataFrame([{ + "process_name": process_name, + "total_vehicle_count": total_vehicle_count, + "completed_count": completed_count, + "waiting_count": waiting_count, + "progress_rate": progress_rate, + "process_status": + "COMPLETE" + if progress_rate == 100 + else "RUNNING", + "created_at": created_at + }]) + + df.to_sql( + name="inspection_process", + con=main_engine, + if_exists="append", + index=False + ) + + except Exception as e: + print(f"오류 발생 : {e}") + + finally: + print("process 종료") + consumer.close() + + +if __name__ == "__main__": + import threading + run(threading.Event()) \ No newline at end of file diff --git a/app/repository/quality_risk_history_repository.py b/app/repository/quality_risk_history_repository.py new file mode 100644 index 0000000..831c22f --- /dev/null +++ b/app/repository/quality_risk_history_repository.py @@ -0,0 +1,124 @@ +from sqlalchemy import text +import pandas as pd + +from app.db import main_engine +from app.kafka.consumer import create_consumer +from app.kafka.topics import QUALITY_INSPECTION_RISK_HISTORY +from app.kafka.options import RISK_HISTORY_GROUP + + +def run(stop_event): + + consumer = create_consumer( + topic=QUALITY_INSPECTION_RISK_HISTORY, + group_id=RISK_HISTORY_GROUP + ) + + try: + + while not stop_event.is_set(): + + # 1초마다 종료 여부 확인 + records = consumer.poll(timeout_ms=1000) + + if not records: + continue + + for _, messages in records.items(): + + for msg in messages: + + row = msg.value + + # Producer에서 전달되는 값 + inspection_type = row["inspection_type"] + inspection_date = row["inspection_date"] + risk_score = row["risk_score"] + + # Repository에서 생성 + start_time = f"{inspection_date} 00:00:00" + end_time = f"{inspection_date} 23:59:59" + + # 같은 날짜 + 같은 검사 타입 존재 여부 확인 + exists = pd.read_sql( + text(""" + SELECT COUNT(*) AS cnt + FROM inspection_risk_history + WHERE inspection_type = :inspection_type + AND DATE(start_time) = DATE(:start_time) + """), + con=main_engine, + params={ + "inspection_type": inspection_type, + "start_time": start_time + } + ) + + # 이미 존재하면 UPDATE + if exists.iloc[0]["cnt"] > 0: + + with main_engine.begin() as conn: + + conn.execute( + text(""" + UPDATE inspection_risk_history + SET + risk_score = :risk_score, + end_time = :end_time + WHERE inspection_type = :inspection_type + AND DATE(start_time) = DATE(:start_time) + """), + { + "risk_score": risk_score, + "end_time": end_time, + "inspection_type": inspection_type, + "start_time": start_time + } + ) + + else: + + # inspection_round 자동 생성 + with main_engine.begin() as conn: + + inspection_round = conn.execute( + text(""" + SELECT COALESCE(MAX(inspection_round), 0) + 1 + FROM inspection_risk_history + WHERE inspection_type = :inspection_type + """), + { + "inspection_type": inspection_type + } + ).scalar() + + df = pd.DataFrame([{ + "inspection_type": inspection_type, + "inspection_round": inspection_round, + "risk_score": risk_score, + "start_time": start_time, + "end_time": end_time + }]) + + df.to_sql( + name="inspection_risk_history", + con=main_engine, + if_exists="append", + index=False + ) + + except Exception as e: + + print(f"오류 발생 : {e}") + + finally: + + print("risk-history 종료") + consumer.close() + + +if __name__ == "__main__": + + import threading + + run(threading.Event()) \ No newline at end of file diff --git a/app/repository/quality_risk_trend_repository.py b/app/repository/quality_risk_trend_repository.py new file mode 100644 index 0000000..16fc11a --- /dev/null +++ b/app/repository/quality_risk_trend_repository.py @@ -0,0 +1,90 @@ +from sqlalchemy import text +import pandas as pd + +from app.db import main_engine +from app.kafka.consumer import create_consumer +from app.kafka.topics import QUALITY_INSPECTION_RISK_TREND +from app.kafka.options import RISK_TREND_GROUP + + +def run(stop_event): + + consumer = create_consumer( + topic=QUALITY_INSPECTION_RISK_TREND, + group_id=RISK_TREND_GROUP + ) + + try: + + while not stop_event.is_set(): + + # 1초마다 종료 여부 확인 + records = consumer.poll(timeout_ms=1000) + + if not records: + continue + + for _, messages in records.items(): + + for msg in messages: + + row = msg.value + + exists = pd.read_sql( + text(""" + SELECT COUNT(*) AS cnt + FROM inspection_risk_trend + WHERE risk_level = :risk_level + AND DATE(created_at) = DATE(:created_at) + """), + con=main_engine, + params={ + "risk_level": row["risk_level"], + "created_at": row["created_at"] + } + ) + + if exists.iloc[0]["cnt"] > 0: + + with main_engine.begin() as conn: + + conn.execute( + text(""" + UPDATE inspection_risk_trend + SET + risk_count = :risk_count, + risk_ratio = :risk_ratio + WHERE + risk_level = :risk_level + AND DATE(created_at) + = DATE(:created_at) + """), + row + ) + + else: + + df = pd.DataFrame([row]) + + df.to_sql( + name="inspection_risk_trend", + con=main_engine, + if_exists="append", + index=False + ) + + except Exception as e: + + print(f"오류 발생 : {e}") + + finally: + + print("risk-trend 종료") + consumer.close() + + +if __name__ == "__main__": + + import threading + + run(threading.Event()) \ No newline at end of file diff --git a/app/repository/quality_status_detail_repository.py b/app/repository/quality_status_detail_repository.py new file mode 100644 index 0000000..3b78df2 --- /dev/null +++ b/app/repository/quality_status_detail_repository.py @@ -0,0 +1,115 @@ +from sqlalchemy import text +import pandas as pd + +from app.db import main_engine +from app.kafka.consumer import create_consumer +from app.kafka.topics import QUALITY_INSPECTION_STATUS_DETAIL +from app.kafka.options import STATUS_DETAIL_GROUP + + +def run(stop_event): + + consumer = create_consumer( + topic=QUALITY_INSPECTION_STATUS_DETAIL, + group_id=STATUS_DETAIL_GROUP + ) + + try: + + while not stop_event.is_set(): + + # 1초마다 종료 여부 확인 + records = consumer.poll(timeout_ms=1000) + + if not records: + continue + + for _, messages in records.items(): + + for msg in messages: + + row = msg.value + + vehicle_id = row["vehicle_id"] + + # 이미 저장된 차량인지 확인 + exists = pd.read_sql( + text(""" + SELECT COUNT(*) AS cnt + FROM inspection_status_detail + WHERE vehicle_id = :vehicle_id + """), + con=main_engine, + params={ + "vehicle_id": vehicle_id + } + ) + + if exists.iloc[0]["cnt"] > 0: + continue + + inspection_status_detail = [{ + "car_code": + row["car_code"], + + "inspection_no": + row["inspection_no"], + + "vehicle_id": + vehicle_id, + + "speed": + row["speed"], + + "att": + row["att"], + + "gear": + row["gear"], + + "battery_voltage": + row["battery_voltage"], + + "fuel_rate": + row["fuel_rate"], + + "status_score": + row["status_score"], + + "inspection_result": + row["inspection_result"], + + "issue_message": + row["issue_message"], + + "created_at": + row["created_at"] + }] + + df = pd.DataFrame( + inspection_status_detail + ) + + df.to_sql( + name="inspection_status_detail", + con=main_engine, + if_exists="append", + index=False + ) + + except Exception as e: + + print(f"오류 발생 : {e}") + + finally: + + print("status-detail Consumer 종료") + + consumer.close() + + +if __name__ == "__main__": + + import threading + + run(threading.Event()) \ No newline at end of file diff --git a/app/repository/quality_summary_repository.py b/app/repository/quality_summary_repository.py new file mode 100644 index 0000000..03c36b1 --- /dev/null +++ b/app/repository/quality_summary_repository.py @@ -0,0 +1,169 @@ +from sqlalchemy import text +import time + +from app.db import main_engine + + +def run(stop_event): + + last_total_count = -1 + + try: + + while not stop_event.is_set(): + + with main_engine.begin() as conn: + + result = conn.execute( + text(""" + SELECT + COUNT(*) AS total_count, + + SUM( + CASE + WHEN UPPER(inspection_result) = 'NORMAL' + THEN 1 + ELSE 0 + END + ) AS normal_count, + + SUM( + CASE + WHEN UPPER(inspection_result) = 'WARNING' + THEN 1 + ELSE 0 + END + ) AS abnormal_count, + + MAX(created_at) AS created_at + + FROM inspection_drive_detail + + WHERE DATE(created_at) = ( + SELECT DATE(MAX(created_at)) + FROM inspection_drive_detail + ) + """) + ).mappings().first() + + total_count = result["total_count"] or 0 + + # 데이터 변화가 없으면 건너뜀 + if total_count == last_total_count: + time.sleep(1) + continue + + normal_count = result["normal_count"] or 0 + abnormal_count = result["abnormal_count"] or 0 + + standby_count = max(0, 100 - total_count) + + if total_count == 0: + + normal_rate = 0 + abnormal_rate = 0 + + else: + + normal_rate = round( + normal_count / total_count * 100, + 2 + ) + + abnormal_rate = round( + abnormal_count / total_count * 100, + 2 + ) + + created_at = result["created_at"] + + # inspection_summary가 비어있는지 확인 + exists = conn.execute( + text(""" + SELECT COUNT(*) + FROM inspection_summary + """) + ).scalar() + + if exists == 0: + + conn.execute( + text(""" + INSERT INTO inspection_summary + ( + total_count, + normal_count, + normal_rate, + abnormal_count, + abnormal_rate, + standby_count, + created_at, + updated_at + ) + VALUES + ( + :total_count, + :normal_count, + :normal_rate, + :abnormal_count, + :abnormal_rate, + :standby_count, + :created_at, + NOW() + ) + """), + { + "total_count": total_count, + "normal_count": normal_count, + "normal_rate": normal_rate, + "abnormal_count": abnormal_count, + "abnormal_rate": abnormal_rate, + "standby_count": standby_count, + "created_at": created_at + } + ) + + else: + + conn.execute( + text(""" + UPDATE inspection_summary + SET + total_count = :total_count, + normal_count = :normal_count, + normal_rate = :normal_rate, + abnormal_count = :abnormal_count, + abnormal_rate = :abnormal_rate, + standby_count = :standby_count, + created_at = :created_at, + updated_at = NOW() + """), + { + "total_count": total_count, + "normal_count": normal_count, + "normal_rate": normal_rate, + "abnormal_count": abnormal_count, + "abnormal_rate": abnormal_rate, + "standby_count": standby_count, + "created_at": created_at + } + ) + + last_total_count = total_count + + # stop_event를 고려하여 1초 대기 + stop_event.wait(1) + + except Exception as e: + + print(f"Summary Aggregator 오류 발생 : {e}") + + finally: + + print("summary 종료") + + +if __name__ == "__main__": + import threading + + run(threading.Event()) \ No newline at end of file diff --git a/app/repository/sampledb_repository.py b/app/repository/sampledb_repository.py index 2b12170..bc1ee51 100644 --- a/app/repository/sampledb_repository.py +++ b/app/repository/sampledb_repository.py @@ -1,66 +1,49 @@ -from typing import Any +from __future__ import annotations from sqlalchemy import create_engine -from sqlalchemy.dialects.mysql import insert -from app.repository.sampledb_schema import equipment, metadata +from app.repository.car_master_repository import CarMasterRepository +from app.repository.equipment_repository import EquipmentRepository +from app.repository.manufacturing_event_repository import ( + ManufacturingEventRepository, +) +from app.repository.manufacturing_event_template_repository import ( + ManufacturingEventTemplateRepository, +) +from app.repository.manufacturing_generation_job_repository import ( + ManufacturingGenerationJobRepository, +) +from app.repository.sampledb_schema_manager import SampleDbSchemaManager from app.utils.database_utils import mysql_connect_args_for_seoul -DEFAULT_EQUIPMENT_ROWS: list[dict[str, Any]] = [ - { - "process_code": process_code, - "equipment_code": f"EQ_{process_code}_{index:03d}", - "equipment_name": f"{process_code.title()} equipment {index}", - "equipment_type": equipment_type, - "status": "NORMAL", - } - for process_code, equipment_type in ( - ("PRESS", "HYDRAULIC_PRESS"), - ("BODY", "ROBOT_ARM"), - ("PAINT", "CAMERA"), - ("ASSEMBLY", "CONVEYOR"), - ) - for index in range(1, 6) -] - - class SampleDbRepository: - """제조 샘플 PRD에 정의된 sampledb 테이블을 생성하고 기본 데이터를 입력""" + """sampledb 전용 repository들을 같은 DB 연결로 묶는 facade다. + + 테이블별 SQL과 상태 관리 책임은 각 repository에 있고, 이 클래스는 서비스가 + 한 객체를 주입받아 사용할 수 있도록 구성 요소만 제공한다. + """ def __init__(self, database_url: str) -> None: - """sampledb 연결에 사용할 SQLAlchemy 엔진을 생성.""" + self.database_url = database_url self.engine = create_engine( database_url, connect_args=mysql_connect_args_for_seoul(database_url), pool_pre_ping=True, future=True, ) - - def ensure_schema(self) -> None: - """sampledb 엔티티가 없으면 생성""" - metadata.create_all(self.engine) - - def seed_equipment(self) -> None: - """기본 설비 데이터를 입력하고 기존 데이터는 유지""" - statement = insert(equipment).values(DEFAULT_EQUIPMENT_ROWS) - update_columns = { - "equipment_name": statement.inserted.equipment_name, - "process_code": statement.inserted.process_code, - "equipment_type": statement.inserted.equipment_type, - "status": statement.inserted.status, - } - statement = statement.on_duplicate_key_update(**update_columns) - - with self.engine.begin() as conn: - conn.execute(statement) + self.schema = SampleDbSchemaManager(self.engine) + self.cars = CarMasterRepository(self.engine) + self.equipment = EquipmentRepository(self.engine) + self.events = ManufacturingEventRepository(self.engine) + self.templates = ManufacturingEventTemplateRepository(self.engine) + self.jobs = ManufacturingGenerationJobRepository(self.engine) def initialize(self) -> None: - """스키마를 생성하고 PRD에 필요한 참조 데이터를 입력""" - self.ensure_schema() - self.seed_equipment() + self.schema.ensure_schema() + self.equipment.seed_defaults() def initialize_sampledb(database_url: str) -> None: - """sampledb 테이블과 참조 설비 데이터를 초기화""" + """sampledb 스키마와 기본 설비 데이터를 초기화한다.""" SampleDbRepository(database_url).initialize() diff --git a/app/repository/sampledb_schema.py b/app/repository/sampledb_schema.py index 9027645..86324ad 100644 --- a/app/repository/sampledb_schema.py +++ b/app/repository/sampledb_schema.py @@ -3,28 +3,38 @@ Boolean, Column, DateTime, - Double, Enum, - Float, ForeignKey, Index, Integer, + JSON, MetaData, String, Table, + Text, UniqueConstraint, func, ) metadata = MetaData() +# 제조 이벤트 흐름에서 공통으로 사용하는 PRD 상태 코드. process_code_enum = Enum("PRESS", "BODY", "PAINT", "ASSEMBLY") equipment_type_enum = Enum("HYDRAULIC_PRESS", "ROBOT_ARM", "CAMERA", "CONVEYOR") -equipment_status_enum = Enum("NORMAL", "WARNING", "FAULT", "MAINTENANCE") -source_type_enum = Enum("BOSCH", "FORD", "PRESS_CURRENT", "ROBOT_CURRENT", "THERMAL_VISION") -data_type_enum = Enum("PROCESS", "SENSOR", "QUALITY", "THERMAL") -quality_result_enum = Enum("NORMAL", "DEFECT") -expected_label_enum = Enum("NORMAL", "WARNING", "FAULT", "DEFECT") +equipment_current_status_enum = Enum( + "RUNNING", + "IDLE", + "STOPPED", + "FAULT", + "MAINTENANCE", +) +dispatch_status_enum = Enum( + "PENDING", + "READY", + "SENT", + "BLOCKED", +) +analysis_status_enum = Enum("NOT_ANALYZED", "NORMAL", "ABNORMAL") car_master = Table( "car_master", @@ -35,7 +45,9 @@ Column("engine_type", String(30), nullable=False), Column("car_color", String(30), nullable=False), Column("fuel_efficiency", Integer, nullable=False), - Column("created_at", DateTime, nullable=False), + # 차량 생성 시각은 원천 시스템에서 제공되지 않을 수 있으므로 NULL을 허용한다. + Column("created_at", DateTime, nullable=True), + UniqueConstraint("vehicle_id", name="uq_car_master_vehicle_id"), ) equipment = Table( @@ -46,85 +58,127 @@ Column("equipment_code", String(50), nullable=False, unique=True), Column("equipment_name", String(100), nullable=False), Column("equipment_type", equipment_type_enum, nullable=False), - Column("status", equipment_status_enum, nullable=False, server_default="NORMAL"), + Column( + "current_status", + equipment_current_status_enum, + nullable=False, + server_default="RUNNING", + ), + Column("last_fault_time", DateTime), + Column("last_recovered_time", DateTime), + Column("reason", String(255)), Column("created_at", DateTime, nullable=False, server_default=func.current_timestamp()), + Column("updated_at", DateTime, nullable=False, server_default=func.current_timestamp()), Index("idx_equipment_process_code", "process_code"), ) -manufacturing_event = Table( - "manufacturing_event", +manufacturing_event_json = Table( + "manufacturing_event_json", metadata, Column("id", BigInteger, primary_key=True, autoincrement=True), - Column("car_master_id", BigInteger, ForeignKey("car_master.id")), - Column("sample_manufacturing_event_id", String(50), nullable=False, unique=True), - Column("equipment_code", String(50), ForeignKey("equipment.equipment_code")), - Column("source_dataset", String(100)), - Column("source_type", source_type_enum, nullable=False), - Column("data_type", data_type_enum, nullable=False), + Column("event_id", String(100), nullable=False), + Column("event_time", DateTime, nullable=True), + Column("car_master_id", BigInteger, nullable=False), Column("process_code", process_code_enum, nullable=False), - Column("equipment_type", equipment_type_enum, nullable=False), - Column("station_code", String(50)), - Column("event_time", DateTime, nullable=False), - Column("metric_code", String(50)), - Column("metric_value", Double), - Column("unit", String(20)), - Column("process_time", Double), - Column("waiting_time", Double), - Column("quality_result", quality_result_enum), - Column("defect_type", String(50)), - Column("expected_is_abnormal", Boolean), - Column("expected_abnormal_type", String(50)), - Column("expected_severity", String(20)), - Column("expected_label", expected_label_enum), + Column("equipment_id", BigInteger, nullable=False), + Column("event_json", JSON, nullable=False), + # Scheduler가 조회하는 발행 가능 상태. 최초 생성 시 PRESS만 READY가 된다. + Column( + "dispatch_status", + dispatch_status_enum, + nullable=False, + server_default="PENDING", + ), + # Kafka Consumer의 공정 분석 결과가 기록되기 전에는 NOT_ANALYZED다. + Column( + "analysis_status", + analysis_status_enum, + nullable=False, + server_default="NOT_ANALYZED", + ), + Column( + "bottleneck_analysis_done", + Boolean, + nullable=False, + server_default="0", + ), + Column( + "defect_transfer_analysis_done", + Boolean, + nullable=False, + server_default="0", + ), + Column("is_sent", Boolean, nullable=False, server_default="0"), + Column("retry_count", Integer, nullable=False, server_default="0"), + Column("error_message", Text), Column("created_at", DateTime, nullable=False, server_default=func.current_timestamp()), - Index("idx_manufacturing_event_car_master_id", "car_master_id"), - Index("idx_manufacturing_event_equipment_code", "equipment_code"), - Index("idx_manufacturing_event_event_time", "event_time"), + Column( + "updated_at", + DateTime, + nullable=False, + server_default=func.current_timestamp(), + server_onupdate=func.current_timestamp(), + ), + # Scheduler의 READY/미전송 조회와 차량별 공정 진행 갱신을 위한 핵심 인덱스. + Index("idx_dispatch", "dispatch_status", "is_sent", "id"), + Index( + "idx_bottleneck_analysis_pending", + "is_sent", + "bottleneck_analysis_done", + "id", + ), + Index( + "idx_defect_transfer_analysis_pending", + "is_sent", + "defect_transfer_analysis_done", + "id", + ), + Index("idx_car_process", "car_master_id", "process_code"), + Index("idx_process_status", "process_code", "dispatch_status"), + Index("idx_equipment_status", "equipment_id", "dispatch_status"), + Index("idx_event_id", "event_id"), ) -thermal_vision = Table( - "thermal_vision", +manufacturing_event_template = Table( + "manufacturing_event_template", metadata, Column("id", BigInteger, primary_key=True, autoincrement=True), - Column("manufacturing_event_id", BigInteger, ForeignKey("manufacturing_event.id"), nullable=False), - Column("car_master_id", BigInteger, ForeignKey("car_master.id")), - Column("image_position", String(50)), - Column("thermal_avg_temp", Double), - Column("thermal_max_temp", Double), - Column("thermal_min_temp", Double), - Column("thermal_std_temp", Double), - Column("thickness_value", Double), - Column("defect_score", Double), - Column("expected_vision_label", String(30)), + Column("template_name", String(50), nullable=False), + Column("template_event_id", String(100), nullable=False, unique=True), + Column("event_offset_us", BigInteger, nullable=False), + Column("car_master_id", BigInteger, ForeignKey("car_master.id"), nullable=False), + Column("equipment_id", BigInteger, ForeignKey("equipment.id"), nullable=False), + Column("process_code", process_code_enum, nullable=False), + Column("station_code", String(50)), + Column("equipment_code", String(50), nullable=False), + Column("equipment_type", String(50)), + Column("equipment_status", String(30)), + Column("event_type", String(50)), + Column("event_json", JSON, nullable=False), Column("created_at", DateTime, nullable=False, server_default=func.current_timestamp()), - UniqueConstraint("manufacturing_event_id", name="uq_thermal_vision_manufacturing_event_id"), - Index("idx_thermal_vision_car_master_id", "car_master_id"), + UniqueConstraint("template_name", "event_offset_us", name="uq_template_offset"), + Index("idx_template_name_offset", "template_name", "event_offset_us"), + Index("idx_template_process_offset", "template_name", "process_code", "event_offset_us"), + Index("idx_template_equipment_offset", "template_name", "equipment_code", "event_offset_us"), ) -robot_arm_vibration = Table( - "robot_arm_vibration", +manufacturing_event_generation_job = Table( + "manufacturing_event_generation_job", metadata, Column("id", BigInteger, primary_key=True, autoincrement=True), - Column("manufacturing_event_id", BigInteger, ForeignKey("manufacturing_event.id"), nullable=False), - Column("equipment_id", BigInteger, ForeignKey("equipment.id"), nullable=False), - Column("measured_at", DateTime, nullable=False), - Column("freq_0_100_hz", Float), - Column("freq_101_200_hz", Float), - Column("freq_201_300_hz", Float), - Column("freq_301_400_hz", Float), - Column("freq_401_500_hz", Float), - Column("freq_501_600_hz", Float), - Column("freq_601_700_hz", Float), - Column("freq_701_800_hz", Float), - Column("freq_801_900_hz", Float), - Column("freq_901_1000_hz", Float), - Column("freq_1001_1100_hz", Float), - Column("freq_1101_1200_hz", Float), - Column("freq_1201_1300_hz", Float), - Column("freq_1301_1400_hz", Float), - Column("freq_1401_1500_hz", Float), - Column("freq_1501_1600_hz", Float), - Index("idx_robot_arm_vibration_event_id", "manufacturing_event_id"), - Index("idx_robot_arm_vibration_equipment_id", "equipment_id"), - Index("idx_robot_arm_vibration_measured_at", "measured_at"), + Column("job_id", String(100), nullable=False, unique=True), + Column("job_type", String(50), nullable=False), + Column("status", String(30), nullable=False), + Column("request_json", JSON, nullable=False), + Column("result_json", JSON), + Column("error_message", String(1000)), + Column("total_expected_events", BigInteger, nullable=False, server_default="0"), + Column("generated_count", BigInteger, nullable=False, server_default="0"), + Column("affected_rows", BigInteger, nullable=False, server_default="0"), + Column("created_at", DateTime, nullable=False, server_default=func.current_timestamp()), + Column("started_at", DateTime), + Column("finished_at", DateTime), + Column("updated_at", DateTime, nullable=False, server_default=func.current_timestamp()), + Index("idx_generation_job_status_created", "status", "created_at"), + Index("idx_generation_job_type_created", "job_type", "created_at"), ) diff --git a/app/repository/sampledb_schema_manager.py b/app/repository/sampledb_schema_manager.py new file mode 100644 index 0000000..e846593 --- /dev/null +++ b/app/repository/sampledb_schema_manager.py @@ -0,0 +1,165 @@ +from __future__ import annotations + +from typing import Any + +from sqlalchemy import inspect, text + +from app.repository.sampledb_schema import metadata + + +class SampleDbSchemaManager: + """sampledb 테이블 생성과 점진적 스키마 마이그레이션을 담당한다.""" + + def __init__(self, engine: Any) -> None: + self.engine = engine + + def ensure_schema(self) -> None: + metadata.create_all(self.engine) + self._migrate_prd_columns() + + def _migrate_prd_columns(self) -> None: + equipment_columns = { + "current_status": "VARCHAR(20) NOT NULL DEFAULT 'RUNNING'", + "last_fault_time": "DATETIME NULL", + "last_recovered_time": "DATETIME NULL", + "reason": "VARCHAR(255) NULL", + "updated_at": ( + "DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP" + if self.engine.dialect.name == "mysql" + else "DATETIME NULL" + ), + } + self._add_missing_columns("equipment", equipment_columns) + self._align_equipment_mysql_types() + self._align_manufacturing_event_json_mysql() + self._allow_car_master_created_at_null() + self._create_missing_indexes("equipment") + self._create_missing_indexes("manufacturing_event_json") + + def _allow_car_master_created_at_null(self) -> None: + columns = inspect(self.engine).get_columns("car_master") + created_at = next( + (column for column in columns if column["name"] == "created_at"), + None, + ) + if created_at is None or created_at["nullable"]: + return + if self.engine.dialect.name == "mysql": + with self.engine.begin() as conn: + conn.execute( + text( + "ALTER TABLE car_master " + "MODIFY COLUMN created_at DATETIME NULL", + ), + ) + + def _align_equipment_mysql_types(self) -> None: + if self.engine.dialect.name != "mysql": + return + equipment_types = { + column["name"]: column["type"].__class__.__name__.upper() + for column in inspect(self.engine).get_columns("equipment") + } + statements: list[str] = [] + if equipment_types.get("current_status") != "ENUM": + statements.append( + "ALTER TABLE equipment MODIFY COLUMN current_status " + "ENUM('RUNNING','IDLE','STOPPED','FAULT','MAINTENANCE') " + "NOT NULL DEFAULT 'RUNNING'", + ) + if statements: + with self.engine.begin() as conn: + for statement in statements: + conn.execute(text(statement)) + + def _align_manufacturing_event_json_mysql(self) -> None: + if self.engine.dialect.name != "mysql": + return + existing_columns = { + column["name"] + for column in inspect(self.engine).get_columns("manufacturing_event_json") + } + with self.engine.begin() as conn: + for column_name, definition in { + "bottleneck_analysis_done": "TINYINT(1) NOT NULL DEFAULT 0", + "defect_transfer_analysis_done": "TINYINT(1) NOT NULL DEFAULT 0", + }.items(): + if column_name in existing_columns: + continue + conn.execute( + text( + "ALTER TABLE manufacturing_event_json " + f"ADD COLUMN {column_name} {definition}", + ), + ) + conn.execute( + text( + "ALTER TABLE manufacturing_event_json " + "MODIFY COLUMN event_time DATETIME NULL, " + "MODIFY COLUMN dispatch_status " + "ENUM('PENDING','READY','SENT','BLOCKED') " + "NOT NULL DEFAULT 'PENDING', " + "MODIFY COLUMN analysis_status " + "ENUM('NOT_ANALYZED','NORMAL','ABNORMAL') " + "NOT NULL DEFAULT 'NOT_ANALYZED', " + "MODIFY COLUMN bottleneck_analysis_done " + "TINYINT(1) NOT NULL DEFAULT 0, " + "MODIFY COLUMN defect_transfer_analysis_done " + "TINYINT(1) NOT NULL DEFAULT 0, " + "MODIFY COLUMN updated_at DATETIME NOT NULL " + "DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP", + ), + ) + conn.execute( + text( + "UPDATE manufacturing_event_json " + "SET bottleneck_analysis_done = " + "CASE WHEN LOWER(CAST(bottleneck_analysis_done AS CHAR)) IN " + "('1', 'true') THEN 1 ELSE 0 END, " + "defect_transfer_analysis_done = " + "CASE WHEN LOWER(CAST(defect_transfer_analysis_done AS CHAR)) IN " + "('1', 'true') THEN 1 ELSE 0 END", + ), + ) + + def _add_missing_columns( + self, + table_name: str, + definitions: dict[str, str], + ) -> None: + existing_columns = self._table_columns(table_name) + missing = [ + (column_name, definition) + for column_name, definition in definitions.items() + if column_name not in existing_columns + ] + if not missing: + return + with self.engine.begin() as conn: + for column_name, definition in missing: + conn.execute( + text( + f"ALTER TABLE {table_name} " + f"ADD COLUMN {column_name} {definition}", + ), + ) + + def _table_columns(self, table_name: str) -> set[str]: + inspector = inspect(self.engine) + if not inspector.has_table(table_name): + return set(metadata.tables[table_name].c.keys()) + return { + column["name"] + for column in inspector.get_columns(table_name) + } + + def _create_missing_indexes(self, table_name: str) -> None: + table = metadata.tables[table_name] + existing_names = { + index["name"] + for index in inspect(self.engine).get_indexes(table_name) + if index.get("name") + } + for index in table.indexes: + if index.name and index.name not in existing_names: + index.create(self.engine, checkfirst=True) diff --git a/app/scheduler/__init__.py b/app/scheduler/__init__.py new file mode 100644 index 0000000..7d514c9 --- /dev/null +++ b/app/scheduler/__init__.py @@ -0,0 +1 @@ +"""Background scheduler package.""" diff --git a/app/scheduler/manufacturing/__init__.py b/app/scheduler/manufacturing/__init__.py new file mode 100644 index 0000000..919de5d --- /dev/null +++ b/app/scheduler/manufacturing/__init__.py @@ -0,0 +1,11 @@ +"""Manufacturing schedulers.""" + +from app.scheduler.manufacturing.manufacturing_event_scheduler import ( + start_manufacturing_event_scheduler, + stop_manufacturing_event_scheduler, +) + +__all__ = [ + "start_manufacturing_event_scheduler", + "stop_manufacturing_event_scheduler", +] diff --git a/app/scheduler/manufacturing/manufacturing_event_scheduler.py b/app/scheduler/manufacturing/manufacturing_event_scheduler.py new file mode 100644 index 0000000..afc75db --- /dev/null +++ b/app/scheduler/manufacturing/manufacturing_event_scheduler.py @@ -0,0 +1,89 @@ +from __future__ import annotations + +import asyncio +import logging +from datetime import datetime, time, timedelta +from zoneinfo import ZoneInfo + +from fastapi import FastAPI + +from app.core.config import settings +from app.repository.sampledb_repository import SampleDbRepository +from app.service.manufacturing import ( + DEFAULT_TEMPLATE_NAME, + ManufacturingEventJsonService, +) + + +logger = logging.getLogger(__name__) +SEOUL_TZ = ZoneInfo("Asia/Seoul") + + +def start_manufacturing_event_scheduler(app: FastAPI) -> None: + """제조 이벤트 템플릿 기반 다음날 데이터 적재 스케줄러를 시작한다.""" + if not settings.manufacturing_event_scheduler_enabled: + return + if not settings.sample_database_connection_url: + logger.info( + "MAIN_DATABASE_URL + SAMPLE_DB_NAME이 없어 제조 이벤트 스케줄러를 시작하지 않습니다.", + ) + return + + task = asyncio.create_task(_run_daily_generation_loop()) + app.state.manufacturing_event_scheduler_task = task + + +async def stop_manufacturing_event_scheduler(app: FastAPI) -> None: + task = getattr(app.state, "manufacturing_event_scheduler_task", None) + if task is None: + return + task.cancel() + try: + await task + except asyncio.CancelledError: + pass + + +async def _run_daily_generation_loop() -> None: + while True: + await asyncio.sleep(_seconds_until_next_run()) + try: + await asyncio.to_thread(_materialize_tomorrow_events) + except Exception: + logger.exception( + "제조 이벤트 다음날 데이터 적재 스케줄러 실행에 실패했습니다.", + ) + + +def _materialize_tomorrow_events() -> dict[str, object] | None: + if not settings.sample_database_connection_url: + return None + + service = ManufacturingEventJsonService( + SampleDbRepository(settings.sample_database_connection_url), + ) + result = service.generate_tomorrow( + template_name=DEFAULT_TEMPLATE_NAME, + events_per_day=settings.manufacturing_event_scheduler_events_per_day, + car_pool_size=settings.manufacturing_event_car_pool_size, + insert_chunk_size=settings.manufacturing_event_insert_chunk_size, + update_existing=True, + ) + logger.info( + "제조 이벤트 다음날 데이터 적재 완료: %s", + { + "templateName": result["templateName"], + "targetDate": result["targetDate"], + "generatedCount": result["generatedCount"], + "storedCountInDate": result["storedCountInDate"], + }, + ) + return result + + +def _seconds_until_next_run() -> float: + now = datetime.now(SEOUL_TZ) + next_run = datetime.combine(now.date(), time(hour=17), tzinfo=SEOUL_TZ) + if next_run <= now: + next_run += timedelta(days=1) + return max(60.0, (next_run - now).total_seconds()) diff --git a/app/scheduler/quality/__init__.py b/app/scheduler/quality/__init__.py new file mode 100644 index 0000000..95732bb --- /dev/null +++ b/app/scheduler/quality/__init__.py @@ -0,0 +1 @@ +"""quality schedulers.""" \ No newline at end of file diff --git a/app/scheduler/quality/drive_detail_producer.py b/app/scheduler/quality/drive_detail_producer.py new file mode 100644 index 0000000..6631b26 --- /dev/null +++ b/app/scheduler/quality/drive_detail_producer.py @@ -0,0 +1,156 @@ +from sqlalchemy import text +from kafka import KafkaProducer + +import os +import json +import threading + +from app.db import ( + main_engine, + sample_engine, +) + +from app.kafka.iam_provider import MSKTokenProvider + + +def run(stop_event): + + producer = KafkaProducer( + bootstrap_servers=[ + os.getenv("BROKER_URL_1"), + os.getenv("BROKER_URL_2") + ], + + security_protocol="SASL_SSL", + + sasl_mechanism="OAUTHBEARER", + + sasl_oauth_token_provider=MSKTokenProvider(), + + value_serializer=lambda x: + json.dumps( + x, + default=str + ).encode("utf-8") + ) + + last_id = 0 + + try: + + while not stop_event.is_set(): + + # 새로 생산된 차량 조회 + with main_engine.connect() as conn: + + cars = conn.execute( + text(""" + SELECT + id, + vehicle_id + FROM inspection_master + WHERE id > :last_id + ORDER BY id + """), + { + "last_id": last_id + } + ).mappings().all() + + if not cars: + stop_event.wait(1) + continue + + for car in cars: + + if stop_event.is_set(): + break + + vehicle_id = car["vehicle_id"] + + # 해당 차량의 주행 데이터 조회 + with sample_engine.connect() as conn: + + drive_rows = conn.execute( + text(""" + SELECT * + FROM car_drive + WHERE vehicle_id = :vehicle_id + ORDER BY created_at + """), + { + "vehicle_id": vehicle_id + } + ).mappings().all() + + if not drive_rows: + + print( + f"[Drive] {vehicle_id} 데이터 없음" + ) + + last_id = car["id"] + continue + + for row in drive_rows: + + message = { + + "vehicle_id": + row["vehicle_id"], + + "throttle_position": + round( + float( + row["throttle_position"] + ), + 2 + ), + + "brake_pressure": + round( + float( + row["brake_pressure"] + ), + 2 + ), + + "steering_angle": + round( + float( + row["steering_angle"] + ), + 2 + ), + + "created_at": + row["created_at"] + } + + producer.send( + "quality.inspection.drive_detail", + value=message + ) + + producer.flush() + + # 처리 완료 차량 갱신 + last_id = car["id"] + + stop_event.wait(1) + + except Exception as e: + + print(f"Drive Producer 오류 : {e}") + + finally: + + producer.flush() + producer.close() + + print("Drive Producer 종료") + + +if __name__ == "__main__": + + run(threading.Event()) \ No newline at end of file diff --git a/app/scheduler/quality/master_test.py b/app/scheduler/quality/master_test.py new file mode 100644 index 0000000..019287b --- /dev/null +++ b/app/scheduler/quality/master_test.py @@ -0,0 +1,105 @@ +from sqlalchemy import create_engine, text +from dotenv import load_dotenv +from urllib.parse import quote_plus +import os +import time + +load_dotenv() + +# Sample DB +SAMPLE_DATABASE_URL = ( + f"mysql+pymysql://{os.getenv('DB_USER')}:" + f"{quote_plus(os.getenv('DB_PASSWORD'))}@" + f"{os.getenv('DB_HOST')}:" + f"{os.getenv('DB_PORT')}/sampledb" +) + +# Main DB +MAIN_DATABASE_URL = ( + f"mysql+pymysql://{os.getenv('DB_USER')}:" + f"{quote_plus(os.getenv('DB_PASSWORD'))}@" + f"{os.getenv('DB_HOST')}:" + f"{os.getenv('DB_PORT')}/maindb" +) + +sample_engine = create_engine( + SAMPLE_DATABASE_URL, + pool_pre_ping=True +) + +main_engine = create_engine( + MAIN_DATABASE_URL, + pool_pre_ping=True +) + +last_id = 0 + +while True: + + # Sample DB에서 아직 복사하지 않은 차량 5건 조회 + with sample_engine.connect() as conn: + + rows = conn.execute( + text(""" + SELECT * + FROM car_master + WHERE id > :last_id + ORDER BY id + LIMIT 1 + """), + {"last_id": last_id} + ).mappings().all() + + # 더 이상 복사할 데이터가 없으면 종료 + if not rows: + print("모든 차량 복사 완료") + break + + # Main DB로 저장 + with main_engine.begin() as conn: + + for row in rows: + + conn.execute( + text(""" + INSERT INTO inspection_master + ( + id, + vehicle_id, + car_type, + engine_type, + car_color, + fuel_efficiency, + created_at + ) + VALUES + ( + :id, + :vehicle_id, + :car_type, + :engine_type, + :car_color, + :fuel_efficiency, + :created_at + ) + """), + { + "id": row["id"], + "vehicle_id": row["vehicle_id"], + "car_type": row["car_type"], + "engine_type": row["engine_type"], + "car_color": row["car_color"], + "fuel_efficiency": row["fuel_efficiency"], + "created_at": row["created_at"] + } + ) + + last_id = row["id"] + + print( + f"{len(rows)}건 복사 완료 " + f"(마지막 ID: {last_id})" + ) + + # 1초 대기 + time.sleep(1) \ No newline at end of file diff --git a/app/scheduler/quality/process_producer.py b/app/scheduler/quality/process_producer.py new file mode 100644 index 0000000..c11c7ea --- /dev/null +++ b/app/scheduler/quality/process_producer.py @@ -0,0 +1,177 @@ +from sqlalchemy import text +from kafka import KafkaProducer + +import os +import json +import threading + +from app.db import main_engine +from app.kafka.iam_provider import MSKTokenProvider + +TOTAL_TARGET = 100 + + +def run(stop_event): + + producer = KafkaProducer( + bootstrap_servers=[ + os.getenv("BROKER_URL_1"), + os.getenv("BROKER_URL_2") + ], + security_protocol="SASL_SSL", + sasl_mechanism="OAUTHBEARER", + sasl_oauth_token_provider=MSKTokenProvider(), + value_serializer=lambda x: json.dumps( + x, + default=str + ).encode("utf-8") + ) + + last_id = 0 + + try: + + while not stop_event.is_set(): + + with main_engine.connect() as conn: + + new_cars = conn.execute( + text(""" + SELECT + id, + vehicle_id, + created_at + FROM inspection_master + WHERE id > :last_id + ORDER BY id + """), + { + "last_id": last_id + } + ).mappings().all() + + if not new_cars: + stop_event.wait(1) + continue + + for car in new_cars: + + if stop_event.is_set(): + break + + # ============================ + # 해당 날짜 생산 차량 개수 계산 + # ============================ + with main_engine.connect() as conn: + + current_count = conn.execute( + text(""" + SELECT COUNT(*) + FROM inspection_master + WHERE DATE(created_at) = DATE(:created_at) + AND id <= :current_id + """), + { + "created_at": car["created_at"], + "current_id": car["id"] + } + ).scalar() + + # 생산 완료 + if current_count >= TOTAL_TARGET: + + process_list = [ + ("VISUAL", TOTAL_TARGET), + ("FUNCTION", TOTAL_TARGET), + ("DRIVE", TOTAL_TARGET), + ("FINAL", TOTAL_TARGET) + ] + + else: + + process_list = [ + + ( + "VISUAL", + min(current_count, TOTAL_TARGET) + ), + + ( + "FUNCTION", + min(max(current_count - 1, 0), TOTAL_TARGET) + ), + + ( + "DRIVE", + min(max(current_count - 2, 0), TOTAL_TARGET) + ), + + ( + "FINAL", + min(max(current_count - 3, 0), TOTAL_TARGET) + ) + ] + + for process_name, completed in process_list: + + waiting = max( + TOTAL_TARGET - completed, + 0 + ) + + progress_rate = round( + completed / TOTAL_TARGET * 100, + 2 + ) + + if progress_rate >= 100: + process_status = "COMPLETE" + elif progress_rate == 0: + process_status = "WAIT" + else: + process_status = "RUNNING" + + message = { + + "process_name": process_name, + + "total_vehicle_count": TOTAL_TARGET, + + "completed_count": completed, + + "waiting_count": waiting, + + "progress_rate": progress_rate, + + "process_status": process_status, + + "created_at": car["created_at"] + + } + + producer.send( + "quality.inspection.process", + value=message + ) + + last_id = car["id"] + + producer.flush() + + stop_event.wait(1) + + except Exception as e: + + print(f"Process Producer 오류 : {e}") + + finally: + + producer.flush() + producer.close() + + print("Process Producer 종료") + + +if __name__ == "__main__": + + run(threading.Event()) \ No newline at end of file diff --git a/app/scheduler/quality/risk_history_producer.py b/app/scheduler/quality/risk_history_producer.py new file mode 100644 index 0000000..7b16ef2 --- /dev/null +++ b/app/scheduler/quality/risk_history_producer.py @@ -0,0 +1,285 @@ +from sqlalchemy import text +from kafka import KafkaProducer + +import os +import json +import threading + +from app.db import ( + main_engine, + sample_engine, +) + +from app.kafka.iam_provider import MSKTokenProvider + + +def run(stop_event): + + producer = KafkaProducer( + + bootstrap_servers=[ + os.getenv("BROKER_URL_1"), + os.getenv("BROKER_URL_2") + ], + + security_protocol="SASL_SSL", + + sasl_mechanism="OAUTHBEARER", + + sasl_oauth_token_provider= + MSKTokenProvider(), + + value_serializer=lambda x: + json.dumps( + x, + default=str + ).encode("utf-8") + ) + + last_id = 0 + + try: + + while not stop_event.is_set(): + + with main_engine.connect() as conn: + + new_cars = conn.execute( + text(""" + SELECT + id, + vehicle_id, + DATE(created_at) + AS inspection_date + FROM inspection_master + WHERE id > :last_id + ORDER BY id + """), + { + "last_id": last_id + } + ).mappings().all() + + if not new_cars: + stop_event.wait(1) + continue + + for car in new_cars: + + if stop_event.is_set(): + break + + vehicle_id = car["vehicle_id"] + + inspection_date = str( + car["inspection_date"] + ) + + scores = {} + + with sample_engine.connect() as conn: + + # DRIVE + row = conn.execute( + text(""" + SELECT * + FROM car_drive + WHERE vehicle_id = + :vehicle_id + LIMIT 1 + """), + { + "vehicle_id": vehicle_id + } + ).mappings().first() + + if row: + + score = 100 + + if float( + row["throttle_position"] + ) > 90: + score -= 20 + + if float( + row["brake_pressure"] + ) > 45: + score -= 20 + + if abs( + float( + row["steering_angle"] + ) + ) > 40: + score -= 20 + + scores["DRIVE"] = max( + score, + 0 + ) + + # CONTROL + row = conn.execute( + text(""" + SELECT * + FROM car_control + WHERE vehicle_id = + :vehicle_id + LIMIT 1 + """), + { + "vehicle_id": vehicle_id + } + ).mappings().first() + + if row: + + score = 100 + + if row[ + "collision_warning" + ] == 1: + score -= 40 + + if row[ + "lane_departure" + ] == 1: + score -= 20 + + if row[ + "traction_control" + ] == 1: + score -= 10 + + if row[ + "abs_active" + ] == 1: + score -= 10 + + scores["CONTROL"] = max( + score, + 0 + ) + + # DYNAMICS + row = conn.execute( + text(""" + SELECT * + FROM car_dynamics + WHERE vehicle_id = + :vehicle_id + LIMIT 1 + """), + { + "vehicle_id": vehicle_id + } + ).mappings().first() + + if row: + + score = 100 + + if abs( + float( + row["yaw_rate"] + ) + ) > 7: + score -= 20 + + if abs( + float( + row["roll"] + ) + ) > 4: + score -= 20 + + if abs( + float( + row["pitch"] + ) + ) > 4: + score -= 20 + + scores["DYNAMICS"] = max( + score, + 0 + ) + + # STATUS + row = conn.execute( + text(""" + SELECT * + FROM car_status + WHERE vehicle_id = + :vehicle_id + LIMIT 1 + """), + { + "vehicle_id": vehicle_id + } + ).mappings().first() + + if row: + + score = 100 + + if float( + row["speed"] + ) > 120: + score -= 20 + + if int( + row["att"] + ) > 4000: + score -= 20 + + if float( + row[ + "battery_voltage" + ] + ) < 12: + score -= 10 + + scores["STATUS"] = max( + score, + 0 + ) + + for inspection_type, risk_score in scores.items(): + + producer.send( + "quality.inspection.risk_history", + value={ + "inspection_type": + inspection_type, + + "inspection_date": + inspection_date, + + "risk_score": + risk_score + } + ) + + last_id = car["id"] + + producer.flush() + + stop_event.wait(1) + + except Exception as e: + + print(f"Risk History Producer 오류 : {e}") + + finally: + + producer.flush() + producer.close() + + print("Risk History Producer 종료") + + +if __name__ == "__main__": + + run(threading.Event()) \ No newline at end of file diff --git a/app/scheduler/quality/risk_trend_producer.py b/app/scheduler/quality/risk_trend_producer.py new file mode 100644 index 0000000..3f5e479 --- /dev/null +++ b/app/scheduler/quality/risk_trend_producer.py @@ -0,0 +1,278 @@ +from sqlalchemy import text +from kafka import KafkaProducer + +import os +import json +import time + +from app.db import ( + main_engine, + sample_engine +) + +from app.kafka.iam_provider import MSKTokenProvider + + +def run(stop_event): + producer = KafkaProducer( + bootstrap_servers=[ + os.getenv("BROKER_URL_1"), + os.getenv("BROKER_URL_2") + ], + + security_protocol="SASL_SSL", + + sasl_mechanism="OAUTHBEARER", + + sasl_oauth_token_provider=MSKTokenProvider(), + + value_serializer=lambda x: + json.dumps(x, default=str).encode("utf-8") + ) + + def calculate_status_risk(row): + + score = 100 + + if float(row["speed"]) > 120: + score -= 20 + + if int(row["att"]) > 4000: + score -= 20 + + if float(row["battery_voltage"]) < 12: + score -= 10 + + return max(score, 0) + + def calculate_control_risk(row): + + score = 100 + + if row["collision_warning"] == 1: + score -= 40 + + if row["lane_departure"] == 1: + score -= 20 + + if row["traction_control"] == 1: + score -= 10 + + if row["abs_active"] == 1: + score -= 10 + + return max(score, 0) + + def calculate_drive_risk(row): + + score = 100 + + if float(row["throttle_position"]) > 90: + score -= 20 + + if float(row["brake_pressure"]) > 45: + score -= 20 + + if abs(float(row["steering_angle"])) > 40: + score -= 20 + + return max(score, 0) + + def calculate_dynamics_risk(row): + + score = 100 + + if abs(float(row["yaw_rate"])) > 7: + score -= 20 + + if abs(float(row["roll"])) > 4: + score -= 20 + + if abs(float(row["pitch"])) > 4: + score -= 20 + + return max(score, 0) + + def get_risk_level(score): + + if score >= 80: + return "LOW" + + elif score >= 50: + return "MEDIUM" + + return "HIGH" + + last_id = 0 + try: + while not stop_event.is_set(): + + with main_engine.connect() as conn: + + cars = conn.execute( + text(""" + SELECT * + FROM inspection_master + WHERE id > :last_id + ORDER BY id + """), + {"last_id": last_id} + ).mappings().all() + + if not cars: + time.sleep(1) + continue + + for car in cars: + + vehicle_id = car["vehicle_id"] + + created_date = ( + car["created_at"] + .strftime("%Y-%m-%d 00:00:00") + ) + + low = 0 + medium = 0 + high = 0 + + with main_engine.connect() as conn: + + today_cars = conn.execute( + text(""" + SELECT vehicle_id + FROM inspection_master + WHERE DATE(created_at) + = + DATE(:created_at) + """), + { + "created_at": + car["created_at"] + } + ).mappings().all() + + for row in today_cars: + + vid = row["vehicle_id"] + + scores = [] + + with sample_engine.connect() as conn: + + status = conn.execute( + text(""" + SELECT * + FROM car_status + WHERE vehicle_id=:vid + LIMIT 1 + """), + {"vid": vid} + ).mappings().first() + + if status: + scores.append( + calculate_status_risk(status) + ) + + control = conn.execute( + text(""" + SELECT * + FROM car_control + WHERE vehicle_id=:vid + LIMIT 1 + """), + {"vid": vid} + ).mappings().first() + + if control: + scores.append( + calculate_control_risk(control) + ) + + drive = conn.execute( + text(""" + SELECT * + FROM car_drive + WHERE vehicle_id=:vid + LIMIT 1 + """), + {"vid": vid} + ).mappings().first() + + if drive: + scores.append( + calculate_drive_risk(drive) + ) + + dynamics = conn.execute( + text(""" + SELECT * + FROM car_dynamics + WHERE vehicle_id=:vid + LIMIT 1 + """), + {"vid": vid} + ).mappings().first() + + if dynamics: + scores.append( + calculate_dynamics_risk(dynamics) + ) + + if not scores: + continue + + avg_score = ( + sum(scores) / len(scores) + ) + + level = get_risk_level( + avg_score + ) + + if level == "LOW": + low += 1 + + elif level == "MEDIUM": + medium += 1 + + else: + high += 1 + + total = low + medium + high + + for level, count in [ + ("LOW", low), + ("MEDIUM", medium), + ("HIGH", high) + ]: + + producer.send( + "quality.inspection.risk_trend", + value={ + "risk_level": level, + + "risk_count": count, + + "risk_ratio": round( + count / total * 100, 2 + ) if total else 0, + + "created_at": + created_date + } + ) + + producer.flush() + + last_id = car["id"] + + time.sleep(1) + + except Exception as e: + print(f"오류 발생 : {e}") + + finally: + producer.close() + print("risk-trend producer 종료") \ No newline at end of file diff --git a/app/scheduler/quality/status_detail_producer.py b/app/scheduler/quality/status_detail_producer.py new file mode 100644 index 0000000..82c5828 --- /dev/null +++ b/app/scheduler/quality/status_detail_producer.py @@ -0,0 +1,214 @@ +from sqlalchemy import text +from kafka import KafkaProducer + +import os +import json +import time + +from app.db import ( + main_engine, + sample_engine, +) + +from app.kafka.iam_provider import MSKTokenProvider + + +def run(stop_event): + + producer = KafkaProducer( + bootstrap_servers=[ + os.getenv("BROKER_URL_1"), + os.getenv("BROKER_URL_2") + ], + security_protocol="SASL_SSL", + sasl_mechanism="OAUTHBEARER", + sasl_oauth_token_provider=MSKTokenProvider(), + value_serializer=lambda x: json.dumps( + x, + default=str + ).encode("utf-8") + ) + + def calculate_status_score(status, control): + + score = 100 + issues = [] + + speed = float(status["speed"]) + rpm = int(status["att"]) + battery = float(status["battery_voltage"]) + + if speed > 120: + score -= 20 + issues.append("over speed") + + if rpm > 4000: + score -= 20 + issues.append("RPM Error") + + if battery < 12: + score -= 10 + issues.append("battery drop") + + if control["collision_warning"] == 1: + score -= 40 + issues.append("crash warning") + + if status["gear"] == "P" and speed > 20: + score -= 30 + issues.append("Parking") + + return max(score, 0), issues + + def get_result(score): + + if score >= 90: + return "PASS" + + elif score >= 70: + return "WARN" + + return "FAIL" + + last_id = 0 + + try: + + while not stop_event.is_set(): + + with main_engine.connect() as conn: + + new_cars = conn.execute( + text(""" + SELECT * + FROM inspection_master + WHERE id > :last_id + ORDER BY id + """), + { + "last_id": last_id + } + ).mappings().all() + + if not new_cars: + time.sleep(1) + continue + + with sample_engine.connect() as conn: + + for car in new_cars: + + if stop_event.is_set(): + break + + vehicle_id = car["vehicle_id"] + + status_row = conn.execute( + text(""" + SELECT * + FROM car_status + WHERE vehicle_id = :vehicle_id + ORDER BY created_at DESC + LIMIT 1 + """), + { + "vehicle_id": vehicle_id + } + ).mappings().first() + + control_row = conn.execute( + text(""" + SELECT * + FROM car_control + WHERE vehicle_id = :vehicle_id + ORDER BY created_at DESC + LIMIT 1 + """), + { + "vehicle_id": vehicle_id + } + ).mappings().first() + + if not status_row or not control_row: + continue + + score, issues = calculate_status_score( + status_row, + control_row + ) + + message = { + "car_code": + vehicle_id.split("-")[0], + + "inspection_no": + f"STATUS-{car['id']:05d}", + + "vehicle_id": + vehicle_id, + + "speed": + float(status_row["speed"]), + + "att": + int(status_row["att"]), + + "gear": + status_row["gear"], + + "battery_voltage": + float( + status_row["battery_voltage"] + ), + + "fuel_rate": + float( + status_row["fuel_rate"] + ), + + "status_score": + score, + + "inspection_result": + get_result(score), + + "issue_message": + ", ".join(issues) + if issues + else "정상", + + "created_at": + status_row["created_at"] + } + + producer.send( + "quality.inspection.status_detail", + value=message + ) + + producer.flush() + + last_id = car["id"] + + time.sleep(1) + + except Exception as e: + + print(f"오류 발생 : {e}") + + finally: + + print("status-detail producer 종료") + + try: + producer.flush() + except Exception: + pass + + producer.close() + + +if __name__ == "__main__": + from threading import Event + + run(Event()) \ No newline at end of file diff --git a/app/search/process_analysis_search.py b/app/search/process_analysis_search.py new file mode 100644 index 0000000..b6d899d --- /dev/null +++ b/app/search/process_analysis_search.py @@ -0,0 +1,717 @@ +from __future__ import annotations + +import logging +from datetime import date as DateType +from datetime import datetime +from typing import Any +from urllib.parse import urlparse + +from app.core.config import settings +from app.utils.datetime_utils import SEOUL_TZ + +logger = logging.getLogger(__name__) + + +class ProcessAnalysisSearchRepository: + def __init__(self) -> None: + self._client: Any | None = None + + @property + def enabled(self) -> bool: + return bool(settings.elasticsearch_url) + + @property + def client(self) -> Any: + if self._client is None: + self._client = self._create_client() + return self._client + + def ensure_indices(self) -> None: + if not self.enabled: + return + + client = self.client + for index_name, body in self._index_definitions().items(): + try: + if client.indices.exists(index=index_name): + continue + client.indices.create(index=index_name, body=body) + logger.info("Elasticsearch index created: %s", index_name) + except Exception: + logger.exception("Failed to ensure Elasticsearch index: %s", index_name) + raise + + def index_sync_event(self, event: dict[str, Any]) -> None: + analysis_type = str(event.get("analysisType") or "").strip().upper() + if analysis_type == "BOTTLENECK_ANALYSIS_SYNC": + self.index_bottleneck_snapshot(event) + return + if analysis_type == "DEFECT_TRANSFER_ANALYSIS_SYNC": + self.index_defect_transfer_prediction(event) + return + # The sync consumer reuses the existing analysis topic, so non-sync + # analysis events can arrive here as well. They are intentionally ignored. + return + + def index_bottleneck_snapshot(self, event: dict[str, Any]) -> None: + if not self.enabled: + return + + snapshot_id = str(event.get("snapshotId") or event.get("syncId") or "").strip() + items = event.get("items") or [] + if not snapshot_id or not isinstance(items, list) or not items: + return + + detected_at = self._normalize_datetime(event.get("detectedAt")) + analyzed_at = self._normalize_datetime(event.get("analyzedAt")) + base_doc = { + "analysisType": "BOTTLENECK_ANALYSIS", + "syncId": str(event.get("syncId") or snapshot_id), + "snapshotId": snapshot_id, + "detectedAt": detected_at, + "analyzedAt": analyzed_at, + "eventId": event.get("eventId"), + "carMasterId": event.get("carMasterId"), + "mostBottleneckProcess": event.get("mostBottleneckProcess"), + "mostBottleneckRiskLevel": event.get("mostBottleneckRiskLevel"), + "sourceService": event.get("sourceService") or "AI_SERVICE", + } + actions: list[dict[str, Any]] = [] + for item in items: + if not isinstance(item, dict): + continue + doc = { + **base_doc, + "rankNo": self._safe_int(item.get("rankNo")), + "manufacturingEventId": item.get("manufacturingEventId"), + "carMasterId": item.get("carMasterId") or event.get("carMasterId"), + "processCode": item.get("processCode"), + "equipmentCode": item.get("equipmentCode"), + "avgDelayTime": self._safe_float(item.get("avgDelayTime")), + "affectedVehicleCount": self._safe_int(item.get("affectedVehicleCount")), + "riskScore": self._safe_float(item.get("riskScore")), + "riskLevel": item.get("riskLevel"), + } + doc_id = self._bottleneck_doc_id(snapshot_id, doc) + actions.append( + { + "_index": settings.elasticsearch_bottleneck_index, + "_id": doc_id, + "_source": doc, + }, + ) + self._bulk_index(actions) + + def index_defect_transfer_prediction(self, event: dict[str, Any]) -> None: + if not self.enabled: + return + + sync_id = str(event.get("syncId") or "").strip() + if not sync_id: + return + + doc = { + "analysisType": "DEFECT_TRANSFER_ANALYSIS", + "syncId": sync_id, + "eventId": event.get("eventId"), + "carMasterId": event.get("carMasterId"), + "vehicleId": event.get("vehicleId"), + "currentProcess": event.get("currentProcess"), + "currentProcessCode": event.get("currentProcessCode"), + "sourceProcessCode": event.get("sourceProcessCode"), + "sourceEquipmentCode": event.get("sourceEquipmentCode"), + "targetEquipmentCode": event.get("targetEquipmentCode"), + "predictedDefectProcess": event.get("predictedDefectProcess"), + "currentDefectProbability": self._safe_float(event.get("currentDefectProbability")), + "transferProbability": self._safe_float(event.get("transferProbability")), + "defectThreshold": self._safe_float(event.get("defectThreshold")), + "transferThreshold": self._safe_float(event.get("transferThreshold")), + "defectProbability": self._safe_float(event.get("defectProbability")), + "expectedTime": event.get("expectedTime"), + "expectedStepsAfter": self._safe_int(event.get("expectedStepsAfter")), + "riskLevel": event.get("riskLevel"), + "predictedAt": self._normalize_datetime(event.get("predictedAt")), + "createdAt": self._normalize_datetime(event.get("createdAt") or event.get("predictedAt")), + "mainCauses": self._normalize_main_causes(event.get("mainCauses") or event.get("causes")), + "featureValues": event.get("featureValues") or {}, + "sourceService": event.get("sourceService") or "AI_SERVICE", + } + doc_id = f"{sync_id}:{doc.get('eventId') or doc.get('carMasterId')}" + self._bulk_index( + [ + { + "_index": settings.elasticsearch_defect_transfer_index, + "_id": doc_id, + "_source": doc, + }, + ], + ) + + def delete_bottleneck_documents_by_date(self, analysis_date: DateType) -> int: + if not self.enabled: + return 0 + response = self.client.delete_by_query( + index=settings.elasticsearch_bottleneck_index, + body={"query": self._date_range_query("detectedAt", analysis_date)}, + refresh=True, + conflicts="proceed", + ) + return self._safe_int(response.get("deleted")) or 0 + + def delete_defect_transfer_documents_by_date(self, analysis_date: DateType) -> int: + if not self.enabled: + return 0 + response = self.client.delete_by_query( + index=settings.elasticsearch_defect_transfer_index, + body={"query": self._date_range_query("predictedAt", analysis_date)}, + refresh=True, + conflicts="proceed", + ) + return self._safe_int(response.get("deleted")) or 0 + + def delete_defect_transfer_documents_by_vehicle_and_date( + self, + *, + vehicle_id: str | None, + analysis_date: DateType, + ) -> int: + if not self.enabled: + return 0 + query: dict[str, Any] = { + "bool": { + "filter": [self._date_range_query("predictedAt", analysis_date)], + }, + } + if vehicle_id: + query["bool"]["must"] = [{"term": {"vehicleId": vehicle_id}}] + response = self.client.delete_by_query( + index=settings.elasticsearch_defect_transfer_index, + body={"query": query}, + refresh=True, + conflicts="proceed", + ) + return self._safe_int(response.get("deleted")) or 0 + + def list_bottleneck_page( + self, + *, + cursor: int, + size: int, + analysis_date: DateType | None = None, + ) -> tuple[list[dict[str, Any]], bool]: + latest_snapshot_id = self._latest_bottleneck_snapshot_id( + analysis_date=analysis_date, + ) + if not latest_snapshot_id: + return [], False + + page = max(cursor, 0) + safe_size = max(1, min(size, 100)) + query = { + "query": { + "term": { + "snapshotId": latest_snapshot_id, + }, + }, + "sort": [ + {"rankNo": {"order": "asc"}}, + {"processCode": {"order": "asc"}}, + {"equipmentCode": {"order": "asc"}}, + ], + "from": page * safe_size, + "size": safe_size + 1, + "track_total_hits": True, + } + response = self.client.search( + index=settings.elasticsearch_bottleneck_index, + body=query, + ) + rows = [ + self._map_bottleneck_source(hit.get("_source") or {}) + for hit in response.get("hits", {}).get("hits", []) + ] + has_next = len(rows) > safe_size + return rows[:safe_size], has_next + + def list_bottleneck_date_options(self) -> list[dict[str, Any]]: + if not self.enabled: + return [] + return self._list_date_options( + index=settings.elasticsearch_bottleneck_index, + date_field="detectedAt", + ) + + def count_bottleneck_page(self) -> int: + latest_snapshot_id = self._latest_bottleneck_snapshot_id() + if not latest_snapshot_id: + return 0 + + query = { + "query": { + "term": { + "snapshotId": latest_snapshot_id, + }, + }, + "size": 0, + "track_total_hits": True, + } + response = self.client.search( + index=settings.elasticsearch_bottleneck_index, + body=query, + ) + total = response.get("hits", {}).get("total", 0) + if isinstance(total, dict): + return int(total.get("value") or 0) + return int(total or 0) + + def list_defect_prediction_page( + self, + *, + cursor: int, + size: int, + analysis_date: DateType | None = None, + ) -> tuple[list[dict[str, Any]], bool]: + page = max(cursor, 0) + safe_size = max(1, min(size, 100)) + query = { + "query": {"match_all": {}}, + "collapse": {"field": "carMasterId"}, + "sort": [ + {"transferProbability": {"order": "desc", "missing": "_last"}}, + {"currentDefectProbability": {"order": "desc", "missing": "_last"}}, + {"predictedAt": {"order": "desc"}}, + {"syncId": {"order": "desc"}}, + ], + "from": page * safe_size, + "size": safe_size + 1, + "track_total_hits": True, + } + if analysis_date is not None: + query["query"] = self._date_range_query("predictedAt", analysis_date) + response = self.client.search( + index=settings.elasticsearch_defect_transfer_index, + body=query, + ) + rows = [ + self._map_defect_source(hit.get("_source") or {}) + for hit in response.get("hits", {}).get("hits", []) + ] + has_next = len(rows) > safe_size + return rows[:safe_size], has_next + + def list_defect_transfer_date_options( + self, + *, + vehicle_id: str | None = None, + ) -> list[dict[str, Any]]: + if not self.enabled: + return [] + query: dict[str, Any] = {"match_all": {}} + if vehicle_id: + query = {"term": {"vehicleId": vehicle_id}} + return self._list_date_options( + index=settings.elasticsearch_defect_transfer_index, + date_field="predictedAt", + query=query, + ) + + def get_latest_defect_cause_document( + self, + *, + vehicle_id: str | None, + analysis_date: DateType | None = None, + ) -> dict[str, Any] | None: + query: dict[str, Any] = { + "size": 1, + "collapse": {"field": "carMasterId"}, + "sort": [ + {"transferProbability": {"order": "desc", "missing": "_last"}}, + {"currentDefectProbability": {"order": "desc", "missing": "_last"}}, + {"predictedAt": {"order": "desc"}}, + {"syncId": {"order": "desc"}}, + ], + } + if vehicle_id: + query["query"] = {"term": {"vehicleId": vehicle_id}} + else: + query["query"] = {"match_all": {}} + if analysis_date is not None: + query["query"] = { + "bool": { + "must": [query["query"]], + "filter": [self._date_range_query("predictedAt", analysis_date)], + }, + } + + response = self.client.search( + index=settings.elasticsearch_defect_transfer_index, + body=query, + ) + hits = response.get("hits", {}).get("hits", []) + if not hits: + return None + return self._map_defect_source(hits[0].get("_source") or {}) + + def _latest_bottleneck_snapshot_id( + self, + *, + analysis_date: DateType | None = None, + ) -> str | None: + query = { + "size": 1, + "query": {"match_all": {}}, + "sort": [ + {"detectedAt": {"order": "desc"}}, + {"rankNo": {"order": "asc"}}, + {"syncId": {"order": "desc"}}, + ], + } + if analysis_date is not None: + query["query"] = self._date_range_query("detectedAt", analysis_date) + response = self.client.search( + index=settings.elasticsearch_bottleneck_index, + body=query, + ) + hits = response.get("hits", {}).get("hits", []) + if not hits: + return None + source = hits[0].get("_source") or {} + snapshot_id = source.get("snapshotId") + return str(snapshot_id) if snapshot_id is not None else None + + @staticmethod + def _date_range_query(field: str, analysis_date: DateType) -> dict[str, Any]: + next_date = analysis_date.fromordinal(analysis_date.toordinal() + 1) + return { + "range": { + field: { + "gte": analysis_date.isoformat(), + "lt": next_date.isoformat(), + }, + }, + } + + def _list_date_options( + self, + *, + index: str, + date_field: str, + query: dict[str, Any] | None = None, + ) -> list[dict[str, Any]]: + body: dict[str, Any] = { + "size": 0, + "track_total_hits": False, + "query": query or {"match_all": {}}, + "aggs": { + "by_date": { + "date_histogram": { + "field": date_field, + "calendar_interval": "day", + "time_zone": "+09:00", + "order": {"_key": "desc"}, + "min_doc_count": 1, + }, + "aggs": { + "sample_doc": { + "top_hits": { + "size": 1, + "_source": ["eventId"], + }, + }, + }, + }, + }, + } + response = self.client.search(index=index, body=body) + buckets = response.get("aggregations", {}).get("by_date", {}).get("buckets", []) + options: list[dict[str, Any]] = [] + for bucket in buckets: + date_value = bucket.get("key_as_string") + if not date_value: + continue + sample_event_id = None + sample_hits = bucket.get("sample_doc", {}).get("hits", {}).get("hits", []) + if sample_hits: + sample_source = sample_hits[0].get("_source") or {} + sample_event_id = sample_source.get("eventId") + options.append( + { + "date": str(date_value)[:10], + "sample_event_id": sample_event_id, + }, + ) + return options + + def _bulk_index(self, actions: list[dict[str, Any]]) -> None: + if not actions: + return + from opensearchpy import helpers + + helpers.bulk(self.client, actions, raise_on_error=True) + + def _create_client(self) -> Any: + if not settings.elasticsearch_url: + raise RuntimeError("Elasticsearch URL is not configured.") + + try: + from opensearchpy import OpenSearch + except ModuleNotFoundError as exc: + raise RuntimeError("opensearch-py is required for Elasticsearch integration.") from exc + + parsed = urlparse(settings.elasticsearch_url) + if not parsed.scheme or not parsed.hostname: + raise ValueError(f"Invalid Elasticsearch URL: {settings.elasticsearch_url}") + + hosts = [ + { + "host": parsed.hostname, + "port": parsed.port or (443 if parsed.scheme == "https" else 80), + "scheme": parsed.scheme, + }, + ] + kwargs: dict[str, Any] = { + "hosts": hosts, + "use_ssl": parsed.scheme == "https", + "verify_certs": settings.elasticsearch_verify_certs, + "ssl_show_warn": False, + "request_timeout": 30, + "retry_on_timeout": True, + "max_retries": 3, + } + if settings.elasticsearch_username: + kwargs["http_auth"] = ( + settings.elasticsearch_username, + settings.elasticsearch_password or "", + ) + return OpenSearch(**kwargs) + + def _index_definitions(self) -> dict[str, dict[str, Any]]: + return { + settings.elasticsearch_bottleneck_index: { + "settings": { + "index": { + "number_of_shards": 1, + "number_of_replicas": 0, + }, + }, + "mappings": { + "dynamic": True, + "properties": { + "analysisType": {"type": "keyword"}, + "syncId": {"type": "keyword"}, + "snapshotId": {"type": "keyword"}, + "detectedAt": {"type": "date"}, + "analyzedAt": {"type": "date"}, + "eventId": {"type": "keyword"}, + "carMasterId": {"type": "long"}, + "mostBottleneckProcess": {"type": "keyword"}, + "mostBottleneckRiskLevel": {"type": "keyword"}, + "rankNo": {"type": "integer"}, + "manufacturingEventId": {"type": "long"}, + "processCode": {"type": "keyword"}, + "equipmentCode": {"type": "keyword"}, + "avgDelayTime": {"type": "double"}, + "affectedVehicleCount": {"type": "integer"}, + "riskScore": {"type": "double"}, + "riskLevel": {"type": "keyword"}, + "sourceService": {"type": "keyword"}, + }, + }, + }, + settings.elasticsearch_defect_transfer_index: { + "settings": { + "index": { + "number_of_shards": 1, + "number_of_replicas": 0, + }, + }, + "mappings": { + "dynamic": True, + "properties": { + "analysisType": {"type": "keyword"}, + "syncId": {"type": "keyword"}, + "eventId": {"type": "keyword"}, + "carMasterId": {"type": "long"}, + "vehicleId": {"type": "keyword"}, + "currentProcess": {"type": "keyword"}, + "currentProcessCode": {"type": "keyword"}, + "sourceProcessCode": {"type": "keyword"}, + "sourceEquipmentCode": {"type": "keyword"}, + "targetEquipmentCode": {"type": "keyword"}, + "predictedDefectProcess": {"type": "keyword"}, + "currentDefectProbability": {"type": "double"}, + "transferProbability": {"type": "double"}, + "defectThreshold": {"type": "double"}, + "transferThreshold": {"type": "double"}, + "defectProbability": {"type": "double"}, + "expectedTime": {"type": "keyword"}, + "expectedStepsAfter": {"type": "integer"}, + "riskLevel": {"type": "keyword"}, + "predictedAt": {"type": "date"}, + "createdAt": {"type": "date"}, + "sourceService": {"type": "keyword"}, + "mainCauses": { + "type": "nested", + "properties": { + "rank": {"type": "integer"}, + "feature": {"type": "keyword"}, + "label": {"type": "text"}, + "value": {"type": "keyword"}, + "impact": {"type": "double"}, + "message": {"type": "text"}, + }, + }, + }, + }, + }, + } + + @staticmethod + def _normalize_datetime(value: Any) -> str | None: + if value is None: + return None + if isinstance(value, datetime): + if value.tzinfo is None: + return value.replace(tzinfo=SEOUL_TZ).isoformat() + return value.astimezone(SEOUL_TZ).isoformat() + text = str(value).strip() + if not text: + return None + try: + parsed = datetime.fromisoformat(text.replace("Z", "+00:00")) + except ValueError: + return text + if parsed.tzinfo is None: + parsed = parsed.replace(tzinfo=SEOUL_TZ) + else: + parsed = parsed.astimezone(SEOUL_TZ) + return parsed.isoformat() + + @staticmethod + def _safe_int(value: Any) -> int | None: + if value is None: + return None + try: + return int(value) + except (TypeError, ValueError): + return None + + @staticmethod + def _safe_float(value: Any) -> float | None: + if value is None: + return None + try: + return float(value) + except (TypeError, ValueError): + return None + + @staticmethod + def _normalize_main_causes(value: Any) -> list[dict[str, Any]]: + if not isinstance(value, list): + return [] + normalized: list[dict[str, Any]] = [] + for cause in value: + if not isinstance(cause, dict): + continue + message = str(cause.get("message") or cause.get("label") or "").strip() + if not message: + continue + normalized.append( + { + "rank": ProcessAnalysisSearchRepository._safe_int(cause.get("rank")) or 0, + "feature": str(cause.get("feature") or ""), + "label": str(cause.get("label") or message), + "value": str(cause.get("value") or ""), + "impact": ProcessAnalysisSearchRepository._safe_float(cause.get("impact")) or 0.0, + "message": message, + }, + ) + return normalized + + @staticmethod + def _bottleneck_doc_id(snapshot_id: str, doc: dict[str, Any]) -> str: + rank_no = doc.get("rankNo") + process_code = str(doc.get("processCode") or "").strip().upper() or "UNKNOWN" + equipment_code = str(doc.get("equipmentCode") or "").strip().upper() or "UNKNOWN" + return f"{snapshot_id}:{rank_no}:{process_code}:{equipment_code}" + + @staticmethod + def _map_bottleneck_source(source: dict[str, Any]) -> dict[str, Any]: + return { + "analysis_type": source.get("analysisType"), + "sync_id": source.get("syncId"), + "snapshot_id": source.get("snapshotId"), + "detected_at": source.get("detectedAt"), + "analyzed_at": source.get("analyzedAt"), + "event_id": source.get("eventId"), + "car_master_id": source.get("carMasterId"), + "most_bottleneck_process": source.get("mostBottleneckProcess"), + "most_bottleneck_risk_level": source.get("mostBottleneckRiskLevel"), + "manufacturing_event_id": source.get("manufacturingEventId"), + "process_code": source.get("processCode"), + "equipment_code": source.get("equipmentCode"), + "rank_no": source.get("rankNo"), + "avg_delay_time": source.get("avgDelayTime"), + "affected_vehicle_count": source.get("affectedVehicleCount"), + "risk_score": source.get("riskScore"), + "risk_level": source.get("riskLevel"), + "source_service": source.get("sourceService"), + } + + @staticmethod + def _map_defect_source(source: dict[str, Any]) -> dict[str, Any]: + current_defect_probability = ProcessAnalysisSearchRepository._normalize_probability( + source.get("currentDefectProbability"), + ) + transfer_probability = ProcessAnalysisSearchRepository._normalize_probability( + source.get("transferProbability"), + ) + defect_probability = ProcessAnalysisSearchRepository._normalize_probability( + source.get("defectProbability"), + ) + if defect_probability is None and current_defect_probability is not None: + defect_probability = current_defect_probability + return { + "analysis_type": source.get("analysisType"), + "sync_id": source.get("syncId"), + "event_id": source.get("eventId"), + "vehicle_id": source.get("vehicleId"), + "car_master_id": source.get("carMasterId"), + "current_process": source.get("currentProcess"), + "current_process_code": source.get("currentProcessCode"), + "source_process_code": source.get("sourceProcessCode") or source.get("currentProcessCode"), + "source_equipment_code": source.get("sourceEquipmentCode"), + "target_equipment_code": source.get("targetEquipmentCode"), + "predicted_defect_process": source.get("predictedDefectProcess"), + "target_defect_probability": transfer_probability, + "defect_probability": defect_probability, + "current_defect_probability": current_defect_probability, + "transfer_probability": transfer_probability, + "defect_threshold": source.get("defectThreshold"), + "transfer_threshold": source.get("transferThreshold"), + "expected_time": source.get("expectedTime"), + "expected_steps_after": source.get("expectedStepsAfter"), + "expected_occurrence_step": source.get("expectedStepsAfter"), + "risk_level": source.get("riskLevel"), + "risk_grade": source.get("riskLevel"), + "predicted_at": source.get("predictedAt"), + "created_at": source.get("createdAt"), + "main_causes": source.get("mainCauses") or source.get("causes") or [], + "causes": source.get("causes") or source.get("mainCauses") or [], + "feature_values": source.get("featureValues") or {}, + "source_service": source.get("sourceService"), + "influence_score": ( + float((source.get("mainCauses") or [{}])[0].get("impact") or 0.0) + if isinstance(source.get("mainCauses"), list) and source.get("mainCauses") + else 0.0 + ), + } + + @staticmethod + def _normalize_probability(value: Any) -> float | None: + if value is None: + return None + normalized = float(value) + if abs(normalized) > 1.0: + normalized /= 100.0 + return round(normalized, 4) diff --git a/app/service/analysis/analysis_maintenance_service.py b/app/service/analysis/analysis_maintenance_service.py new file mode 100644 index 0000000..5c2b371 --- /dev/null +++ b/app/service/analysis/analysis_maintenance_service.py @@ -0,0 +1,855 @@ +from __future__ import annotations + +import logging +from datetime import date as DateType +from datetime import datetime +from pathlib import Path +from uuid import uuid4 +from typing import Any + +from sqlalchemy import select + +from app.core.config import settings +from app.dto.response.analysis_maintenance_response import ( + AnalysisMaintenanceResponse, + AnalysisMaintenanceSummary, +) +from app.ml.inference.bottleneck_detector import BottleneckDetector +from app.ml.inference.defect_transfer_detector import ( + DefectTransferDetector, + has_only_model_probability_cause, +) +from app.repository.bottleneck_analysis_repository import BottleneckAnalysisRepository +from app.repository.defect_transfer_prediction_repository import ( + DefectTransferPredictionRepository, +) +from app.repository.sampledb_schema import car_master +from app.search.process_analysis_search import ProcessAnalysisSearchRepository +from app.utils.database_utils import mysql_connect_args_for_seoul +from app.utils.datetime_utils import SEOUL_TZ, seoul_now +from app.utils.process_label_utils import NEXT_PROCESS, format_process_with_line +from app.utils.process_label_utils import equipment_code_for_car_process + + +logger = logging.getLogger(__name__) + + +class AnalysisMaintenanceService: + def __init__(self) -> None: + self.bottleneck_repository = BottleneckAnalysisRepository( + settings.bottleneck_database_url, + event_database_url=settings.sample_database_connection_url, + ) + self.defect_repository = DefectTransferPredictionRepository( + settings.main_database_connection_url, + event_database_url=settings.sample_database_connection_url or settings.main_database_connection_url, + ) + self.search_repository = self._create_search_repository() + self.bottleneck_detector = BottleneckDetector( + Path("app/ml/artifacts/bottleneck/bottleneck_iforest_model.pkl"), + ) + self.defect_detector = DefectTransferDetector() + + def backfill_bottleneck( + self, + *, + from_date: DateType, + to_date: DateType, + reindex_es: bool = True, + reset_flags: bool = True, + dry_run: bool = False, + ) -> AnalysisMaintenanceResponse: + items: list[AnalysisMaintenanceSummary] = [] + totals = self._empty_totals() + + for current_date in self._date_range(from_date, to_date): + histories = self.bottleneck_repository.list_manufacturing_event_histories( + analysis_date=current_date, + ) + source_count = len(histories) + if source_count == 0: + items.append( + self._summary( + "bottleneck", + current_date, + source_count=0, + processed=0, + saved=0, + skipped=0, + failed=0, + deleted=0, + reindexed=0, + notes=["no source events"], + ), + ) + continue + + if reset_flags and not dry_run: + self.bottleneck_repository.reset_bottleneck_analysis_done( + [ + int(row["manufacturing_event_id"]) + for row in histories + if row.get("manufacturing_event_id") is not None + ], + ) + + if dry_run: + items.append( + self._summary( + "bottleneck", + current_date, + source_count=source_count, + processed=source_count, + saved=source_count, + skipped=0, + failed=0, + deleted=0, + reindexed=0, + notes=["dry-run"], + ), + ) + totals["source_count"] += source_count + totals["processed_count"] += source_count + totals["saved_count"] += source_count + continue + + deleted_count = self.bottleneck_repository.delete_results_by_date(current_date) + new_summaries = self.bottleneck_detector.summarize_manufacturing_event_histories(histories) + ranked_summaries = self._rank_bottleneck_summaries(new_summaries) + detected_at = self._analysis_detected_at(histories) + self.bottleneck_repository.replace_results( + ranked_summaries, + detected_at=detected_at, + start_rank=1, + end_rank=max(len(ranked_summaries), 1), + ) + + es_reindexed_count = 0 + if reindex_es: + es_reindexed_count = self._reindex_bottleneck_day( + current_date=current_date, + histories=histories, + summaries=ranked_summaries, + detected_at=detected_at, + ) + + self.bottleneck_repository.mark_bottleneck_analysis_done( + [ + int(row["manufacturing_event_id"]) + for row in histories + if row.get("manufacturing_event_id") is not None + ], + ) + + items.append( + self._summary( + "bottleneck", + current_date, + source_count=source_count, + processed=source_count, + saved=len(ranked_summaries), + skipped=0, + failed=0, + deleted=deleted_count, + reindexed=es_reindexed_count, + notes=[], + ), + ) + totals["source_count"] += source_count + totals["processed_count"] += source_count + totals["saved_count"] += len(ranked_summaries) + totals["deleted_count"] += deleted_count + totals["es_reindexed_count"] += es_reindexed_count + self._clear_analysis_caches() + + return self._response("backfill", items, totals) + + def backfill_defect_transfer( + self, + *, + from_date: DateType, + to_date: DateType, + reindex_es: bool = True, + reset_flags: bool = True, + dry_run: bool = False, + ) -> AnalysisMaintenanceResponse: + items: list[AnalysisMaintenanceSummary] = [] + totals = self._empty_totals() + + for current_date in self._date_range(from_date, to_date): + source_rows = self.defect_repository.list_prediction_source_events( + analysis_date=current_date, + ) + source_count = len(source_rows) + if source_count == 0: + items.append( + self._summary( + "defect-transfer", + current_date, + source_count=0, + processed=0, + saved=0, + skipped=0, + failed=0, + deleted=0, + reindexed=0, + notes=["no source events"], + ), + ) + continue + + if reset_flags and not dry_run: + self.defect_repository.delete_source_analysis_done_flags( + event_ids=[int(row["id"]) for row in source_rows], + column_name="defect_transfer_analysis_done", + ) + + if dry_run: + items.append( + self._summary( + "defect-transfer", + current_date, + source_count=source_count, + processed=source_count, + saved=source_count, + skipped=0, + failed=0, + deleted=0, + reindexed=0, + notes=["dry-run"], + ), + ) + totals["source_count"] += source_count + totals["processed_count"] += source_count + totals["saved_count"] += source_count + continue + + deleted_count = self.defect_repository.delete_predictions_by_date(current_date) + processed = 0 + saved = 0 + skipped = 0 + failed = 0 + for row in source_rows: + try: + prediction = self.defect_detector.predict_event( + self._event_json(row.get("event_json")), + str(row.get("process_code") or ""), + ) + if has_only_model_probability_cause(prediction.causes): + skipped += 1 + continue + predicted_at = self._predict_at(row, current_date) + saved += self.defect_repository.replace_prediction_result( + event_id=str(row["event_id"]), + car_master_id=int(row["car_master_id"]), + source_process_code=prediction.current_process_code, + target_process_code=prediction.predicted_process_code, + current_defect_probability=prediction.defect_probability, + target_defect_probability=prediction.transfer_probability, + predicted_defect_process=self._format_predicted_defect_process( + prediction.predicted_process_code, + row, + ), + expected_occurrence_step=prediction.expected_steps_after, + risk_grade=prediction.risk_level, + causes=[ + { + "message": cause.message, + "label": cause.label, + "impact": cause.impact, + } + for cause in prediction.causes + ], + predicted_at=predicted_at, + ) + processed += 1 + self.defect_repository.mark_defect_transfer_analysis_done(str(row["event_id"])) + except Exception: + failed += 1 + logger.exception( + "Failed to backfill defect transfer prediction: event_id=%s", + row.get("event_id"), + ) + + es_reindexed_count = 0 + if reindex_es: + es_reindexed_count = self._reindex_defect_transfer_day( + current_date=current_date, + source_rows=source_rows, + ) + + items.append( + self._summary( + "defect-transfer", + current_date, + source_count=source_count, + processed=processed, + saved=saved, + skipped=skipped, + failed=failed, + deleted=deleted_count, + reindexed=es_reindexed_count, + notes=[], + ), + ) + totals["source_count"] += source_count + totals["processed_count"] += processed + totals["saved_count"] += saved + totals["skipped_count"] += skipped + totals["failed_count"] += failed + totals["deleted_count"] += deleted_count + totals["es_reindexed_count"] += es_reindexed_count + self._clear_analysis_caches() + + return self._response("backfill", items, totals) + + def reindex_bottleneck( + self, + *, + from_date: DateType, + to_date: DateType, + dry_run: bool = False, + ) -> AnalysisMaintenanceResponse: + items: list[AnalysisMaintenanceSummary] = [] + totals = self._empty_totals() + + for current_date in self._date_range(from_date, to_date): + histories = self.bottleneck_repository.list_manufacturing_event_histories( + analysis_date=current_date, + ) + source_count = len(histories) + if source_count == 0: + items.append( + self._summary( + "bottleneck", + current_date, + source_count=0, + processed=0, + saved=0, + skipped=0, + failed=0, + deleted=0, + reindexed=0, + notes=["no source events"], + ), + ) + continue + + if dry_run: + items.append( + self._summary( + "bottleneck", + current_date, + source_count=source_count, + processed=source_count, + saved=source_count, + skipped=0, + failed=0, + deleted=0, + reindexed=0, + notes=["dry-run"], + ), + ) + totals["source_count"] += source_count + totals["processed_count"] += source_count + totals["saved_count"] += source_count + continue + + summaries = self._rank_bottleneck_summaries( + self.bottleneck_detector.summarize_manufacturing_event_histories(histories), + ) + detected_at = self._analysis_detected_at(histories) + es_reindexed_count = self._reindex_bottleneck_day( + current_date=current_date, + histories=histories, + summaries=summaries, + detected_at=detected_at, + ) + + items.append( + self._summary( + "bottleneck", + current_date, + source_count=source_count, + processed=source_count, + saved=len(summaries), + skipped=0, + failed=0, + deleted=0, + reindexed=es_reindexed_count, + notes=[], + ), + ) + totals["source_count"] += source_count + totals["processed_count"] += source_count + totals["saved_count"] += len(summaries) + totals["es_reindexed_count"] += es_reindexed_count + self._clear_analysis_caches() + + return self._response("reindex", items, totals) + + def reindex_defect_transfer( + self, + *, + from_date: DateType, + to_date: DateType, + dry_run: bool = False, + ) -> AnalysisMaintenanceResponse: + items: list[AnalysisMaintenanceSummary] = [] + totals = self._empty_totals() + + for current_date in self._date_range(from_date, to_date): + source_rows = self.defect_repository.list_prediction_source_events( + analysis_date=current_date, + ) + source_count = len(source_rows) + if source_count == 0: + items.append( + self._summary( + "defect-transfer", + current_date, + source_count=0, + processed=0, + saved=0, + skipped=0, + failed=0, + deleted=0, + reindexed=0, + notes=["no source events"], + ), + ) + continue + + if dry_run: + items.append( + self._summary( + "defect-transfer", + current_date, + source_count=source_count, + processed=source_count, + saved=source_count, + skipped=0, + failed=0, + deleted=0, + reindexed=0, + notes=["dry-run"], + ), + ) + totals["source_count"] += source_count + totals["processed_count"] += source_count + totals["saved_count"] += source_count + continue + + es_reindexed_count = self._reindex_defect_transfer_day( + current_date=current_date, + source_rows=source_rows, + ) + items.append( + self._summary( + "defect-transfer", + current_date, + source_count=source_count, + processed=source_count, + saved=0, + skipped=0, + failed=0, + deleted=0, + reindexed=es_reindexed_count, + notes=[], + ), + ) + totals["source_count"] += source_count + totals["processed_count"] += source_count + totals["es_reindexed_count"] += es_reindexed_count + self._clear_analysis_caches() + + return self._response("reindex", items, totals) + + def _reindex_bottleneck_day( + self, + *, + current_date: DateType, + histories: list[dict[str, Any]], + summaries: list[dict[str, Any]], + detected_at: datetime, + ) -> int: + if self.search_repository is None: + return 0 + self.search_repository.delete_bottleneck_documents_by_date(current_date) + sync_event = self._build_bottleneck_sync_event( + histories=histories, + summaries=summaries, + detected_at=detected_at, + ) + self.search_repository.index_bottleneck_snapshot(sync_event) + return len(summaries) + + def _reindex_defect_transfer_day( + self, + *, + current_date: DateType, + source_rows: list[dict[str, Any]], + ) -> int: + if self.search_repository is None: + return 0 + self.search_repository.delete_defect_transfer_documents_by_date(current_date) + indexed = 0 + for row in source_rows: + try: + prediction = self.defect_detector.predict_event( + self._event_json(row.get("event_json")), + str(row.get("process_code") or ""), + ) + if has_only_model_probability_cause(prediction.causes): + continue + sync_event = self._build_defect_transfer_sync_event( + row=row, + prediction=prediction, + ) + self.search_repository.index_defect_transfer_prediction(sync_event) + indexed += 1 + except Exception: + logger.exception( + "Failed to reindex defect transfer document: event_id=%s", + row.get("event_id"), + ) + return indexed + + def _build_bottleneck_sync_event( + self, + *, + histories: list[dict[str, Any]], + summaries: list[dict[str, Any]], + detected_at: datetime, + ) -> dict[str, Any]: + sync_id = f"SNAP-{uuid4()}" + first_history = histories[0] + first_summary = summaries[0] if summaries else {} + detected_at_iso = self._to_seoul_iso(detected_at) + return { + "syncId": sync_id, + "analysisType": "BOTTLENECK_ANALYSIS_SYNC", + "sourceService": "AI_SERVICE", + "detectedAt": detected_at_iso, + "analyzedAt": detected_at_iso, + "eventId": first_history.get("event_id"), + "carMasterId": first_history.get("car_master_id"), + "mostBottleneckProcess": first_summary.get("process_code"), + "mostBottleneckRiskLevel": self._risk_level(float(first_summary.get("risk_score") or 0.0)), + "items": [ + { + "manufacturingEventId": summary.get("manufacturing_event_id"), + "carMasterId": summary.get("car_master_id") or first_history.get("car_master_id"), + "processCode": summary.get("process_code"), + "equipmentCode": summary.get("equipment_code"), + "rankNo": summary.get("rank_no"), + "avgDelayTime": summary.get("avg_delay_time"), + "affectedVehicleCount": summary.get("affected_vehicle_count"), + "riskScore": summary.get("risk_score"), + "riskLevel": self._risk_level(float(summary.get("risk_score") or 0.0)), + } + for summary in summaries + ], + } + + def _build_defect_transfer_sync_event( + self, + *, + row: dict[str, Any], + prediction: Any, + ) -> dict[str, Any]: + sync_id = f"SYNC-{uuid4()}" + event_json = self._event_json(row.get("event_json")) + vehicle_id = self._vehicle_id_for_car_master_id(int(row["car_master_id"])) + source_equipment_code = self._source_equipment_code(row, event_json) + current_process = format_process_with_line( + str(row.get("process_code") or ""), + source_equipment_code, + ) + predicted_process = self._format_predicted_defect_process( + prediction.predicted_process_code, + row, + ) + target_equipment_code = self._target_equipment_code( + prediction.predicted_process_code, + row, + event_json, + ) + fallback_date = self._analysis_date(row) + predicted_at = self._predict_at(row, fallback_date) + predicted_at_iso = self._to_seoul_iso(predicted_at) + causes = [ + { + "rank": cause.rank, + "feature": cause.feature, + "label": cause.label, + "value": cause.value, + "impact": cause.impact, + "message": cause.message, + } + for cause in prediction.causes + ] + return { + "syncId": sync_id, + "analysisType": "DEFECT_TRANSFER_ANALYSIS_SYNC", + "sourceService": "AI_SERVICE", + "eventId": row["event_id"], + "carMasterId": row["car_master_id"], + "vehicleId": vehicle_id, + "currentProcessCode": prediction.current_process_code, + "currentProcess": current_process, + "sourceEquipmentCode": source_equipment_code, + "targetEquipmentCode": target_equipment_code, + "predictedDefectProcess": predicted_process, + "defectProbability": round(prediction.defect_probability, 4), + "currentDefectProbability": prediction.defect_probability, + "transferProbability": prediction.transfer_probability, + "defectThreshold": prediction.defect_threshold, + "transferThreshold": prediction.transfer_threshold, + "expectedStepsAfter": prediction.expected_steps_after, + "expectedTime": ( + f"{prediction.expected_steps_after} steps later" + if prediction.expected_steps_after is not None + else None + ), + "riskLevel": prediction.risk_level, + "predictedAt": predicted_at_iso, + "createdAt": predicted_at_iso, + "mainCauses": causes, + "causes": causes, + "featureValues": prediction.feature_values, + } + + @staticmethod + def _source_equipment_code(row: dict[str, Any], event_json: dict[str, Any]) -> str | None: + equipment = event_json.get("equipment", {}) if isinstance(event_json, dict) else {} + code = equipment.get("equipmentCode") if isinstance(equipment, dict) else None + if code: + return str(code) + equipment_id = row.get("equipment_id") + return str(equipment_id) if equipment_id is not None else None + + def _vehicle_id_for_car_master_id(self, car_master_id: int) -> str | None: + with self.defect_repository.event_engine.connect() as conn: + value = conn.execute( + select(car_master.c.vehicle_id).where(car_master.c.id == car_master_id), + ).scalar() + return str(value) if value is not None else None + + @staticmethod + def _analysis_date(row: dict[str, Any]) -> DateType: + value = row.get("event_time") + if isinstance(value, datetime): + return AnalysisMaintenanceService._to_seoul_naive(value).date() + return seoul_now().date() + + @staticmethod + def _predict_at(row: dict[str, Any], fallback_date: DateType) -> datetime: + value = row.get("event_time") + if isinstance(value, datetime): + return AnalysisMaintenanceService._to_seoul_naive(value) + return datetime.combine(fallback_date, datetime.min.time()) + + @staticmethod + def _format_predicted_defect_process( + process_code: str | None, + row: dict[str, Any], + ) -> str | None: + if process_code is None: + return None + normalized = str(process_code).strip().upper() + source_code = str(row.get("process_code") or "").strip().upper() + if normalized == source_code: + event_json = row.get("event_json") + if isinstance(event_json, dict): + equipment = event_json.get("equipment", {}) + equipment_code = str(equipment.get("equipmentCode") or "") + else: + equipment_code = "" + else: + equipment_code = equipment_code_for_car_process( + car_master_id=int(row["car_master_id"]), + process_code=normalized, + ) + return format_process_with_line(normalized, equipment_code) + + @staticmethod + def _target_equipment_code( + process_code: str | None, + row: dict[str, Any], + event_json: dict[str, Any], + ) -> str | None: + if process_code is None: + return None + normalized = str(process_code).strip().upper() + source_code = str(row.get("process_code") or "").strip().upper() + if normalized == source_code: + return AnalysisMaintenanceService._source_equipment_code(row, event_json) + return equipment_code_for_car_process( + car_master_id=int(row["car_master_id"]), + process_code=normalized, + ) + + @staticmethod + def _date_range(from_date: DateType, to_date: DateType): + current = from_date + while current <= to_date: + yield current + current = current.fromordinal(current.toordinal() + 1) + + @staticmethod + def _risk_level(risk_score: float) -> str: + return "HIGH" if risk_score >= 3.0 else "NORMAL" + + @staticmethod + def _analysis_detected_at(histories: list[dict[str, Any]]) -> datetime: + candidates = [ + AnalysisMaintenanceService._to_seoul_naive(value) + for value in (row.get("event_time") for row in histories) + if isinstance(value, datetime) + ] + if candidates: + return max(candidates) + return seoul_now().replace(tzinfo=None) + + @staticmethod + def _to_seoul_naive(value: datetime) -> datetime: + if value.tzinfo is None: + return value + return value.astimezone(SEOUL_TZ).replace(tzinfo=None) + + @staticmethod + def _to_seoul_iso(value: datetime) -> str: + if value.tzinfo is None: + return value.replace(tzinfo=SEOUL_TZ).isoformat() + return value.astimezone(SEOUL_TZ).isoformat() + + @staticmethod + def _rank_bottleneck_summaries( + summaries: list[dict[str, Any]], + ) -> list[dict[str, Any]]: + ranked = sorted( + summaries, + key=lambda row: ( + float(row.get("risk_score") or 0.0), + float(row.get("avg_delay_time") or 0.0), + int(row.get("affected_vehicle_count") or 0), + int(row.get("manufacturing_event_id") or 0), + int(row.get("car_master_id") or 0), + str(row.get("process_code") or "").strip().upper(), + str(row.get("equipment_code") or "").strip().upper(), + ), + reverse=True, + ) + deduped: list[dict[str, Any]] = [] + seen_keys: set[tuple[str, str]] = set() + for row in ranked: + key = ( + str(row.get("process_code") or "").strip().upper(), + str(row.get("equipment_code") or "").strip().upper(), + ) + if key in seen_keys: + continue + seen_keys.add(key) + deduped.append(row) + return [{**row, "rank_no": index + 1} for index, row in enumerate(deduped)] + + @staticmethod + def _event_json(value: Any) -> dict[str, Any]: + if isinstance(value, dict): + return value + return {} + + @staticmethod + def _empty_totals() -> dict[str, int]: + return { + "source_count": 0, + "processed_count": 0, + "saved_count": 0, + "skipped_count": 0, + "failed_count": 0, + "deleted_count": 0, + "es_reindexed_count": 0, + } + + @staticmethod + def _summary( + analysis_name: str, + source_from: DateType, + *, + source_count: int, + processed: int, + saved: int, + skipped: int, + failed: int, + deleted: int, + reindexed: int, + notes: list[str], + ) -> AnalysisMaintenanceSummary: + return AnalysisMaintenanceSummary( + analysisName=analysis_name, + sourceFrom=source_from, + sourceTo=source_from, + sourceCount=source_count, + processedCount=processed, + savedCount=saved, + skippedCount=skipped, + failedCount=failed, + deletedCount=deleted, + esReindexedCount=reindexed, + notes=notes, + ) + + @staticmethod + def _response( + mode: str, + items: list[AnalysisMaintenanceSummary], + totals: dict[str, int], + ) -> AnalysisMaintenanceResponse: + return AnalysisMaintenanceResponse( + mode=mode, + items=items, + totalSourceCount=totals["source_count"], + totalProcessedCount=totals["processed_count"], + totalSavedCount=totals["saved_count"], + totalSkippedCount=totals["skipped_count"], + totalFailedCount=totals["failed_count"], + totalDeletedCount=totals["deleted_count"], + totalEsReindexedCount=totals["es_reindexed_count"], + extra={}, + ) + + @staticmethod + def _create_search_repository() -> ProcessAnalysisSearchRepository | None: + if not settings.elasticsearch_url: + return None + try: + repository = ProcessAnalysisSearchRepository() + repository.ensure_indices() + return repository + except Exception: + logger.exception("Elasticsearch maintenance repository is unavailable.") + return None + + @staticmethod + def _clear_analysis_caches() -> None: + if not settings.redis_url: + return + try: + from redis import Redis + + redis_client = Redis.from_url( + settings.redis_connection_url, + decode_responses=True, + ) + patterns = [ + f"{settings.redis_key_prefix}:process:bottleneck:*", + f"{settings.redis_key_prefix}:process:defect-transfer:*", + ] + keys: list[str] = [] + for pattern in patterns: + keys.extend(list(redis_client.scan_iter(match=pattern))) + if keys: + redis_client.delete(*keys) + except Exception: + logger.exception("Failed to clear analysis caches after maintenance.") diff --git a/app/service/analysis/bottleneck_service.py b/app/service/analysis/bottleneck_service.py index 08268c3..79da595 100644 --- a/app/service/analysis/bottleneck_service.py +++ b/app/service/analysis/bottleneck_service.py @@ -1,3 +1,10 @@ +from __future__ import annotations + +import logging +import re +from collections import Counter +from datetime import date as DateType +from datetime import datetime from pathlib import Path from typing import Any @@ -5,30 +12,51 @@ from app.core.config import settings from app.core.exceptions import AppException -from app.dto.response import BottleneckAnalysisItem, BottleneckAnalysisPage +from app.dto.response import ( + AnalysisDateOption, + BottleneckAnalysisItem, + BottleneckAnalysisPage, +) from app.ml.inference.bottleneck_detector import BottleneckDetector from app.repository.bottleneck_analysis_repository import BottleneckAnalysisRepository -from app.utils.datetime_utils import seoul_now_iso +from app.search.process_analysis_search import ProcessAnalysisSearchRepository +from app.utils.datetime_utils import SEOUL_TZ, seoul_now from app.utils.json_utils import from_json, to_json -DEFAULT_BOTTLENECK_MODEL_PATH = Path("app/ml/artifacts/bottleneck_iforest_model.pkl") +DEFAULT_BOTTLENECK_MODEL_PATH = Path("app/ml/artifacts/bottleneck/bottleneck_iforest_model.pkl") +BOTTLENECK_CACHE_VERSION = "v14" +PROCESS_CODE_LABELS = { + "PRESS": "프레스", + "BODY": "차체", + "PAINT": "도장", + "ASSEMBLY": "의장", + "INSPECTION": "검사", +} +PROCESS_EQUIPMENT_PREFIXES = { + "PRESS": "P", + "BODY": "S", + "PAINT": "L", + "ASSEMBLY": "A", + "INSPECTION": "I", +} +logger = logging.getLogger(__name__) class BottleneckAnalysisService: - """공정 이력 데이터를 분석해 병목 순위 결과를 제공하는 서비스""" - + """병목 분석 결과를 조회하고 필요 시 원천 이벤트를 다시 분석한다.""" def __init__( self, *, model_path: str | Path | None = None, database_url: str | None = None, ) -> None: - """병목 분석에 필요한 저장소, 모델, Redis 클라이언트 상태를 초기화""" self.model_path = Path(model_path or DEFAULT_BOTTLENECK_MODEL_PATH) self.repository = BottleneckAnalysisRepository( database_url or settings.bottleneck_database_url, + event_database_url=settings.sample_database_connection_url, ) + self.search_repository = self._create_search_repository() self.detector = BottleneckDetector(self.model_path) self._redis_client: Any | None = None @@ -37,37 +65,87 @@ def get_realtime_bottlenecks( *, cursor: int | None, size: int, + date: DateType | None = None, ) -> BottleneckAnalysisPage: - """현재 공정 이력을 분석하고 순위가 매겨진 결과 페이지를 반환""" + """병목 결과를 ES 우선으로 읽고, 실패 시 캐시와 DB로 내려준다.""" + # ES를 우선 조회하고, 실패하면 Redis와 DB 순으로 안전하게 내려간다. size = max(1, min(size, 100)) page = max(cursor or 0, 0) - - saved_count, has_next = self.run_analysis_and_save(cursor=page, size=size) - - # 저장소에서 요청 페이지 범위만 조회 - rows = self.repository.list_results(cursor=page, size=size) - if saved_count == 0 or not rows: - raise AppException( - "병목 분석 결과를 찾을 수 없습니다.", - status_code=status.HTTP_404_NOT_FOUND, + cache_key = self._bottleneck_cache_key( + cursor=cursor, + size=size, + date=date, + ) + date_options = self._safe_get_date_options() + selected_date = self._resolve_date(date, date_options) + rows: list[dict[str, Any]] + has_next = False + if self.search_repository is not None: + try: + rows, has_next = self.search_repository.list_bottleneck_page( + cursor=page, + size=size, + analysis_date=selected_date, + ) + except Exception: + logger.exception("Elasticsearch bottleneck query failed. Falling back to DB.") + cached_value = self._cache_get(cache_key) + if cached_value: + return BottleneckAnalysisPage.model_validate(from_json(cached_value)) + rows = self.repository.list_results( + cursor=page, + size=size, + analysis_date=selected_date, + ) + has_next = self.repository.count_results( + analysis_date=selected_date, + ) > (page + 1) * size + else: + cached_value = self._cache_get(cache_key) + if cached_value: + return BottleneckAnalysisPage.model_validate(from_json(cached_value)) + rows = self.repository.list_results( + cursor=page, + size=size, + analysis_date=selected_date, + ) + has_next = self.repository.count_results( + analysis_date=selected_date, + ) > (page + 1) * size + if not rows: + return BottleneckAnalysisPage( + mostBottleneckProcess=None, + mostBottleneckRiskLevel=None, + date=selected_date, + dateOptions=date_options, + content=[], + hasNext=False, + nextCursor=None, ) - next_cursor = page + 1 if has_next else None + top_row = rows[0] return BottleneckAnalysisPage( + mostBottleneckProcess=self._format_process_label(top_row["process_code"]), + mostBottleneckRiskLevel=self._risk_level_label(float(top_row["risk_score"])), + date=selected_date, + dateOptions=date_options, content=[ BottleneckAnalysisItem( rankNo=int(row["rank_no"]), - processCode=str(row["process_code"]), - stationCode=str(row["station_code"]), - avgDelayTime=round(float(row["avg_delay_time"]), 1), + processCode=self._format_process_code( + row["process_code"], + row.get("equipment_code"), + ), + delayTime=round(float(row["avg_delay_time"]), 2), affectedVehicleCount=int(row["affected_vehicle_count"]), - riskScore=int(row["risk_score"]), + riskScore=float(row["risk_score"]), + riskLevel=self._risk_level_label(float(row["risk_score"])), ) for row in rows ], hasNext=has_next, - nextCursor=next_cursor, + nextCursor=page + 1 if has_next else None, ) def get_cached_realtime_bottlenecks( @@ -75,76 +153,69 @@ def get_cached_realtime_bottlenecks( *, cursor: int | None, size: int, + date: DateType | None = None, ) -> BottleneckAnalysisPage: - """Redis에 결과가 있으면 반환하고, 없으면 분석 후 캐시에 저장""" - cache_key = self._bottleneck_cache_key(cursor=cursor, size=size) - try: - redis_client = self._redis() - # cursor와 size를 key에 포함해 페이지별 캐시를 분리 - cached_value = redis_client.get(cache_key) - if cached_value: - return BottleneckAnalysisPage.model_validate(from_json(cached_value)) - except Exception as exc: - self._redis_client = None - raise AppException( - "Redis 캐시 조회에 실패했습니다.", - status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, - ) from exc - - page = self.get_realtime_bottlenecks(cursor=cursor, size=size) - try: - # 오래된 결과가 과도하게 남지 않도록 설정된 TTL로 저장 - self._redis().setex( - cache_key, - settings.redis_cache_ttl_seconds, - to_json(page.model_dump(by_alias=False)), - ) - except Exception as exc: - self._redis_client = None - raise AppException( - "Redis 캐시 저장에 실패했습니다.", - status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, - ) from exc + """조회한 병목 결과를 Redis 캐시에 저장한 뒤 반환한다.""" + cache_key = self._bottleneck_cache_key( + cursor=cursor, + size=size, + date=date, + ) + page = self.get_realtime_bottlenecks( + cursor=cursor, + size=size, + date=date, + ) + self._cache_set(cache_key, page.model_dump(by_alias=False)) return page def run_analysis_and_save(self, *, cursor: int, size: int) -> tuple[int, bool]: - """전체 공정 이력을 분석하고 요청한 순위 페이지 결과만 저장""" - histories = self.repository.list_product_process_histories() + """원천 이벤트를 다시 분석해 병목 결과를 갱신한다.""" + merged_summaries = self.refresh_results_from_events() + offset = cursor * size + page_summaries = merged_summaries[offset : offset + size] + has_next = len(merged_summaries) > offset + size + return len(page_summaries), has_next + + def refresh_results_from_events(self) -> list[dict[str, Any]]: + """아직 분석되지 않은 원천 이벤트만 읽어 병목 순위를 재계산한다.""" + # 아직 분석되지 않은 원천 이벤트를 다시 읽어서 병목 순위를 갱신한다. + histories = self.repository.list_pending_manufacturing_event_histories() if not histories: - raise AppException( - "공정 이력 데이터를 찾을 수 없습니다.", - status_code=status.HTTP_404_NOT_FOUND, - ) + return self._current_bottleneck_results() if not self.model_path.exists(): raise AppException( - f"병목 탐지 모델을 찾을 수 없습니다: {self.model_path}", + f"Bottleneck model not found: {self.model_path}", status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, ) - summaries = self.detector.summarize_product_process_histories(histories) - offset = cursor * size - page_summaries = summaries[offset : offset + size] - has_next = len(summaries) > offset + size - - if page_summaries: - start_rank = offset + 1 - end_rank = offset + len(page_summaries) - self.repository.replace_results( - page_summaries, - detected_at=seoul_now_iso(), - start_rank=start_rank, - end_rank=end_rank, - ) - return len(page_summaries), has_next + new_summaries = self.detector.summarize_manufacturing_event_histories(histories) + merged_summaries = self._rank_bottleneck_summaries( + self._current_bottleneck_results() + new_summaries, + ) + detected_at = self._analysis_detected_at(histories) + self.repository.replace_results( + merged_summaries, + detected_at=detected_at, + start_rank=1, + end_rank=max(len(merged_summaries), 1), + ) + self.repository.mark_bottleneck_analysis_done( + [ + int(row["manufacturing_event_id"]) + for row in histories + if row.get("manufacturing_event_id") is not None + ], + ) + return merged_summaries def _redis(self) -> Any: - """병목 캐시 작업에 사용할 Redis 클라이언트를 생성하고 재사용""" if self._redis_client is None: try: from redis import Redis except ModuleNotFoundError as exc: - raise RuntimeError("병목 캐시를 사용하려면 redis 패키지가 필요합니다.") from exc + raise RuntimeError("redis package is required for bottleneck cache.") from exc self._redis_client = Redis.from_url( settings.redis_connection_url, @@ -152,12 +223,194 @@ def _redis(self) -> Any: ) return self._redis_client - def _bottleneck_cache_key(self, *, cursor: int | None, size: int) -> str: - """요청한 병목 결과 페이지에 대한 Redis key를 생성""" + def _cache_get(self, cache_key: str) -> str | None: + if not settings.redis_url: + return None + try: + return self._redis().get(cache_key) + except Exception: + self._redis_client = None + logger.exception("Bottleneck Redis cache lookup failed.") + return None + + def _cache_set(self, cache_key: str, data: dict[str, Any]) -> None: + if not settings.redis_url: + return + try: + self._redis().setex( + cache_key, + settings.redis_cache_ttl_seconds, + to_json(data), + ) + except Exception: + self._redis_client = None + logger.exception("Bottleneck Redis cache write failed.") + + def _bottleneck_cache_key( + self, + *, + cursor: int | None, + size: int, + date: DateType | None, + ) -> str: page = max(cursor or 0, 0) safe_size = max(1, min(size, 100)) - return f"{settings.redis_key_prefix}:process:bottleneck:{page}:{safe_size}" + return ( + f"{settings.redis_key_prefix}:process:bottleneck:" + f"{BOTTLENECK_CACHE_VERSION}:{self._safe_cache_part(date.isoformat() if date else None)}:{page}:{safe_size}" + ) + + @staticmethod + def _safe_cache_part(value: str | None) -> str: + text = str(value or "__default__").strip() + return text.replace(":", "_").replace("/", "_").replace("\\", "_") + + @staticmethod + def _format_process_code( + process_code: Any, + equipment_code: Any | None = None, + ) -> str: + normalized = str(process_code or "").strip().upper() + label = PROCESS_CODE_LABELS.get(normalized, normalized) + prefix = PROCESS_EQUIPMENT_PREFIXES.get(normalized) + equipment_no = BottleneckAnalysisService._equipment_number(equipment_code) + if prefix and equipment_no is not None: + return f"{label} ({prefix}{equipment_no})" + return label + + @staticmethod + def _format_process_label(process_code: Any) -> str: + normalized = str(process_code or "").strip().upper() + return PROCESS_CODE_LABELS.get(normalized, normalized) + + @staticmethod + def _risk_level_label(risk_score: float) -> str: + return "HIGH" if risk_score >= 3.0 else "NORMAL" + + def _current_bottleneck_results(self) -> list[dict[str, Any]]: + total_count = self.repository.count_results() + if total_count <= 0: + return [] + return self.repository.list_results( + cursor=0, + size=total_count, + ) + + def _get_date_options(self) -> list[AnalysisDateOption]: + """화면용 날짜 옵션을 detected_at 스냅샷 기준으로 만든다.""" + # 화면의 날짜 선택 옵션은 detected_at 스냅샷 기준으로 구성한다. + if self.search_repository is not None: + try: + options = self.search_repository.list_bottleneck_date_options() + except Exception: + logger.exception("Failed to load bottleneck date options from Elasticsearch.") + options = self.repository.list_date_options() + else: + options = self.repository.list_date_options() + return [ + AnalysisDateOption.model_validate( + { + "date": row["date"], + "sampleEventId": row.get("sample_event_id"), + }, + ) + for row in options + if row.get("date") is not None + ] + + def _safe_get_date_options(self) -> list[AnalysisDateOption]: + """날짜 옵션 조회 실패 시 빈 목록으로 안전하게 처리한다.""" + # 날짜 옵션 조회 실패로 전체 API가 깨지지 않도록 방어한다. + try: + return self._get_date_options() + except Exception: + logger.exception("Failed to load bottleneck date options.") + return [] + + @staticmethod + def _resolve_date( + requested_date: DateType | None, + date_options: list[AnalysisDateOption], + ) -> DateType | None: + if requested_date is not None: + return requested_date + if date_options: + return date_options[0].date + return None + + @staticmethod + def _analysis_detected_at(histories: list[dict[str, Any]]) -> datetime: + """분석된 이벤트 묶음의 기준 detected_at 시각을 계산한다.""" + candidates = [ + BottleneckAnalysisService._to_seoul_naive(value) + for value in (row.get("event_time") for row in histories) + if isinstance(value, datetime) + ] + if candidates: + return max(candidates) + return seoul_now().replace(tzinfo=None) + + @staticmethod + def _to_seoul_naive(value: datetime) -> datetime: + if value.tzinfo is None: + return value + return value.astimezone(SEOUL_TZ).replace(tzinfo=None) + + @staticmethod + def _create_search_repository() -> ProcessAnalysisSearchRepository | None: + """ES 설정이 있으면 검색 저장소를 만들고, 없으면 사용하지 않는다.""" + if not settings.elasticsearch_url: + return None + try: + repository = ProcessAnalysisSearchRepository() + repository.ensure_indices() + return repository + except Exception: + logger.exception("Elasticsearch bottleneck repository is unavailable.") + return None + + @staticmethod + def _rank_bottleneck_summaries( + summaries: list[dict[str, Any]], + ) -> list[dict[str, Any]]: + """병목 점수와 지연 시간을 기준으로 결과를 정렬한다.""" + ranked = sorted( + summaries, + key=lambda row: ( + float(row.get("risk_score") or 0.0), + float(row.get("avg_delay_time") or 0.0), + int(row.get("affected_vehicle_count") or 0), + int(row.get("manufacturing_event_id") or 0), + int(row.get("car_master_id") or 0), + str(row.get("process_code") or "").strip().upper(), + str(row.get("equipment_code") or "").strip().upper(), + ), + reverse=True, + ) + deduped: list[dict[str, Any]] = [] + seen_keys: set[tuple[str, str]] = set() + + for row in ranked: + key = ( + str(row.get("process_code") or "").strip().upper(), + str(row.get("equipment_code") or "").strip().upper(), + ) + if key in seen_keys: + continue + seen_keys.add(key) + deduped.append(row) + + return [{**row, "rank_no": index + 1} for index, row in enumerate(deduped)] + + @staticmethod + def _equipment_number(equipment_code: Any | None) -> int | None: + if equipment_code is None: + return None + match = re.search(r"(\d+)$", str(equipment_code).strip()) + if not match: + return None + return int(match.group(1)) + def get_bottleneck_analysis_service() -> BottleneckAnalysisService: - """FastAPI 의존성 주입에 사용할 병목 분석 서비스를 생성""" return BottleneckAnalysisService() diff --git a/app/service/analysis/defect_transfer_service.py b/app/service/analysis/defect_transfer_service.py new file mode 100644 index 0000000..b313049 --- /dev/null +++ b/app/service/analysis/defect_transfer_service.py @@ -0,0 +1,681 @@ +from __future__ import annotations + +import logging +from functools import lru_cache +from datetime import date as DateType +from typing import Any + +from fastapi import status +from sqlalchemy.exc import SQLAlchemyError + +from app.core.config import settings +from app.core.exceptions import AppException +from app.dto.response import AnalysisDateOption +from app.dto.response.defect_transfer_response import ( + DefectTransferCauseItem, + DefectTransferCausePage, + DefectTransferPredictionItem, + DefectTransferPredictionPage, +) +from app.repository.defect_transfer_prediction_repository import ( + DefectTransferPredictionRepository, +) +from app.search.process_analysis_search import ProcessAnalysisSearchRepository +from app.utils.json_utils import from_json, to_json +from app.utils.process_label_utils import ( + NEXT_PROCESS, + equipment_code_for_car_process, + format_process_with_line, +) + + +DEFECT_TRANSFER_CACHE_VERSION = "v11" +logger = logging.getLogger(__name__) + + +class DefectTransferAnalysisService: + """불량 전이 예측 결과와 원인 분석을 ES 우선으로 조회한다.""" + def __init__( + self, + *, + database_url: str | None = None, + event_database_url: str | None = None, + repository: DefectTransferPredictionRepository | None = None, + ) -> None: + main_database_url = database_url or settings.main_database_connection_url + sample_database_url = event_database_url or settings.sample_database_connection_url + if not sample_database_url: + raise AppException( + "sample database connection URL is required.", + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + ) + self.repository = repository or DefectTransferPredictionRepository( + main_database_url, + event_database_url=sample_database_url, + ) + self.search_repository = self._create_search_repository() + self._redis_client: Any | None = None + + def get_cached_predictions( + self, + *, + cursor: int | None, + size: int, + date: DateType | None = None, + ) -> DefectTransferPredictionPage: + cache_key = self._prediction_cache_key( + cursor=cursor, + size=size, + date=date, + ) + page = self.get_predictions( + cursor=cursor, + size=size, + date=date, + ) + self._cache_set(cache_key, page.model_dump(by_alias=False)) + return page + + def get_cached_cause_analysis( + self, + *, + vehicle_id: str | None, + cursor: int | None, + size: int, + date: DateType | None = None, + ) -> DefectTransferCausePage: + cache_key = self._cause_cache_key( + vehicle_id=vehicle_id, + cursor=cursor, + size=size, + date=date, + ) + page = self.get_cause_analysis( + vehicle_id=vehicle_id, + cursor=cursor, + size=size, + date=date, + ) + self._cache_set(cache_key, page.model_dump(by_alias=False)) + return page + + def clear_cache(self) -> None: + """불량 전이 조회 캐시를 모두 삭제한다.""" + if not settings.redis_url: + return + try: + redis_client = self._redis() + pattern = f"{settings.redis_key_prefix}:process:defect-transfer:*" + keys = list(redis_client.scan_iter(match=pattern)) + if keys: + redis_client.delete(*keys) + except Exception as exc: + self._redis_client = None + raise AppException( + "Defect transfer Redis cache clear failed.", + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + ) from exc + + def get_predictions( + self, + *, + cursor: int | None, + size: int, + date: DateType | None = None, + ) -> DefectTransferPredictionPage: + """불량 전이 목록을 ES 우선으로 조회하고, 실패 시 DB로 내려간다.""" + """조회한 불량 전이 목록을 Redis 캐시에 저장한다.""" + # ES를 먼저 보고, 실패하면 Redis 캐시와 DB 결과로 이어서 반환한다. + page = max(cursor or 0, 0) + safe_size = max(1, min(size, 100)) + cache_key = self._prediction_cache_key( + cursor=cursor, + size=size, + date=date, + ) + date_options = self._safe_get_date_options() + selected_date = self._resolve_date(date, date_options) + rows: list[dict[str, Any]] + has_next = False + if self.search_repository is not None: + try: + rows, has_next = self.search_repository.list_defect_prediction_page( + cursor=page, + size=safe_size, + analysis_date=selected_date, + ) + except Exception: + logger.exception("Elasticsearch defect prediction query failed. Falling back to DB.") + cached_value = self._cache_get(cache_key) + if cached_value: + cached_page = DefectTransferPredictionPage.model_validate(from_json(cached_value)) + if cached_page.content: + return cached_page + try: + rows, has_next = self.repository.list_prediction_page( + cursor=page, + size=safe_size, + analysis_date=selected_date, + ) + except SQLAlchemyError as exc: + raise self._db_exception() from exc + else: + cached_value = self._cache_get(cache_key) + if cached_value: + cached_page = DefectTransferPredictionPage.model_validate(from_json(cached_value)) + if cached_page.content: + return cached_page + try: + rows, has_next = self.repository.list_prediction_page( + cursor=page, + size=safe_size, + analysis_date=selected_date, + ) + except SQLAlchemyError as exc: + raise self._db_exception() from exc + + return DefectTransferPredictionPage( + content=[self._to_prediction_item(row) for row in rows], + date=selected_date, + dateOptions=date_options, + hasNext=has_next, + nextCursor=page + 1 if has_next else None, + ) + + def get_diagnostics(self) -> dict[str, Any]: + try: + diagnostics = self.repository.diagnostics() + except SQLAlchemyError as exc: + raise self._db_exception() from exc + + if diagnostics["sourceEventCount"] == 0: + status_text = "NO_SOURCE_EVENTS" + message = "sampledb.manufacturing_event_json source events not found." + elif diagnostics["sentSourceEventCount"] == 0: + status_text = "NO_SENT_SOURCE_EVENTS" + message = "No sent source events were found." + elif diagnostics["predictionResultRowCount"] == 0: + status_text = "NO_PREDICTION_RESULTS" + message = "No defect transfer prediction results were found." + elif diagnostics["visiblePredictionCarCount"] == 0: + status_text = "NO_VISIBLE_PREDICTIONS" + message = "Prediction rows exist, but none are visible in the list." + else: + status_text = "OK" + message = "Defect transfer analysis data is available." + + return { + **diagnostics, + "status": status_text, + "message": message, + } + + def get_cause_analysis( + self, + *, + vehicle_id: str | None, + cursor: int | None, + size: int, + date: DateType | None = None, + ) -> DefectTransferCausePage: + """대표 원인과 상세 원인을 함께 반환하는 불량 전이 원인 분석을 조회한다.""" + """조회한 불량 전이 원인 분석을 Redis 캐시에 저장한다.""" + # 원인 분석은 대표 원인과 상세 원인을 분리해서 화면에 맞게 구성한다. + page = max(cursor or 0, 0) + safe_size = max(1, min(size, 100)) + cache_key = self._cause_cache_key( + vehicle_id=vehicle_id, + cursor=cursor, + size=size, + date=date, + ) + date_options = self._safe_get_date_options(vehicle_id=vehicle_id) + selected_date = self._resolve_date(date, date_options) + selected: dict[str, Any] | None + if self.search_repository is not None: + try: + selected = self.search_repository.get_latest_defect_cause_document( + vehicle_id=vehicle_id, + analysis_date=selected_date, + ) + if selected is None: + selected, _rows, _has_next = self.repository.list_cause_page( + vehicle_id=vehicle_id, + cursor=page, + size=safe_size, + analysis_date=selected_date, + ) + except Exception: + logger.exception("Elasticsearch defect cause query failed. Falling back to DB.") + cached_value = self._cache_get(cache_key) + if cached_value: + cached_page = DefectTransferCausePage.model_validate(from_json(cached_value)) + if cached_page.content: + return cached_page + try: + selected, _rows, _has_next = self.repository.list_cause_page( + vehicle_id=vehicle_id, + cursor=page, + size=safe_size, + analysis_date=selected_date, + ) + except SQLAlchemyError as exc: + raise self._db_exception() from exc + else: + cached_value = self._cache_get(cache_key) + if cached_value: + cached_page = DefectTransferCausePage.model_validate(from_json(cached_value)) + if cached_page.content: + return cached_page + try: + selected, _rows, _has_next = self.repository.list_cause_page( + vehicle_id=vehicle_id, + cursor=page, + size=safe_size, + analysis_date=selected_date, + ) + except SQLAlchemyError as exc: + raise self._db_exception() from exc + + if selected is None: + return DefectTransferCausePage( + vehicleId=vehicle_id, + carMasterId=None, + predictedDefectProbability=None, + riskLevel=None, + currentProcess=None, + predictedDefectProcess=None, + transferProbability=None, + date=selected_date, + dateOptions=date_options, + content=[], + hasNext=False, + nextCursor=None, + ) + + representative_cause, detail_causes = self._build_cause_sections(selected) + offset = page * safe_size + display_detail_causes = detail_causes[offset : offset + safe_size] + has_next = len(detail_causes) > offset + safe_size + + return DefectTransferCausePage( + vehicleId=str(selected.get("vehicle_id")), + carMasterId=int(selected["car_master_id"]), + predictedDefectProbability=self._normalize_probability( + selected.get("target_defect_probability"), + ), + riskLevel=selected.get("risk_grade"), + currentProcess=format_process_with_line( + selected.get("source_process_code"), + selected.get("source_equipment_code"), + ), + predictedDefectProcess=self._resolve_predicted_defect_process(selected), + transferProbability=self._normalize_probability(selected.get("target_defect_probability")), + date=selected_date, + dateOptions=date_options, + content=[representative_cause], + representativeCause=representative_cause, + detailCauses=display_detail_causes, + hasNext=has_next, + nextCursor=page + 1 if has_next else None, + ) + + def _to_prediction_item( + self, + row: dict[str, Any], + ) -> DefectTransferPredictionItem: + """DB row를 불량 전이 목록 응답 DTO로 변환한다.""" + # 저장된 결과 row를 목록 카드용 DTO로 변환한다. + return DefectTransferPredictionItem( + vehicleId=str(row.get("vehicle_id")), + carMasterId=int(row["car_master_id"]), + currentProcess=format_process_with_line( + row.get("source_process_code"), + row.get("source_equipment_code"), + ), + predictedDefectProcess=self._resolve_predicted_defect_process(row), + defectProbability=self._result_probability(row), + expectedTime=( + f"{int(row['expected_occurrence_step'])}단계 후" + if row.get("expected_occurrence_step") is not None + else None + ), + riskLevel=str(row.get("risk_grade") or "LOW"), + ) + + @staticmethod + def _normalize_probability(value: Any) -> float: + # 99.24 또는 0.9924처럼 들어와도 화면에서는 동일한 확률로 맞춘다. + if value is None: + return 0.0 + normalized = float(value) + if abs(normalized) > 1.0: + normalized /= 100.0 + return round(normalized, 4) + + @classmethod + def _result_probability(cls, row: dict[str, Any]) -> float: + # 현재 화면 기준 확률은 current -> defect -> target 순으로 확인한다. + value = row.get("current_defect_probability") + if value is None: + value = row.get("defect_probability") + if value is None: + value = row.get("target_defect_probability") + return cls._normalize_probability(value) + + @classmethod + def _resolve_predicted_defect_process(cls, row: dict[str, Any]) -> str | None: + # 목표 공정이 있으면 우선 사용하고, 없으면 다음 공정을 계산한다. + if cls._result_probability(row) <= 0: + return None + + source_code = str(row.get("source_process_code") or "").strip().upper() + process_code = row.get("target_process_code") or NEXT_PROCESS.get(source_code) + if not process_code: + return None + process_code = str(process_code).strip().upper() + if process_code == source_code: + equipment_code = row.get("source_equipment_code") + else: + equipment_code = row.get("target_equipment_code") or equipment_code_for_car_process( + car_master_id=int(row["car_master_id"]), + process_code=process_code, + ) + + db_val = row.get("predicted_defect_process") + if db_val and "(" in str(db_val) and ")" in str(db_val): + return str(db_val) + + return format_process_with_line(process_code, equipment_code) + + @staticmethod + def _display_value(value: Any) -> str: + if isinstance(value, float): + return f"{value:.2f}" + return str(value) + + @classmethod + def _is_displayable_cause(cls, row: dict[str, Any]) -> bool: + message = cls._primary_cause_message(row).strip() + if not message: + return False + + value = cls._first_number(message) + if value is None: + return True + + thresholds = { + "pressure": 0.0, + "temperature": 4.0, + "vibration": 0.45, + "cycle time": 55.0, + "wip": 24.0, + "rms": 2.2, + } + lower_message = message.lower() + for prefix, threshold in thresholds.items(): + if prefix in lower_message: + return value > threshold + return value > 0.0 + + @staticmethod + def _primary_cause_message(row: dict[str, Any]) -> str: + main_causes = row.get("main_causes") + if isinstance(main_causes, list) and main_causes: + first = main_causes[0] + if isinstance(first, dict): + message = first.get("message") or first.get("label") or "" + return str(message).strip() + + return "" + + @classmethod + def _build_cause_sections( + cls, + row: dict[str, Any], + ) -> tuple[DefectTransferCauseItem, list[DefectTransferCauseItem]]: + """대표 원인 1개와 상세 원인 리스트를 분리해 구성한다.""" + # 대표 원인 1개와 보조 원인 리스트를 분리해 응답 구조를 만든다. + main_causes = cls._normalize_main_causes(row.get("main_causes") or row.get("causes")) + if main_causes: + representative_cause = cls._to_cause_item( + { + "rank": main_causes[0].get("rank") or 1, + "feature": main_causes[0].get("feature") or "main_causes", + "label": main_causes[0].get("label") or main_causes[0].get("message") or "", + "value": main_causes[0].get("value") or "", + "impact": main_causes[0].get("impact") or 0.0, + "message": main_causes[0].get("message") or main_causes[0].get("label") or "", + }, + rank=1, + ) + detail_causes = [ + cls._to_cause_item( + { + "rank": cause.get("rank") or index, + "feature": cause.get("feature") or "main_causes", + "label": cause.get("label") or cause.get("message") or "", + "value": cause.get("value") or "", + "impact": cause.get("impact") or 0.0, + "message": cause.get("message") or cause.get("label") or "", + }, + rank=index, + ) + for index, cause in enumerate(main_causes[1:], start=2) + ] + return representative_cause, detail_causes + + summary_message = cls._primary_cause_message(row) + if not summary_message: + summary_message = "no main cause available" + representative_cause = cls._to_cause_item( + { + "rank": 1, + "feature": "main_causes", + "label": summary_message, + "value": "", + "impact": float(row.get("influence_score") or 0.0), + "message": summary_message, + }, + rank=1, + ) + return representative_cause, [] + + @staticmethod + def _normalize_main_causes(causes: list[dict[str, Any]]) -> list[dict[str, Any]]: + normalized: list[dict[str, Any]] = [] + for cause in causes[:5]: + message = str(cause.get("message") or cause.get("label") or "").strip() + if not message: + continue + try: + impact = float(cause.get("impact") or 0.0) + except (TypeError, ValueError): + impact = 0.0 + normalized.append( + { + "message": message, + "impact": impact, + }, + ) + + if normalized: + return normalized + + return [ + { + "message": "no main cause available", + "impact": 0.0, + }, + ] + + @classmethod + def _to_cause_item( + cls, + row: dict[str, Any], + *, + rank: int, + ) -> DefectTransferCauseItem: + message = str(row.get("message") or row.get("label") or "").strip() + if not message: + message = cls._primary_cause_message(row) + if not message: + message = "no main cause available" + + return DefectTransferCauseItem( + rank=int(row.get("rank") or rank), + feature=str(row.get("feature") or "main_causes"), + label=str(row.get("label") or message), + value=str(row.get("value") or ""), + impact=float(row.get("impact") or 0.0), + message=message, + ) + + @staticmethod + def _first_number(text: str) -> float | None: + import re + + match = re.search(r"-?\d+(?:\.\d+)?", text) + return float(match.group(0)) if match else None + + @staticmethod + def _db_exception() -> AppException: + return AppException( + "Defect transfer analysis query failed. Please check DB settings and permissions.", + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + ) + + @staticmethod + def _create_search_repository() -> ProcessAnalysisSearchRepository | None: + if not settings.elasticsearch_url: + return None + try: + repository = ProcessAnalysisSearchRepository() + repository.ensure_indices() + return repository + except Exception: + logger.exception("Elasticsearch defect transfer repository is unavailable.") + return None + + def _cache_get(self, cache_key: str) -> str | None: + if not settings.redis_url: + return None + try: + return self._redis().get(cache_key) + except Exception: + self._redis_client = None + logger.exception("Defect transfer Redis cache lookup failed.") + return None + + def _cache_set(self, cache_key: str, data: dict[str, Any]) -> None: + if not settings.redis_url: + return + try: + self._redis().setex( + cache_key, + settings.redis_cache_ttl_seconds, + to_json(data), + ) + except Exception: + self._redis_client = None + logger.exception("Defect transfer Redis cache write failed.") + + def _redis(self) -> Any: + if self._redis_client is None: + try: + from redis import Redis + except ModuleNotFoundError as exc: + raise RuntimeError("redis package is required for defect transfer cache.") from exc + + self._redis_client = Redis.from_url( + settings.redis_connection_url, + decode_responses=True, + ) + return self._redis_client + + @staticmethod + def _safe_cache_part(value: Any) -> str: + text = str(value or "__default__").strip() + return text.replace(":", "_").replace("/", "_").replace("\\", "_") + + def _prediction_cache_key( + self, + *, + cursor: int | None, + size: int, + date: DateType | None, + ) -> str: + page = max(cursor or 0, 0) + safe_size = max(1, min(size, 100)) + return ( + f"{settings.redis_key_prefix}:process:defect-transfer:" + f"predictions:{DEFECT_TRANSFER_CACHE_VERSION}:{self._safe_cache_part(date.isoformat() if date else None)}:{page}:{safe_size}" + ) + + def _cause_cache_key( + self, + *, + vehicle_id: str | None, + cursor: int | None, + size: int, + date: DateType | None, + ) -> str: + page = max(cursor or 0, 0) + safe_size = max(1, min(size, 100)) + return ( + f"{settings.redis_key_prefix}:process:defect-transfer:" + f"causes:{DEFECT_TRANSFER_CACHE_VERSION}:{self._safe_cache_part(vehicle_id)}:{self._safe_cache_part(date.isoformat() if date else None)}:{page}:{safe_size}" + ) + + def _get_date_options( + self, + *, + vehicle_id: str | None = None, + ) -> list[AnalysisDateOption]: + if self.search_repository is not None: + try: + options = self.search_repository.list_defect_transfer_date_options( + vehicle_id=vehicle_id, + ) + except Exception: + logger.exception("Failed to load defect transfer date options from Elasticsearch.") + options = self.repository.list_date_options(vehicle_id=vehicle_id) + else: + options = self.repository.list_date_options(vehicle_id=vehicle_id) + return [ + AnalysisDateOption.model_validate( + { + "date": row["date"], + "sampleEventId": row.get("sample_event_id"), + }, + ) + for row in options + if row.get("date") is not None + ] + + def _safe_get_date_options( + self, + *, + vehicle_id: str | None = None, + ) -> list[AnalysisDateOption]: + try: + return self._get_date_options(vehicle_id=vehicle_id) + except Exception: + logger.exception("Failed to load defect transfer date options.") + return [] + + @staticmethod + def _resolve_date( + requested_date: DateType | None, + date_options: list[AnalysisDateOption], + ) -> DateType | None: + if requested_date is not None: + return requested_date + if date_options: + return date_options[0].date + return None + + +@lru_cache(maxsize=1) +def get_defect_transfer_analysis_service() -> DefectTransferAnalysisService: + return DefectTransferAnalysisService() diff --git a/app/service/manufacturing/__init__.py b/app/service/manufacturing/__init__.py new file mode 100644 index 0000000..3cb7b42 --- /dev/null +++ b/app/service/manufacturing/__init__.py @@ -0,0 +1,22 @@ +"""Manufacturing service package.""" + +from app.service.manufacturing.manufacturing_event_json_service import ( + DEFAULT_CAR_POOL_SIZE, + DEFAULT_EVENTS_PER_DAY, + DEFAULT_INSERT_CHUNK_SIZE, + DEFAULT_TEMPLATE_NAME, + ManufacturingEventJsonService, + get_manufacturing_event_json_service, + resume_incomplete_generation_jobs, +) + +__all__ = [ + "DEFAULT_CAR_POOL_SIZE", + "DEFAULT_EVENTS_PER_DAY", + "DEFAULT_INSERT_CHUNK_SIZE", + "DEFAULT_TEMPLATE_NAME", + "ManufacturingEventJsonService", + "get_manufacturing_event_json_service", + "resume_incomplete_generation_jobs", +] + diff --git a/app/service/manufacturing/manufacturing_event_json_service.py b/app/service/manufacturing/manufacturing_event_json_service.py new file mode 100644 index 0000000..0e00b36 --- /dev/null +++ b/app/service/manufacturing/manufacturing_event_json_service.py @@ -0,0 +1,1384 @@ +from __future__ import annotations + +import copy +import hashlib +import logging +from concurrent.futures import ThreadPoolExecutor +from datetime import date, datetime, time, timedelta +from typing import Any, Callable +from uuid import uuid4 + +from fastapi import status + +from app.core.config import settings +from app.core.exceptions import AppException +from app.data_generation.manufacturing_event_json_builder import ( + ABNORMAL_RATIO, + EventBuildRequest, + ManufacturingEventJsonBuilder, + initial_dispatch_status, + is_abnormal_operation_status, + normalize_event_json, + validate_process_data, +) +from app.repository.sampledb_repository import SampleDbRepository + + +# 실제 생성 수량은 vehicle_id의 생산일자에 해당하는 car_master 수로 결정한다. +DEFAULT_EVENTS_PER_DAY: int | None = None +DEFAULT_CAR_POOL_SIZE: int | None = None +DEFAULT_INSERT_CHUNK_SIZE = 1_000 +DEFAULT_TEMPLATE_NAME = "default" +TEMPLATE_ANCHOR_DATE = date(2000, 1, 1) +ProgressCallback = Callable[[dict[str, Any]], None] +JOB_TYPE_GENERATE_RANGE = "GENERATE_RANGE" +JOB_TYPE_GENERATE_TOMORROW = "GENERATE_TOMORROW" +JOB_TYPE_GENERATE_TEMPLATE = "GENERATE_TEMPLATE" +_generation_job_executor = ThreadPoolExecutor( + # 대량 생성 job끼리 DB insert 부하가 겹치지 않도록 단일 worker로 직렬 처리한다. + max_workers=1, + thread_name_prefix="manufacturing-event-generation-job", +) +logger = logging.getLogger(__name__) + + +class ManufacturingEventJsonService: + """CSV 원천 데이터를 통합 제조 이벤트 JSON으로 생성하고 sampledb에 저장한다.""" + + def __init__( + self, + repository: SampleDbRepository, + builder: ManufacturingEventJsonBuilder | None = None, + ) -> None: + self.repository = repository + self.builder = builder or ManufacturingEventJsonBuilder() + + def generate_range( + self, + *, + start_date: date, + end_date: date, + events_per_day: int | None = DEFAULT_EVENTS_PER_DAY, + car_pool_size: int | None = DEFAULT_CAR_POOL_SIZE, + insert_chunk_size: int = DEFAULT_INSERT_CHUNK_SIZE, + update_existing: bool = True, + progress_callback: ProgressCallback | None = None, + ) -> dict[str, Any]: + """생산일자별 car_master 차량 전체에 4공정 이벤트를 생성한다.""" + if start_date > end_date: + raise AppException( + "start_date는 end_date보다 이후일 수 없습니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + vehicle_limit = _resolve_vehicle_limit(events_per_day, car_pool_size) + if insert_chunk_size < 1: + raise AppException( + "insert_chunk_size는 1 이상이어야 합니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + + # 생성 전에 PRD 스키마와 공정별 기본 설비 5개를 보장한다. + self.repository.schema.ensure_schema() + self.repository.equipment.seed_defaults() + equipment_map = self.repository.equipment.get_map() + production_dates = list(_date_range(start_date, end_date)) + daily_car_maps = { + production_date: self.repository.cars.get_map_by_production_date( + production_date, + limit=vehicle_limit, + ) + for production_date in production_dates + } + total_vehicle_count = sum(len(car_map) for car_map in daily_car_maps.values()) + abnormal_vehicle_count = sum( + round(len(car_map) * ABNORMAL_RATIO) + for car_map in daily_car_maps.values() + ) + normal_vehicle_count = total_vehicle_count - abnormal_vehicle_count + total_events = total_vehicle_count * 4 + affected_rows = 0 + generated_count = 0 + distribution = {"PRESS": 0, "BODY": 0, "PAINT": 0, "ASSEMBLY": 0} + abnormal_distribution = {"PRESS": 0, "BODY": 0, "PAINT": 0, "ASSEMBLY": 0} + # 날짜별 차량 수가 달라도 공통 chunk 단위로 이어서 저장한다. + chunk: list[dict[str, Any]] = [] + for production_date, car_id_map in daily_car_maps.items(): + daily_event_count = len(car_id_map) * 4 + request = EventBuildRequest( + start_date=production_date, + end_date=production_date, + events_per_day=daily_event_count, + car_id_map=car_id_map, + equipment_map=equipment_map, + ) + for row in self.builder.iter_rows(request): + chunk.append(row) + generated_count += 1 + distribution[str(row["process_code"])] += 1 + if is_abnormal_operation_status( + row["event_json"]["equipmentStatus"]["operationStatus"], + ): + abnormal_distribution[str(row["process_code"])] += 1 + if len(chunk) >= insert_chunk_size: + affected_rows += self.repository.events.insert_rows( + chunk, + update_existing=update_existing, + ) + chunk = [] + if progress_callback: + progress_callback( + { + "generatedCount": generated_count, + "affectedRows": affected_rows, + "totalExpectedEvents": total_events, + }, + ) + if chunk: + affected_rows += self.repository.events.insert_rows( + chunk, + update_existing=update_existing, + ) + if progress_callback: + progress_callback( + { + "generatedCount": generated_count, + "affectedRows": affected_rows, + "totalExpectedEvents": total_events, + }, + ) + + return { + "startDate": start_date.isoformat(), + "endDate": end_date.isoformat(), + "requestedEventCountPerDay": events_per_day, + "totalExpectedEvents": total_events, + "generatedCount": generated_count, + "affectedRows": affected_rows, + # event_time을 NULL로 저장하므로 현재 작업에서 생성한 건수를 반환한다. + "storedCountInRange": generated_count, + "carPoolSize": total_vehicle_count, + "normalVehicleCount": normal_vehicle_count, + "discardVehicleCount": abnormal_vehicle_count, + "dailyVehicleCounts": { + production_date.isoformat(): len(car_id_map) + for production_date, car_id_map in daily_car_maps.items() + }, + "insertChunkSize": insert_chunk_size, + "processDistribution": distribution, + "abnormalDistribution": abnormal_distribution, + "normalEventCount": generated_count - sum(abnormal_distribution.values()), + "abnormalEventCount": sum(abnormal_distribution.values()), + } + + def enqueue_generate_range_job( + self, + *, + start_date: date, + end_date: date, + events_per_day: int | None = DEFAULT_EVENTS_PER_DAY, + car_pool_size: int | None = DEFAULT_CAR_POOL_SIZE, + insert_chunk_size: int = DEFAULT_INSERT_CHUNK_SIZE, + ) -> dict[str, Any]: + """기간 생성 요청을 DB job으로 등록하고 background worker에 전달한다.""" + if start_date > end_date: + raise AppException( + "start_date는 end_date보다 이후일 수 없습니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + vehicle_limit = _resolve_vehicle_limit(events_per_day, car_pool_size) + if insert_chunk_size < 1: + raise AppException( + "insert_chunk_size는 1 이상이어야 합니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + + request_json = { + "startDate": start_date.isoformat(), + "endDate": end_date.isoformat(), + "eventCount": events_per_day, + "carPoolSize": car_pool_size, + "insertChunkSize": insert_chunk_size, + } + total_expected_events = sum( + _selected_vehicle_count( + self.repository.cars.count_by_production_date(production_date), + vehicle_limit, + production_date, + ) + for production_date in _date_range(start_date, end_date) + ) * 4 + if total_expected_events < 1: + raise AppException( + "요청 날짜에 해당하는 car_master 차량이 없습니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + return self._create_and_submit_generation_job( + job_type=JOB_TYPE_GENERATE_RANGE, + request_json=request_json, + total_expected_events=total_expected_events, + ) + + def generate_template( + self, + *, + template_name: str = DEFAULT_TEMPLATE_NAME, + production_date: date = date(2026, 6, 1), + event_count: int | None = None, + car_pool_size: int | None = None, + insert_chunk_size: int = DEFAULT_INSERT_CHUNK_SIZE, + replace: bool = False, + update_existing: bool = False, + progress_callback: ProgressCallback | None = None, + ) -> dict[str, Any]: + """날짜를 제외한 하루 기준 제조 이벤트 패턴을 템플릿으로 저장한다.""" + vehicle_limit = _resolve_vehicle_limit(event_count, car_pool_size) + if insert_chunk_size < 1: + raise AppException( + "insert_chunk_size는 1 이상이어야 합니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + + normalized_template_name = _normalize_template_name(template_name) + self.repository.schema.ensure_schema() + self.repository.equipment.seed_defaults() + if replace: + self.repository.templates.delete(normalized_template_name) + + # 템플릿도 production_date와 vehicle_id가 일치하는 실제 차량 PK만 참조한다. + car_id_map = self.repository.cars.get_map_by_production_date( + production_date, + limit=vehicle_limit, + ) + resolved_event_count = len(car_id_map) * 4 + equipment_map = self.repository.equipment.get_map() + request = EventBuildRequest( + start_date=TEMPLATE_ANCHOR_DATE, + end_date=TEMPLATE_ANCHOR_DATE, + events_per_day=resolved_event_count, + car_id_map=car_id_map, + equipment_map=equipment_map, + ) + + affected_rows = 0 + generated_count = 0 + distribution = {"PRESS": 0, "BODY": 0, "PAINT": 0, "ASSEMBLY": 0} + abnormal_distribution = {"PRESS": 0, "BODY": 0, "PAINT": 0, "ASSEMBLY": 0} + chunk: list[dict[str, Any]] = [] + # 실제 날짜 대신 고정 기준일과 하루 시작 기준 offset을 저장한다. + # 이후 어느 날짜에도 동일한 생산 패턴을 재사용할 수 있다. + anchor_datetime = datetime.combine(TEMPLATE_ANCHOR_DATE, time.min) + for row in self.builder.iter_rows(request): + generated_count += 1 + distribution[str(row["process_code"])] += 1 + if is_abnormal_operation_status( + row["event_json"]["equipmentStatus"]["operationStatus"], + ): + abnormal_distribution[str(row["process_code"])] += 1 + template_event_id = ( + f"TMPL-{normalized_template_name.upper()}-{generated_count:06d}" + ) + event_json = copy.deepcopy(row["event_json"]) + event_json["event"]["eventId"] = template_event_id + event_offset_us = int( + (row["event_time"] - anchor_datetime).total_seconds() * 1_000_000, + ) + chunk.append( + { + "template_name": normalized_template_name, + "template_event_id": template_event_id, + "event_offset_us": event_offset_us, + "car_master_id": row["car_master_id"], + "equipment_id": row["equipment_id"], + "process_code": row["process_code"], + "station_code": row["station_code"], + "equipment_code": row["equipment_code"], + "equipment_type": row["equipment_type"], + "equipment_status": row["equipment_status"], + "event_type": row["event_type"], + "event_json": event_json, + }, + ) + if len(chunk) >= insert_chunk_size: + affected_rows += self.repository.templates.insert_rows( + chunk, + update_existing=update_existing, + ) + chunk = [] + if progress_callback: + progress_callback( + { + "generatedCount": generated_count, + "affectedRows": affected_rows, + "totalExpectedEvents": resolved_event_count, + }, + ) + if chunk: + affected_rows += self.repository.templates.insert_rows( + chunk, + update_existing=update_existing, + ) + if progress_callback: + progress_callback( + { + "generatedCount": generated_count, + "affectedRows": affected_rows, + "totalExpectedEvents": resolved_event_count, + }, + ) + + stored_count = self.repository.templates.count(normalized_template_name) + return { + "templateName": normalized_template_name, + "productionDate": production_date.isoformat(), + "eventCount": resolved_event_count, + "generatedCount": generated_count, + "affectedRows": affected_rows, + "storedCount": stored_count, + "carPoolSize": len(car_id_map), + "insertChunkSize": insert_chunk_size, + "processDistribution": distribution, + "abnormalDistribution": abnormal_distribution, + "normalEventCount": generated_count - sum(abnormal_distribution.values()), + "abnormalEventCount": sum(abnormal_distribution.values()), + "timeDistribution": [ + {"range": "00:00-05:00", "density": "LOW"}, + {"range": "05:00-08:00", "density": "MEDIUM"}, + {"range": "08:00-12:00", "density": "HIGH"}, + {"range": "12:00-13:00", "density": "LOW"}, + {"range": "13:00-18:00", "density": "HIGH"}, + {"range": "18:00-22:00", "density": "MEDIUM"}, + {"range": "22:00-24:00", "density": "LOW"}, + ], + } + + def enqueue_generate_template_job( + self, + *, + template_name: str = DEFAULT_TEMPLATE_NAME, + production_date: date = date(2026, 6, 1), + event_count: int | None = None, + car_pool_size: int | None = None, + insert_chunk_size: int = DEFAULT_INSERT_CHUNK_SIZE, + replace: bool = False, + ) -> dict[str, Any]: + vehicle_limit = _resolve_vehicle_limit(event_count, car_pool_size) + if insert_chunk_size < 1: + raise AppException( + "insert_chunk_size는 1 이상이어야 합니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + + available_vehicle_count = self.repository.cars.count_by_production_date( + production_date, + ) + selected_vehicle_count = _selected_vehicle_count( + available_vehicle_count, + vehicle_limit, + production_date, + ) + request_json = { + "templateName": template_name, + "productionDate": production_date.isoformat(), + "eventCount": event_count, + "carPoolSize": car_pool_size, + "insertChunkSize": insert_chunk_size, + "replace": replace, + } + return self._create_and_submit_generation_job( + job_type=JOB_TYPE_GENERATE_TEMPLATE, + request_json=request_json, + total_expected_events=selected_vehicle_count * 4, + ) + + def list_template_events( + self, + *, + template_name: str = DEFAULT_TEMPLATE_NAME, + limit: int, + offset: int = 0, + process_code: str | None = None, + ) -> list[dict[str, Any]]: + return self.repository.templates.list_rows( + template_name=_normalize_template_name(template_name), + limit=limit, + offset=offset, + process_code=process_code, + ) + + def replay_template_events( + self, + *, + template_name: str = DEFAULT_TEMPLATE_NAME, + target_date: date, + limit: int, + offset: int = 0, + process_code: str | None = None, + ) -> list[dict[str, Any]]: + template_rows = self.list_template_events( + template_name=template_name, + limit=limit, + offset=offset, + process_code=process_code, + ) + return [ + _materialize_template_row(row, target_date=target_date) + for row in template_rows + ] + + def materialize_template_events( + self, + *, + template_name: str = DEFAULT_TEMPLATE_NAME, + target_date: date, + insert_chunk_size: int = DEFAULT_INSERT_CHUNK_SIZE, + update_existing: bool = True, + progress_callback: ProgressCallback | None = None, + ) -> dict[str, Any]: + """저장된 템플릿에 목표 날짜와 결정적 변동을 입혀 실제 이벤트로 적재한다.""" + if insert_chunk_size < 1: + raise AppException( + "insert_chunk_size는 1 이상이어야 합니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + + normalized_template_name = _normalize_template_name(template_name) + self.repository.schema.ensure_schema() + total_template_events = self.repository.templates.count( + normalized_template_name, + ) + if total_template_events < 1: + raise AppException( + "저장된 제조 이벤트 템플릿이 없습니다. 먼저 템플릿을 생성해주세요.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + + affected_rows = 0 + generated_count = 0 + distribution = {"PRESS": 0, "BODY": 0, "PAINT": 0, "ASSEMBLY": 0} + abnormal_distribution = {"PRESS": 0, "BODY": 0, "PAINT": 0, "ASSEMBLY": 0} + # 템플릿 역시 페이지 단위로 읽어 대량 materialize 시 메모리 사용량을 제한한다. + offset = 0 + while offset < total_template_events: + template_rows = self.repository.templates.list_rows( + template_name=normalized_template_name, + limit=insert_chunk_size, + offset=offset, + ) + if not template_rows: + break + + materialized_rows = [ + _materialize_template_row(row, target_date=target_date) + for row in template_rows + ] + affected_rows += self.repository.events.insert_rows( + materialized_rows, + update_existing=update_existing, + ) + for row in materialized_rows: + distribution[str(row["process_code"])] += 1 + if is_abnormal_operation_status( + row["event_json"]["equipmentStatus"]["operationStatus"], + ): + abnormal_distribution[str(row["process_code"])] += 1 + + generated_count += len(materialized_rows) + offset += len(template_rows) + if progress_callback: + progress_callback( + { + "generatedCount": generated_count, + "affectedRows": affected_rows, + "totalExpectedEvents": total_template_events, + }, + ) + + return { + "templateName": normalized_template_name, + "targetDate": target_date.isoformat(), + "templateEventCount": total_template_events, + "generatedCount": generated_count, + "affectedRows": affected_rows, + # event_time을 NULL로 저장하므로 현재 materialize한 건수를 반환한다. + "storedCountInDate": generated_count, + "insertChunkSize": insert_chunk_size, + "updateExisting": update_existing, + "processDistribution": distribution, + "abnormalDistribution": abnormal_distribution, + "normalEventCount": generated_count - sum(abnormal_distribution.values()), + "abnormalEventCount": sum(abnormal_distribution.values()), + "variationMode": "target_date_and_template_event_id_seed", + } + + def ensure_template( + self, + *, + template_name: str = DEFAULT_TEMPLATE_NAME, + production_date: date = date(2026, 6, 1), + event_count: int | None = None, + car_pool_size: int | None = None, + insert_chunk_size: int = DEFAULT_INSERT_CHUNK_SIZE, + ) -> dict[str, Any]: + """요청 수량과 정확히 일치하는 템플릿이 없으면 전체를 다시 생성한다.""" + normalized_template_name = _normalize_template_name(template_name) + self.repository.schema.ensure_schema() + vehicle_limit = _resolve_vehicle_limit(event_count, car_pool_size) + available_vehicle_count = self.repository.cars.count_by_production_date( + production_date, + ) + selected_vehicle_count = _selected_vehicle_count( + available_vehicle_count, + vehicle_limit, + production_date, + ) + resolved_event_count = selected_vehicle_count * 4 + stored_count = self.repository.templates.count(normalized_template_name) + # 차량당 4공정 보장이 중요하므로 "이상"이 아니라 정확히 같은 건수만 재사용한다. + if stored_count == resolved_event_count: + return { + "templateName": normalized_template_name, + "eventCount": resolved_event_count, + "storedCount": stored_count, + "created": False, + } + + result = self.generate_template( + template_name=normalized_template_name, + production_date=production_date, + event_count=event_count, + car_pool_size=car_pool_size, + insert_chunk_size=insert_chunk_size, + replace=stored_count > 0, + update_existing=stored_count > 0, + ) + return { + **result, + "created": True, + } + + def generate_initial_demo_range( + self, + *, + events_per_day: int | None = DEFAULT_EVENTS_PER_DAY, + car_pool_size: int | None = DEFAULT_CAR_POOL_SIZE, + insert_chunk_size: int = DEFAULT_INSERT_CHUNK_SIZE, + update_existing: bool = True, + progress_callback: ProgressCallback | None = None, + ) -> dict[str, Any]: + return self.generate_range( + start_date=date(2026, 6, 1), + end_date=date(2026, 6, 16), + events_per_day=events_per_day, + car_pool_size=car_pool_size, + insert_chunk_size=insert_chunk_size, + update_existing=update_existing, + progress_callback=progress_callback, + ) + + def generate_tomorrow( + self, + *, + base_date: date | None = None, + template_name: str = DEFAULT_TEMPLATE_NAME, + events_per_day: int | None = DEFAULT_EVENTS_PER_DAY, + car_pool_size: int | None = DEFAULT_CAR_POOL_SIZE, + insert_chunk_size: int = DEFAULT_INSERT_CHUNK_SIZE, + update_existing: bool = True, + progress_callback: ProgressCallback | None = None, + ) -> dict[str, Any]: + """기준일 다음날 vehicle_id 생산일자의 차량 전체로 이벤트를 생성한다.""" + target_date = (base_date or date.today()) + timedelta(days=1) + result = self.generate_range( + start_date=target_date, + end_date=target_date, + events_per_day=events_per_day, + car_pool_size=car_pool_size, + insert_chunk_size=insert_chunk_size, + update_existing=update_existing, + progress_callback=progress_callback, + ) + return { + **result, + "baseDate": (base_date or date.today()).isoformat(), + "targetDate": target_date.isoformat(), + "templateName": template_name, + "generationMode": "CAR_MASTER_PRODUCTION_DATE", + } + + def enqueue_generate_tomorrow_job( + self, + *, + base_date: date | None = None, + template_name: str = DEFAULT_TEMPLATE_NAME, + events_per_day: int | None = DEFAULT_EVENTS_PER_DAY, + car_pool_size: int | None = DEFAULT_CAR_POOL_SIZE, + insert_chunk_size: int = DEFAULT_INSERT_CHUNK_SIZE, + ) -> dict[str, Any]: + vehicle_limit = _resolve_vehicle_limit(events_per_day, car_pool_size) + if insert_chunk_size < 1: + raise AppException( + "insert_chunk_size는 1 이상이어야 합니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + + request_json = { + "baseDate": base_date.isoformat() if base_date else None, + "templateName": template_name, + "eventCount": events_per_day, + "carPoolSize": car_pool_size, + "insertChunkSize": insert_chunk_size, + } + target_date = (base_date or date.today()) + timedelta(days=1) + available_vehicle_count = self.repository.cars.count_by_production_date( + target_date, + ) + selected_vehicle_count = _selected_vehicle_count( + available_vehicle_count, + vehicle_limit, + target_date, + ) + return self._create_and_submit_generation_job( + job_type=JOB_TYPE_GENERATE_TOMORROW, + request_json=request_json, + total_expected_events=selected_vehicle_count * 4, + ) + + def get_generation_job(self, job_id: str) -> dict[str, Any]: + self.repository.schema.ensure_schema() + job = self.repository.jobs.get(job_id) + if not job: + raise AppException( + "제조 이벤트 생성 job을 찾을 수 없습니다.", + status_code=status.HTTP_404_NOT_FOUND, + ) + return job + + def _create_and_submit_generation_job( + self, + *, + job_type: str, + request_json: dict[str, Any], + total_expected_events: int, + ) -> dict[str, Any]: + """job 상태 row를 먼저 남긴 뒤 단일 background worker에 실행을 위임한다.""" + self.repository.schema.ensure_schema() + job_id = str(uuid4()) + job = self.repository.jobs.create( + job_id=job_id, + job_type=job_type, + request_json=request_json, + total_expected_events=total_expected_events, + ) + _generation_job_executor.submit( + _run_generation_job, + self.repository.database_url, + job_id, + ) + return job + + def list_events( + self, + *, + limit: int, + offset: int, + start_date: date | None = None, + end_date: date | None = None, + process_code: str | None = None, + is_sent: bool | None = None, + ) -> list[dict[str, Any]]: + return self.repository.events.list_rows( + limit=limit, + offset=offset, + start_date=start_date, + end_date=end_date, + process_code=process_code, + is_sent=is_sent, + ) + +def get_manufacturing_event_json_service() -> ManufacturingEventJsonService: + if not settings.sample_database_connection_url: + raise AppException( + "MAIN_DATABASE_URL + SAMPLE_DB_NAME 설정이 필요합니다.", + status_code=status.HTTP_503_SERVICE_UNAVAILABLE, + ) + return ManufacturingEventJsonService( + SampleDbRepository(settings.sample_database_connection_url), + ) + + +def _run_generation_job(database_url: str, job_id: str) -> None: + """비동기 생성 job의 RUNNING/SUCCEEDED/FAILED 상태 전이를 관리한다.""" + repository = SampleDbRepository(database_url) + service = ManufacturingEventJsonService(repository) + # uvicorn --reload의 이전/신규 프로세스나 다중 worker가 같은 미완료 job을 + # 동시에 복구하지 못하도록 DB advisory lock으로 생성 작업 전체를 직렬화한다. + with repository.jobs.execution_lock() as acquired: + if not acquired: + logger.error("제조 이벤트 생성 전역 잠금을 획득하지 못했습니다: job_id=%s", job_id) + return + + # 잠금을 기다리는 동안 다른 프로세스가 완료했을 수 있으므로 상태를 다시 읽는다. + job = repository.jobs.get(job_id) + if not job: + logger.warning("제조 이벤트 생성 job을 찾을 수 없습니다: job_id=%s", job_id) + return + if job["status"] in {"SUCCEEDED", "FAILED"}: + logger.info( + "이미 종료된 제조 이벤트 생성 job을 건너뜁니다: job_id=%s status=%s", + job_id, + job["status"], + ) + return + + try: + repository.jobs.mark_running(job_id) + result = _execute_generation_job(service, repository, job) + repository.jobs.mark_succeeded(job_id, result) + logger.info( + "제조 이벤트 생성 job 완료: job_id=%s job_type=%s generated=%s affected=%s", + job_id, + job["jobType"], + result.get("generatedCount"), + result.get("affectedRows"), + ) + except Exception as exc: + message = getattr(exc, "message", str(exc)) + repository.jobs.mark_failed(job_id, message) + logger.exception( + "제조 이벤트 생성 job 실패: job_id=%s job_type=%s", + job_id, + job.get("jobType"), + ) + + +def _execute_generation_job( + service: ManufacturingEventJsonService, + repository: SampleDbRepository, + job: dict[str, Any], +) -> dict[str, Any]: + """저장된 job 요청을 종류별 동기 서비스 메서드 호출로 변환한다.""" + request = job["request"] + progress_callback = lambda progress: repository.jobs.update_progress( + job["jobId"], + progress, + ) + + if job["jobType"] == JOB_TYPE_GENERATE_RANGE: + return service.generate_range( + start_date=date.fromisoformat(request["startDate"]), + end_date=date.fromisoformat(request["endDate"]), + events_per_day=_optional_int( + request.get("eventCount", request.get("eventsPerDay")), + ), + car_pool_size=_optional_int(request.get("carPoolSize")), + insert_chunk_size=int(request["insertChunkSize"]), + update_existing=True, + progress_callback=progress_callback, + ) + + if job["jobType"] == JOB_TYPE_GENERATE_TEMPLATE: + return service.generate_template( + template_name=str(request["templateName"]), + production_date=date.fromisoformat(request["productionDate"]), + event_count=_optional_int(request.get("eventCount")), + car_pool_size=_optional_int(request.get("carPoolSize")), + insert_chunk_size=int(request["insertChunkSize"]), + replace=bool(request["replace"]), + update_existing=bool(request["replace"]), + progress_callback=progress_callback, + ) + + if job["jobType"] == JOB_TYPE_GENERATE_TOMORROW: + base_date = ( + date.fromisoformat(request["baseDate"]) + if request.get("baseDate") + else None + ) + return service.generate_tomorrow( + base_date=base_date, + template_name=str(request["templateName"]), + events_per_day=_optional_int( + request.get("eventCount", request.get("eventsPerDay")), + ), + car_pool_size=_optional_int(request.get("carPoolSize")), + insert_chunk_size=int(request["insertChunkSize"]), + update_existing=True, + progress_callback=progress_callback, + ) + + raise AppException( + "지원하지 않는 제조 이벤트 생성 job 유형입니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + + +def resume_incomplete_generation_jobs(database_url: str) -> int: + repository = SampleDbRepository(database_url) + repository.schema.ensure_schema() + jobs = repository.jobs.list_resumable() + for job in jobs: + _generation_job_executor.submit( + _run_generation_job, + database_url, + job["jobId"], + ) + if jobs: + logger.info("미완료 제조 이벤트 생성 job %s건을 worker에 재등록했습니다.", len(jobs)) + return len(jobs) + + +def _normalize_template_name(template_name: str) -> str: + normalized = "".join( + char.lower() if char.isalnum() else "_" + for char in template_name.strip() + ).strip("_") + return normalized or DEFAULT_TEMPLATE_NAME + + +def _resolve_vehicle_limit( + event_count: int | None, + car_pool_size: int | None, +) -> int | None: + """선택적 수량 제한을 차량 수로 정규화한다.""" + if event_count is not None: + if event_count < 4 or event_count % 4 != 0: + raise AppException( + "event_count는 차량당 4공정 기준으로 4의 배수여야 합니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + event_vehicle_count = event_count // 4 + if car_pool_size is not None and car_pool_size != event_vehicle_count: + raise AppException( + "event_count와 car_pool_size가 일치하지 않습니다: " + f"event_count/4={event_vehicle_count}, " + f"car_pool_size={car_pool_size}", + status_code=status.HTTP_400_BAD_REQUEST, + ) + return event_vehicle_count + + if car_pool_size is not None: + if car_pool_size < 1: + raise AppException( + "car_pool_size는 1 이상이어야 합니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + return car_pool_size + return None + + +def _selected_vehicle_count( + available_count: int, + vehicle_limit: int | None, + production_date: date, +) -> int: + if available_count < 1: + raise AppException( + f"{production_date.isoformat()} 생산 차량이 car_master에 없습니다.", + status_code=status.HTTP_400_BAD_REQUEST, + ) + if vehicle_limit is not None and available_count < vehicle_limit: + raise AppException( + "요청한 차량 수보다 해당 날짜의 car_master가 부족합니다: " + f"date={production_date.isoformat()}, required={vehicle_limit}, " + f"actual={available_count}", + status_code=status.HTTP_400_BAD_REQUEST, + ) + return vehicle_limit if vehicle_limit is not None else available_count + + +def _date_range(start_date: date, end_date: date): + current = start_date + while current <= end_date: + yield current + current += timedelta(days=1) + + +def _optional_int(value: Any) -> int | None: + return int(value) if value is not None else None + + +def _materialize_template_row( + row: dict[str, Any], + *, + target_date: date, +) -> dict[str, Any]: + """템플릿 한 행을 목표 날짜의 manufacturing_event_json 행으로 변환한다.""" + event_time = datetime.combine(target_date, time.min) + timedelta( + microseconds=int(row["event_offset_us"]), + ) + sequence_no = int(str(row["template_event_id"]).rsplit("-", 1)[-1]) + event_id = f"EVT-{target_date:%Y%m%d}-{sequence_no:06d}" + event_json = copy.deepcopy(row["event_json"]) + event_json["event"]["eventId"] = event_id + event_json["event"]["eventTime"] = None + event_json["equipmentStatus"]["lastNormalTime"] = None + event_json["equipmentStatus"]["statusChangedTime"] = None + # 날짜와 template_event_id가 같으면 항상 같은 값이 나오도록 결정적으로 변동한다. + _apply_date_variation( + event_json, + target_date=target_date, + template_event_id=str(row["template_event_id"]), + ) + event_json = normalize_event_json(event_json) + # 날짜별 변동 후에도 해당 공정의 processData 블록 하나와 필수 필드를 보장한다. + validate_process_data( + str(row["process_code"]), + event_json.get("processData", {}), + ) + return { + "event_id": event_id, + "event_time": event_time, + "car_master_id": row["car_master_id"], + "equipment_id": row["equipment_id"], + "process_code": row["process_code"], + "station_code": row["station_code"], + "equipment_code": row["equipment_code"], + "equipment_type": row["equipment_type"], + "equipment_status": event_json["equipmentStatus"]["operationStatus"], + "event_type": row["event_type"], + "event_json": event_json, + # 재생된 이벤트도 최초 공정 제어 규칙을 그대로 따른다. + "dispatch_status": initial_dispatch_status(str(row["process_code"])), + "analysis_status": "NOT_ANALYZED", + "bottleneck_analysis_done": False, + "defect_transfer_analysis_done": False, + "retry_count": 0, + "error_message": None, + } + + +def _apply_date_variation( + event_json: dict[str, Any], + *, + target_date: date, + template_event_id: str, +) -> None: + """정상/이상 클래스는 보존하면서 날짜별 센서·공정 수치에 작은 변화를 준다.""" + seed_key = f"{target_date.isoformat()}:{template_event_id}" + sensor = event_json.get("sensor", {}) + process_metrics = event_json.get("processMetrics", {}) + process_data = event_json.get("processData", {}) + + # 각 센서 값을 먼저 바꾼 뒤 processData와 설비 상태를 다시 동기화한다. + _vary_current(sensor.get("current", {}), seed_key) + _vary_vibration(sensor.get("vibration", {}), seed_key) + _vary_robot_arm_vibration(sensor.get("robotArmVibration", {}), seed_key) + _vary_thermal(sensor.get("thermal", {}), seed_key) + _vary_process_metrics(process_metrics, seed_key) + _sync_process_data(process_data, sensor, process_metrics, seed_key) + _refresh_equipment_status(event_json, sensor, process_metrics) + + +def _vary_current(current: dict[str, Any], seed_key: str) -> None: + if not current: + return + original_rms = _as_float(current.get("rmsAmpere")) + original_max = _as_float(current.get("maxAmpere"), original_rms) + original_min = _as_float(current.get("minAmpere"), original_rms) + + rms = _jitter_numeric( + original_rms, + seed_key, + "current.rmsAmpere", + pct=0.035, + precision=9, + min_value=0.0, + ) + upper_spread = max(original_max - original_rms, rms * 0.035, 0.001) + lower_spread = max(original_rms - original_min, rms * 0.035, 0.001) + upper_spread *= _factor(seed_key, "current.upperSpread", 0.12) + lower_spread *= _factor(seed_key, "current.lowerSpread", 0.12) + + current["rmsAmpere"] = rms + current["maxAmpere"] = _round(rms + upper_spread, 9) + current["minAmpere"] = _round(max(0.0, rms - lower_spread), 9) + + +def _vary_vibration(vibration: dict[str, Any], seed_key: str) -> None: + if not vibration: + return + vibration["accelerationG"] = _jitter_numeric( + _as_float(vibration.get("accelerationG")), + seed_key, + "vibration.accelerationG", + pct=0.08, + precision=9, + min_value=0.0, + ) + vibration["vibrationRms"] = _jitter_numeric( + _as_float(vibration.get("vibrationRms")), + seed_key, + "vibration.vibrationRms", + pct=0.065, + precision=9, + min_value=0.0, + ) + vibration["vibrationPeak"] = _jitter_numeric( + _as_float(vibration.get("vibrationPeak")), + seed_key, + "vibration.vibrationPeak", + pct=0.075, + precision=9, + min_value=0.0, + ) + vibration["vibrationScore"] = _round( + _clamp( + _as_float(vibration.get("vibrationScore")) + + _noise(seed_key, "vibration.vibrationScore", -0.025, 0.025), + 0.0, + 0.99, + ), + 6, + ) + + +def _vary_robot_arm_vibration(robot: dict[str, Any], seed_key: str) -> None: + if not robot: + return + robot["frequencyHz"] = _jitter_numeric( + _as_float(robot.get("frequencyHz")), + seed_key, + "robot.frequencyHz", + pct=0.035, + precision=3, + min_value=0.0, + ) + for field in ("amplitude", "vibrationRms", "vibrationPeak"): + robot[field] = _jitter_numeric( + _as_float(robot.get(field)), + seed_key, + f"robot.{field}", + pct=0.07, + precision=9, + min_value=0.0, + ) + robot["vibrationScore"] = _round( + _clamp( + _as_float(robot.get("vibrationScore")) + + _noise(seed_key, "robot.vibrationScore", -0.03, 0.03), + 0.0, + 0.99, + ), + 6, + ) + + +def _vary_thermal(thermal: dict[str, Any], seed_key: str) -> None: + if not thermal: + return + original_avg = _as_float(thermal.get("avgTemperature")) + original_max = _as_float(thermal.get("maxTemperature"), original_avg) + original_min = _as_float(thermal.get("minTemperature"), original_avg) + + avg_temp = _round( + original_avg + _noise(seed_key, "thermal.avgTemperature", -0.85, 0.85), + 3, + ) + upper_spread = max(original_max - original_avg, 0.25) + lower_spread = max(original_avg - original_min, 0.25) + upper_spread *= _factor(seed_key, "thermal.upperSpread", 0.08) + lower_spread *= _factor(seed_key, "thermal.lowerSpread", 0.08) + + thermal["avgTemperature"] = avg_temp + thermal["thermalScore"] = avg_temp + thermal["maxTemperature"] = _round(max(avg_temp, avg_temp + upper_spread), 3) + thermal["minTemperature"] = _round(min(avg_temp, avg_temp - lower_spread), 3) + + +def _vary_process_metrics(metrics: dict[str, Any], seed_key: str) -> None: + if not metrics: + return + cycle_time = _jitter_numeric( + _as_float(metrics.get("cycleTimeSec"), 1.0), + seed_key, + "metrics.cycleTimeSec", + pct=0.045, + precision=3, + min_value=1.0, + ) + processing_time = _jitter_numeric( + _as_float(metrics.get("processingTimeSec"), cycle_time * 0.85), + seed_key, + "metrics.processingTimeSec", + pct=0.04, + precision=3, + min_value=0.5, + ) + processing_time = _round(min(processing_time, max(0.5, cycle_time - 0.5)), 3) + waiting_time = _round( + max( + 0.5, + cycle_time + - processing_time + + _noise(seed_key, "metrics.waitingTimeSec", -0.35, 1.15), + ), + 3, + ) + station_delay = _jitter_numeric( + _as_float(metrics.get("stationDelaySec")), + seed_key, + "metrics.stationDelaySec", + pct=0.12, + precision=3, + min_value=0.0, + ) + idle_time = _jitter_numeric( + _as_float(metrics.get("equipmentIdleTimeSec")), + seed_key, + "metrics.equipmentIdleTimeSec", + pct=0.13, + precision=3, + min_value=0.0, + ) + + metrics["cycleTimeSec"] = cycle_time + metrics["processingTimeSec"] = processing_time + metrics["waitingTimeSec"] = waiting_time + metrics["stationDelaySec"] = station_delay + metrics["throughputPerMin"] = _round(60 / cycle_time, 3) + metrics["queueLength"] = max( + 0, + _as_int(metrics.get("queueLength")) + _noise_int(seed_key, "metrics.queue", 2), + ) + metrics["wipCount"] = max( + 0, + _as_int(metrics.get("wipCount")) + _noise_int(seed_key, "metrics.wip", 3), + ) + metrics["equipmentIdleTimeSec"] = idle_time + + +def _press_count_increase_flag( + *, + station_delay_sec: float, + equipment_idle_time_sec: float, +) -> bool | None: + if station_delay_sec <= 2.0 and equipment_idle_time_sec < 6.0: + return True + if station_delay_sec <= 3.0: + return None + return False + + +def _body_robot_motion_status(vibration_score: float) -> str: + if vibration_score >= 0.45: + return "ABNORMAL" + if vibration_score >= 0.40: + return "WARNING" + return "NORMAL" + + +def _body_robot_operation_mode(vibration_score: float) -> str: + return "STOPPED" if vibration_score >= 0.45 else "AUTO" + + +def _sync_process_data( + process_data: dict[str, Any], + sensor: dict[str, Any], + metrics: dict[str, Any], + seed_key: str, +) -> None: + """변동된 센서/공정 지표와 공정별 processData의 파생값을 일치시킨다.""" + if not process_data: + return + + press = process_data.get("press") + if isinstance(press, dict): + press["timestampDelaySec"] = metrics.get("stationDelaySec", 0.0) + press["countIncreaseYn"] = _press_count_increase_flag( + station_delay_sec=_as_float(metrics.get("stationDelaySec")), + equipment_idle_time_sec=_as_float(metrics.get("equipmentIdleTimeSec")), + ) + + body = process_data.get("body") + if isinstance(body, dict): + robot_score = _as_float( + sensor.get("robotArmVibration", {}).get("vibrationScore"), + ) + body["robotMotionStatus"] = _body_robot_motion_status(robot_score) + body["robotOperationMode"] = _body_robot_operation_mode(robot_score) + + paint = process_data.get("paint") + if isinstance(paint, dict): + thermal_std_temp = _jitter_numeric( + _as_float(paint.get("thermalStdTemp")), + seed_key, + "paint.thermalStdTemp", + pct=0.05, + absolute=0.18, + precision=3, + min_value=0.0, + ) + original_thermal_std_temp = _as_float(paint.get("thermalStdTemp")) + if original_thermal_std_temp < 2.0: + thermal_std_temp = min(1.99, thermal_std_temp) + elif original_thermal_std_temp < 5.0: + thermal_std_temp = min(4.99, max(2.0, thermal_std_temp)) + else: + thermal_std_temp = max(5.0, thermal_std_temp) + paint["thermalStdTemp"] = _round(thermal_std_temp, 3) + + thickness_value = _jitter_numeric( + _as_float(paint.get("thicknessValue")), + seed_key, + "paint.thicknessValue", + pct=0.01, + absolute=0.9, + precision=3, + min_value=0.0, + ) + original_thickness_value = _as_float(paint.get("thicknessValue")) + if original_thickness_value < 80.0: + thickness_value = min(79.9, thickness_value) + elif original_thickness_value < 90.0: + thickness_value = min(89.9, max(80.0, thickness_value)) + elif original_thickness_value <= 120.0: + thickness_value = min(120.0, max(90.0, thickness_value)) + elif original_thickness_value <= 130.0: + thickness_value = min(130.0, max(120.0, thickness_value)) + else: + thickness_value = max(130.1, thickness_value) + paint["thicknessValue"] = _round(thickness_value, 3) + + original_defect_score = _as_float(paint.get("defectScore")) + defect_score = _round( + _clamp( + original_defect_score + + _noise(seed_key, "paint.defectScore", -0.025, 0.025), + 0.0, + 0.99, + ), + 4, + ) + if original_defect_score < 0.4: + defect_score = min(0.39, defect_score) + elif original_defect_score < 0.6: + defect_score = min(0.59, max(0.4, defect_score)) + else: + defect_score = max(0.6, defect_score) + paint["defectScore"] = defect_score + + surface_quality_score = _jitter_numeric( + _as_float(paint.get("surfaceQualityScore")), + seed_key, + "paint.surfaceQualityScore", + pct=0.02, + absolute=1.5, + precision=3, + min_value=0.0, + ) + original_surface_quality_score = _as_float(paint.get("surfaceQualityScore")) + if original_surface_quality_score >= 80.0: + surface_quality_score = max(80.0, surface_quality_score) + elif original_surface_quality_score >= 60.0: + surface_quality_score = min(79.9, max(60.0, surface_quality_score)) + else: + surface_quality_score = min(59.9, surface_quality_score) + paint["surfaceQualityScore"] = _round(surface_quality_score, 3) + paint["visionLabel"] = "DEFECT" if defect_score >= 0.4 else "NORMAL" + + assembly = process_data.get("assembly") + if isinstance(assembly, dict): + delta = 1 if _noise(seed_key, "assembly.errorFlip", 0.0, 1.0) > 0.92 else 0 + base_sequence_error = _as_int(assembly.get("sequenceErrorCount")) + sequence_error_count = max(0, min(2, base_sequence_error + delta)) + assembly["sequenceErrorCount"] = sequence_error_count + assembly["fasteningErrorCount"] = max( + 0, + min(2, _as_int(assembly.get("fasteningErrorCount")) + delta), + ) + assembly["missingPartCount"] = max( + 0, + min(2, _as_int(assembly.get("missingPartCount")) + (1 if delta else 0)), + ) + expected_sequence = str(assembly.get("expectedSequence", "")) + expected_steps = expected_sequence.split(">") + if len(expected_steps) == 4: + assembly["actualSequence"] = ( + ">".join( + [ + expected_steps[0], + expected_steps[2], + expected_steps[1], + expected_steps[3], + ], + ) + if sequence_error_count + else expected_sequence + ) + + +def _refresh_equipment_status( + event_json: dict[str, Any], + sensor: dict[str, Any], + metrics: dict[str, Any], +) -> None: + """날짜별 수치 변동 후에도 생성된 상태와 이상 분류를 그대로 유지한다.""" + equipment_status = event_json.get("equipmentStatus", {}) + # 센서와 지표는 날짜별로 변동하지만 정상/이상 7:3 분포와 최초 랜덤 + # operationStatus는 변경하지 않는다. + _ = sensor, metrics + equipment_status["lastNormalTime"] = None + equipment_status["statusChangedTime"] = None + + +def _jitter_numeric( + value: float, + seed_key: str, + field: str, + *, + pct: float, + precision: int, + min_value: float | None = None, + max_value: float | None = None, + absolute: float | None = None, +) -> float: + base = _as_float(value) + delta = _noise(seed_key, field, -absolute, absolute) if absolute else 0.0 + varied = base * _factor(seed_key, field, pct) + delta + if min_value is not None: + varied = max(min_value, varied) + if max_value is not None: + varied = min(max_value, varied) + return _round(varied, precision) + + +def _factor(seed_key: str, field: str, pct: float) -> float: + return 1.0 + _noise(seed_key, field, -pct, pct) + + +def _noise(seed_key: str, field: str, low: float, high: float) -> float: + """해시 기반 의사 난수로 같은 날짜·이벤트·필드에 같은 변동값을 반환한다.""" + digest = hashlib.blake2b( + f"{seed_key}:{field}".encode("utf-8"), + digest_size=8, + ).digest() + ratio = int.from_bytes(digest, "big") / ((1 << 64) - 1) + return low + (high - low) * ratio + + +def _noise_int(seed_key: str, field: str, spread: int) -> int: + if spread <= 0: + return 0 + return int(round(_noise(seed_key, field, -spread, spread))) + + +def _as_float(value: Any, default: float = 0.0) -> float: + try: + return float(value) + except (TypeError, ValueError): + return default + + +def _as_int(value: Any, default: int = 0) -> int: + try: + return int(value) + except (TypeError, ValueError): + return default + + +def _clamp(value: float, low: float, high: float) -> float: + return min(high, max(low, value)) + + +def _round(value: float, precision: int) -> float: + return round(float(value), precision) diff --git a/app/utils/analysis_time_window.py b/app/utils/analysis_time_window.py new file mode 100644 index 0000000..bfcfa11 --- /dev/null +++ b/app/utils/analysis_time_window.py @@ -0,0 +1,58 @@ +from __future__ import annotations + +from dataclasses import dataclass +from datetime import date, datetime, time, timedelta + +from app.utils.datetime_utils import seoul_now + + +@dataclass(frozen=True) +class AnalysisTimeWindow: + selected_date: date | None + start_at: datetime | None + end_at: datetime | None + + +def build_analysis_time_window( + *, + date_value: date | None = None, + from_at: datetime | None = None, + to_at: datetime | None = None, + end_at: datetime | None = None, + default_to_today: bool = True, +) -> AnalysisTimeWindow: + if date_value is not None: + start_at = datetime.combine(date_value, time.min) + return AnalysisTimeWindow( + selected_date=date_value, + start_at=start_at, + end_at=start_at + timedelta(days=1), + ) + + normalized_from = _normalize_datetime(from_at) + normalized_to = _normalize_datetime(to_at) + normalized_end = _normalize_datetime(end_at) + final_end = normalized_to or normalized_end + + if normalized_from is None and final_end is None and default_to_today: + today = seoul_now().date() + start_at = datetime.combine(today, time.min) + return AnalysisTimeWindow( + selected_date=today, + start_at=start_at, + end_at=start_at + timedelta(days=1), + ) + + return AnalysisTimeWindow( + selected_date=None, + start_at=normalized_from, + end_at=final_end, + ) + + +def _normalize_datetime(value: datetime | None) -> datetime | None: + if value is None: + return None + if value.tzinfo is not None: + return value.replace(tzinfo=None) + return value diff --git a/app/utils/process_label_utils.py b/app/utils/process_label_utils.py new file mode 100644 index 0000000..ab68314 --- /dev/null +++ b/app/utils/process_label_utils.py @@ -0,0 +1,67 @@ +from __future__ import annotations + +import hashlib +import re +from typing import Any + +PROCESS_LABELS = { + "PRESS": "프레스", + "BODY": "차체", + "PAINT": "도장", + "ASSEMBLY": "의장", +} + +PROCESS_EQUIPMENT_PREFIXES = { + "PRESS": "P", + "BODY": "S", + "PAINT": "L", + "ASSEMBLY": "A", +} + +NEXT_PROCESS = { + "PRESS": "BODY", + "BODY": "PAINT", + "PAINT": "ASSEMBLY", +} + +LINE_STATION_COUNT = 5 + + +def equipment_number(equipment_code: Any | None) -> int | None: + if equipment_code is None: + return None + match = re.search(r"(\d+)$", str(equipment_code).strip()) + if not match: + return None + return int(match.group(1)) + + +def equipment_no_for_car_process(*, car_master_id: int, process_code: str) -> int: + normalized = str(process_code or "").strip().upper() + digest = hashlib.blake2b( + f"{car_master_id}:{normalized}:equipment".encode("utf-8"), + digest_size=8, + ).digest() + return int.from_bytes(digest, "big") % LINE_STATION_COUNT + 1 + + +def equipment_code_for_car_process(*, car_master_id: int, process_code: str) -> str: + normalized = str(process_code or "").strip().upper() + equipment_no = equipment_no_for_car_process( + car_master_id=car_master_id, + process_code=normalized, + ) + return f"EQ_{normalized}_{equipment_no:03d}" + + +def format_process_with_line( + process_code: Any, + equipment_code: Any | None = None, +) -> str: + normalized = str(process_code or "").strip().upper() + label = PROCESS_LABELS.get(normalized, normalized) + prefix = PROCESS_EQUIPMENT_PREFIXES.get(normalized) + equipment_no = equipment_number(equipment_code) + if prefix and equipment_no is not None: + return f"{label} ({prefix}{equipment_no})" + return label diff --git a/app/websocket/__init__.py b/app/websocket/__init__.py new file mode 100644 index 0000000..1296f9e --- /dev/null +++ b/app/websocket/__init__.py @@ -0,0 +1 @@ +"""WebSocket helpers for realtime API notifications.""" diff --git a/app/websocket/analysis_manager.py b/app/websocket/analysis_manager.py new file mode 100644 index 0000000..1add0ba --- /dev/null +++ b/app/websocket/analysis_manager.py @@ -0,0 +1,75 @@ +from __future__ import annotations + +import asyncio +import logging +from typing import Any + +from fastapi import WebSocket + + +logger = logging.getLogger(__name__) + + +class AnalysisWebSocketManager: + """Keep active dashboard websocket connections and broadcast update hints.""" + + def __init__(self) -> None: + self._connections: list[WebSocket] = [] + self._loop: asyncio.AbstractEventLoop | None = None + + async def connect(self, websocket: WebSocket) -> None: + await websocket.accept() + self._loop = asyncio.get_running_loop() + if websocket not in self._connections: + self._connections.append(websocket) + await websocket.send_json({"type": "CONNECTED"}) + + def disconnect(self, websocket: WebSocket) -> None: + try: + self._connections.remove(websocket) + except ValueError: + pass + + async def broadcast(self, message: dict[str, Any]) -> None: + if not self._connections: + return + + disconnected: list[WebSocket] = [] + for websocket in tuple(self._connections): + try: + await websocket.send_json(message) + except Exception: + disconnected.append(websocket) + + for websocket in disconnected: + self.disconnect(websocket) + + def broadcast_from_thread(self, message: dict[str, Any]) -> None: + loop = self._loop + if loop is None or not loop.is_running(): + logger.warning( + "Skipped process analysis websocket broadcast: " + "event_loop_unavailable type=%s", + message.get("type"), + ) + return + if not self._connections: + logger.warning( + "Skipped process analysis websocket broadcast: " + "active_connections=0 type=%s", + message.get("type"), + ) + return + + future = asyncio.run_coroutine_threadsafe(self.broadcast(message), loop) + future.add_done_callback(self._log_broadcast_failure) + + @staticmethod + def _log_broadcast_failure(future: asyncio.Future[Any]) -> None: + try: + future.result() + except Exception: + logger.exception("Failed to broadcast process analysis websocket update.") + + +analysis_websocket_manager = AnalysisWebSocketManager() diff --git a/app/worker_main.py b/app/worker_main.py new file mode 100644 index 0000000..15bc8d5 --- /dev/null +++ b/app/worker_main.py @@ -0,0 +1,159 @@ +# app/worker_main.py + +import threading +import time +import signal +import sys +import logging +import os + +from app.db import ( + main_dispose_engine, + sample_dispose_engine, +) + +from app.scheduler.quality.drive_detail_producer import run as drive_producer +from app.scheduler.quality.status_detail_producer import run as status_producer +from app.scheduler.quality.risk_history_producer import run as history_producer +from app.scheduler.quality.risk_trend_producer import run as trend_producer +from app.scheduler.quality.process_producer import run as process_producer +#from app.scheduler.quality.stomp_client import run as stomp_client + +from app.repository.quality_drive_detail_repository import run as drive_repository +from app.repository.quality_status_detail_repository import run as status_repository +from app.repository.quality_risk_history_repository import run as history_repository +from app.repository.quality_risk_trend_repository import run as trend_repository +from app.repository.quality_process_repository import run as process_repository +from app.repository.quality_summary_repository import run as summary_repository + +os.makedirs("logs", exist_ok=True) + +logging.basicConfig( + level=logging.INFO, + format="%(asctime)s [%(levelname)s] [%(threadName)s] %(message)s", + handlers=[ + logging.FileHandler("logs/worker.log", encoding="utf-8"), + logging.StreamHandler(sys.stdout) + ] +) + +logger = logging.getLogger(__name__) + +# ========================= +# STOP FLAG (핵심) +# ========================= +stop_event = threading.Event() +cleanup_done = False +threads = [] + + +# ========================= +# THREAD WRAPPER +# ========================= +def start_thread(name, target): + logger.info(f"[START] {name}") + + thread = threading.Thread( + target=lambda: target(stop_event), + daemon=True, + name=name + ) + + thread.start() + return thread + + +# ========================= +# CLEAN SHUTDOWN +# ========================= +def cleanup(): + global cleanup_done + + if cleanup_done: + return + + cleanup_done = True + + logger.info("\n🧹 Graceful Shutdown 시작...") + + # 1. stop signal 전달 + stop_event.set() + + # 2. thread 종료 대기 + logger.info("⏳ threads join 중...") + for t in threads: + try: + t.join(timeout=5) + except Exception: + pass + + # 3. DB connection pool 종료 + try: + main_dispose_engine() + sample_dispose_engine() + except Exception as e: + logger.info("DB dispose error:", e) + + logger.info("✅ Shutdown 완료") + + +# ========================= +# SIGNAL HANDLER +# ========================= +def handle_exit(signum, frame): + logger.info("\n⚠️ 종료 신호 감지 (Ctrl+C)") + cleanup() + sys.exit(0) + + +signal.signal(signal.SIGINT, handle_exit) +signal.signal(signal.SIGTERM, handle_exit) + + +# ========================= +# MAIN +# ========================= +if __name__ == "__main__": + + logger.info("=" * 60) + logger.info("🚀 AI-Service 시작") + logger.info("=" * 60) + + # ===================== + # PRODUCERS + # ===================== + threads.append(start_thread("Drive Producer", drive_producer)) + threads.append(start_thread("Status Producer", status_producer)) + threads.append(start_thread("History Producer", history_producer)) + threads.append(start_thread("Trend Producer", trend_producer)) + threads.append(start_thread("Process Producer", process_producer)) + + # ===================== + # CONSUMERS / REPOSITORY + # ===================== + threads.append(start_thread("Drive Consumer", drive_repository)) + threads.append(start_thread("Status Consumer", status_repository)) + threads.append(start_thread("History Consumer", history_repository)) + threads.append(start_thread("Trend Consumer", trend_repository)) + threads.append(start_thread("Process Consumer", process_repository)) + threads.append(start_thread("Summary Aggregator", summary_repository)) + + # ===================== + # STOMP + # ===================== + #threads.append(start_thread("STOMP Client", stomp_client)) + + logger.info("\n📡 서비스 실행 중... (Ctrl+C로 종료)") + + # ===================== + # BLOCKING LOOP (STOP EVENT 기반) + # ===================== + try: + while not stop_event.is_set(): + time.sleep(1) + + except KeyboardInterrupt: + handle_exit(None, None) + + finally: + cleanup() \ No newline at end of file diff --git a/docs/MANUFACUTRING_REFERENCE.md b/docs/MANUFACUTRING_REFERENCE.md new file mode 100644 index 0000000..507e6ac --- /dev/null +++ b/docs/MANUFACUTRING_REFERENCE.md @@ -0,0 +1,369 @@ +# 프레스·차체 이상탐지 기준값 레퍼런스 정리 + +현재 프레스와 차체 공정의 기준값은 일부가 코드에 고정 숫자로 들어가 있지만, 그 숫자들이 ISO 문서에 직접 명시된 공식 기준값은 아닙니다. + +예를 들어 현재 코드의 다음 값들은 내부 하드코딩 값입니다. + +``` +프레스 전류 RMS: 1.5A +차체 진동 점수: 0.75 / 1.25 +차체 주파수 피크: 0.015 / 0.03 +``` + +따라서 이 값을 다른 고정 숫자로 단순 교체하기보다는, ISO 문서의 측정·관리 원칙을 근거로 **설비별 정상 데이터를 이용해 NORMAL, WARNING, DANGER 기준을 만드는 방식**이 적절합니다. + +## 핵심 개념 + +ISO 문서에서 모든 프레스와 로봇에 공통으로 적용되는 다음과 같은 숫자를 제공하는 것은 아닙니다. + +``` +프레스 전류 10A 이상 위험 +로봇 진동 0.5 이상 위험 +사이클 시간 40초 이상 위험 +``` + +설비 종류, 모터 정격, 차종, 금형, 로봇 프로그램, 작업 속도에 따라 정상값이 달라지기 때문입니다. + +그래서 다음 방식으로 기준을 만듭니다. + +``` +정상 데이터의 평균값 = μ +정상 데이터가 평소 흔들리는 정도 = σ +``` + +이를 기준으로: + +| 상태 | 기준 | +| --- | --- | +| 정상 | 평균에서 2σ 이내 | +| 경고 | 평균에서 2σ 이상 3σ 미만 벗어남 | +| 위험 | 평균에서 3σ 이상 벗어남 | + +여기서 `σ`는 시그마라고 읽으며, 정상 데이터의 변동 정도를 뜻합니다. + +예를 들어 정상 사이클 시간이 평균 40초이고 표준편차가 1초라면: + +| 상태 | 기준 | +| --- | --- | +| 정상 | 38~42초 | +| 경고 | 37~38초 또는 42~43초 | +| 위험 | 37초 미만 또는 43초 초과 | + +즉, ISO 기반 기준이라는 것은 ISO에 적힌 절대 숫자를 그대로 쓰는 것이 아니라, **ISO의 관리도 원칙을 우리 설비의 정상 데이터에 적용해 기준값을 만드는 방식**입니다. + +--- + +# 1. 프레스 공정 + +현재 프레스 이상탐지에는 다음 값이 사용됩니다. + +| 지표 | 의미 | +| --- | --- | +| 사이클 시간 | 제품 한 개를 처리하는 데 걸린 시간 | +| 지연시간 | 공정이 평소보다 지연된 시간 | +| 전류 RMS | 모터나 설비가 사용하는 전류의 평균적인 크기 | +| 생산 카운트 | 생산 수량이 정상적으로 증가했는지 여부 | +| 설비 상태 | RUNNING, WARNING, STOPPED, FAULT 등의 상태 | + +현재 프레스에서는 압력, 하중, 금형 상태, 제품 치수 등은 이상탐지에 직접 사용하지 않습니다. + +## 프레스 기준값에 사용할 레퍼런스 + +### ISO 22400 + +제조 공정의 KPI, 사이클 시간, 생산성 등의 정의와 관리 방식을 다루는 표준입니다. + +이 문서는 “프레스 사이클은 40초가 정상”이라는 숫자를 정해주는 것이 아니라, 사이클 시간을 어떤 의미로 관리해야 하는지를 제공합니다. + +따라서 사이클 시간과 지연시간을 관리하는 기본 근거로 사용할 수 있습니다. + +### ISO 7870 + +통계적 공정관리와 관리도에 대한 표준입니다. + +정상 데이터의 평균과 표준편차를 이용해 정상, 경고, 위험 구간을 만드는 근거로 사용할 수 있습니다. + +즉: + +``` +2σ 이내 = 정상 +2σ~3σ = 경고 +3σ 초과 = 위험 +``` + +이라는 운영 기준을 만들 때 사용하는 핵심 문서입니다. + +### ISO 20958 + +전동기의 전류 신호를 이용한 상태감시 방법을 다루는 표준입니다. + +현재 코드의 `1.5A`처럼 모든 설비에 같은 전류 기준을 쓰는 대신, 모터와 운전 조건별 전류 패턴을 분석해야 한다는 근거로 사용할 수 있습니다. + +이 표준이 “1.5A 이상 위험”이라는 값을 제공하는 것은 아닙니다. + +## 프레스 추천 기준 + +| 지표 | 추천 기준 | +| --- | --- | +| 사이클 시간 | 차종·금형·작업별 정상 평균 ±2σ는 정상, 2~3σ는 경고, 3σ 이상은 위험 | +| 지연시간 | 정상 평균+2σ 이하는 정상, 2~3σ는 경고, 3σ 초과는 위험 | +| 전류 RMS | 동일 모터·동작 단계의 정상 평균 ±2σ는 정상, 2~3σ는 경고, 3σ 이상 또는 제조사 과부하 한계 초과는 위험 | +| 생산 카운트 | `true` 정상, `null` 데이터 누락 경고, `false` 위험 | +| 설비 상태 | `RUNNING` 정상, `WARNING` 경고, `STOPPED/FAULT` 위험 | + +### 사이클 시간 + +사이클 시간은 모든 설비에 같은 기준을 쓰면 안 됩니다. + +다음 조건별로 정상 기준을 따로 만들어야 합니다. + +``` +프레스 설비 +차종 +금형 +작업 코드 +``` + +예를 들어: + +``` +프레스 1호기 + 차종 A + 금형 D01 +평균 사이클 시간: 40초 +표준편차: 1초 +``` + +이라면: + +``` +정상: 38~42초 +경고: 37~38초 또는 42~43초 +위험: 37초 미만 또는 43초 초과 +``` + +처럼 기준을 만들 수 있습니다. + +### 지연시간 + +지연시간은 낮은 값이 문제가 되지 않으므로 상한만 확인하면 됩니다. + +예를 들어: + +``` +평균 지연시간: 3초 +표준편차: 1초 +``` + +라면: + +``` +정상: 5초 이하 +경고: 5초 초과~6초 이하 +위험: 6초 초과 +``` + +가 됩니다. + +### 전류 RMS + +현재 코드의 `1.5A` 기준은 설비 정격이나 운전 조건과 무관하기 때문에 근거가 부족합니다. + +전류 기준을 만들기 전에 다음 정보가 필요합니다. + +``` +어떤 모터의 전류인지 +단상인지 3상 RMS인지 +타격·복귀·대기 중 언제 측정한 값인지 +모터 정격전류가 얼마인지 +``` + +그다음 동작 단계별 정상 데이터를 모아 평균과 표준편차를 계산해야 합니다. + +예를 들어 타격 단계 전류가: + +``` +평균 12A +표준편차 0.8A +``` + +라면: + +``` +정상: 10.4~13.6A +경고: 9.6~10.4A 또는 13.6~14.4A +위험: 9.6A 미만 또는 14.4A 초과 +``` + +로 설정할 수 있습니다. + +또한 모터 제조사에서 정한 과부하 한계가 있다면 통계 기준보다 제조사 한계를 우선 적용해야 합니다. + +--- + +# 2. 차체 공정 + +현재 차체 이상탐지에서는 용접 전류나 용접 품질값을 사용하지 않습니다. + +실제 사용되는 값은 다음과 같습니다. + +| 지표 | 의미 | +| --- | --- | +| 로봇 진동 점수 | 로봇이 평소보다 얼마나 심하게 진동하는지 나타내는 내부 점수 | +| 주파수 피크 | 특정 주파수에서 진동이 얼마나 크게 발생하는지 | +| 주파수 대역값 | 저주파·중주파·고주파 등 각 구간의 진동 크기 | +| 로봇 동작 상태 | NORMAL, ABNORMAL, COLLISION_RISK 등의 상태 | +| 로봇 운전 모드 | AUTO, MANUAL, STOPPED 등의 상태 | +| 설비 상태 | RUNNING, WARNING, STOPPED, FAULT 등의 상태 | + +현재 코드의 `0.75`, `1.25`, `0.015`, `0.03`은 ISO 공식 진동 기준이 아니라 내부 점수식에서 사용하기 위해 설정된 값입니다. + +## 차체 기준값에 사용할 레퍼런스 + +### ISO 13373 + +진동 센서의 설치 위치, 측정 조건, 데이터 수집, 시간영역 분석, 주파수영역 분석 방법을 다루는 표준입니다. + +차체 로봇 진동과 주파수 데이터를 사용할 때 다음을 명확히 해야 한다는 근거가 됩니다. + +``` +센서 위치 +측정 단위 +샘플링 주파수 +FFT 계산 방식 +RMS인지 Peak인지 +동일한 로봇 동작 조건인지 +``` + +### ISO 20816 + +기계 진동의 크기와 변화량을 이용해 상태를 평가하는 원칙을 제공합니다. + +다만 현재의 `robotVibrationScore`처럼 단위가 불명확한 내부 점수에 ISO 20816의 수치를 직접 적용할 수는 없습니다. + +먼저 진동값이 다음 중 무엇인지 확인해야 합니다. + +``` +속도 RMS: mm/s +가속도 RMS: m/s² 또는 g +Peak +Peak-to-Peak +FFT amplitude +PSD +``` + +### ISO 7870 + +프레스와 마찬가지로 정상 데이터의 평균과 표준편차를 이용해 정상, 경고, 위험 구간을 만드는 근거로 사용합니다. + +## 차체 추천 기준 + +| 지표 | 추천 기준 | +| --- | --- | +| 로봇 진동 점수 | 같은 로봇·프로그램·속도·적재량 조건의 평균+2σ 이하 정상, 2~3σ 경고, 3σ 초과 위험 | +| 주파수 피크 | 각 주파수 대역의 정상 평균+2σ 이하 정상, 2~3σ 경고, 3σ 초과 위험 | +| 로봇 상태 | `NORMAL` 정상, `WARNING/UNKNOWN` 경고, `ABNORMAL/COLLISION_RISK` 위험 | +| 운전 모드 | 생산 중 `AUTO` 정상, 계획정비 중 `MANUAL/STOPPED` 제외, 생산 중 예상하지 않은 `MANUAL/STOPPED` 위험 | +| 설비 상태 | `RUNNING` 정상, `WARNING` 경고, `STOPPED/FAULT` 위험 | + +### 로봇 진동 점수 + +로봇 진동은 다음 조건에 따라 정상값이 달라질 수 있습니다. + +``` +로봇 번호 +작업 프로그램 +작업 속도 +payload +로봇 자세 +작업 구간 +``` + +따라서 다음 데이터는 하나의 기준으로 섞으면 안 됩니다. + +``` +R01 + 프로그램 P100 + 속도 80% + payload 20kg +R01 + 프로그램 P200 + 속도 60% + payload 10kg +R02 + 프로그램 P100 + 속도 80% + payload 20kg +``` + +각 조건별로 정상 평균과 표준편차를 따로 계산해야 합니다. + +예를 들어: + +``` +조건: R01 / P100 / 속도 80% / payload 20kg +평균 진동 점수: 0.30 +표준편차: 0.05 +``` + +라면: + +``` +정상: 0.40 이하 +경고: 0.40 초과~0.45 이하 +위험: 0.45 초과 +``` + +로 기준을 만들 수 있습니다. + +### 주파수 피크와 주파수 대역 + +현재처럼 모든 주파수 대역에 동일한 `0.015`, `0.03`을 적용하는 것은 적절하지 않습니다. + +각 주파수 구간은 원래 진동 크기가 다를 수 있기 때문에 대역별 기준이 필요합니다. + +예: + +``` +0~10Hz +10~50Hz +50~100Hz +``` + +각 대역에서 정상 데이터를 별도로 모아 평균과 표준편차를 계산합니다. + +예를 들어: + +| 주파수 대역 | 정상 평균 | 표준편차 | 정상 상한 | 경고 상한 | 위험 | +| --- | --- | --- | --- | --- | --- | +| 0~10Hz | 0.006 | 0.001 | 0.008 | 0.009 | 0.009 초과 | +| 10~50Hz | 0.015 | 0.003 | 0.021 | 0.024 | 0.024 초과 | +| 50~100Hz | 0.004 | 0.0005 | 0.005 | 0.0055 | 0.0055 초과 | + +즉, “대역별 기준”이란 주파수 구간마다 서로 다른 정상·경고·위험 값을 사용하는 것을 의미합니다. + +--- + +# 최종 정리 + +## 프레스 + +| 지표 | 레퍼런스 | 기준 설정 방법 | +| --- | --- | --- | +| 사이클 시간 | ISO 22400 + ISO 7870 | 차종·금형·작업별 정상 평균과 표준편차로 2σ·3σ 기준 생성 | +| 지연시간 | ISO 7870 | 작업별 정상 지연시간의 평균+2σ, 평균+3σ 사용 | +| 전류 RMS | ISO 20958 + ISO 7870 | 모터·운전 단계별 정상 전류 기준 생성, 제조사 과부하 한계 병행 | +| 생산 카운트 | 공정 논리 기준 | `true` 정상, `null` 경고, `false` 위험 | +| 설비 상태 | 설비 상태 코드 | `RUNNING` 정상, `WARNING` 경고, `STOPPED/FAULT` 위험 | + +## 차체 + +| 지표 | 레퍼런스 | 기준 설정 방법 | +| --- | --- | --- | +| 로봇 진동 점수 | ISO 13373 + ISO 7870 | 로봇·프로그램·속도·payload별 정상 평균과 2σ·3σ 기준 생성 | +| 주파수 피크 | ISO 13373 + ISO 7870 | 각 주파수 대역별 정상 평균과 2σ·3σ 기준 생성 | +| 진동 물리량 | ISO 20816 | 단위와 센서 위치가 확인된 경우 상태평가 참고 | +| 로봇 상태 | 컨트롤러 상태 코드 | `NORMAL`, `WARNING`, `ABNORMAL/COLLISION_RISK`로 구분 | +| 운전 모드 | 생산 운영 기준 | 생산 중 `AUTO` 정상, 비정상 `MANUAL/STOPPED` 위험 | +| 설비 상태 | 설비 상태 코드 | `RUNNING` 정상, `WARNING` 경고, `STOPPED/FAULT` 위험 | + + +# 도장 레퍼런스 + +도장 기준점 & 레퍼런스 정리 + +| 지표 | 추천 기준점 | 레퍼런스 / 설명 | +| --- | --- | --- | +| 표면 품질 점수 `surfaceQualityScore` | 정상: 80점 이상 / 경고: 60~80점 / 위험: 60점 미만 | ISO 4628-1은 도막 결함의 수량·크기·강도 및 외관 변화를 0~5 등급으로 평가하는 체계를 제시함. 이를 내부 100점 점수로 환산해 ISO 1 수준 이하를 정상, ISO 2 수준을 경고, ISO 3 이상을 위험으로 매핑. | +| 도막 두께 `thicknessValue` | 목표: 115μm / 정상: 90~120μm / 경고: 80~90 또는 120~130μm / 위험: 80μm 미만 또는 130μm 초과 | PPG Refinish 자료에서 OEM 도장 마감 두께는 약 90~120μm라고 설명함. ISO 2808은 도료·바니시 도막 두께 측정 방법을 다루는 표준. 80~130μm는 90~120μm 정상 범위에 ±10μm guard band를 둔 운영 기준. | +| 불량 점수 `defectScore` | 정상: 0.4 미만 / 경고: 0.4~0.6 / 위험: 0.6 이상 | ISO 4628-1의 0~5 결함 등급을 0~1 내부 점수로 정규화. ISO 2/5 = 0.4를 경고, ISO 3/5 = 0.6을 위험 기준으로 매핑. 단, `visionLabel != NORMAL`이면 최소 WARNING 유지. | +| 온도 편차 `thermalStdTemp` | 정상: 2℃ 미만 / 경고: 2~5℃ / 위험: 5℃ 이상 | Eurotherm의 건조·경화 오븐 자료에서 표준 오븐 온도 범위는 ±5℃, 중요 적용 분야는 ±2℃까지 좁힐 수 있다고 설명함. 이를 온도 균일도 관리 기준으로 사용. | \ No newline at end of file diff --git a/docs/elasticsearch-migration-guideline.md b/docs/elasticsearch-migration-guideline.md new file mode 100644 index 0000000..9cbf3f4 --- /dev/null +++ b/docs/elasticsearch-migration-guideline.md @@ -0,0 +1,468 @@ +# 병목 및 불량전이 조회의 Elasticsearch 전환 가이드 + +## 1. 목적 + +현재 병목 조회와 불량전이 조회는 MySQL 결과 테이블과 Redis 캐시를 중심으로 동작한다. +이 문서는 조회 계층을 Elasticsearch(OpenSearch 포함) 기반으로 전환할 때의 설계 원칙, 마이그레이션 순서, 운영 체크포인트를 정리한 가이드다. + +이 저장소 기준의 연동 주체는 **제조 서비스가 아니라 현재 AI 서비스**다. +즉, 제조 서비스는 원천 이벤트 생성과 전달까지만 책임지고, 병목/불량전이의 ES 인덱싱과 조회는 이 서비스에서 처리하는 구성이 맞다. + +핵심 목표는 다음과 같다. + +- 조회 성능을 안정화한다. +- 최신 결과를 빠르게 검색 가능하게 만든다. +- 기존 API 응답 형식은 유지한다. +- DB는 원장(source of truth), ES는 조회용 read model로 분리한다. + +## 2. 현재 구조 요약 + +### 병목 조회 + +현재 병목 조회는 다음 흐름이다. + +- Kafka raw 이벤트 수신 +- 병목 분석 수행 +- `bottleneck_analysis_result` 테이블에 저장 +- Redis 캐시로 페이지 응답 캐싱 +- API는 Redis 캐시를 우선 조회하고, 없으면 DB에서 조회 + +관련 코드: + +- [`app/api/routers/process.py`](../app/api/routers/process.py) +- [`app/service/analysis/bottleneck_service.py`](../app/service/analysis/bottleneck_service.py) +- [`app/repository/bottleneck_analysis_repository.py`](../app/repository/bottleneck_analysis_repository.py) + +### 불량전이 조회 + +현재 불량전이 조회는 다음 흐름이다. + +- raw 이벤트 또는 배치에서 불량전이 예측 수행 +- `defect_transfer_prediction_result` 테이블에 저장 +- Redis 캐시로 predictions / causes 페이지 캐싱 +- API는 캐시를 우선 조회하고, 없으면 DB와 이벤트 DB를 조합해 조회 + +관련 코드: + +- [`app/api/routers/defect_transfer.py`](../app/api/routers/defect_transfer.py) +- [`app/service/analysis/defect_transfer_service.py`](../app/service/analysis/defect_transfer_service.py) +- [`app/repository/defect_transfer_prediction_repository.py`](../app/repository/defect_transfer_prediction_repository.py) + +## 3. 전환 원칙 + +### 3.0 연동 위치 + +- 제조 서비스 + - 원천 제조 이벤트 생성 + - 분석 요청 또는 raw event 발행 + - ES 직접 연동은 하지 않음 +- 현재 AI 서비스 + - 병목/불량전이 분석 결과 생성 + - ES 인덱싱 + - 조회 API 제공 + +### 3.1 유지할 것 + +- API 경로와 응답 DTO +- 분석/예측의 계산 로직 +- MySQL 결과 테이블의 저장 책임 +- Redis 캐시의 선택적 사용 + +### 3.2 바꿀 것 + +- 조회 대상의 1차 소스를 MySQL에서 ES로 이동 +- 페이지 조회 방식에 맞는 ES 문서 구조 설계 +- 인덱싱/재색인/동기화 파이프라인 추가 + +### 3.3 절대 분리할 것 + +- MySQL은 결과 저장과 정합성 기준으로 유지 +- ES는 검색과 리스트 응답 전용으로 사용 +- ES 장애 시에는 DB fallback 또는 캐시 fallback 전략을 둔다 + +## 4. 목표 아키텍처 + +권장 구조는 아래와 같다. + +```text +Kafka/raw event -> analysis service -> MySQL result table + \-> outbox/event topic -> ES indexer -> Elasticsearch + +API -> Redis cache -> Elasticsearch -> fallback MySQL +``` + +권장 역할 분리: + +- MySQL + - 분석 결과의 원장 저장 + - 재처리/검증 기준 +- Elasticsearch + - 조회용 read model + - 최신 결과 검색, 정렬, 필터, collapse, highlight +- Redis + - 짧은 TTL 응답 캐시 + - 동일 페이지 반복 요청 완화 +- Kafka 또는 outbox + - ES 동기화 이벤트 전달 + +## 5. 인덱스 설계 + +## 5.1 병목 인덱스 + +권장 인덱스 예시: + +- `ai-bottleneck-result-v1` + +문서 단위는 다음 둘 중 하나를 추천한다. + +1. `rank` 기준 스냅샷 문서 +2. `manufacturing_event_id` 기준 원천 이벤트 문서 + +현재 API가 “병목 순위 페이지”를 반환하므로, 실무적으로는 스냅샷 단위 문서가 단순하다. + +예시 필드: + +- `snapshotId` +- `detectedAt` +- `rankNo` +- `processCode` +- `equipmentCode` +- `avgDelayTime` +- `affectedVehicleCount` +- `riskScore` +- `riskLevel` +- `mostBottleneckProcess` +- `mostBottleneckRiskLevel` + +권장 정렬: + +- `rankNo asc` +- 필요 시 `riskScore desc` +- 필요 시 `detectedAt desc` + +### 병목 문서 ID + +권장 ID는 다음 중 하나다. + +- `detectedAt + rankNo` +- `snapshotId + rankNo` + +이렇게 하면 재색인 시 중복 문서를 쉽게 방지할 수 있다. + +## 5.2 불량전이 인덱스 + +권장 인덱스 예시: + +- `ai-defect-transfer-result-v1` + +불량전이는 조회 유형이 두 가지다. + +1. predictions: 차량/이벤트 단위 목록 +2. causes: 특정 차량의 최신 이벤트에 대한 원인 목록 + +권장 문서 구조: + +- `eventId` +- `manufacturingEventId` +- `carMasterId` +- `vehicleId` +- `sourceProcessCode` +- `sourceEquipmentCode` +- `targetProcessCode` +- `targetEquipmentCode` +- `currentDefectProbability` +- `targetDefectProbability` +- `predictedDefectProcess` +- `expectedOccurrenceStep` +- `riskGrade` +- `predictedAt` +- `influenceScore` +- `mainCauses` as nested or object array + +### 불량전이 문서 ID + +권장 ID는 `manufacturingEventId` 또는 `eventId`다. + +이유: + +- 같은 이벤트에 대해 예측 결과는 최신 값 1개가 적합하다. +- upsert가 쉽다. +- 중복 적재를 피하기 쉽다. + +## 6. 매핑 가이드 + +### 6.1 병목 매핑 포인트 + +현재 `bottleneck_analysis_result` 테이블의 컬럼을 ES 필드로 1:1 매핑한다. + +중요한 점: + +- `riskScore`, `avgDelayTime`는 numeric type으로 저장 +- `rankNo`는 integer +- `detectedAt`는 date +- `processCode`는 keyword +- `equipmentCode`는 keyword + +### 6.2 불량전이 매핑 포인트 + +불량전이는 검색 조건이 다양하므로 다음처럼 나누는 것이 좋다. + +- 식별자: `keyword` +- 수치: `double` or `integer` +- 시간: `date` +- 원인 목록: `nested` 권장 + +`mainCauses`가 단순 배열이 아니라 원인별 필터링/정렬의 대상이 된다면 `nested`로 설계하는 편이 안전하다. + +## 7. 조회 로직 변경 방식 + +## 7.1 병목 조회 + +현재 로직은 DB에서 최신 스냅샷을 읽고 페이지를 자른다. +ES 전환 후에는 다음과 같이 바꾼다. + +### 추천 방식 + +- 최신 스냅샷을 ES에서 찾는다. +- `detectedAt`이 가장 최신인 문서 집합만 조회한다. +- `rankNo asc`로 페이지를 자른다. + +### 구현 포인트 + +- `cursor`가 페이지 번호이므로 우선 `from + size` 방식으로 시작할 수 있다. +- 데이터량이 많아지면 `search_after`로 바꾸는 것이 좋다. +- 응답의 `mostBottleneckProcess`와 `mostBottleneckRiskLevel`은 첫 문서 또는 별도 summary 문서에서 가져온다. + +### 서비스 변경 방향 + +- `BottleneckAnalysisService.get_realtime_bottlenecks()`가 ES repository를 호출하도록 변경 +- Redis 캐시는 유지 가능 +- DB fallback은 장애 대응용으로 둔다 + +## 7.2 불량전이 predictions + +현재는 결과 테이블의 전체 rows를 읽고 차량별 최신 결과를 뽑는다. +ES에서는 다음 둘 중 하나를 추천한다. + +### 옵션 A: 최신 결과만 저장 + +- 차량 또는 이벤트별 최신 결과 1건만 ES에 저장 +- `collapse` 없이 바로 정렬 가능 + +장점: + +- 조회가 단순하다 +- 응답 속도가 좋다 + +단점: + +- 이력 조회가 어려워진다 + +### 옵션 B: 모든 결과 저장 후 최신 문서 선별 [선택] + +- `carMasterId`로 collapse +- `predictedAt desc`로 최신값 선택 + +장점: + +- 이력 보존이 쉽다 + +단점: + +- 쿼리가 다소 복잡하다 + +실무적으로는 predictions는 옵션 A, 이력/감사 목적은 MySQL 원장 유지가 가장 무난하다. + +## 7.3 불량전이 causes + +현재는 특정 vehicleId의 최신 이벤트를 기준으로 cause list를 만든다. +ES 전환 후에는 다음과 같이 설계한다. + +- `vehicleId` 또는 `carMasterId`로 필터 +- `predictedAt desc`로 최신 이벤트 선택 +- `mainCauses`는 nested query 또는 source filtering으로 조회 + +`get_cached_cause_analysis()`는 ES 문서를 읽어 DTO로 변환하는 역할만 하도록 단순화한다. + +## 8. 동기화 전략 + +ES 전환의 핵심은 “어떻게 최신성을 보장할 것인가”다. + +### 8.1 권장 순서 + +1. MySQL에 결과 저장 +2. 저장 완료 후 outbox 또는 Kafka 이벤트 발행 +3. ES indexer가 이벤트 소비 +4. ES에 upsert + +### 8.2 동기화 방식 선택 + +#### 방식 1. 애플리케이션 dual write + +- 저장 서비스에서 MySQL 저장 후 ES도 직접 저장 + +장점: + +- 구현이 빠르다 + +단점: + +- 부분 실패와 재시도 처리 복잡 +- 정합성 이슈 가능 + +#### 방식 2. Kafka/outbox 기반 비동기 동기화 [선택] + +- 저장과 발행을 분리 +- ES indexer가 별도 소비자 역할 수행 + +장점: + +- 운영 안정성이 높다 +- 재처리와 재색인이 쉽다 + +단점: + +- 구성 요소가 하나 더 필요하다 + +권장: + +- 장기적으로는 방식 2 +- 단기 POC는 방식 1도 가능 + +## 9. 마이그레이션 단계 + +### 1단계. ES 설정 추가 + +- ES/OpenSearch URL +- 인증 정보 +- 인덱스 이름 +- timeouts / retry / bulk size + +### 2단계. Read repository 추가 + +- `BottleneckSearchRepository` +- `DefectTransferSearchRepository` + +### 3단계. Indexer 추가 + +- 병목 결과 upsert +- 불량전이 결과 upsert +- bulk indexing 지원 + +### 4단계. 백필 작업 추가 + +- 기존 MySQL 결과를 ES에 한 번 채운다 +- 문서 ID 기준으로 재실행 가능해야 한다 + +### 5단계. API read path 전환 + +- Redis -> ES -> DB fallback +- 또는 Redis -> ES만 먼저 적용 + +### 6단계. 정합성 검증 + +- DB와 ES 결과 수 비교 +- 상위 N개 순위 비교 +- 차량별 최신 예측 비교 + +### 7단계. 캐시 버전 업 + +- ES 전환 시 캐시 키 버전을 올려 구 응답과 섞이지 않게 한다 + +## 10. 코드 변경 포인트 + +### 10.1 설정 + +`app/core/config.py`에 ES 관련 설정을 추가한다. + +예시: + +- `ELASTICSEARCH_URL` +- `ELASTICSEARCH_USERNAME` +- `ELASTICSEARCH_PASSWORD` +- `ELASTICSEARCH_BOTTLENECK_INDEX` +- `ELASTICSEARCH_DEFECT_TRANSFER_INDEX` + +### 10.2 서비스 + +다음 서비스가 핵심 변경 지점이다. + +- [`app/service/analysis/bottleneck_service.py`](../app/service/analysis/bottleneck_service.py) +- [`app/service/analysis/defect_transfer_service.py`](../app/service/analysis/defect_transfer_service.py) + +현재는 repository를 통해 DB를 읽는데, 이후에는 search repository를 주입받도록 바꾼다. + +### 10.3 저장 로직 + +다음 저장 지점에서 ES 이벤트를 함께 발행하거나 outbox를 남긴다. + +- 병목 분석 저장 +- 불량전이 예측 저장 + +### 10.4 캐시 무효화 + +현재 Redis 캐시 무효화는 raw event 수신 시점에 수행된다. +ES 전환 후에는 다음 중 하나를 선택한다. + +- 캐시 유지 + ES 반영 시점에 키 무효화 +- 캐시 축소 + 짧은 TTL만 유지 + +## 11. 성능 가이드 + +### 권장 기준 + +- page size는 100 이하 유지 +- bulk size는 500~2000 사이에서 조정 +- index refresh interval은 write 빈도에 맞춘다 +- shard 수는 초기에는 최소화한다 + +### 검색 팁 + +- keyword 필드는 `term` / `terms` +- 날짜 범위는 `range` +- 최신 1건은 `sort + size=1` +- 차량별 최신 결과는 `collapse` 또는 미리 최신 문서만 저장 + +## 12. 장애 및 롤백 전략 + +### 장애 대응 + +- ES 조회 실패 시 DB fallback +- ES indexer 실패 시 재시도 큐에 적재 +- bulk 실패는 item 단위 실패 로그를 남긴다 + +### 롤백 + +- read path를 다시 DB로 되돌릴 수 있어야 한다 +- ES를 단순 보조 인프라로 취급한다 +- 인덱스 버전은 `v1`, `v2`처럼 명시한다 + +## 13. 검증 항목 + +전환 후 아래를 반드시 비교한다. + +- 병목 상위 5개 순위가 DB와 동일한가 +- 병목 `mostBottleneckProcess`가 동일한가 +- 불량전이 predictions 결과 건수가 동일한가 +- vehicleId별 cause 페이지가 동일한가 +- 최신성 지연이 허용 범위 이내인가 + +## 14. 추천 구현 순서 + +1. ES 설정과 client 추가 +2. search repository 작성 +3. 기존 DB 결과를 ES로 백필 +4. 병목 조회부터 ES read path로 전환 +5. 불량전이 predictions 전환 +6. 불량전이 causes 전환 +7. 캐시와 fallback 정리 +8. DB-only 조회 코드 정리 + +## 15. 결론 + +가장 중요한 원칙은 두 가지다. + +1. 저장의 기준은 MySQL로 유지한다. +2. 조회의 기준은 Elasticsearch로 옮긴다. + +이렇게 하면 정합성은 유지하면서도, 병목/불량전이 같은 조회성 API를 훨씬 유연하게 확장할 수 있다. diff --git a/main.py b/main.py deleted file mode 100644 index 87906df..0000000 --- a/main.py +++ /dev/null @@ -1,2 +0,0 @@ -from app.main import app - diff --git a/requirements.txt b/requirements.txt index e7ae5bc..ea6fd7b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -8,13 +8,24 @@ python-dotenv>=1.0.1,<2.0.0 sqlalchemy>=2.0.36,<3.0.0 pymysql>=1.1.1,<2.0.0 -# LLM & External API +# LLM & LangChain httpx>=0.28.0 openai>=1.59.0,<2.0.0 +langchain>=0.3.0 +langchain-core>=0.3.0 +langchain-openai>=0.2.0 +langchain-community>=0.3.0 +tiktoken>=0.8.0 + +# Vector Store (RAG) +opensearch-py>=2.7.0 +faiss-cpu>=1.9.0 # Kafka aiokafka>=0.12.0 confluent-kafka>=2.6.0 +aws-msk-iam-sasl-signer-python>=1.0.2 +kafka-python==2.2.15 # Redis Cache redis>=5.2.0,<6.0.0 @@ -23,14 +34,18 @@ redis>=5.2.0,<6.0.0 pandas>=2.2.0 numpy>=1.26.0 scipy>=1.13.0 +python-jose>=3.5.0 # Machine Learning joblib>=1.4.0 scikit-learn>=1.5.0 lightgbm>=4.5.0 xgboost>=2.1.0 +catboost>=1.2.7 +pyreadr>=0.5.2 +torch>=2.3.0 shap>=0.46.0 # Common orjson>=3.10.0 -loguru>=0.7.0,<0.8.0 +loguru>=0.7.0,<0.8.0 \ No newline at end of file