Ajouter des dépendances

allinone.py

@@ -1,882 +0,0 @@
-<<<<<<< HEAD
-import pandas as pd
-import numpy as np
-from xgboost import XGBClassifier
-from lightgbm import LGBMClassifier
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.linear_model import LogisticRegression
-from sklearn.svm import SVC
-from sklearn.preprocessing import StandardScaler, LabelEncoder
-from sklearn.model_selection import StratifiedKFold
-from sklearn.metrics import classification_report, recall_score, f1_score
-from sklearn.impute import SimpleImputer
-from imblearn.over_sampling import SMOTE
-from imblearn.under_sampling import RandomUnderSampler
-from imblearn.pipeline import Pipeline
-import joblib
-from flask import Flask, request, jsonify
-from flask_cors import CORS
-import os
-import warnings
-import time
-from tqdm import tqdm
-import threading
-import logging
-from tenacity import retry, wait_fixed, stop_after_attempt
-
-warnings.filterwarnings('ignore', category=UserWarning)
-os.environ["LOKY_MAX_CPU_COUNT"] = "1"
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-app = Flask(__name__)
-CORS(app)
-
-NEW_DATA_FILE = 'new_data.csv'
-DATASET_PATH = "my_datasheet_80000.csv"
-MIN_NEW_SAMPLES_FOR_RETRAIN = 100
-
-# Feature sets for each task
-PRIORITY_FEATURES = [
-    'SpO2', 'Frquce_Rprtr(rpm)', 'Pouls', 'PA', 'Temperature', 'SpO2_Severity', 'Tachypnea', 'Bradypnea',
-    'Tachycardia', 'Bradycardia', 'Critical_Signs', 'SpO2_Temp_Ratio', 'Pouls_PA_Ratio', 'Temp_Pouls_Ratio',
-    'SpO2_PA_Diff', 'SpO2_Temp_Diff', 'PA_Pouls_Diff', 'SpO2_Log', 'Temp_Squared', 'Suggested_Priority'
-]
-
-SERVICE_FEATURES = [
-    'Age', 'Sexe', 'Enceinte', 'SpO2', 'Frquce_Rprtr(rpm)', 'Pouls', 'ECG', 'PA', 'Temperature', 'IMC',
-    'Age_Category', 'Temp_Anomaly', 'PA_High', 'PA_Low', 'Pouls_SpO2_Ratio', 'PA_Temp_Ratio', 'IMC_Temp_Ratio'
-]
-
-priority_model = None
-service_model = None
-priority_scaler = None
-service_scaler = None
-priority_imputer = None
-service_imputer = None
-label_encoder_service = LabelEncoder()
-
-model_lock = threading.Lock()
-
-def enhanced_features(df):
-    df['Tachypnea'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Frquce_Rprtr(rpm)'] > 40) or 
-                                         (row['Age'] < 12 and row['Frquce_Rprtr(rpm)'] > 30) or 
-                                         (row['Age'] >= 12 and row['Frquce_Rprtr(rpm)'] > 20) else 0, axis=1)
-    df['Bradypnea'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Frquce_Rprtr(rpm)'] < 20) or 
-                                         (row['Age'] < 12 and row['Frquce_Rprtr(rpm)'] < 12) or 
-                                         (row['Age'] >= 12 and row['Frquce_Rprtr(rpm)'] < 8) else 0, axis=1)
-    df['Tachycardia'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Pouls'] > 160) or 
-                                           (row['Age'] < 12 and row['Pouls'] > 120) or 
-                                           (row['Age'] >= 12 and row['Pouls'] > 100) else 0, axis=1)
-    df['Bradycardia'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Pouls'] < 90) or 
-                                           (row['Age'] < 12 and row['Pouls'] < 70) or 
-                                           (row['Age'] >= 12 and row['Pouls'] < 50) else 0, axis=1)
-    df['SpO2_Temp_Ratio'] = df['SpO2'] / (df['Temperature'] + 1e-6)
-    df['Pouls_PA_Ratio'] = df['Pouls'] / (df['PA'] + 1e-6)
-    df['Temp_Pouls_Ratio'] = df['Temperature'] / (df['Pouls'] + 1e-6)
-    df['SpO2_PA_Diff'] = df['SpO2'] - df['PA'] / 10
-    df['SpO2_Temp_Diff'] = df['SpO2'] - df['Temperature']
-    df['PA_Pouls_Diff'] = df['PA'] - df['Pouls']
-    df['IMC_Temp_Ratio'] = df['IMC'] / (df['Temperature'] + 1e-6)
-    df['SpO2_Log'] = np.log1p(df['SpO2'])
-    df['Temp_Squared'] = df['Temperature'] ** 2
-    df['Pouls_SpO2_Ratio'] = df['Pouls'] / (df['SpO2'] + 1e-6)
-    df['PA_Temp_Ratio'] = df['PA'] / (df['Temperature'] + 1e-6)
-    df['Age_Category'] = pd.cut(df['Age'], bins=[0, 1, 12, 45, 65, 120], labels=[0, 1, 2, 3, 4])
-    df['Temp_Anomaly'] = df['Temperature'].apply(lambda x: 1 if x < 35 or x > 38 else 0)
-    df['PA_High'] = df['PA'].apply(lambda x: 1 if x > 160 else 0)
-    df['PA_Low'] = df['PA'].apply(lambda x: 1 if x < 90 else 0)
-    df['SpO2_Severity'] = pd.cut(df['SpO2'], bins=[0, 85, 90, 92, 100], labels=[3, 2, 1, 0])
-    df['Critical_Signs'] = ((df['SpO2'] < 85) | (df['Pouls'] > 150) | (df['Temperature'] > 40) | 
-                            (df['PA'] > 200) | (df['PA'] < 70)).astype(int)
-    return df
-
-def compute_service_and_priority(row):
-    age = row['Age']
-    spO2 = row['SpO2']
-    frq_resp = row['Frquce_Rprtr(rpm)']
-    pouls = row['Pouls']
-    ecg = row['ECG']
-    pa = row['PA']
-    temp = row['Temperature']
-    enceinte = row['Enceinte']
-    imc = row['IMC']
-
-    if age <= 18:
-        service = 'Pédiatriques'
-    elif enceinte:
-        service = 'Gynécologie/Obstétrique'
-    elif ecg == 1 or (pouls < 50 or pouls > 110) or (frq_resp > 20):
-        service = 'Neurologie'
-    elif spO2 < 92 or frq_resp > 18 or pouls > 100 or pa < 90 or pa > 160:
-        service = 'Cardiorespiratoire'
-    elif (imc > 30 and (temp > 38 and temp <= 40) and 70 <= pouls <= 90) or \
-         (70 <= pouls <= 90 and 110 <= pa <= 130 and spO2 >= 97 and temp <= 37.5):
-        service = 'Médecine générale'
-    elif temp > 40:
-        service = 'Radiothérapie'
-    else:
-        service = 'Chirurgie'
-
-    if spO2 < 85 or temp > 40 or pouls > 150 or pa < 70 or pa > 200:
-        priorite = 1
-    elif spO2 < 88 or temp > 39.5 or pouls > 130 or pa < 80 or pa > 180 or frq_resp > 25:
-        priorite = 2
-    elif spO2 < 90 or temp > 38.5 or pouls > 110 or pa < 90 or pa > 160 or frq_resp > 20:
-        priorite = 3
-    elif spO2 < 92 or temp > 38 or pouls > 100 or pa < 100 or pa > 140 or frq_resp > 18:
-        priorite = 4
-    else:
-        priorite = 5
-
-    return service, priorite
-
-def get_smote_strategy(y, max_samples=1000):
-    class_counts = pd.Series(y).value_counts()
-    strategy = {}
-    for cls, count in class_counts.items():
-        target = min(max_samples, max(count * 2, 100))  # Ensure reasonable class sizes
-    return strategy
-
-def train_priority_model():
-    global priority_model, priority_scaler, priority_imputer
-    try:
-        data = pd.read_csv(DATASET_PATH)
-        data['Sexe'] = data['Sexe'].map({'Masculin': 0, 'Feminin': 1})
-        data['Enceinte'] = data['Enceinte'].astype(int)
-        data['ECG'] = data['ECG'].map({'Normal': 0, 'Anormal': 1})
-        data = enhanced_features(data)
-        data[['Suggested_Service', 'Suggested_Priority']] = data.apply(compute_service_and_priority, axis=1, result_type='expand')
-        data['Suggested_Priority'] = data['Suggested_Priority'].astype(int)
-
-        X = data[PRIORITY_FEATURES]
-        y = data['Priorite'].values - 1  # Shift to 0-based indexing
-
-        priority_imputer = SimpleImputer(strategy='median')
-        X_imputed = priority_imputer.fit_transform(X)
-        priority_scaler = StandardScaler()
-        X_scaled = priority_scaler.fit_transform(X_imputed)
-
-        models = {
-            'XGBoost': XGBClassifier(n_estimators=100, max_depth=4, learning_rate=0.05, n_jobs=-1, random_state=42),
-            'LightGBM': LGBMClassifier(n_estimators=100, max_depth=2, learning_rate=0.05, min_child_samples=5, 
-                                      reg_alpha=0.5, reg_lambda=0.5, n_jobs=-1, random_state=42, verbose=-1),
-            'RandomForest': RandomForestClassifier(n_estimators=100, max_depth=8, n_jobs=-1, random_state=42),
-            'LogisticRegression': LogisticRegression(max_iter=1000, multi_class='multinomial', random_state=42),
-            'SVM': SVC(probability=True, random_state=42)
-        }
-
-        skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
-        results = {}
-
-        for name, model in models.items():
-            logger.info(f"\nEvaluating {name} for Priority...")
-            scores = {'f1': [], 'recall_p1': [], 'time': []}
-            for train_idx, test_idx in tqdm(skf.split(X_scaled, y), total=5):
-                X_train, X_test = X_scaled[train_idx], X_scaled[test_idx]
-                y_train, y_test = y[train_idx], y[test_idx]
-                
-                min_class_size = pd.Series(y_train).value_counts().min()
-                k_neighbors = min(5, max(1, min_class_size - 1))
-                pipeline = Pipeline([
-                    ('under', RandomUnderSampler(sampling_strategy='majority', random_state=42)),
-                    ('over', SMOTE(sampling_strategy=get_smote_strategy(y_train), random_state=42, k_neighbors=k_neighbors))
-                ])
-                X_train_res, y_train_res = pipeline.fit_resample(X_train, y_train)
-                class_sizes = pd.Series(y_train_res).value_counts().to_dict()
-                logger.info(f"{name} - Resampled class sizes: {class_sizes}")
-                
-                start_time = time.time()
-                model.fit(X_train_res, y_train_res)
-                train_time = time.time() - start_time
-                
-                y_pred = model.predict(X_test)
-                scores['f1'].append(f1_score(y_test, y_pred, average='macro'))
-                scores['recall_p1'].append(recall_score(y_test, y_pred, labels=[0], average=None, zero_division=0)[0])
-                scores['time'].append(train_time)
-                logger.info(f"{name} Fold - F1: {scores['f1'][-1]:.3f}, Recall P1: {scores['recall_p1'][-1]:.3f}")
-
-            results[name] = {
-                'f1': np.mean(scores['f1']),
-                'recall_p1': np.mean(scores['recall_p1']),
-                'time': np.mean(scores['time'])
-            }
-            if name == 'LightGBM':
-                feature_importance = pd.Series(model.feature_importances_, index=PRIORITY_FEATURES).sort_values(ascending=False)
-                logger.info(f"LightGBM Priority Feature Importance:\n{feature_importance}")
-
-        logger.info("\nPriority Model Comparison:")
-        for name, res in results.items():
-            logger.info(f"{name}: F1={res['f1']:.3f}, Recall P1={res['recall_p1']:.3f}, Time={res['time']:.2f}s")
-
-        best_model = max(results, key=lambda k: results[k]['f1'] + results[k]['recall_p1'])
-        logger.info(f"Best Priority Model: {best_model}")
-
-        with model_lock:
-            priority_model = models[best_model]
-            priority_model.fit(X_scaled, y)
-
-        timestamp = int(time.time())
-        joblib.dump(priority_model, f'priority_model_{timestamp}.pkl')
-        joblib.dump(priority_scaler, 'priority_scaler.pkl')
-        joblib.dump(priority_imputer, 'priority_imputer.pkl')
-        logger.info("Priority model saved.")
-    except Exception as e:
-        logger.error(f"Error in priority training: {e}")
-        raise
-
-def train_service_model():
-    global service_model, service_scaler, service_imputer, label_encoder_service
-    try:
-        data = pd.read_csv(DATASET_PATH)
-        data['Sexe'] = data['Sexe'].map({'Masculin': 0, 'Feminin': 1})
-        data['Enceinte'] = data['Enceinte'].astype(int)
-        data['ECG'] = data['ECG'].map({'Normal': 0, 'Anormal': 1})
-        data = enhanced_features(data)
-        data[['Suggested_Service', 'Suggested_Priority']] = data.apply(compute_service_and_priority, axis=1, result_type='expand')
-
-        X = data[SERVICE_FEATURES]
-        y = label_encoder_service.fit_transform(data['Service_Suivant'].fillna('Unknown'))
-
-        service_imputer = SimpleImputer(strategy='median')
-        X_imputed = service_imputer.fit_transform(X)
-        service_scaler = StandardScaler()
-        X_scaled = service_scaler.fit_transform(X_imputed)
-
-        models = {
-            'XGBoost': XGBClassifier(n_estimators=100, max_depth=4, learning_rate=0.05, n_jobs=-1, random_state=42),
-            'LightGBM': LGBMClassifier(n_estimators=100, max_depth=2, learning_rate=0.05, min_child_samples=5, 
-                                      reg_alpha=0.5, reg_lambda=0.5, n_jobs=-1, random_state=42, verbose=-1),
-            'RandomForest': RandomForestClassifier(n_estimators=100, max_depth=8, n_jobs=-1, random_state=42),
-            'LogisticRegression': LogisticRegression(max_iter=1000, multi_class='multinomial', random_state=42),
-            'SVM': SVC(probability=True, random_state=42)
-        }
-
-        skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
-        results = {}
-
-        for name, model in models.items():
-            logger.info(f"\nEvaluating {name} for Service...")
-            scores = {'f1': [], 'time': []}
-            for train_idx, test_idx in tqdm(skf.split(X_scaled, y), total=5):
-                X_train, X_test = X_scaled[train_idx], X_scaled[test_idx]
-                y_train, y_test = y[train_idx], y[test_idx]
-                
-                min_class_size = pd.Series(y_train).value_counts().min()
-                k_neighbors = min(5, max(1, min_class_size - 1))
-                pipeline = Pipeline([
-                    ('under', RandomUnderSampler(sampling_strategy='majority', random_state=42)),
-                    ('over', SMOTE(sampling_strategy=get_smote_strategy(y_train), random_state=42, k_neighbors=k_neighbors))
-                ])
-                X_train_res, y_train_res = pipeline.fit_resample(X_train, y_train)
-                class_sizes = pd.Series(y_train_res).value_counts().to_dict()
-                logger.info(f"{name} - Resampled class sizes: {class_sizes}")
-                
-                start_time = time.time()
-                model.fit(X_train_res, y_train_res)
-                train_time = time.time() - start_time
-                
-                y_pred = model.predict(X_test)
-                scores['f1'].append(f1_score(y_test, y_pred, average='macro'))
-                scores['time'].append(train_time)
-
-            results[name] = {
-                'f1': np.mean(scores['f1']),
-                'time': np.mean(scores['time'])
-            }
-            if name == 'LightGBM':
-                feature_importance = pd.Series(model.feature_importances_, index=SERVICE_FEATURES).sort_values(ascending=False)
-                logger.info(f"LightGBM Service Feature Importance:\n{feature_importance}")
-
-        logger.info("\nService Model Comparison:")
-        for name, res in results.items():
-            logger.info(f"{name}: F1={res['f1']:.3f}, Time={res['time']:.2f}s")
-
-        best_model = max(results, key=lambda k: results[k]['f1'])
-        logger.info(f"Best Service Model: {best_model}")
-
-        with model_lock:
-            service_model = models[best_model]
-            service_model.fit(X_scaled, y)
-
-        timestamp = int(time.time())
-        joblib.dump(service_model, f'service_model_{timestamp}.pkl')
-        joblib.dump(service_scaler, 'service_scaler.pkl')
-        joblib.dump(service_imputer, 'service_imputer.pkl')
-        joblib.dump(label_encoder_service, 'label_encoder_service.pkl')
-        logger.info("Service model saved.")
-    except Exception as e:
-        logger.error(f"Error in service training: {e}")
-        raise
-
-@retry(wait=wait_fixed(2), stop=stop_after_attempt(3))
-def retrain_models():
-    global priority_model, service_model, priority_scaler, service_scaler, priority_imputer, service_imputer, label_encoder_service
-    while True:
-        time.sleep(3600)
-        if os.path.exists(NEW_DATA_FILE) and os.path.getsize(NEW_DATA_FILE) > 0:
-            try:
-                new_data = pd.read_csv(NEW_DATA_FILE)
-                if len(new_data) >= MIN_NEW_SAMPLES_FOR_RETRAIN:
-                    orig_data = pd.read_csv(DATASET_PATH)
-                    orig_data['Sexe'] = orig_data['Sexe'].map({'Masculin': 0, 'Feminin': 1})
-                    orig_data['Enceinte'] = orig_data['Enceinte'].astype(int)
-                    orig_data['ECG'] = orig_data['ECG'].map({'Normal': 0, 'Anormal': 1})
-                    new_data = enhanced_features(new_data)
-                    combined_data = pd.concat([orig_data, new_data], ignore_index=True)
-
-                    # Priority retraining
-                    X_priority = combined_data[PRIORITY_FEATURES]
-                    y_priority = combined_data['Priorite'].values - 1
-                    X_priority_imputed = priority_imputer.transform(X_priority)
-                    X_priority_scaled = priority_scaler.transform(X_priority_imputed)
-                    with model_lock:
-                        priority_model.fit(X_priority_scaled, y_priority)
-
-                    # Service retraining
-                    X_service = combined_data[SERVICE_FEATURES]
-                    y_service = label_encoder_service.transform(combined_data['Service_Suivant'].fillna('Unknown'))
-                    X_service_imputed = service_imputer.transform(X_service)
-                    X_service_scaled = service_scaler.transform(X_service_imputed)
-                    with model_lock:
-                        service_model.fit(X_service_scaled, y_service)
-
-                    timestamp = int(time.time())
-                    joblib.dump(priority_model, f'priority_model_{timestamp}.pkl')
-                    joblib.dump(service_model, f'service_model_{timestamp}.pkl')
-                    new_data.to_csv(f'archive_new_data_{timestamp}.csv', index=False)
-                    open(NEW_DATA_FILE, 'w').close()
-                    logger.info("Models retrained and saved.")
-            except Exception as e:
-                logger.error(f"Error in retrain: {e}")
-
-@app.route('/predict', methods=['POST'])
-def predict():
-    global priority_model, service_model, priority_scaler, service_scaler, priority_imputer, service_imputer, label_encoder_service
-    try:
-        data = request.get_json()
-        required_fields = ['age', 'sexe', 'enceinte', 'spo2', 'freq_resp', 'pouls', 'ecg', 'pa', 'temperature', 'imc']
-        missing_fields = [field for field in required_fields if field not in data]
-        if missing_fields:
-            return jsonify({'error': f'Missing fields: {", ".join(missing_fields)}'}), 400
-
-        input_data = {
-            'Age': float(data['age']),
-            'Sexe': 0 if data['sexe'].lower() == 'masculin' else 1,
-            'Enceinte': 1 if bool(data['enceinte']) else 0,
-            'SpO2': float(data['spo2']),
-            'Frquce_Rprtr(rpm)': float(data['freq_resp']),
-            'Pouls': float(data['pouls']),
-            'ECG': 0 if data['ecg'].lower() == 'normal' else 1,
-            'PA': float(data['pa']),
-            'Temperature': float(data['temperature']),
-            'IMC': float(data['imc']),
-        }
-
-        input_df = pd.DataFrame([input_data])
-        input_df = enhanced_features(input_df)
-        suggested_service, suggested_priority = compute_service_and_priority(input_df.iloc[0])
-        input_df['Suggested_Priority'] = suggested_priority
-
-        with model_lock:
-            # Priority prediction
-            priority_input = input_df[PRIORITY_FEATURES]
-            priority_imputed = priority_imputer.transform(priority_input)
-            priority_scaled = priority_scaler.transform(priority_imputed)
-            priority_probs = priority_model.predict_proba(priority_scaled)[0]
-            priority_pred = np.argmax(priority_probs) + 1
-            priority_conf = float(max(priority_probs))
-
-            # Service prediction
-            service_input = input_df[SERVICE_FEATURES]
-            service_imputed = service_imputer.transform(service_input)
-            service_scaled = service_scaler.transform(service_imputed)
-            service_probs = service_model.predict_proba(service_scaled)[0]
-            service_pred_idx = np.argmax(service_probs)
-            service_pred = label_encoder_service.inverse_transform([service_pred_idx])[0]
-            service_conf = float(max(service_probs))
-
-            # Fallback to rule-based logic if confidence is low or critical conditions apply
-            if priority_conf < 0.7 or input_df['Critical_Signs'][0] == 1:
-                priority_pred = suggested_priority
-            if service_conf < 0.7 or input_df['Enceinte'][0] == 1:
-                service_pred = suggested_service if input_df['Enceinte'][0] == 0 else 'Gynécologie/Obstétrique'
-
-        input_df['Priorite'] = priority_pred
-        input_df['Service_Suivant'] = service_pred
-        if not os.path.exists(NEW_DATA_FILE):
-            input_df.to_csv(NEW_DATA_FILE, index=False)
-        else:
-            input_df.to_csv(NEW_DATA_FILE, mode='a', header=False, index=False)
-
-        logger.info(f"Predicted: service={service_pred}, priority={priority_pred}, service_conf={service_conf}, priority_conf={priority_conf}")
-        return jsonify({
-            'priority': int(priority_pred),
-            'service_suivant': service_pred,
-            'priority_confidence': priority_conf,
-            'service_confidence': service_conf
-        })
-    except Exception as e:
-        logger.error(f"Prediction error: {str(e)}")
-        return jsonify({'error': str(e)}), 500
-
-if __name__ == '__main__':
-    FORCE_RETRAIN = True
-    if FORCE_RETRAIN or not (os.path.exists('priority_model.pkl') and os.path.exists('service_model.pkl')):
-        train_priority_model()
-        train_service_model()
-    else:
-        with model_lock:
-            priority_model = joblib.load('priority_model.pkl')
-            service_model = joblib.load('service_model.pkl')
-            priority_scaler = joblib.load('priority_scaler.pkl')
-            service_scaler = joblib.load('service_scaler.pkl')
-            priority_imputer = joblib.load('priority_imputer.pkl')
-            service_imputer = joblib.load('service_imputer.pkl')
-            label_encoder_service = joblib.load('label_encoder_service.pkl')
-
-    retrain_thread = threading.Thread(target=retrain_models, daemon=True)
-    retrain_thread.start()
-=======
-import pandas as pd
-import numpy as np
-from xgboost import XGBClassifier
-from lightgbm import LGBMClassifier
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.linear_model import LogisticRegression
-from sklearn.svm import SVC
-from sklearn.preprocessing import StandardScaler, LabelEncoder
-from sklearn.model_selection import StratifiedKFold
-from sklearn.metrics import classification_report, recall_score, f1_score
-from sklearn.impute import SimpleImputer
-from imblearn.over_sampling import SMOTE
-from imblearn.under_sampling import RandomUnderSampler
-from imblearn.pipeline import Pipeline
-import joblib
-from flask import Flask, request, jsonify
-from flask_cors import CORS
-import os
-import warnings
-import time
-from tqdm import tqdm
-import threading
-import logging
-from tenacity import retry, wait_fixed, stop_after_attempt
-
-warnings.filterwarnings('ignore', category=UserWarning)
-os.environ["LOKY_MAX_CPU_COUNT"] = "1"
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-app = Flask(__name__)
-CORS(app)
-
-NEW_DATA_FILE = 'new_data.csv'
-DATASET_PATH = "my_datasheet_80000.csv"
-MIN_NEW_SAMPLES_FOR_RETRAIN = 100
-
-# Feature sets for each task
-PRIORITY_FEATURES = [
-    'SpO2', 'Frquce_Rprtr(rpm)', 'Pouls', 'PA', 'Temperature', 'SpO2_Severity', 'Tachypnea', 'Bradypnea',
-    'Tachycardia', 'Bradycardia', 'Critical_Signs', 'SpO2_Temp_Ratio', 'Pouls_PA_Ratio', 'Temp_Pouls_Ratio',
-    'SpO2_PA_Diff', 'SpO2_Temp_Diff', 'PA_Pouls_Diff', 'SpO2_Log', 'Temp_Squared', 'Suggested_Priority'
-]
-
-SERVICE_FEATURES = [
-    'Age', 'Sexe', 'Enceinte', 'SpO2', 'Frquce_Rprtr(rpm)', 'Pouls', 'ECG', 'PA', 'Temperature', 'IMC',
-    'Age_Category', 'Temp_Anomaly', 'PA_High', 'PA_Low', 'Pouls_SpO2_Ratio', 'PA_Temp_Ratio', 'IMC_Temp_Ratio'
-]
-
-priority_model = None
-service_model = None
-priority_scaler = None
-service_scaler = None
-priority_imputer = None
-service_imputer = None
-label_encoder_service = LabelEncoder()
-
-model_lock = threading.Lock()
-
-def enhanced_features(df):
-    df['Tachypnea'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Frquce_Rprtr(rpm)'] > 40) or 
-                                         (row['Age'] < 12 and row['Frquce_Rprtr(rpm)'] > 30) or 
-                                         (row['Age'] >= 12 and row['Frquce_Rprtr(rpm)'] > 20) else 0, axis=1)
-    df['Bradypnea'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Frquce_Rprtr(rpm)'] < 20) or 
-                                         (row['Age'] < 12 and row['Frquce_Rprtr(rpm)'] < 12) or 
-                                         (row['Age'] >= 12 and row['Frquce_Rprtr(rpm)'] < 8) else 0, axis=1)
-    df['Tachycardia'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Pouls'] > 160) or 
-                                           (row['Age'] < 12 and row['Pouls'] > 120) or 
-                                           (row['Age'] >= 12 and row['Pouls'] > 100) else 0, axis=1)
-    df['Bradycardia'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Pouls'] < 90) or 
-                                           (row['Age'] < 12 and row['Pouls'] < 70) or 
-                                           (row['Age'] >= 12 and row['Pouls'] < 50) else 0, axis=1)
-    df['SpO2_Temp_Ratio'] = df['SpO2'] / (df['Temperature'] + 1e-6)
-    df['Pouls_PA_Ratio'] = df['Pouls'] / (df['PA'] + 1e-6)
-    df['Temp_Pouls_Ratio'] = df['Temperature'] / (df['Pouls'] + 1e-6)
-    df['SpO2_PA_Diff'] = df['SpO2'] - df['PA'] / 10
-    df['SpO2_Temp_Diff'] = df['SpO2'] - df['Temperature']
-    df['PA_Pouls_Diff'] = df['PA'] - df['Pouls']
-    df['IMC_Temp_Ratio'] = df['IMC'] / (df['Temperature'] + 1e-6)
-    df['SpO2_Log'] = np.log1p(df['SpO2'])
-    df['Temp_Squared'] = df['Temperature'] ** 2
-    df['Pouls_SpO2_Ratio'] = df['Pouls'] / (df['SpO2'] + 1e-6)
-    df['PA_Temp_Ratio'] = df['PA'] / (df['Temperature'] + 1e-6)
-    df['Age_Category'] = pd.cut(df['Age'], bins=[0, 1, 12, 45, 65, 120], labels=[0, 1, 2, 3, 4])
-    df['Temp_Anomaly'] = df['Temperature'].apply(lambda x: 1 if x < 35 or x > 38 else 0)
-    df['PA_High'] = df['PA'].apply(lambda x: 1 if x > 160 else 0)
-    df['PA_Low'] = df['PA'].apply(lambda x: 1 if x < 90 else 0)
-    df['SpO2_Severity'] = pd.cut(df['SpO2'], bins=[0, 85, 90, 92, 100], labels=[3, 2, 1, 0])
-    df['Critical_Signs'] = ((df['SpO2'] < 85) | (df['Pouls'] > 150) | (df['Temperature'] > 40) | 
-                            (df['PA'] > 200) | (df['PA'] < 70)).astype(int)
-    return df
-
-def compute_service_and_priority(row):
-    age = row['Age']
-    spO2 = row['SpO2']
-    frq_resp = row['Frquce_Rprtr(rpm)']
-    pouls = row['Pouls']
-    ecg = row['ECG']
-    pa = row['PA']
-    temp = row['Temperature']
-    enceinte = row['Enceinte']
-    imc = row['IMC']
-
-    if age <= 18:
-        service = 'Pédiatriques'
-    elif enceinte:
-        service = 'Gynécologie/Obstétrique'
-    elif ecg == 1 or (pouls < 50 or pouls > 110) or (frq_resp > 20):
-        service = 'Neurologie'
-    elif spO2 < 92 or frq_resp > 18 or pouls > 100 or pa < 90 or pa > 160:
-        service = 'Cardiorespiratoire'
-    elif (imc > 30 and (temp > 38 and temp <= 40) and 70 <= pouls <= 90) or \
-         (70 <= pouls <= 90 and 110 <= pa <= 130 and spO2 >= 97 and temp <= 37.5):
-        service = 'Médecine générale'
-    elif temp > 40:
-        service = 'Radiothérapie'
-    else:
-        service = 'Chirurgie'
-
-    if spO2 < 85 or temp > 40 or pouls > 150 or pa < 70 or pa > 200:
-        priorite = 1
-    elif spO2 < 88 or temp > 39.5 or pouls > 130 or pa < 80 or pa > 180 or frq_resp > 25:
-        priorite = 2
-    elif spO2 < 90 or temp > 38.5 or pouls > 110 or pa < 90 or pa > 160 or frq_resp > 20:
-        priorite = 3
-    elif spO2 < 92 or temp > 38 or pouls > 100 or pa < 100 or pa > 140 or frq_resp > 18:
-        priorite = 4
-    else:
-        priorite = 5
-
-    return service, priorite
-
-def get_smote_strategy(y, max_samples=1000):
-    class_counts = pd.Series(y).value_counts()
-    strategy = {}
-    for cls, count in class_counts.items():
-        target = min(max_samples, max(count * 2, 100))  # Ensure reasonable class sizes
-    return strategy
-
-def train_priority_model():
-    global priority_model, priority_scaler, priority_imputer
-    try:
-        data = pd.read_csv(DATASET_PATH)
-        data['Sexe'] = data['Sexe'].map({'Masculin': 0, 'Feminin': 1})
-        data['Enceinte'] = data['Enceinte'].astype(int)
-        data['ECG'] = data['ECG'].map({'Normal': 0, 'Anormal': 1})
-        data = enhanced_features(data)
-        data[['Suggested_Service', 'Suggested_Priority']] = data.apply(compute_service_and_priority, axis=1, result_type='expand')
-        data['Suggested_Priority'] = data['Suggested_Priority'].astype(int)
-
-        X = data[PRIORITY_FEATURES]
-        y = data['Priorite'].values - 1  # Shift to 0-based indexing
-
-        priority_imputer = SimpleImputer(strategy='median')
-        X_imputed = priority_imputer.fit_transform(X)
-        priority_scaler = StandardScaler()
-        X_scaled = priority_scaler.fit_transform(X_imputed)
-
-        models = {
-            'XGBoost': XGBClassifier(n_estimators=100, max_depth=4, learning_rate=0.05, n_jobs=-1, random_state=42),
-            'LightGBM': LGBMClassifier(n_estimators=100, max_depth=2, learning_rate=0.05, min_child_samples=5, 
-                                      reg_alpha=0.5, reg_lambda=0.5, n_jobs=-1, random_state=42, verbose=-1),
-            'RandomForest': RandomForestClassifier(n_estimators=100, max_depth=8, n_jobs=-1, random_state=42),
-            'LogisticRegression': LogisticRegression(max_iter=1000, multi_class='multinomial', random_state=42),
-            'SVM': SVC(probability=True, random_state=42)
-        }
-
-        skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
-        results = {}
-
-        for name, model in models.items():
-            logger.info(f"\nEvaluating {name} for Priority...")
-            scores = {'f1': [], 'recall_p1': [], 'time': []}
-            for train_idx, test_idx in tqdm(skf.split(X_scaled, y), total=5):
-                X_train, X_test = X_scaled[train_idx], X_scaled[test_idx]
-                y_train, y_test = y[train_idx], y[test_idx]
-                
-                min_class_size = pd.Series(y_train).value_counts().min()
-                k_neighbors = min(5, max(1, min_class_size - 1))
-                pipeline = Pipeline([
-                    ('under', RandomUnderSampler(sampling_strategy='majority', random_state=42)),
-                    ('over', SMOTE(sampling_strategy=get_smote_strategy(y_train), random_state=42, k_neighbors=k_neighbors))
-                ])
-                X_train_res, y_train_res = pipeline.fit_resample(X_train, y_train)
-                class_sizes = pd.Series(y_train_res).value_counts().to_dict()
-                logger.info(f"{name} - Resampled class sizes: {class_sizes}")
-                
-                start_time = time.time()
-                model.fit(X_train_res, y_train_res)
-                train_time = time.time() - start_time
-                
-                y_pred = model.predict(X_test)
-                scores['f1'].append(f1_score(y_test, y_pred, average='macro'))
-                scores['recall_p1'].append(recall_score(y_test, y_pred, labels=[0], average=None, zero_division=0)[0])
-                scores['time'].append(train_time)
-                logger.info(f"{name} Fold - F1: {scores['f1'][-1]:.3f}, Recall P1: {scores['recall_p1'][-1]:.3f}")
-
-            results[name] = {
-                'f1': np.mean(scores['f1']),
-                'recall_p1': np.mean(scores['recall_p1']),
-                'time': np.mean(scores['time'])
-            }
-            if name == 'LightGBM':
-                feature_importance = pd.Series(model.feature_importances_, index=PRIORITY_FEATURES).sort_values(ascending=False)
-                logger.info(f"LightGBM Priority Feature Importance:\n{feature_importance}")
-
-        logger.info("\nPriority Model Comparison:")
-        for name, res in results.items():
-            logger.info(f"{name}: F1={res['f1']:.3f}, Recall P1={res['recall_p1']:.3f}, Time={res['time']:.2f}s")
-
-        best_model = max(results, key=lambda k: results[k]['f1'] + results[k]['recall_p1'])
-        logger.info(f"Best Priority Model: {best_model}")
-
-        with model_lock:
-            priority_model = models[best_model]
-            priority_model.fit(X_scaled, y)
-
-        timestamp = int(time.time())
-        joblib.dump(priority_model, f'priority_model_{timestamp}.pkl')
-        joblib.dump(priority_scaler, 'priority_scaler.pkl')
-        joblib.dump(priority_imputer, 'priority_imputer.pkl')
-        logger.info("Priority model saved.")
-    except Exception as e:
-        logger.error(f"Error in priority training: {e}")
-        raise
-
-def train_service_model():
-    global service_model, service_scaler, service_imputer, label_encoder_service
-    try:
-        data = pd.read_csv(DATASET_PATH)
-        data['Sexe'] = data['Sexe'].map({'Masculin': 0, 'Feminin': 1})
-        data['Enceinte'] = data['Enceinte'].astype(int)
-        data['ECG'] = data['ECG'].map({'Normal': 0, 'Anormal': 1})
-        data = enhanced_features(data)
-        data[['Suggested_Service', 'Suggested_Priority']] = data.apply(compute_service_and_priority, axis=1, result_type='expand')
-
-        X = data[SERVICE_FEATURES]
-        y = label_encoder_service.fit_transform(data['Service_Suivant'].fillna('Unknown'))
-
-        service_imputer = SimpleImputer(strategy='median')
-        X_imputed = service_imputer.fit_transform(X)
-        service_scaler = StandardScaler()
-        X_scaled = service_scaler.fit_transform(X_imputed)
-
-        models = {
-            'XGBoost': XGBClassifier(n_estimators=100, max_depth=4, learning_rate=0.05, n_jobs=-1, random_state=42),
-            'LightGBM': LGBMClassifier(n_estimators=100, max_depth=2, learning_rate=0.05, min_child_samples=5, 
-                                      reg_alpha=0.5, reg_lambda=0.5, n_jobs=-1, random_state=42, verbose=-1),
-            'RandomForest': RandomForestClassifier(n_estimators=100, max_depth=8, n_jobs=-1, random_state=42),
-            'LogisticRegression': LogisticRegression(max_iter=1000, multi_class='multinomial', random_state=42),
-            'SVM': SVC(probability=True, random_state=42)
-        }
-
-        skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
-        results = {}
-
-        for name, model in models.items():
-            logger.info(f"\nEvaluating {name} for Service...")
-            scores = {'f1': [], 'time': []}
-            for train_idx, test_idx in tqdm(skf.split(X_scaled, y), total=5):
-                X_train, X_test = X_scaled[train_idx], X_scaled[test_idx]
-                y_train, y_test = y[train_idx], y[test_idx]
-                
-                min_class_size = pd.Series(y_train).value_counts().min()
-                k_neighbors = min(5, max(1, min_class_size - 1))
-                pipeline = Pipeline([
-                    ('under', RandomUnderSampler(sampling_strategy='majority', random_state=42)),
-                    ('over', SMOTE(sampling_strategy=get_smote_strategy(y_train), random_state=42, k_neighbors=k_neighbors))
-                ])
-                X_train_res, y_train_res = pipeline.fit_resample(X_train, y_train)
-                class_sizes = pd.Series(y_train_res).value_counts().to_dict()
-                logger.info(f"{name} - Resampled class sizes: {class_sizes}")
-                
-                start_time = time.time()
-                model.fit(X_train_res, y_train_res)
-                train_time = time.time() - start_time
-                
-                y_pred = model.predict(X_test)
-                scores['f1'].append(f1_score(y_test, y_pred, average='macro'))
-                scores['time'].append(train_time)
-
-            results[name] = {
-                'f1': np.mean(scores['f1']),
-                'time': np.mean(scores['time'])
-            }
-            if name == 'LightGBM':
-                feature_importance = pd.Series(model.feature_importances_, index=SERVICE_FEATURES).sort_values(ascending=False)
-                logger.info(f"LightGBM Service Feature Importance:\n{feature_importance}")
-
-        logger.info("\nService Model Comparison:")
-        for name, res in results.items():
-            logger.info(f"{name}: F1={res['f1']:.3f}, Time={res['time']:.2f}s")
-
-        best_model = max(results, key=lambda k: results[k]['f1'])
-        logger.info(f"Best Service Model: {best_model}")
-
-        with model_lock:
-            service_model = models[best_model]
-            service_model.fit(X_scaled, y)
-
-        timestamp = int(time.time())
-        joblib.dump(service_model, f'service_model_{timestamp}.pkl')
-        joblib.dump(service_scaler, 'service_scaler.pkl')
-        joblib.dump(service_imputer, 'service_imputer.pkl')
-        joblib.dump(label_encoder_service, 'label_encoder_service.pkl')
-        logger.info("Service model saved.")
-    except Exception as e:
-        logger.error(f"Error in service training: {e}")
-        raise
-
-@retry(wait=wait_fixed(2), stop=stop_after_attempt(3))
-def retrain_models():
-    global priority_model, service_model, priority_scaler, service_scaler, priority_imputer, service_imputer, label_encoder_service
-    while True:
-        time.sleep(3600)
-        if os.path.exists(NEW_DATA_FILE) and os.path.getsize(NEW_DATA_FILE) > 0:
-            try:
-                new_data = pd.read_csv(NEW_DATA_FILE)
-                if len(new_data) >= MIN_NEW_SAMPLES_FOR_RETRAIN:
-                    orig_data = pd.read_csv(DATASET_PATH)
-                    orig_data['Sexe'] = orig_data['Sexe'].map({'Masculin': 0, 'Feminin': 1})
-                    orig_data['Enceinte'] = orig_data['Enceinte'].astype(int)
-                    orig_data['ECG'] = orig_data['ECG'].map({'Normal': 0, 'Anormal': 1})
-                    new_data = enhanced_features(new_data)
-                    combined_data = pd.concat([orig_data, new_data], ignore_index=True)
-
-                    # Priority retraining
-                    X_priority = combined_data[PRIORITY_FEATURES]
-                    y_priority = combined_data['Priorite'].values - 1
-                    X_priority_imputed = priority_imputer.transform(X_priority)
-                    X_priority_scaled = priority_scaler.transform(X_priority_imputed)
-                    with model_lock:
-                        priority_model.fit(X_priority_scaled, y_priority)
-
-                    # Service retraining
-                    X_service = combined_data[SERVICE_FEATURES]
-                    y_service = label_encoder_service.transform(combined_data['Service_Suivant'].fillna('Unknown'))
-                    X_service_imputed = service_imputer.transform(X_service)
-                    X_service_scaled = service_scaler.transform(X_service_imputed)
-                    with model_lock:
-                        service_model.fit(X_service_scaled, y_service)
-
-                    timestamp = int(time.time())
-                    joblib.dump(priority_model, f'priority_model_{timestamp}.pkl')
-                    joblib.dump(service_model, f'service_model_{timestamp}.pkl')
-                    new_data.to_csv(f'archive_new_data_{timestamp}.csv', index=False)
-                    open(NEW_DATA_FILE, 'w').close()
-                    logger.info("Models retrained and saved.")
-            except Exception as e:
-                logger.error(f"Error in retrain: {e}")
-
-@app.route('/predict', methods=['POST'])
-def predict():
-    global priority_model, service_model, priority_scaler, service_scaler, priority_imputer, service_imputer, label_encoder_service
-    try:
-        data = request.get_json()
-        required_fields = ['age', 'sexe', 'enceinte', 'spo2', 'freq_resp', 'pouls', 'ecg', 'pa', 'temperature', 'imc']
-        missing_fields = [field for field in required_fields if field not in data]
-        if missing_fields:
-            return jsonify({'error': f'Missing fields: {", ".join(missing_fields)}'}), 400
-
-        input_data = {
-            'Age': float(data['age']),
-            'Sexe': 0 if data['sexe'].lower() == 'masculin' else 1,
-            'Enceinte': 1 if bool(data['enceinte']) else 0,
-            'SpO2': float(data['spo2']),
-            'Frquce_Rprtr(rpm)': float(data['freq_resp']),
-            'Pouls': float(data['pouls']),
-            'ECG': 0 if data['ecg'].lower() == 'normal' else 1,
-            'PA': float(data['pa']),
-            'Temperature': float(data['temperature']),
-            'IMC': float(data['imc']),
-        }
-
-        input_df = pd.DataFrame([input_data])
-        input_df = enhanced_features(input_df)
-        suggested_service, suggested_priority = compute_service_and_priority(input_df.iloc[0])
-        input_df['Suggested_Priority'] = suggested_priority
-
-        with model_lock:
-            # Priority prediction
-            priority_input = input_df[PRIORITY_FEATURES]
-            priority_imputed = priority_imputer.transform(priority_input)
-            priority_scaled = priority_scaler.transform(priority_imputed)
-            priority_probs = priority_model.predict_proba(priority_scaled)[0]
-            priority_pred = np.argmax(priority_probs) + 1
-            priority_conf = float(max(priority_probs))
-
-            # Service prediction
-            service_input = input_df[SERVICE_FEATURES]
-            service_imputed = service_imputer.transform(service_input)
-            service_scaled = service_scaler.transform(service_imputed)
-            service_probs = service_model.predict_proba(service_scaled)[0]
-            service_pred_idx = np.argmax(service_probs)
-            service_pred = label_encoder_service.inverse_transform([service_pred_idx])[0]
-            service_conf = float(max(service_probs))
-
-            # Fallback to rule-based logic if confidence is low or critical conditions apply
-            if priority_conf < 0.7 or input_df['Critical_Signs'][0] == 1:
-                priority_pred = suggested_priority
-            if service_conf < 0.7 or input_df['Enceinte'][0] == 1:
-                service_pred = suggested_service if input_df['Enceinte'][0] == 0 else 'Gynécologie/Obstétrique'
-
-        input_df['Priorite'] = priority_pred
-        input_df['Service_Suivant'] = service_pred
-        if not os.path.exists(NEW_DATA_FILE):
-            input_df.to_csv(NEW_DATA_FILE, index=False)
-        else:
-            input_df.to_csv(NEW_DATA_FILE, mode='a', header=False, index=False)
-
-        logger.info(f"Predicted: service={service_pred}, priority={priority_pred}, service_conf={service_conf}, priority_conf={priority_conf}")
-        return jsonify({
-            'priority': int(priority_pred),
-            'service_suivant': service_pred,
-            'priority_confidence': priority_conf,
-            'service_confidence': service_conf
-        })
-    except Exception as e:
-        logger.error(f"Prediction error: {str(e)}")
-        return jsonify({'error': str(e)}), 500
-
-if __name__ == '__main__':
-    FORCE_RETRAIN = True
-    if FORCE_RETRAIN or not (os.path.exists('priority_model.pkl') and os.path.exists('service_model.pkl')):
-        train_priority_model()
-        train_service_model()
-    else:
-        with model_lock:
-            priority_model = joblib.load('priority_model.pkl')
-            service_model = joblib.load('service_model.pkl')
-            priority_scaler = joblib.load('priority_scaler.pkl')
-            service_scaler = joblib.load('service_scaler.pkl')
-            priority_imputer = joblib.load('priority_imputer.pkl')
-            service_imputer = joblib.load('service_imputer.pkl')
-            label_encoder_service = joblib.load('label_encoder_service.pkl')
-
-    retrain_thread = threading.Thread(target=retrain_models, daemon=True)
-    retrain_thread.start()
->>>>>>> 12fbcdcf1e034f735bed38d79600e83ccc29f849
-    app.run(debug=False, host='0.0.0.0', port=5000)

