🍷 Wine Scraping

Scraping, Partie I

scraping_functions.py ⇒ Le coeur du scraper

1. Construit des URL avec query parameters en utilisant le package yarl.

URL_INIT = URL.build(scheme="https", host="vinatis.com")
WHITE = "achat-vin-blanc"
RED = "achat-vin-rouge"
ROSE = "achat-vin-rose"

>>> URL_INIT / WHITE % {"page": 1, "tri": 7}
... URL('https://vinatis.com/achat-vin-blanc?page=1&tri=7')

2. create_session crée une session HTML avec un User-Agent et un Proxy aléatoire, pouvant changer entre les requêtes.
3. Possède un décorateur @random_waiter(min, max) permettant de générer un temps d’attente aléatoire entre les deux bornes spécifiées entre chaque requête GET pour éviter d’envoyer trop de requêtes dans un laps de temps réduit.
4. create_all_wine_urls permet de créer l’ensemble des liens href.
5. export_wine_links permet d’exporter ces liens dans un fichier CSV.

Scraping, Partie II

1. On va ensuite requêter ces liens href avec create_json et récupérer les pages brutes en HTML.
2. La fonction scraping du module mystical_soup va permettre d’extraire toutes les informations intéressantes de la page brute et renvoyer la dataclass Vin sérialisable en JSON.

Exemple d’un Vin et ses caractéristiques sérialisés en JSON :

{
        "name": "PINOT NOIR 2019 LAS PIZARRAS - ERRAZURIZ",
        "capacity": "0,75 L",
        "price": "94,90 €",
        "price_bundle": null,
        "characteristics": "Vin Rouge / Chili / Central Valley / Aconcagua Valley DO / 13,5 % vol / 100% Pinot noir",
        "note": null,
        "keywords": [
            "Elégance",
            "Finesse",
            "Harmonie"
        ],
        "others": null,
        "picture": "https://www.vinatis.com/67234-detail_default/pinot-noir-2019-las-pizarras-errazuriz.png",
        "classification": null,
        "millesime": "2019",
        "cepage": "100% Pinot noir",
        "gouts": "Rouge Charnu et fruité",
        "par_gouts": "Puissant",
        "oeil": "Robe rubis aux reflets violets.",
        "nez": "Nez complexe sur la griotte, les épices et les champignons (truffe).",
        "bouche": "Bouche fruitée et florale. Tanins structurés, élégants et fins. finale harmonieuse et persistante.",
        "temperature": "8-10°C",
        "service": "En bouteille ou en carafe",
        "conservation_1": "2026",
        "conservation_2": "A boire et à garder",
        "accords_vins": "Apéritif, Entrée, Charcuterie, Viande rouge, Viande blanche, Volaille, Gibier, Champignon, Barbecue, Cuisine du monde, Fromage, Dessert fruité, Dessert chocolaté",
        "accords_reco": "Gigot d'agneau aux herbes de Provence; Tikka massala; Plateau de fromages."
    }

🧹 Cleaning

Mais ce JSON brut doit être nettoyé et considérablement restructuré !

1. Nous avons choisi d’utiliser polars 🐻 et non pas pandas 🐼 pour le faire.
2. Toutes les fonctions de nettoyage sont contenues dans bear_cleaner.py.
3. La fonction super_pipe permet de chainer toutes les transformations dans un pipeline propre pour structurer notre Dataframe.
4. Nous obtenons ainsi un Dataframe de taille (4006,40) prêt pour le Machine Learning

Machine Learning - Procédure

1. Deux variables à prédire : unit_price & type
2. Utilisation de 6 modèles de Machine Learning
3. ➶ Optimisation des hyperparamètres ⇒ models.py
4. 🏹 Prédiction sur les données de test ⇒ prediction.py
5. 🧪 Utilisation d’un pipeline sklearn
   • Evite le Data Leakage
   • Procédure standardisée pour l’ensemble des modèles.

➶ ML : Optimisation

1. Choix des 21 variables explicatives
2. Preprocessing : OneHotEncoder(), Imputation NA, MinMaxScaler()
3. Optimisation des hyperparamètres par Cross-Validation

• Avec optimisation_script.py on optimise les hyperparamètres des modèles et on récupère sous forme de CSV :
  • Les scores de test et d’entrainement
  • Les écarts-type σtest et σtrain
  • Les hyperparamètres optimaux pour chaque modèle

Modèle,Score Test,Score Entrainement,Ecart-Type Test,Ecart-Type Train,Paramètres,Score Test data,Mode
Random Forest,0.934,0.941,0.007,0.007,"{'entrainement__max_depth': 9, 'entrainement__n_estimators': 30, 'imputation__strategy': 'median'}",0.9301745635910225,classification
K Neighbors,0.954,0.965,0.012,0.003,"{'entrainement__n_neighbors': 5, 'imputation__strategy': 'median'}",0.9600997506234414,classification
Réseaux de neurones,0.976,0.997,0.007,0.001,"{'entrainement__hidden_layer_sizes': (100,), 'entrainement__max_iter': 1000, 'entrainement__solver': 'adam', 'imputation__strategy': 'median'}",0.9800498753117207,classification
Boosting,0.975,1.0,0.009,0.0,"{'entrainement__learning_rate': 0.5, 'entrainement__n_estimators': 200, 'imputation__strategy': 'median'}",0.9812967581047382,classification
Ridge,0.979,0.983,0.009,0.002,"{'entrainement__alpha': 0.015625, 'imputation__strategy': 'mean'}",0.9812967581047382,classification
Support Vector,0.981,0.992,0.008,0.002,"{'entrainement__C': 3.281341424030552, 'imputation__strategy': 'median'}",0.9825436408977556,classification