app.py

@@ -1,162 +1,882 @@
-import faicons as fa
-import plotly.express as px
-
-# Load data and compute static values
-from shared import app_dir, tips
-from shinywidgets import render_plotly
-
-from shiny import reactive, render
-from shiny.express import input, ui
-
-bill_rng = (min(tips.total_bill), max(tips.total_bill))
-
-# Add page title and sidebar
-ui.page_opts(title="Restaurant tipping", fillable=True)
-
-with ui.sidebar(open="desktop"):
-    ui.input_slider(
-        "total_bill",
-        "Bill amount",
-        min=bill_rng[0],
-        max=bill_rng[1],
-        value=bill_rng,
-        pre="$",
-    )
-    ui.input_checkbox_group(
-        "time",
-        "Food service",
-        ["Lunch", "Dinner"],
-        selected=["Lunch", "Dinner"],
-        inline=True,
-    )
-    ui.input_action_button("reset", "Reset filter")
-
-# Add main content
-ICONS = {
-    "user": fa.icon_svg("user", "regular"),
-    "wallet": fa.icon_svg("wallet"),
-    "currency-dollar": fa.icon_svg("dollar-sign"),
-    "ellipsis": fa.icon_svg("ellipsis"),
-}
-
-with ui.layout_columns(fill=False):
-    with ui.value_box(showcase=ICONS["user"]):
-        "Total tippers"
-
-        @render.express
-        def total_tippers():
-            tips_data().shape[0]
-
-    with ui.value_box(showcase=ICONS["wallet"]):
-        "Average tip"
-
-        @render.express
-        def average_tip():
-            d = tips_data()
-            if d.shape[0] > 0:
-                perc = d.tip / d.total_bill
-                f"{perc.mean():.1%}"
-
-    with ui.value_box(showcase=ICONS["currency-dollar"]):
-        "Average bill"
-
-        @render.express
-        def average_bill():
-            d = tips_data()
-            if d.shape[0] > 0:
-                bill = d.total_bill.mean()
-                f"${bill:.2f}"
-
-
-with ui.layout_columns(col_widths=[6, 6, 12]):
-    with ui.card(full_screen=True):
-        ui.card_header("Tips data")
-
-        @render.data_frame
-        def table():
-            return render.DataGrid(tips_data())
-
-    with ui.card(full_screen=True):
-        with ui.card_header(class_="d-flex justify-content-between align-items-center"):
-            "Total bill vs tip"
-            with ui.popover(title="Add a color variable", placement="top"):
-                ICONS["ellipsis"]
-                ui.input_radio_buttons(
-                    "scatter_color",
-                    None,
-                    ["none", "sex", "smoker", "day", "time"],
-                    inline=True,
-                )
-
-        @render_plotly
-        def scatterplot():
-            color = input.scatter_color()
-            return px.scatter(
-                tips_data(),
-                x="total_bill",
-                y="tip",
-                color=None if color == "none" else color,
-                trendline="lowess",
-            )
-
-    with ui.card(full_screen=True):
-        with ui.card_header(class_="d-flex justify-content-between align-items-center"):
-            "Tip percentages"
-            with ui.popover(title="Add a color variable"):
-                ICONS["ellipsis"]
-                ui.input_radio_buttons(
-                    "tip_perc_y",
-                    "Split by:",
-                    ["sex", "smoker", "day", "time"],
-                    selected="day",
-                    inline=True,
-                )
-
-        @render_plotly
-        def tip_perc():
-            from ridgeplot import ridgeplot
-
-            dat = tips_data()
-            dat["percent"] = dat.tip / dat.total_bill
-            yvar = input.tip_perc_y()
-            uvals = dat[yvar].unique()
-
-            samples = [[dat.percent[dat[yvar] == val]] for val in uvals]
-
-            plt = ridgeplot(
-                samples=samples,
-                labels=uvals,
-                bandwidth=0.01,
-                colorscale="viridis",
-                colormode="row-index",
-            )
-
-            plt.update_layout(
-                legend=dict(
-                    orientation="h", yanchor="bottom", y=1.02, xanchor="center", x=0.5
-                )
-            )
-
-            return plt
-
-
-ui.include_css(app_dir / "styles.css")
-
-# --------------------------------------------------------
-# Reactive calculations and effects
-# --------------------------------------------------------
-
-
-@reactive.calc
-def tips_data():
-    bill = input.total_bill()
-    idx1 = tips.total_bill.between(bill[0], bill[1])
-    idx2 = tips.time.isin(input.time())
-    return tips[idx1 & idx2]
-
-
-@reactive.effect
-@reactive.event(input.reset)
-def _():
-    ui.update_slider("total_bill", value=bill_rng)
-    ui.update_checkbox_group("time", selected=["Lunch", "Dinner"])
+<<<<<<< HEAD
+import pandas as pd
+import numpy as np
+from xgboost import XGBClassifier
+from lightgbm import LGBMClassifier
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.model_selection import StratifiedKFold
+from sklearn.metrics import classification_report, recall_score, f1_score
+from sklearn.impute import SimpleImputer
+from imblearn.over_sampling import SMOTE
+from imblearn.under_sampling import RandomUnderSampler
+from imblearn.pipeline import Pipeline
+import joblib
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import os
+import warnings
+import time
+from tqdm import tqdm
+import threading
+import logging
+from tenacity import retry, wait_fixed, stop_after_attempt
+
+warnings.filterwarnings('ignore', category=UserWarning)
+os.environ["LOKY_MAX_CPU_COUNT"] = "1"
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+CORS(app)
+
+NEW_DATA_FILE = 'new_data.csv'
+DATASET_PATH = "my_datasheet_80000.csv"
+MIN_NEW_SAMPLES_FOR_RETRAIN = 100
+
+# Feature sets for each task
+PRIORITY_FEATURES = [
+    'SpO2', 'Frquce_Rprtr(rpm)', 'Pouls', 'PA', 'Temperature', 'SpO2_Severity', 'Tachypnea', 'Bradypnea',
+    'Tachycardia', 'Bradycardia', 'Critical_Signs', 'SpO2_Temp_Ratio', 'Pouls_PA_Ratio', 'Temp_Pouls_Ratio',
+    'SpO2_PA_Diff', 'SpO2_Temp_Diff', 'PA_Pouls_Diff', 'SpO2_Log', 'Temp_Squared', 'Suggested_Priority'
+]
+
+SERVICE_FEATURES = [
+    'Age', 'Sexe', 'Enceinte', 'SpO2', 'Frquce_Rprtr(rpm)', 'Pouls', 'ECG', 'PA', 'Temperature', 'IMC',
+    'Age_Category', 'Temp_Anomaly', 'PA_High', 'PA_Low', 'Pouls_SpO2_Ratio', 'PA_Temp_Ratio', 'IMC_Temp_Ratio'
+]
+
+priority_model = None
+service_model = None
+priority_scaler = None
+service_scaler = None
+priority_imputer = None
+service_imputer = None
+label_encoder_service = LabelEncoder()
+
+model_lock = threading.Lock()
+
+def enhanced_features(df):
+    df['Tachypnea'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Frquce_Rprtr(rpm)'] > 40) or 
+                                         (row['Age'] < 12 and row['Frquce_Rprtr(rpm)'] > 30) or 
+                                         (row['Age'] >= 12 and row['Frquce_Rprtr(rpm)'] > 20) else 0, axis=1)
+    df['Bradypnea'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Frquce_Rprtr(rpm)'] < 20) or 
+                                         (row['Age'] < 12 and row['Frquce_Rprtr(rpm)'] < 12) or 
+                                         (row['Age'] >= 12 and row['Frquce_Rprtr(rpm)'] < 8) else 0, axis=1)
+    df['Tachycardia'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Pouls'] > 160) or 
+                                           (row['Age'] < 12 and row['Pouls'] > 120) or 
+                                           (row['Age'] >= 12 and row['Pouls'] > 100) else 0, axis=1)
+    df['Bradycardia'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Pouls'] < 90) or 
+                                           (row['Age'] < 12 and row['Pouls'] < 70) or 
+                                           (row['Age'] >= 12 and row['Pouls'] < 50) else 0, axis=1)
+    df['SpO2_Temp_Ratio'] = df['SpO2'] / (df['Temperature'] + 1e-6)
+    df['Pouls_PA_Ratio'] = df['Pouls'] / (df['PA'] + 1e-6)
+    df['Temp_Pouls_Ratio'] = df['Temperature'] / (df['Pouls'] + 1e-6)
+    df['SpO2_PA_Diff'] = df['SpO2'] - df['PA'] / 10
+    df['SpO2_Temp_Diff'] = df['SpO2'] - df['Temperature']
+    df['PA_Pouls_Diff'] = df['PA'] - df['Pouls']
+    df['IMC_Temp_Ratio'] = df['IMC'] / (df['Temperature'] + 1e-6)
+    df['SpO2_Log'] = np.log1p(df['SpO2'])
+    df['Temp_Squared'] = df['Temperature'] ** 2
+    df['Pouls_SpO2_Ratio'] = df['Pouls'] / (df['SpO2'] + 1e-6)
+    df['PA_Temp_Ratio'] = df['PA'] / (df['Temperature'] + 1e-6)
+    df['Age_Category'] = pd.cut(df['Age'], bins=[0, 1, 12, 45, 65, 120], labels=[0, 1, 2, 3, 4])
+    df['Temp_Anomaly'] = df['Temperature'].apply(lambda x: 1 if x < 35 or x > 38 else 0)
+    df['PA_High'] = df['PA'].apply(lambda x: 1 if x > 160 else 0)
+    df['PA_Low'] = df['PA'].apply(lambda x: 1 if x < 90 else 0)
+    df['SpO2_Severity'] = pd.cut(df['SpO2'], bins=[0, 85, 90, 92, 100], labels=[3, 2, 1, 0])
+    df['Critical_Signs'] = ((df['SpO2'] < 85) | (df['Pouls'] > 150) | (df['Temperature'] > 40) | 
+                            (df['PA'] > 200) | (df['PA'] < 70)).astype(int)
+    return df
+
+def compute_service_and_priority(row):
+    age = row['Age']
+    spO2 = row['SpO2']
+    frq_resp = row['Frquce_Rprtr(rpm)']
+    pouls = row['Pouls']
+    ecg = row['ECG']
+    pa = row['PA']
+    temp = row['Temperature']
+    enceinte = row['Enceinte']
+    imc = row['IMC']
+
+    if age <= 18:
+        service = 'Pédiatriques'
+    elif enceinte:
+        service = 'Gynécologie/Obstétrique'
+    elif ecg == 1 or (pouls < 50 or pouls > 110) or (frq_resp > 20):
+        service = 'Neurologie'
+    elif spO2 < 92 or frq_resp > 18 or pouls > 100 or pa < 90 or pa > 160:
+        service = 'Cardiorespiratoire'
+    elif (imc > 30 and (temp > 38 and temp <= 40) and 70 <= pouls <= 90) or \
+         (70 <= pouls <= 90 and 110 <= pa <= 130 and spO2 >= 97 and temp <= 37.5):
+        service = 'Médecine générale'
+    elif temp > 40:
+        service = 'Radiothérapie'
+    else:
+        service = 'Chirurgie'
+
+    if spO2 < 85 or temp > 40 or pouls > 150 or pa < 70 or pa > 200:
+        priorite = 1
+    elif spO2 < 88 or temp > 39.5 or pouls > 130 or pa < 80 or pa > 180 or frq_resp > 25:
+        priorite = 2
+    elif spO2 < 90 or temp > 38.5 or pouls > 110 or pa < 90 or pa > 160 or frq_resp > 20:
+        priorite = 3
+    elif spO2 < 92 or temp > 38 or pouls > 100 or pa < 100 or pa > 140 or frq_resp > 18:
+        priorite = 4
+    else:
+        priorite = 5
+
+    return service, priorite
+
+def get_smote_strategy(y, max_samples=1000):
+    class_counts = pd.Series(y).value_counts()
+    strategy = {}
+    for cls, count in class_counts.items():
+        target = min(max_samples, max(count * 2, 100))  # Ensure reasonable class sizes
+    return strategy
+
+def train_priority_model():
+    global priority_model, priority_scaler, priority_imputer
+    try:
+        data = pd.read_csv(DATASET_PATH)
+        data['Sexe'] = data['Sexe'].map({'Masculin': 0, 'Feminin': 1})
+        data['Enceinte'] = data['Enceinte'].astype(int)
+        data['ECG'] = data['ECG'].map({'Normal': 0, 'Anormal': 1})
+        data = enhanced_features(data)
+        data[['Suggested_Service', 'Suggested_Priority']] = data.apply(compute_service_and_priority, axis=1, result_type='expand')
+        data['Suggested_Priority'] = data['Suggested_Priority'].astype(int)
+
+        X = data[PRIORITY_FEATURES]
+        y = data['Priorite'].values - 1  # Shift to 0-based indexing
+
+        priority_imputer = SimpleImputer(strategy='median')
+        X_imputed = priority_imputer.fit_transform(X)
+        priority_scaler = StandardScaler()
+        X_scaled = priority_scaler.fit_transform(X_imputed)
+
+        models = {
+            'XGBoost': XGBClassifier(n_estimators=100, max_depth=4, learning_rate=0.05, n_jobs=-1, random_state=42),
+            'LightGBM': LGBMClassifier(n_estimators=100, max_depth=2, learning_rate=0.05, min_child_samples=5, 
+                                      reg_alpha=0.5, reg_lambda=0.5, n_jobs=-1, random_state=42, verbose=-1),
+            'RandomForest': RandomForestClassifier(n_estimators=100, max_depth=8, n_jobs=-1, random_state=42),
+            'LogisticRegression': LogisticRegression(max_iter=1000, multi_class='multinomial', random_state=42),
+            'SVM': SVC(probability=True, random_state=42)
+        }
+
+        skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
+        results = {}
+
+        for name, model in models.items():
+            logger.info(f"\nEvaluating {name} for Priority...")
+            scores = {'f1': [], 'recall_p1': [], 'time': []}
+            for train_idx, test_idx in tqdm(skf.split(X_scaled, y), total=5):
+                X_train, X_test = X_scaled[train_idx], X_scaled[test_idx]
+                y_train, y_test = y[train_idx], y[test_idx]
+                
+                min_class_size = pd.Series(y_train).value_counts().min()
+                k_neighbors = min(5, max(1, min_class_size - 1))
+                pipeline = Pipeline([
+                    ('under', RandomUnderSampler(sampling_strategy='majority', random_state=42)),
+                    ('over', SMOTE(sampling_strategy=get_smote_strategy(y_train), random_state=42, k_neighbors=k_neighbors))
+                ])
+                X_train_res, y_train_res = pipeline.fit_resample(X_train, y_train)
+                class_sizes = pd.Series(y_train_res).value_counts().to_dict()
+                logger.info(f"{name} - Resampled class sizes: {class_sizes}")
+                
+                start_time = time.time()
+                model.fit(X_train_res, y_train_res)
+                train_time = time.time() - start_time
+                
+                y_pred = model.predict(X_test)
+                scores['f1'].append(f1_score(y_test, y_pred, average='macro'))
+                scores['recall_p1'].append(recall_score(y_test, y_pred, labels=[0], average=None, zero_division=0)[0])
+                scores['time'].append(train_time)
+                logger.info(f"{name} Fold - F1: {scores['f1'][-1]:.3f}, Recall P1: {scores['recall_p1'][-1]:.3f}")
+
+            results[name] = {
+                'f1': np.mean(scores['f1']),
+                'recall_p1': np.mean(scores['recall_p1']),
+                'time': np.mean(scores['time'])
+            }
+            if name == 'LightGBM':
+                feature_importance = pd.Series(model.feature_importances_, index=PRIORITY_FEATURES).sort_values(ascending=False)
+                logger.info(f"LightGBM Priority Feature Importance:\n{feature_importance}")
+
+        logger.info("\nPriority Model Comparison:")
+        for name, res in results.items():
+            logger.info(f"{name}: F1={res['f1']:.3f}, Recall P1={res['recall_p1']:.3f}, Time={res['time']:.2f}s")
+
+        best_model = max(results, key=lambda k: results[k]['f1'] + results[k]['recall_p1'])
+        logger.info(f"Best Priority Model: {best_model}")
+
+        with model_lock:
+            priority_model = models[best_model]
+            priority_model.fit(X_scaled, y)
+
+        timestamp = int(time.time())
+        joblib.dump(priority_model, f'priority_model_{timestamp}.pkl')
+        joblib.dump(priority_scaler, 'priority_scaler.pkl')
+        joblib.dump(priority_imputer, 'priority_imputer.pkl')
+        logger.info("Priority model saved.")
+    except Exception as e:
+        logger.error(f"Error in priority training: {e}")
+        raise
+
+def train_service_model():
+    global service_model, service_scaler, service_imputer, label_encoder_service
+    try:
+        data = pd.read_csv(DATASET_PATH)
+        data['Sexe'] = data['Sexe'].map({'Masculin': 0, 'Feminin': 1})
+        data['Enceinte'] = data['Enceinte'].astype(int)
+        data['ECG'] = data['ECG'].map({'Normal': 0, 'Anormal': 1})
+        data = enhanced_features(data)
+        data[['Suggested_Service', 'Suggested_Priority']] = data.apply(compute_service_and_priority, axis=1, result_type='expand')
+
+        X = data[SERVICE_FEATURES]
+        y = label_encoder_service.fit_transform(data['Service_Suivant'].fillna('Unknown'))
+
+        service_imputer = SimpleImputer(strategy='median')
+        X_imputed = service_imputer.fit_transform(X)
+        service_scaler = StandardScaler()
+        X_scaled = service_scaler.fit_transform(X_imputed)
+
+        models = {
+            'XGBoost': XGBClassifier(n_estimators=100, max_depth=4, learning_rate=0.05, n_jobs=-1, random_state=42),
+            'LightGBM': LGBMClassifier(n_estimators=100, max_depth=2, learning_rate=0.05, min_child_samples=5, 
+                                      reg_alpha=0.5, reg_lambda=0.5, n_jobs=-1, random_state=42, verbose=-1),
+            'RandomForest': RandomForestClassifier(n_estimators=100, max_depth=8, n_jobs=-1, random_state=42),
+            'LogisticRegression': LogisticRegression(max_iter=1000, multi_class='multinomial', random_state=42),
+            'SVM': SVC(probability=True, random_state=42)
+        }
+
+        skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
+        results = {}
+
+        for name, model in models.items():
+            logger.info(f"\nEvaluating {name} for Service...")
+            scores = {'f1': [], 'time': []}
+            for train_idx, test_idx in tqdm(skf.split(X_scaled, y), total=5):
+                X_train, X_test = X_scaled[train_idx], X_scaled[test_idx]
+                y_train, y_test = y[train_idx], y[test_idx]
+                
+                min_class_size = pd.Series(y_train).value_counts().min()
+                k_neighbors = min(5, max(1, min_class_size - 1))
+                pipeline = Pipeline([
+                    ('under', RandomUnderSampler(sampling_strategy='majority', random_state=42)),
+                    ('over', SMOTE(sampling_strategy=get_smote_strategy(y_train), random_state=42, k_neighbors=k_neighbors))
+                ])
+                X_train_res, y_train_res = pipeline.fit_resample(X_train, y_train)
+                class_sizes = pd.Series(y_train_res).value_counts().to_dict()
+                logger.info(f"{name} - Resampled class sizes: {class_sizes}")
+                
+                start_time = time.time()
+                model.fit(X_train_res, y_train_res)
+                train_time = time.time() - start_time
+                
+                y_pred = model.predict(X_test)
+                scores['f1'].append(f1_score(y_test, y_pred, average='macro'))
+                scores['time'].append(train_time)
+
+            results[name] = {
+                'f1': np.mean(scores['f1']),
+                'time': np.mean(scores['time'])
+            }
+            if name == 'LightGBM':
+                feature_importance = pd.Series(model.feature_importances_, index=SERVICE_FEATURES).sort_values(ascending=False)
+                logger.info(f"LightGBM Service Feature Importance:\n{feature_importance}")
+
+        logger.info("\nService Model Comparison:")
+        for name, res in results.items():
+            logger.info(f"{name}: F1={res['f1']:.3f}, Time={res['time']:.2f}s")
+
+        best_model = max(results, key=lambda k: results[k]['f1'])
+        logger.info(f"Best Service Model: {best_model}")
+
+        with model_lock:
+            service_model = models[best_model]
+            service_model.fit(X_scaled, y)
+
+        timestamp = int(time.time())
+        joblib.dump(service_model, f'service_model_{timestamp}.pkl')
+        joblib.dump(service_scaler, 'service_scaler.pkl')
+        joblib.dump(service_imputer, 'service_imputer.pkl')
+        joblib.dump(label_encoder_service, 'label_encoder_service.pkl')
+        logger.info("Service model saved.")
+    except Exception as e:
+        logger.error(f"Error in service training: {e}")
+        raise
+
+@retry(wait=wait_fixed(2), stop=stop_after_attempt(3))
+def retrain_models():
+    global priority_model, service_model, priority_scaler, service_scaler, priority_imputer, service_imputer, label_encoder_service
+    while True:
+        time.sleep(3600)
+        if os.path.exists(NEW_DATA_FILE) and os.path.getsize(NEW_DATA_FILE) > 0:
+            try:
+                new_data = pd.read_csv(NEW_DATA_FILE)
+                if len(new_data) >= MIN_NEW_SAMPLES_FOR_RETRAIN:
+                    orig_data = pd.read_csv(DATASET_PATH)
+                    orig_data['Sexe'] = orig_data['Sexe'].map({'Masculin': 0, 'Feminin': 1})
+                    orig_data['Enceinte'] = orig_data['Enceinte'].astype(int)
+                    orig_data['ECG'] = orig_data['ECG'].map({'Normal': 0, 'Anormal': 1})
+                    new_data = enhanced_features(new_data)
+                    combined_data = pd.concat([orig_data, new_data], ignore_index=True)
+
+                    # Priority retraining
+                    X_priority = combined_data[PRIORITY_FEATURES]
+                    y_priority = combined_data['Priorite'].values - 1
+                    X_priority_imputed = priority_imputer.transform(X_priority)
+                    X_priority_scaled = priority_scaler.transform(X_priority_imputed)
+                    with model_lock:
+                        priority_model.fit(X_priority_scaled, y_priority)
+
+                    # Service retraining
+                    X_service = combined_data[SERVICE_FEATURES]
+                    y_service = label_encoder_service.transform(combined_data['Service_Suivant'].fillna('Unknown'))
+                    X_service_imputed = service_imputer.transform(X_service)
+                    X_service_scaled = service_scaler.transform(X_service_imputed)
+                    with model_lock:
+                        service_model.fit(X_service_scaled, y_service)
+
+                    timestamp = int(time.time())
+                    joblib.dump(priority_model, f'priority_model_{timestamp}.pkl')
+                    joblib.dump(service_model, f'service_model_{timestamp}.pkl')
+                    new_data.to_csv(f'archive_new_data_{timestamp}.csv', index=False)
+                    open(NEW_DATA_FILE, 'w').close()
+                    logger.info("Models retrained and saved.")
+            except Exception as e:
+                logger.error(f"Error in retrain: {e}")
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    global priority_model, service_model, priority_scaler, service_scaler, priority_imputer, service_imputer, label_encoder_service
+    try:
+        data = request.get_json()
+        required_fields = ['age', 'sexe', 'enceinte', 'spo2', 'freq_resp', 'pouls', 'ecg', 'pa', 'temperature', 'imc']
+        missing_fields = [field for field in required_fields if field not in data]
+        if missing_fields:
+            return jsonify({'error': f'Missing fields: {", ".join(missing_fields)}'}), 400
+
+        input_data = {
+            'Age': float(data['age']),
+            'Sexe': 0 if data['sexe'].lower() == 'masculin' else 1,
+            'Enceinte': 1 if bool(data['enceinte']) else 0,
+            'SpO2': float(data['spo2']),
+            'Frquce_Rprtr(rpm)': float(data['freq_resp']),
+            'Pouls': float(data['pouls']),
+            'ECG': 0 if data['ecg'].lower() == 'normal' else 1,
+            'PA': float(data['pa']),
+            'Temperature': float(data['temperature']),
+            'IMC': float(data['imc']),
+        }
+
+        input_df = pd.DataFrame([input_data])
+        input_df = enhanced_features(input_df)
+        suggested_service, suggested_priority = compute_service_and_priority(input_df.iloc[0])
+        input_df['Suggested_Priority'] = suggested_priority
+
+        with model_lock:
+            # Priority prediction
+            priority_input = input_df[PRIORITY_FEATURES]
+            priority_imputed = priority_imputer.transform(priority_input)
+            priority_scaled = priority_scaler.transform(priority_imputed)
+            priority_probs = priority_model.predict_proba(priority_scaled)[0]
+            priority_pred = np.argmax(priority_probs) + 1
+            priority_conf = float(max(priority_probs))
+
+            # Service prediction
+            service_input = input_df[SERVICE_FEATURES]
+            service_imputed = service_imputer.transform(service_input)
+            service_scaled = service_scaler.transform(service_imputed)
+            service_probs = service_model.predict_proba(service_scaled)[0]
+            service_pred_idx = np.argmax(service_probs)
+            service_pred = label_encoder_service.inverse_transform([service_pred_idx])[0]
+            service_conf = float(max(service_probs))
+
+            # Fallback to rule-based logic if confidence is low or critical conditions apply
+            if priority_conf < 0.7 or input_df['Critical_Signs'][0] == 1:
+                priority_pred = suggested_priority
+            if service_conf < 0.7 or input_df['Enceinte'][0] == 1:
+                service_pred = suggested_service if input_df['Enceinte'][0] == 0 else 'Gynécologie/Obstétrique'
+
+        input_df['Priorite'] = priority_pred
+        input_df['Service_Suivant'] = service_pred
+        if not os.path.exists(NEW_DATA_FILE):
+            input_df.to_csv(NEW_DATA_FILE, index=False)
+        else:
+            input_df.to_csv(NEW_DATA_FILE, mode='a', header=False, index=False)
+
+        logger.info(f"Predicted: service={service_pred}, priority={priority_pred}, service_conf={service_conf}, priority_conf={priority_conf}")
+        return jsonify({
+            'priority': int(priority_pred),
+            'service_suivant': service_pred,
+            'priority_confidence': priority_conf,
+            'service_confidence': service_conf
+        })
+    except Exception as e:
+        logger.error(f"Prediction error: {str(e)}")
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == '__main__':
+    FORCE_RETRAIN = True
+    if FORCE_RETRAIN or not (os.path.exists('priority_model.pkl') and os.path.exists('service_model.pkl')):
+        train_priority_model()
+        train_service_model()
+    else:
+        with model_lock:
+            priority_model = joblib.load('priority_model.pkl')
+            service_model = joblib.load('service_model.pkl')
+            priority_scaler = joblib.load('priority_scaler.pkl')
+            service_scaler = joblib.load('service_scaler.pkl')
+            priority_imputer = joblib.load('priority_imputer.pkl')
+            service_imputer = joblib.load('service_imputer.pkl')
+            label_encoder_service = joblib.load('label_encoder_service.pkl')
+
+    retrain_thread = threading.Thread(target=retrain_models, daemon=True)
+    retrain_thread.start()
+=======
+import pandas as pd
+import numpy as np
+from xgboost import XGBClassifier
+from lightgbm import LGBMClassifier
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.model_selection import StratifiedKFold
+from sklearn.metrics import classification_report, recall_score, f1_score
+from sklearn.impute import SimpleImputer
+from imblearn.over_sampling import SMOTE
+from imblearn.under_sampling import RandomUnderSampler
+from imblearn.pipeline import Pipeline
+import joblib
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import os
+import warnings
+import time
+from tqdm import tqdm
+import threading
+import logging
+from tenacity import retry, wait_fixed, stop_after_attempt
+
+warnings.filterwarnings('ignore', category=UserWarning)
+os.environ["LOKY_MAX_CPU_COUNT"] = "1"
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+CORS(app)
+
+NEW_DATA_FILE = 'new_data.csv'
+DATASET_PATH = "my_datasheet_80000.csv"
+MIN_NEW_SAMPLES_FOR_RETRAIN = 100
+
+# Feature sets for each task
+PRIORITY_FEATURES = [
+    'SpO2', 'Frquce_Rprtr(rpm)', 'Pouls', 'PA', 'Temperature', 'SpO2_Severity', 'Tachypnea', 'Bradypnea',
+    'Tachycardia', 'Bradycardia', 'Critical_Signs', 'SpO2_Temp_Ratio', 'Pouls_PA_Ratio', 'Temp_Pouls_Ratio',
+    'SpO2_PA_Diff', 'SpO2_Temp_Diff', 'PA_Pouls_Diff', 'SpO2_Log', 'Temp_Squared', 'Suggested_Priority'
+]
+
+SERVICE_FEATURES = [
+    'Age', 'Sexe', 'Enceinte', 'SpO2', 'Frquce_Rprtr(rpm)', 'Pouls', 'ECG', 'PA', 'Temperature', 'IMC',
+    'Age_Category', 'Temp_Anomaly', 'PA_High', 'PA_Low', 'Pouls_SpO2_Ratio', 'PA_Temp_Ratio', 'IMC_Temp_Ratio'
+]
+
+priority_model = None
+service_model = None
+priority_scaler = None
+service_scaler = None
+priority_imputer = None
+service_imputer = None
+label_encoder_service = LabelEncoder()
+
+model_lock = threading.Lock()
+
+def enhanced_features(df):
+    df['Tachypnea'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Frquce_Rprtr(rpm)'] > 40) or 
+                                         (row['Age'] < 12 and row['Frquce_Rprtr(rpm)'] > 30) or 
+                                         (row['Age'] >= 12 and row['Frquce_Rprtr(rpm)'] > 20) else 0, axis=1)
+    df['Bradypnea'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Frquce_Rprtr(rpm)'] < 20) or 
+                                         (row['Age'] < 12 and row['Frquce_Rprtr(rpm)'] < 12) or 
+                                         (row['Age'] >= 12 and row['Frquce_Rprtr(rpm)'] < 8) else 0, axis=1)
+    df['Tachycardia'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Pouls'] > 160) or 
+                                           (row['Age'] < 12 and row['Pouls'] > 120) or 
+                                           (row['Age'] >= 12 and row['Pouls'] > 100) else 0, axis=1)
+    df['Bradycardia'] = df.apply(lambda row: 1 if (row['Age'] < 1 and row['Pouls'] < 90) or 
+                                           (row['Age'] < 12 and row['Pouls'] < 70) or 
+                                           (row['Age'] >= 12 and row['Pouls'] < 50) else 0, axis=1)
+    df['SpO2_Temp_Ratio'] = df['SpO2'] / (df['Temperature'] + 1e-6)
+    df['Pouls_PA_Ratio'] = df['Pouls'] / (df['PA'] + 1e-6)
+    df['Temp_Pouls_Ratio'] = df['Temperature'] / (df['Pouls'] + 1e-6)
+    df['SpO2_PA_Diff'] = df['SpO2'] - df['PA'] / 10
+    df['SpO2_Temp_Diff'] = df['SpO2'] - df['Temperature']
+    df['PA_Pouls_Diff'] = df['PA'] - df['Pouls']
+    df['IMC_Temp_Ratio'] = df['IMC'] / (df['Temperature'] + 1e-6)
+    df['SpO2_Log'] = np.log1p(df['SpO2'])
+    df['Temp_Squared'] = df['Temperature'] ** 2
+    df['Pouls_SpO2_Ratio'] = df['Pouls'] / (df['SpO2'] + 1e-6)
+    df['PA_Temp_Ratio'] = df['PA'] / (df['Temperature'] + 1e-6)
+    df['Age_Category'] = pd.cut(df['Age'], bins=[0, 1, 12, 45, 65, 120], labels=[0, 1, 2, 3, 4])
+    df['Temp_Anomaly'] = df['Temperature'].apply(lambda x: 1 if x < 35 or x > 38 else 0)
+    df['PA_High'] = df['PA'].apply(lambda x: 1 if x > 160 else 0)
+    df['PA_Low'] = df['PA'].apply(lambda x: 1 if x < 90 else 0)
+    df['SpO2_Severity'] = pd.cut(df['SpO2'], bins=[0, 85, 90, 92, 100], labels=[3, 2, 1, 0])
+    df['Critical_Signs'] = ((df['SpO2'] < 85) | (df['Pouls'] > 150) | (df['Temperature'] > 40) | 
+                            (df['PA'] > 200) | (df['PA'] < 70)).astype(int)
+    return df
+
+def compute_service_and_priority(row):
+    age = row['Age']
+    spO2 = row['SpO2']
+    frq_resp = row['Frquce_Rprtr(rpm)']
+    pouls = row['Pouls']
+    ecg = row['ECG']
+    pa = row['PA']
+    temp = row['Temperature']
+    enceinte = row['Enceinte']
+    imc = row['IMC']
+
+    if age <= 18:
+        service = 'Pédiatriques'
+    elif enceinte:
+        service = 'Gynécologie/Obstétrique'
+    elif ecg == 1 or (pouls < 50 or pouls > 110) or (frq_resp > 20):
+        service = 'Neurologie'
+    elif spO2 < 92 or frq_resp > 18 or pouls > 100 or pa < 90 or pa > 160:
+        service = 'Cardiorespiratoire'
+    elif (imc > 30 and (temp > 38 and temp <= 40) and 70 <= pouls <= 90) or \
+         (70 <= pouls <= 90 and 110 <= pa <= 130 and spO2 >= 97 and temp <= 37.5):
+        service = 'Médecine générale'
+    elif temp > 40:
+        service = 'Radiothérapie'
+    else:
+        service = 'Chirurgie'
+
+    if spO2 < 85 or temp > 40 or pouls > 150 or pa < 70 or pa > 200:
+        priorite = 1
+    elif spO2 < 88 or temp > 39.5 or pouls > 130 or pa < 80 or pa > 180 or frq_resp > 25:
+        priorite = 2
+    elif spO2 < 90 or temp > 38.5 or pouls > 110 or pa < 90 or pa > 160 or frq_resp > 20:
+        priorite = 3
+    elif spO2 < 92 or temp > 38 or pouls > 100 or pa < 100 or pa > 140 or frq_resp > 18:
+        priorite = 4
+    else:
+        priorite = 5
+
+    return service, priorite
+
+def get_smote_strategy(y, max_samples=1000):
+    class_counts = pd.Series(y).value_counts()
+    strategy = {}
+    for cls, count in class_counts.items():
+        target = min(max_samples, max(count * 2, 100))  # Ensure reasonable class sizes
+    return strategy
+
+def train_priority_model():
+    global priority_model, priority_scaler, priority_imputer
+    try:
+        data = pd.read_csv(DATASET_PATH)
+        data['Sexe'] = data['Sexe'].map({'Masculin': 0, 'Feminin': 1})
+        data['Enceinte'] = data['Enceinte'].astype(int)
+        data['ECG'] = data['ECG'].map({'Normal': 0, 'Anormal': 1})
+        data = enhanced_features(data)
+        data[['Suggested_Service', 'Suggested_Priority']] = data.apply(compute_service_and_priority, axis=1, result_type='expand')
+        data['Suggested_Priority'] = data['Suggested_Priority'].astype(int)
+
+        X = data[PRIORITY_FEATURES]
+        y = data['Priorite'].values - 1  # Shift to 0-based indexing
+
+        priority_imputer = SimpleImputer(strategy='median')
+        X_imputed = priority_imputer.fit_transform(X)
+        priority_scaler = StandardScaler()
+        X_scaled = priority_scaler.fit_transform(X_imputed)
+
+        models = {
+            'XGBoost': XGBClassifier(n_estimators=100, max_depth=4, learning_rate=0.05, n_jobs=-1, random_state=42),
+            'LightGBM': LGBMClassifier(n_estimators=100, max_depth=2, learning_rate=0.05, min_child_samples=5, 
+                                      reg_alpha=0.5, reg_lambda=0.5, n_jobs=-1, random_state=42, verbose=-1),
+            'RandomForest': RandomForestClassifier(n_estimators=100, max_depth=8, n_jobs=-1, random_state=42),
+            'LogisticRegression': LogisticRegression(max_iter=1000, multi_class='multinomial', random_state=42),
+            'SVM': SVC(probability=True, random_state=42)
+        }
+
+        skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
+        results = {}
+
+        for name, model in models.items():
+            logger.info(f"\nEvaluating {name} for Priority...")
+            scores = {'f1': [], 'recall_p1': [], 'time': []}
+            for train_idx, test_idx in tqdm(skf.split(X_scaled, y), total=5):
+                X_train, X_test = X_scaled[train_idx], X_scaled[test_idx]
+                y_train, y_test = y[train_idx], y[test_idx]
+                
+                min_class_size = pd.Series(y_train).value_counts().min()
+                k_neighbors = min(5, max(1, min_class_size - 1))
+                pipeline = Pipeline([
+                    ('under', RandomUnderSampler(sampling_strategy='majority', random_state=42)),
+                    ('over', SMOTE(sampling_strategy=get_smote_strategy(y_train), random_state=42, k_neighbors=k_neighbors))
+                ])
+                X_train_res, y_train_res = pipeline.fit_resample(X_train, y_train)
+                class_sizes = pd.Series(y_train_res).value_counts().to_dict()
+                logger.info(f"{name} - Resampled class sizes: {class_sizes}")
+                
+                start_time = time.time()
+                model.fit(X_train_res, y_train_res)
+                train_time = time.time() - start_time
+                
+                y_pred = model.predict(X_test)
+                scores['f1'].append(f1_score(y_test, y_pred, average='macro'))
+                scores['recall_p1'].append(recall_score(y_test, y_pred, labels=[0], average=None, zero_division=0)[0])
+                scores['time'].append(train_time)
+                logger.info(f"{name} Fold - F1: {scores['f1'][-1]:.3f}, Recall P1: {scores['recall_p1'][-1]:.3f}")
+
+            results[name] = {
+                'f1': np.mean(scores['f1']),
+                'recall_p1': np.mean(scores['recall_p1']),
+                'time': np.mean(scores['time'])
+            }
+            if name == 'LightGBM':
+                feature_importance = pd.Series(model.feature_importances_, index=PRIORITY_FEATURES).sort_values(ascending=False)
+                logger.info(f"LightGBM Priority Feature Importance:\n{feature_importance}")
+
+        logger.info("\nPriority Model Comparison:")
+        for name, res in results.items():
+            logger.info(f"{name}: F1={res['f1']:.3f}, Recall P1={res['recall_p1']:.3f}, Time={res['time']:.2f}s")
+
+        best_model = max(results, key=lambda k: results[k]['f1'] + results[k]['recall_p1'])
+        logger.info(f"Best Priority Model: {best_model}")
+
+        with model_lock:
+            priority_model = models[best_model]
+            priority_model.fit(X_scaled, y)
+
+        timestamp = int(time.time())
+        joblib.dump(priority_model, f'priority_model_{timestamp}.pkl')
+        joblib.dump(priority_scaler, 'priority_scaler.pkl')
+        joblib.dump(priority_imputer, 'priority_imputer.pkl')
+        logger.info("Priority model saved.")
+    except Exception as e:
+        logger.error(f"Error in priority training: {e}")
+        raise
+
+def train_service_model():
+    global service_model, service_scaler, service_imputer, label_encoder_service
+    try:
+        data = pd.read_csv(DATASET_PATH)
+        data['Sexe'] = data['Sexe'].map({'Masculin': 0, 'Feminin': 1})
+        data['Enceinte'] = data['Enceinte'].astype(int)
+        data['ECG'] = data['ECG'].map({'Normal': 0, 'Anormal': 1})
+        data = enhanced_features(data)
+        data[['Suggested_Service', 'Suggested_Priority']] = data.apply(compute_service_and_priority, axis=1, result_type='expand')
+
+        X = data[SERVICE_FEATURES]
+        y = label_encoder_service.fit_transform(data['Service_Suivant'].fillna('Unknown'))
+
+        service_imputer = SimpleImputer(strategy='median')
+        X_imputed = service_imputer.fit_transform(X)
+        service_scaler = StandardScaler()
+        X_scaled = service_scaler.fit_transform(X_imputed)
+
+        models = {
+            'XGBoost': XGBClassifier(n_estimators=100, max_depth=4, learning_rate=0.05, n_jobs=-1, random_state=42),
+            'LightGBM': LGBMClassifier(n_estimators=100, max_depth=2, learning_rate=0.05, min_child_samples=5, 
+                                      reg_alpha=0.5, reg_lambda=0.5, n_jobs=-1, random_state=42, verbose=-1),
+            'RandomForest': RandomForestClassifier(n_estimators=100, max_depth=8, n_jobs=-1, random_state=42),
+            'LogisticRegression': LogisticRegression(max_iter=1000, multi_class='multinomial', random_state=42),
+            'SVM': SVC(probability=True, random_state=42)
+        }
+
+        skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
+        results = {}
+
+        for name, model in models.items():
+            logger.info(f"\nEvaluating {name} for Service...")
+            scores = {'f1': [], 'time': []}
+            for train_idx, test_idx in tqdm(skf.split(X_scaled, y), total=5):
+                X_train, X_test = X_scaled[train_idx], X_scaled[test_idx]
+                y_train, y_test = y[train_idx], y[test_idx]
+                
+                min_class_size = pd.Series(y_train).value_counts().min()
+                k_neighbors = min(5, max(1, min_class_size - 1))
+                pipeline = Pipeline([
+                    ('under', RandomUnderSampler(sampling_strategy='majority', random_state=42)),
+                    ('over', SMOTE(sampling_strategy=get_smote_strategy(y_train), random_state=42, k_neighbors=k_neighbors))
+                ])
+                X_train_res, y_train_res = pipeline.fit_resample(X_train, y_train)
+                class_sizes = pd.Series(y_train_res).value_counts().to_dict()
+                logger.info(f"{name} - Resampled class sizes: {class_sizes}")
+                
+                start_time = time.time()
+                model.fit(X_train_res, y_train_res)
+                train_time = time.time() - start_time
+                
+                y_pred = model.predict(X_test)
+                scores['f1'].append(f1_score(y_test, y_pred, average='macro'))
+                scores['time'].append(train_time)
+
+            results[name] = {
+                'f1': np.mean(scores['f1']),
+                'time': np.mean(scores['time'])
+            }
+            if name == 'LightGBM':
+                feature_importance = pd.Series(model.feature_importances_, index=SERVICE_FEATURES).sort_values(ascending=False)
+                logger.info(f"LightGBM Service Feature Importance:\n{feature_importance}")
+
+        logger.info("\nService Model Comparison:")
+        for name, res in results.items():
+            logger.info(f"{name}: F1={res['f1']:.3f}, Time={res['time']:.2f}s")
+
+        best_model = max(results, key=lambda k: results[k]['f1'])
+        logger.info(f"Best Service Model: {best_model}")
+
+        with model_lock:
+            service_model = models[best_model]
+            service_model.fit(X_scaled, y)
+
+        timestamp = int(time.time())
+        joblib.dump(service_model, f'service_model_{timestamp}.pkl')
+        joblib.dump(service_scaler, 'service_scaler.pkl')
+        joblib.dump(service_imputer, 'service_imputer.pkl')
+        joblib.dump(label_encoder_service, 'label_encoder_service.pkl')
+        logger.info("Service model saved.")
+    except Exception as e:
+        logger.error(f"Error in service training: {e}")
+        raise
+
+@retry(wait=wait_fixed(2), stop=stop_after_attempt(3))
+def retrain_models():
+    global priority_model, service_model, priority_scaler, service_scaler, priority_imputer, service_imputer, label_encoder_service
+    while True:
+        time.sleep(3600)
+        if os.path.exists(NEW_DATA_FILE) and os.path.getsize(NEW_DATA_FILE) > 0:
+            try:
+                new_data = pd.read_csv(NEW_DATA_FILE)
+                if len(new_data) >= MIN_NEW_SAMPLES_FOR_RETRAIN:
+                    orig_data = pd.read_csv(DATASET_PATH)
+                    orig_data['Sexe'] = orig_data['Sexe'].map({'Masculin': 0, 'Feminin': 1})
+                    orig_data['Enceinte'] = orig_data['Enceinte'].astype(int)
+                    orig_data['ECG'] = orig_data['ECG'].map({'Normal': 0, 'Anormal': 1})
+                    new_data = enhanced_features(new_data)
+                    combined_data = pd.concat([orig_data, new_data], ignore_index=True)
+
+                    # Priority retraining
+                    X_priority = combined_data[PRIORITY_FEATURES]
+                    y_priority = combined_data['Priorite'].values - 1
+                    X_priority_imputed = priority_imputer.transform(X_priority)
+                    X_priority_scaled = priority_scaler.transform(X_priority_imputed)
+                    with model_lock:
+                        priority_model.fit(X_priority_scaled, y_priority)
+
+                    # Service retraining
+                    X_service = combined_data[SERVICE_FEATURES]
+                    y_service = label_encoder_service.transform(combined_data['Service_Suivant'].fillna('Unknown'))
+                    X_service_imputed = service_imputer.transform(X_service)
+                    X_service_scaled = service_scaler.transform(X_service_imputed)
+                    with model_lock:
+                        service_model.fit(X_service_scaled, y_service)
+
+                    timestamp = int(time.time())
+                    joblib.dump(priority_model, f'priority_model_{timestamp}.pkl')
+                    joblib.dump(service_model, f'service_model_{timestamp}.pkl')
+                    new_data.to_csv(f'archive_new_data_{timestamp}.csv', index=False)
+                    open(NEW_DATA_FILE, 'w').close()
+                    logger.info("Models retrained and saved.")
+            except Exception as e:
+                logger.error(f"Error in retrain: {e}")
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    global priority_model, service_model, priority_scaler, service_scaler, priority_imputer, service_imputer, label_encoder_service
+    try:
+        data = request.get_json()
+        required_fields = ['age', 'sexe', 'enceinte', 'spo2', 'freq_resp', 'pouls', 'ecg', 'pa', 'temperature', 'imc']
+        missing_fields = [field for field in required_fields if field not in data]
+        if missing_fields:
+            return jsonify({'error': f'Missing fields: {", ".join(missing_fields)}'}), 400
+
+        input_data = {
+            'Age': float(data['age']),
+            'Sexe': 0 if data['sexe'].lower() == 'masculin' else 1,
+            'Enceinte': 1 if bool(data['enceinte']) else 0,
+            'SpO2': float(data['spo2']),
+            'Frquce_Rprtr(rpm)': float(data['freq_resp']),
+            'Pouls': float(data['pouls']),
+            'ECG': 0 if data['ecg'].lower() == 'normal' else 1,
+            'PA': float(data['pa']),
+            'Temperature': float(data['temperature']),
+            'IMC': float(data['imc']),
+        }
+
+        input_df = pd.DataFrame([input_data])
+        input_df = enhanced_features(input_df)
+        suggested_service, suggested_priority = compute_service_and_priority(input_df.iloc[0])
+        input_df['Suggested_Priority'] = suggested_priority
+
+        with model_lock:
+            # Priority prediction
+            priority_input = input_df[PRIORITY_FEATURES]
+            priority_imputed = priority_imputer.transform(priority_input)
+            priority_scaled = priority_scaler.transform(priority_imputed)
+            priority_probs = priority_model.predict_proba(priority_scaled)[0]
+            priority_pred = np.argmax(priority_probs) + 1
+            priority_conf = float(max(priority_probs))
+
+            # Service prediction
+            service_input = input_df[SERVICE_FEATURES]
+            service_imputed = service_imputer.transform(service_input)
+            service_scaled = service_scaler.transform(service_imputed)
+            service_probs = service_model.predict_proba(service_scaled)[0]
+            service_pred_idx = np.argmax(service_probs)
+            service_pred = label_encoder_service.inverse_transform([service_pred_idx])[0]
+            service_conf = float(max(service_probs))
+
+            # Fallback to rule-based logic if confidence is low or critical conditions apply
+            if priority_conf < 0.7 or input_df['Critical_Signs'][0] == 1:
+                priority_pred = suggested_priority
+            if service_conf < 0.7 or input_df['Enceinte'][0] == 1:
+                service_pred = suggested_service if input_df['Enceinte'][0] == 0 else 'Gynécologie/Obstétrique'
+
+        input_df['Priorite'] = priority_pred
+        input_df['Service_Suivant'] = service_pred
+        if not os.path.exists(NEW_DATA_FILE):
+            input_df.to_csv(NEW_DATA_FILE, index=False)
+        else:
+            input_df.to_csv(NEW_DATA_FILE, mode='a', header=False, index=False)
+
+        logger.info(f"Predicted: service={service_pred}, priority={priority_pred}, service_conf={service_conf}, priority_conf={priority_conf}")
+        return jsonify({
+            'priority': int(priority_pred),
+            'service_suivant': service_pred,
+            'priority_confidence': priority_conf,
+            'service_confidence': service_conf
+        })
+    except Exception as e:
+        logger.error(f"Prediction error: {str(e)}")
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == '__main__':
+    FORCE_RETRAIN = True
+    if FORCE_RETRAIN or not (os.path.exists('priority_model.pkl') and os.path.exists('service_model.pkl')):
+        train_priority_model()
+        train_service_model()
+    else:
+        with model_lock:
+            priority_model = joblib.load('priority_model.pkl')
+            service_model = joblib.load('service_model.pkl')
+            priority_scaler = joblib.load('priority_scaler.pkl')
+            service_scaler = joblib.load('service_scaler.pkl')
+            priority_imputer = joblib.load('priority_imputer.pkl')
+            service_imputer = joblib.load('service_imputer.pkl')
+            label_encoder_service = joblib.load('label_encoder_service.pkl')
+
+    retrain_thread = threading.Thread(target=retrain_models, daemon=True)
+    retrain_thread.start()
+>>>>>>> 12fbcdcf1e034f735bed38d79600e83ccc29f849
+    app.run(debug=False, host='0.0.0.0', port=5000)