🏹 ML : Prédiction

• Deux types de prédictions :
  • Classification sur le type de vin (Vin Rouge / Blanc / Rosé)
  • Régression sur le prix d’une bouteille de vin
• Avec prediction_script.py on réalise les prédictions avec tous les modèles

name,type,random_forest,boosting,ridge,knn,mlp,support_vector
LES CARLINES 2021 - MAS HAUT BUIS,Vin Rouge,Vin Rouge,Vin Rouge,Vin Rouge,Vin Rouge,Vin Rouge,Vin Rouge
LA BARGEMONE ROSE 2022 - COMMANDERIE DE LA BARGEMONE,Vin Rosé,Vin Blanc,Vin Rosé,Vin Rosé,Vin Rosé,Vin Rosé,Vin Rosé
TEMPRANILLO 2021- VEGA DEMARA,Vin Rouge,Vin Rouge,Vin Rouge,Vin Rouge,Vin Rouge,Vin Rouge,Vin Rouge
CHÂTEAUNEUF DU PAPE - ALCHIMIE 2020 - DOMAINE DES 3 CELLIER,Vin Rouge,Vin Rouge,Vin Rouge,Vin Rouge,Vin Rouge,Vin Rouge,Vin Rouge

• Pour les 800 vins qui n’ont pas servi dans notre Cross Validation on réalise une prédiction par chacun de nos 6 modèles, le tout stocké dans un fichier CSV !

🔬 Metrics

• Regression:
  • Erreur moyenne absolue : MAE(y,ˆy) = 1n∑|yi−^yi|
  • Erreur quadratique moyenne : MSE(y,ˆy) = 1n∑(yi−^yi)2
  • Erreur Résiduelle Maximale : MaxError(y, ˆy) = max(|yi−^yi|)
  • R2 Score = 1−∑(yi−^yi)2∑(yi−¯yi)2
• Classification:
  • Accuracy Score : AS(y,ˆy) = 1n∑(^yi=yi)
  • Precision = true positivetrue positive + false positive
  • Recall = true positivetrue positive + false negative
  • F1 Score = 2×precision × recallprecision + recall

💻 Application

🕵 Framework utilisé : streamlit

• 🤷 Pourquoi ? Facilité de mise en oeuvre
  • Base de données
  • Statistiques descriptives (corrélations, répartition, etc.)
  • Machine Learning
• 👨‍🏭 Comment ? Forte flexibilité → L’utilisateur peut jouer avec les données
  • Sidebar avec de nombreux sélecteurs

Choix du stockage, Partie II

• 5 tables de résultats de Machine Learning sont obtenues grâce à l’exécution de ml_trigger qui se charge d’éxécuter l’ensemble des scripts d’export.

Voici un schéma du processus d’ingestion des tables :

Un code de Deutsche Qualität

• Annotations de type claires
• Docstrings explicites et soignées
• Gestion des dépendances avec Poetry
• Modularité
• Docker
• Tests des features de l’application
• Git pour versionner notre projet
• Black pour formater notre code
• Un beau README

Code certifié conforme par l’Agent Smith∗

∗ L’Agent Smith tient par ailleurs à préciser qu’il n’a reçu aucun pot-de-vin de notre part pour ce diagnostic malgré son enrichissement personnel fulgurant…

Annotations de type

def model_rf(x_train: pd.DataFrame, y_train: pd.Series, mode: str) -> GridSearchCV:
    ...

• Expliciter au maximum les types d’entrée et de sortie des fonctions.
• On peut parler de documentation implicite ⇒ on cherche à éviter à un utilisateur d’utiliser des objets incompatibles avec ce qui a été établi.

Docstrings

• Chaque fonction à interface publique possède une docstring structurée :
  • Nom de la fonction et description succinte
  • Paramètre(s) d’entrée et paramètre(s) de sortie
    
  • Levée d’exception (si il y en a)
  • Au minimum un exemple d’utilisation

Exemple avec la fonction model_rf du module models.py :

"""`model_rf`: Effectue une recherche exhaustive (Cross-Validation) des meilleurs paramètres
    en utilisant une Random Forest. Les paramètres optimisés sont :

    - n_estimators
    - max_depth

    ---------
    `Parameters`
    --------- ::

        x_train (pd.DataFrame): # L'ensemble d'entrainement
        y_train (pd.Series): # La variable à prédire
        mode (str): # regression | classification

    `Raises`
    --------- ::

        ValueError: # Une erreur est levée quand le mode est invalide

    `Returns`
    --------- ::

        GridSearchCV

    `Example(s)`
    ---------

    >>> model_rf(x_train=X_train, y_train=y_train, mode = "regression")
    ... Entrainement du modèle : Random Forest
    ... GridSearchCV(estimator=Pipeline(steps=[('imputation', SimpleImputer()),
    ...                                   ('echelle', MinMaxScaler()),
    ...                                   ('entrainement',
    ...                                    RandomForestRegressor())]),
    ...         n_jobs=-1,
    ...         param_grid={'entrainement__max_depth': range(1, 10),
    ...                     'entrainement__n_estimators': range(10, 50, 10),
    ...                     'imputation__strategy': ['mean', 'median',
    ...                                              'most_frequent']},
    ...         return_train_score=True)
    """

🧙‍♂️ Poetry

Gestion des dépendances : poetry simplifie la gestion des dépendances en utilisant un fichier de configuration pyproject.toml. Il permet de spécifier les dépendances directes et les dépendances de développement requises pour le projet.

Environnement Virtuel : venv isolé pour le projet, aidant à maintenir un environnement de développement propre et évitant les conflits entre les versions des packages.

Installation de dépendances : Facilite l’installation des dépendances définies dans le fichier de configuration en utilisant la commande poetry install.

py -m poetry install

🚢 Modulaire !

Séparation des composants du projet :

├───data
│   ├───🍷vins.json
│   ├───💾wine_links.csv
│   └───tables
│       ├───💾pred_classification.csv
│       ├───💾pred_regression.csv
│       ├───💾result_ml_classification.csv
│       └───💾result_ml_regression.csv
│       └───💾importance.csv
├───src
│   └───📦modules
│       ├───⚙app
│       │   ├───🐍st_functions.py
│       │   ├───🐍st_plots.py
│       │   ├───🐍st_selectors.py
│       │   ├───🐍st_tables.py
│       │   └───🐍st_tables.py
│       ├───⚙ml_models
│       │   ├───🐍importance_script.py
│       │   ├───🐍models.py
│       │   ├───🐍optimisation_script.py
│       │   ├───🐍prediction_script.py
│       │   └───🐍prediction.py
│       ├───⚙scraping
│       │   ├───🐍mystical_soup.py
│       │   ├───🐍page_scraper.py
│       │   ├───🐍scraping_functions.py
│       │   ├───🐍vin_dataclass.py
│       │   └───🐍wine_scraper.py
│       ├───🐍ml_trigger.py
│       ├───🐍scraping_trigger.py
│       ├───🐍bear_cleaner.py
│       └───🐍utils.py
├───🐳Dockerfile
├───🧙‍♂️poetry.lock
├───📍pyproject.toml
├───📘README.md
└───🐍streamlit_app.py

🐳 Docker, Partie I

Pourquoi utiliser Docker ?

Isolation : Docker permet d’isoler l’application, ses dépendances et son environnement d’exécution dans un conteneur. Cela signifie que l’application s’exécute avec ses propres ressources et dépendances sans affecter l’environnement hôte.

Portabilité : Une fois que l’image Docker est créée, elle peut être exécutée sur n’importe quel système prenant en charge Docker, offrant une portabilité élevée.

Comment ? ⇒ Dockerfile

Docker assure la reproductibilité en permettant à n’importe qui de construire et d’exécuter le même conteneur à partir des spécifications définies dans le Dockerfile.

🐳 Docker, Partie II

• Contenu du Dockerfile :

FROM python:3.10-slim-buster
WORKDIR /app

COPY pyproject.toml poetry.lock ./

RUN pip install poetry \ 
    && poetry config virtualenvs.create false \
    && poetry install --no-dev --no-interaction --no-ansi

COPY streamlit_app.py .
COPY src ./src
COPY data ./data
COPY img ./img

RUN addgroup --system app \
    && adduser --system --group app

USER app

EXPOSE 8501

HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health

ENTRYPOINT ["python", "-m", "streamlit", "run", "streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

🏗️ Le conteneur en action !

Il faut tout d’abord s’assurer d’avoir téléchargé Docker Desktop avant toute chose.

Une fois installé, l’image est construite en exécutant la commande suivante dans un terminal :

docker image build . -t "wine_scraping"

Une fois la création de l’image terminée, on peut consulter la taille de celle-ci avec :

docker images

Ensuite, pour lancer le conteneur Docker avec l’utilisateur app sur le port initial (8501) de streamlit, il suffit de faire :

docker run -u app -p 8501:8501 wine_scraping

🎉 Une fois le conteneur lancé, on le voit apparaitre dans Docker Desktop. Pour accéder à l’application, il faut se rendre sur http://localhost:8501/.

Fin

On ne sait pas pourquoi on a fait tout ça, car nous voulions simplement trouver une bouteille pour fêter notre anniversaire, et on se retrouve avec une application d’analyse de données qui ne nous aide en aucun cas à trouver notre breuvage…😵