requirements.txt

@@ -10,9 +10,6 @@ imblearn
 joblib
 tqdm
 tenacity
-plotly
-shinywidgets
-shiny
-ridgeplot
+
 
 

shared.py

@@ -1,6 +0,0 @@
-from pathlib import Path
-
-import pandas as pd
-
-app_dir = Path(__file__).parent
-tips = pd.read_csv(app_dir / "tips.csv")

styles.css

@@ -1,12 +0,0 @@
-:root {
-  --bslib-sidebar-main-bg: #f8f8f8;
-}
-
-.popover {
-  --bs-popover-header-bg: #222;
-  --bs-popover-header-color: #fff;
-}
-
-.popover .btn-close {
-  filter: var(--bs-btn-close-white-filter);
-}

tips.csv

@@ -1,245 +0,0 @@
-total_bill,tip,sex,smoker,day,time,size
-16.99,1.01,Female,No,Sun,Dinner,2
-10.34,1.66,Male,No,Sun,Dinner,3
-21.01,3.5,Male,No,Sun,Dinner,3
-23.68,3.31,Male,No,Sun,Dinner,2
-24.59,3.61,Female,No,Sun,Dinner,4
-25.29,4.71,Male,No,Sun,Dinner,4
-8.77,2.0,Male,No,Sun,Dinner,2
-26.88,3.12,Male,No,Sun,Dinner,4
-15.04,1.96,Male,No,Sun,Dinner,2
-14.78,3.23,Male,No,Sun,Dinner,2
-10.27,1.71,Male,No,Sun,Dinner,2
-35.26,5.0,Female,No,Sun,Dinner,4
-15.42,1.57,Male,No,Sun,Dinner,2
-18.43,3.0,Male,No,Sun,Dinner,4
-14.83,3.02,Female,No,Sun,Dinner,2
-21.58,3.92,Male,No,Sun,Dinner,2
-10.33,1.67,Female,No,Sun,Dinner,3
-16.29,3.71,Male,No,Sun,Dinner,3
-16.97,3.5,Female,No,Sun,Dinner,3
-20.65,3.35,Male,No,Sat,Dinner,3
-17.92,4.08,Male,No,Sat,Dinner,2
-20.29,2.75,Female,No,Sat,Dinner,2
-15.77,2.23,Female,No,Sat,Dinner,2
-39.42,7.58,Male,No,Sat,Dinner,4
-19.82,3.18,Male,No,Sat,Dinner,2
-17.81,2.34,Male,No,Sat,Dinner,4
-13.37,2.0,Male,No,Sat,Dinner,2
-12.69,2.0,Male,No,Sat,Dinner,2
-21.7,4.3,Male,No,Sat,Dinner,2
-19.65,3.0,Female,No,Sat,Dinner,2
-9.55,1.45,Male,No,Sat,Dinner,2
-18.35,2.5,Male,No,Sat,Dinner,4
-15.06,3.0,Female,No,Sat,Dinner,2
-20.69,2.45,Female,No,Sat,Dinner,4
-17.78,3.27,Male,No,Sat,Dinner,2
-24.06,3.6,Male,No,Sat,Dinner,3
-16.31,2.0,Male,No,Sat,Dinner,3
-16.93,3.07,Female,No,Sat,Dinner,3
-18.69,2.31,Male,No,Sat,Dinner,3
-31.27,5.0,Male,No,Sat,Dinner,3
-16.04,2.24,Male,No,Sat,Dinner,3
-17.46,2.54,Male,No,Sun,Dinner,2
-13.94,3.06,Male,No,Sun,Dinner,2
-9.68,1.32,Male,No,Sun,Dinner,2
-30.4,5.6,Male,No,Sun,Dinner,4
-18.29,3.0,Male,No,Sun,Dinner,2
-22.23,5.0,Male,No,Sun,Dinner,2
-32.4,6.0,Male,No,Sun,Dinner,4
-28.55,2.05,Male,No,Sun,Dinner,3
-18.04,3.0,Male,No,Sun,Dinner,2
-12.54,2.5,Male,No,Sun,Dinner,2
-10.29,2.6,Female,No,Sun,Dinner,2
-34.81,5.2,Female,No,Sun,Dinner,4
-9.94,1.56,Male,No,Sun,Dinner,2
-25.56,4.34,Male,No,Sun,Dinner,4
-19.49,3.51,Male,No,Sun,Dinner,2
-38.01,3.0,Male,Yes,Sat,Dinner,4
-26.41,1.5,Female,No,Sat,Dinner,2
-11.24,1.76,Male,Yes,Sat,Dinner,2
-48.27,6.73,Male,No,Sat,Dinner,4
-20.29,3.21,Male,Yes,Sat,Dinner,2
-13.81,2.0,Male,Yes,Sat,Dinner,2
-11.02,1.98,Male,Yes,Sat,Dinner,2
-18.29,3.76,Male,Yes,Sat,Dinner,4
-17.59,2.64,Male,No,Sat,Dinner,3
-20.08,3.15,Male,No,Sat,Dinner,3
-16.45,2.47,Female,No,Sat,Dinner,2
-3.07,1.0,Female,Yes,Sat,Dinner,1
-20.23,2.01,Male,No,Sat,Dinner,2
-15.01,2.09,Male,Yes,Sat,Dinner,2
-12.02,1.97,Male,No,Sat,Dinner,2
-17.07,3.0,Female,No,Sat,Dinner,3
-26.86,3.14,Female,Yes,Sat,Dinner,2
-25.28,5.0,Female,Yes,Sat,Dinner,2
-14.73,2.2,Female,No,Sat,Dinner,2
-10.51,1.25,Male,No,Sat,Dinner,2
-17.92,3.08,Male,Yes,Sat,Dinner,2
-27.2,4.0,Male,No,Thur,Lunch,4
-22.76,3.0,Male,No,Thur,Lunch,2
-17.29,2.71,Male,No,Thur,Lunch,2
-19.44,3.0,Male,Yes,Thur,Lunch,2
-16.66,3.4,Male,No,Thur,Lunch,2
-10.07,1.83,Female,No,Thur,Lunch,1
-32.68,5.0,Male,Yes,Thur,Lunch,2
-15.98,2.03,Male,No,Thur,Lunch,2
-34.83,5.17,Female,No,Thur,Lunch,4
-13.03,2.0,Male,No,Thur,Lunch,2
-18.28,4.0,Male,No,Thur,Lunch,2
-24.71,5.85,Male,No,Thur,Lunch,2
-21.16,3.0,Male,No,Thur,Lunch,2
-28.97,3.0,Male,Yes,Fri,Dinner,2
-22.49,3.5,Male,No,Fri,Dinner,2
-5.75,1.0,Female,Yes,Fri,Dinner,2
-16.32,4.3,Female,Yes,Fri,Dinner,2
-22.75,3.25,Female,No,Fri,Dinner,2
-40.17,4.73,Male,Yes,Fri,Dinner,4
-27.28,4.0,Male,Yes,Fri,Dinner,2
-12.03,1.5,Male,Yes,Fri,Dinner,2
-21.01,3.0,Male,Yes,Fri,Dinner,2
-12.46,1.5,Male,No,Fri,Dinner,2
-11.35,2.5,Female,Yes,Fri,Dinner,2
-15.38,3.0,Female,Yes,Fri,Dinner,2
-44.3,2.5,Female,Yes,Sat,Dinner,3
-22.42,3.48,Female,Yes,Sat,Dinner,2
-20.92,4.08,Female,No,Sat,Dinner,2
-15.36,1.64,Male,Yes,Sat,Dinner,2
-20.49,4.06,Male,Yes,Sat,Dinner,2
-25.21,4.29,Male,Yes,Sat,Dinner,2
-18.24,3.76,Male,No,Sat,Dinner,2
-14.31,4.0,Female,Yes,Sat,Dinner,2
-14.0,3.0,Male,No,Sat,Dinner,2
-7.25,1.0,Female,No,Sat,Dinner,1
-38.07,4.0,Male,No,Sun,Dinner,3
-23.95,2.55,Male,No,Sun,Dinner,2
-25.71,4.0,Female,No,Sun,Dinner,3
-17.31,3.5,Female,No,Sun,Dinner,2
-29.93,5.07,Male,No,Sun,Dinner,4
-10.65,1.5,Female,No,Thur,Lunch,2
-12.43,1.8,Female,No,Thur,Lunch,2
-24.08,2.92,Female,No,Thur,Lunch,4
-11.69,2.31,Male,No,Thur,Lunch,2
-13.42,1.68,Female,No,Thur,Lunch,2
-14.26,2.5,Male,No,Thur,Lunch,2
-15.95,2.0,Male,No,Thur,Lunch,2
-12.48,2.52,Female,No,Thur,Lunch,2
-29.8,4.2,Female,No,Thur,Lunch,6
-8.52,1.48,Male,No,Thur,Lunch,2
-14.52,2.0,Female,No,Thur,Lunch,2
-11.38,2.0,Female,No,Thur,Lunch,2
-22.82,2.18,Male,No,Thur,Lunch,3
-19.08,1.5,Male,No,Thur,Lunch,2
-20.27,2.83,Female,No,Thur,Lunch,2
-11.17,1.5,Female,No,Thur,Lunch,2
-12.26,2.0,Female,No,Thur,Lunch,2
-18.26,3.25,Female,No,Thur,Lunch,2
-8.51,1.25,Female,No,Thur,Lunch,2
-10.33,2.0,Female,No,Thur,Lunch,2
-14.15,2.0,Female,No,Thur,Lunch,2
-16.0,2.0,Male,Yes,Thur,Lunch,2
-13.16,2.75,Female,No,Thur,Lunch,2
-17.47,3.5,Female,No,Thur,Lunch,2
-34.3,6.7,Male,No,Thur,Lunch,6
-41.19,5.0,Male,No,Thur,Lunch,5
-27.05,5.0,Female,No,Thur,Lunch,6
-16.43,2.3,Female,No,Thur,Lunch,2
-8.35,1.5,Female,No,Thur,Lunch,2
-18.64,1.36,Female,No,Thur,Lunch,3
-11.87,1.63,Female,No,Thur,Lunch,2
-9.78,1.73,Male,No,Thur,Lunch,2
-7.51,2.0,Male,No,Thur,Lunch,2
-14.07,2.5,Male,No,Sun,Dinner,2
-13.13,2.0,Male,No,Sun,Dinner,2
-17.26,2.74,Male,No,Sun,Dinner,3
-24.55,2.0,Male,No,Sun,Dinner,4
-19.77,2.0,Male,No,Sun,Dinner,4
-29.85,5.14,Female,No,Sun,Dinner,5
-48.17,5.0,Male,No,Sun,Dinner,6
-25.0,3.75,Female,No,Sun,Dinner,4
-13.39,2.61,Female,No,Sun,Dinner,2
-16.49,2.0,Male,No,Sun,Dinner,4
-21.5,3.5,Male,No,Sun,Dinner,4
-12.66,2.5,Male,No,Sun,Dinner,2
-16.21,2.0,Female,No,Sun,Dinner,3
-13.81,2.0,Male,No,Sun,Dinner,2
-17.51,3.0,Female,Yes,Sun,Dinner,2
-24.52,3.48,Male,No,Sun,Dinner,3
-20.76,2.24,Male,No,Sun,Dinner,2
-31.71,4.5,Male,No,Sun,Dinner,4
-10.59,1.61,Female,Yes,Sat,Dinner,2
-10.63,2.0,Female,Yes,Sat,Dinner,2
-50.81,10.0,Male,Yes,Sat,Dinner,3
-15.81,3.16,Male,Yes,Sat,Dinner,2
-7.25,5.15,Male,Yes,Sun,Dinner,2
-31.85,3.18,Male,Yes,Sun,Dinner,2
-16.82,4.0,Male,Yes,Sun,Dinner,2
-32.9,3.11,Male,Yes,Sun,Dinner,2
-17.89,2.0,Male,Yes,Sun,Dinner,2
-14.48,2.0,Male,Yes,Sun,Dinner,2
-9.6,4.0,Female,Yes,Sun,Dinner,2
-34.63,3.55,Male,Yes,Sun,Dinner,2
-34.65,3.68,Male,Yes,Sun,Dinner,4
-23.33,5.65,Male,Yes,Sun,Dinner,2
-45.35,3.5,Male,Yes,Sun,Dinner,3
-23.17,6.5,Male,Yes,Sun,Dinner,4
-40.55,3.0,Male,Yes,Sun,Dinner,2
-20.69,5.0,Male,No,Sun,Dinner,5
-20.9,3.5,Female,Yes,Sun,Dinner,3
-30.46,2.0,Male,Yes,Sun,Dinner,5
-18.15,3.5,Female,Yes,Sun,Dinner,3
-23.1,4.0,Male,Yes,Sun,Dinner,3
-15.69,1.5,Male,Yes,Sun,Dinner,2
-19.81,4.19,Female,Yes,Thur,Lunch,2
-28.44,2.56,Male,Yes,Thur,Lunch,2
-15.48,2.02,Male,Yes,Thur,Lunch,2
-16.58,4.0,Male,Yes,Thur,Lunch,2
-7.56,1.44,Male,No,Thur,Lunch,2
-10.34,2.0,Male,Yes,Thur,Lunch,2
-43.11,5.0,Female,Yes,Thur,Lunch,4
-13.0,2.0,Female,Yes,Thur,Lunch,2
-13.51,2.0,Male,Yes,Thur,Lunch,2
-18.71,4.0,Male,Yes,Thur,Lunch,3
-12.74,2.01,Female,Yes,Thur,Lunch,2
-13.0,2.0,Female,Yes,Thur,Lunch,2
-16.4,2.5,Female,Yes,Thur,Lunch,2
-20.53,4.0,Male,Yes,Thur,Lunch,4
-16.47,3.23,Female,Yes,Thur,Lunch,3
-26.59,3.41,Male,Yes,Sat,Dinner,3
-38.73,3.0,Male,Yes,Sat,Dinner,4
-24.27,2.03,Male,Yes,Sat,Dinner,2
-12.76,2.23,Female,Yes,Sat,Dinner,2
-30.06,2.0,Male,Yes,Sat,Dinner,3
-25.89,5.16,Male,Yes,Sat,Dinner,4
-48.33,9.0,Male,No,Sat,Dinner,4
-13.27,2.5,Female,Yes,Sat,Dinner,2
-28.17,6.5,Female,Yes,Sat,Dinner,3
-12.9,1.1,Female,Yes,Sat,Dinner,2
-28.15,3.0,Male,Yes,Sat,Dinner,5
-11.59,1.5,Male,Yes,Sat,Dinner,2
-7.74,1.44,Male,Yes,Sat,Dinner,2
-30.14,3.09,Female,Yes,Sat,Dinner,4
-12.16,2.2,Male,Yes,Fri,Lunch,2
-13.42,3.48,Female,Yes,Fri,Lunch,2
-8.58,1.92,Male,Yes,Fri,Lunch,1
-15.98,3.0,Female,No,Fri,Lunch,3
-13.42,1.58,Male,Yes,Fri,Lunch,2
-16.27,2.5,Female,Yes,Fri,Lunch,2
-10.09,2.0,Female,Yes,Fri,Lunch,2
-20.45,3.0,Male,No,Sat,Dinner,4
-13.28,2.72,Male,No,Sat,Dinner,2
-22.12,2.88,Female,Yes,Sat,Dinner,2
-24.01,2.0,Male,Yes,Sat,Dinner,4
-15.69,3.0,Male,Yes,Sat,Dinner,3
-11.61,3.39,Male,No,Sat,Dinner,2
-10.77,1.47,Male,No,Sat,Dinner,2
-15.53,3.0,Male,Yes,Sat,Dinner,2
-10.07,1.25,Male,No,Sat,Dinner,2
-12.6,1.0,Male,Yes,Sat,Dinner,2
-32.83,1.17,Male,Yes,Sat,Dinner,2
-35.83,4.67,Female,No,Sat,Dinner,3
-29.03,5.92,Male,No,Sat,Dinner,3
-27.18,2.0,Female,Yes,Sat,Dinner,2
-22.67,2.0,Male,Yes,Sat,Dinner,2
-17.82,1.75,Male,No,Sat,Dinner,2
-18.78,3.0,Female,No,Thur,Dinner,2