Pour essayer les exemples présents dans ce tutoriel :
Ce chapitre est issu du travail produit dans le cadre d’un hackathon de l’Insee avec Raphaële Adjerad et présente quelques éléments qui peuvent être utiles pour l’enrichissement de données d’entreprises à partir d’un répertoire officiel.
:warning: Il nécessite une version particulière du package elasticsearch pour tenir compte de l’héritage de la version 7 du moteur Elastic. Pour cela, faire
pip install elasticsearch==8.2.01 Introduction
Dans le cadre particulier de l’identification des entreprises, Elasticsearch fait partie de la solution retenue par l’API “Sirene données ouvertes” (DINUM) (cf https://annuaire-entreprises.data.gouv.fr/) l’API de recherche d’entreprises Française de la Fabrique numérique des Ministères Sociaux (cf https://api.recherche-entreprises.fabrique.social.gouv.fr/)le projet de l’Insee “Amélioration de l’identification de l’employeur dans le recensement”, pour faire une première sélection des établissements pertinents pour un bulletin de recensement donné. Dans le cadre de l’identification des individus, Elasticsearch fait partie de la solution envisagée pour l’identification des individus au RNIPP (Répertoire national des personnes physiques) pour le projet CSNS (Code statistique non signifiant), et est la solution technique sous-jacente au projet matchID du ministère de l’intérieur.
Au delà du secteur public, on peut citer qu’Amazon AWS fait partie des utilisateurs historiques d’Elasticsearch.
1.1 Objectif
Ce chapitre vise à approfondir les éléments présentés sur Elastic précédemment. L’idée est de se placer dans un contexte opérationnel où on reçoit des informations sur des entreprises telles que l’adresse et la localisation et qu’on désire associer à des données administratives considérées plus fliables.
1.2 Réplication de ce chapitre
Comme le précédent, ce chapitre est plus exigeant en termes d’infrastructures que les précédents. Il nécessite un serveur Elastic. Les utilisateurs du SSP Cloud pourront répliquer les exemples de ce cours car cette technologie est disponible (que ce soit pour indexer une base ou pour requêter une base existante).
La première partie de ce tutoriel, qui consiste à créer une base Sirene géolocalisée à partir des données open-data ne nécessite pas d’architecture particulière et peut ainsi être exécutée en utilisant les packages suivants :
import numpy as np
import pandas as pd1.3 Sources
Ce chapitre va utiliser plusieurs sources de diffusion de l’Insee:
- Le stock des établissements présents dans les données de diffusion Sirene ;
- Les données Sirene géolocalisées
Les données à siretiser sont celles du registre Français des émissions polluantes établi par le Ministère de la Transition Energétique. Le jeu de données est disponible sur data.gouv
2 Préparation des données à identifier
Le jeu de données présente déjà
l’identifiant
de l’établissement, dit numéro siret.
Nous allons faire comme si nous étions
en amont de cet appariement et que nous
désirons trouver ce numéro. La présence
dans la base de ce numéro nous permettra d’évaluer la qualité
de notre méthode de recherche avec
Elastic.
import requests
import zipfile
import pandas as pd
url = "https://www.data.gouv.fr/fr/datasets/r/9af639b9-e2b6-4d7d-8c5f-0c4953c48663"
req = requests.get(url)
with open("irep.zip", "wb") as f:
f.write(req.content)
with zipfile.ZipFile("irep.zip", "r") as zip_ref:
zip_ref.extractall("irep")
etablissements = pd.read_csv("irep/2019/etablissements.csv", sep=";")3 Constitution du référentiel administratif géolocalisé
Dans un premier temps, on va combiner ensemble les différentes sources open-data pour créer un référentiel fiable d’entreprises géolocalisées.
3.1 Importer la base déjà créée
Les données à utiliser pour constuire une base Sirene géolocalisée
sont trop volumineuses pour les serveurs mis à disposition
gratuitement par Github pour la compilation de ce site web.
Nous proposons ainsi une version déjà construite, stockée
dans l’espace de mise à disposition du SSP Cloud. Ce fichier est
au format parquet et est ouvert à
tous, même pour les personnes ne disposant pas d’un compte.
Le code ayant construit cette base est présenté ci-dessous.
Pour importer cette base, on utilise les fonctionalités
de pyarrow qui permettent d’importer un fichier sur
un système de stockage cloud comme s’il était
présent sur le disque :
from pyarrow import fs
import pyarrow as pa
import pyarrow.parquet as pq
bucket = "lgaliana"
path = "diffusion/sirene_geolocalized.parquet"
s3 = fs.S3FileSystem(endpoint_override="http://" + "minio.lab.sspcloud.fr")
df_geolocalized = (
pq.ParquetDataset(f"{bucket}/{path}", filesystem=s3).read_pandas().to_pandas()
)
df_geolocalized.head(3)3.2 Reproduire la construction de la base
La première base d’entrée à utiliser est disponible sur data.gouv
import requests
import zipfile
url_download = (
"https://www.data.gouv.fr/fr/datasets/r/0651fb76-bcf3-4f6a-a38d-bc04fa708576"
)
req = requests.get(url_download)
with open("sirene.zip", "wb") as f:
f.write(req.content)
with zipfile.ZipFile("sirene.zip", "r") as zip_ref:
zip_ref.extractall("sirene")On va importer seulement les colonnes utiles et simplifier la structure pour être en mesure de ne garder que les informations qui nous intéressent (nom de l’entreprise, adresse, commune, code postal…)
import pandas as pd
import numpy as np
list_cols = [
"siren",
"siret",
"activitePrincipaleRegistreMetiersEtablissement",
"complementAdresseEtablissement",
"numeroVoieEtablissement",
"typeVoieEtablissement",
"libelleVoieEtablissement",
"codePostalEtablissement",
"libelleCommuneEtablissement",
"codeCommuneEtablissement",
"etatAdministratifEtablissement",
"denominationUsuelleEtablissement",
"activitePrincipaleEtablissement",
]
df = pd.read_csv("sirene/StockEtablissement_utf8.csv", usecols=list_cols)
df["numero"] = (
df["numeroVoieEtablissement"]
.replace("-", np.NaN)
.str.split()
.str[0]
.str.extract("(\d+)", expand=False)
.fillna("0")
.astype(int)
)
df["numero"] = df["numero"].astype(str).replace("0", "")
df["adresse"] = (
df["numero"]
+ " "
+ df["typeVoieEtablissement"]
+ " "
+ df["libelleVoieEtablissement"]
)
df["adresse"] = df["adresse"].replace(np.nan, "")
df = df.loc[df["etatAdministratifEtablissement"] == "A"]
df.rename(
{
"denominationUsuelleEtablissement": "denom",
"libelleCommuneEtablissement": "commune",
"codeCommuneEtablissement": "code_commune",
"codePostalEtablissement": "code_postal",
},
axis="columns",
inplace=True,
)
df["ape"] = df["activitePrincipaleEtablissement"].str.replace("\.", "", regex=True)
df["denom"] = df["denom"].replace(np.nan, "")
df_siret = df.loc[
:,
[
"siren",
"siret",
"adresse",
"ape",
"denom",
"commune",
"code_commune",
"code_postal",
],
]
df_siret["code_postal"] = (
df_siret["code_postal"]
.replace(np.nan, "0")
.astype(int)
.astype(str)
.replace("0", "")
)On importe ensuite les données géolocalisées
import zipfile
import shutil
import os
# os.remove("sirene.zip")
# shutil.rmtree('sirene/')
url_geoloc = "https://files.data.gouv.fr/insee-sirene-geo/GeolocalisationEtablissement_Sirene_pour_etudes_statistiques_utf8.zip"
r = requests.get(url_geoloc)
with open("geoloc.zip", "wb") as f:
f.write(r.content)
with zipfile.ZipFile("geoloc.zip", "r") as zip_ref:
zip_ref.extractall("geoloc")
df_geoloc = pd.read_csv(
"geoloc/GeolocalisationEtablissement_Sirene_pour_etudes_statistiques_utf8.csv",
usecols=["siret", "epsg", "x_longitude", "y_latitude"],
sep=";",
)Il ne reste plus qu’à associer les deux jeux de données
df_geolocalized = df_siret.merge(df_geoloc, on="siret")
df_geolocalized["code_commune"] = df_geolocalized["code_commune"].astype(str)Si vous avez accès à un espace de stockage cloud de type
S3, il est possible d’utiliser pyarrow pour enregister
cette base. Afin de l’enregistrer dans un espace de stockage
public, nous allons l’enregistrer dans un dossier diffusion1
from pyarrow import fs
import pyarrow as pa
import pyarrow.parquet as pq
bucket = "lgaliana"
path = "diffusion/sirene_geolocalized.parquet"
s3 = fs.S3FileSystem(endpoint_override="http://" + "minio.lab.sspcloud.fr")
table = pa.Table.from_pandas(df_geolocalized)4 Connexion à ElasticSearch
On va supposer que l’utilisateur dispose déjà d’un serveur Elastic fonctionnel mais désire créer un nouvel index. Si vous utilisez le SSPCloud, la démarche de création d’un service Elastic est disponible dans le chapitre précédent.
from elasticsearch import Elasticsearch
HOST = "elasticsearch-master"
def elastic():
"""Connection avec Elastic sur le data lab"""
es = Elasticsearch(
[{"host": HOST, "port": 9200, "scheme": "http"}],
http_compress=True,
request_timeout=200,
)
return es
es = elastic()
es<Elasticsearch(['http://elasticsearch-master:9200'])>5 Indexation de notre base Sirène géolocalisée
5.1 Définition du mapping
On va procéder par étape en essayant d’utiliser la structure la plus simple possible.
:one: On s’occupe d’abord de définir le mapping pour les variables textuelles.
string_var = ["adresse", "denom", "ape", "commune"]
map_string = {
"type": "text",
"fields": {"keyword": {"type": "keyword", "ignore_above": 256}},
}
mapping_string = {l: map_string for l in string_var}:two: Les variables catégorielles sont utilisées
par le biais du type keyword:
# keywords
keyword_var = ["siren", "siret", "code_commune", "code_postal"]
map_keywords = {
"type": "text",
"fields": {"keyword": {"type": "keyword", "ignore_above": 256}},
}
mapping_keywords = {l: map_keywords for l in keyword_var}:three: La nouveauté par rapport à la partie
précédente est l’utilisation de la
dimension géographique. Elastic propose
le type geo_point pour cela.
# geoloc
mapping_geoloc = {"location": {"type": "geo_point"}}On collecte tout cela ensemble dans un dictionnaire:
# mapping
mapping_elastic = {
"mappings": {"properties": {**mapping_string, **mapping_geoloc, **mapping_keywords}}
}Il est tout à fait possible de définir un mapping plus raffiné. Ici, on va privilégier l’utilisation d’un mapping simple pour illustrer la recherche par distance géographique en priorité.
5.2 Création de l’index
Pour créer le nouvel index, on s’assure d’abord de ne pas déjà l’avoir créé et on passe le mapping défini précédemment.
if es.indices.exists("sirene"):
es.indices.delete("sirene")
es.indices.create(index="sirene", body=mapping_elastic)5.3 Indexation de la base géolocalisée
Pour le moment, l’index est vide. Il convient de le peupler.
Il est néanmoins nécessaire de créer le champ location
au format attendu par elastic: lat, lon à partir
de nos colonnes.
df_geolocalized["location"] = (
df_geolocalized["y_latitude"].astype(str)
+ ", "
+ df_geolocalized["x_longitude"].astype(str)
)La fonction suivante permet de structurer chaque
ligne du DataFrame telle qu’Elastic l’attend:
def gen_dict_from_pandas(index_name, df):
"""
Lit un dataframe pandas Open Food Facts, renvoi un itérable = dictionnaire des données à indexer, sous l'index fourni
"""
for i, row in df.iterrows():
header = {"_op_type": "index", "_index": index_name, "_id": i}
yield {**header, **row}Enfin, on peut industrialiser l’indexation
de notre DataFrame en faisant tourner de
manière successive cette fonction :
from elasticsearch.helpers import bulk, parallel_bulk
from collections import deque
deque(
parallel_bulk(
client=es,
actions=gen_dict_from_pandas("sirene", df_geolocalized),
chunk_size=1000,
thread_count=4,
)
)es.count(index="sirene")ObjectApiResponse({'count': 13059694, '_shards': {'total': 1, 'successful': 1, 'skipped': 0, 'failed': 0}})6 Recherche
Pour se faciliter la création de cartes réactives, nous allons régulièrement utiliser la fonction suivante qui s’appuie sur un code déjà présenté dans un autre chapitre.
def plot_folium_sirene(df, yvar, xvar):
center = df[[yvar, xvar]].mean().values.tolist()
sw = df[[yvar, xvar]].min().values.tolist()
ne = df[[yvar, xvar]].max().values.tolist()
m = folium.Map(location=center, tiles="OpenStreetMap")
# I can add marker one by one on the map
for i in range(0, len(df)):
folium.Marker(
[df.iloc[i][yvar], df.iloc[i][xvar]],
popup=df.iloc[i]["_source.denom"]
+ f'<br>(Score: {df.iloc[i]["_score"]:.2f})',
icon=folium.Icon(icon="home"),
).add_to(m)
m.fit_bounds([sw, ne])
return m6.1 Premier exemple de requête géographique
ex1 = es.search(
index="sirene",
body="""{
"query": {
"bool": {
"must":
{ "match": { "denom": "institut national de la statistique"}}
}
}
}
""",
)["hits"]["hits"]
echo_insee = pd.json_normalize(ex1)
echo_inseeOn remarque déjà que les intitulés ne sont pas bons. Quand est-il de leurs localisations ?
plot_folium_sirene(echo_insee, yvar="_source.y_latitude", xvar="_source.x_longitude")Ce premier essai nous suggère qu’il est nécessaire d’améliorer notre recherche. Plusieurs voies sont possibles:
- Améliorer le preprocessing de nos champs textuels en excluant, par exemple, les stopwords ;
- Effectuer une restriction géographique pour mieux cibler l’ensemble de recherche
- Trouver une variable catégorielle jouant le rôle de variable de blocage2 pour mieux cibler les paires pertinentes
Concernant la restriction géographique, Elastic fournit une approche très efficace de ciblage géographique. En connaissant une position approximative de l’entreprise à rechercher, il est ainsi possible de rechercher dans un rayon d’une taille plus ou moins grande. En supposant qu’on connaisse précisément la localisation de l’Insee, on peut chercher dans un rayon relativement restreint. Si notre position était plus approximative, on pourrait rechercher dans un rayon plus large.
ex2 = es.search(
index="sirene",
body="""{
"query": {
"bool": {
"must":
{ "match": { "denom": "institut national de la statistique"}}
,
"filter":
{"geo_distance": {
"distance": "1km",
"location": {
"lat": "48.8168",
"lon": "2.3099"
}
}
}
}
}
}
""",
)["hits"]["hits"]
echo_insee = pd.json_normalize(ex2)
echo_inseeHint
Connaître la localisation précise d’une entreprise nécessite déjà une bonne remontée d’information sur celle-ci. Il est plus plausible de supposer qu’on dispose, dans une phase amont de la chaine de production, de l’adresse de celle-ci. Dans ce cas, il est utile d’utiliser un service de géocodage, comme l’API Adresse développée par Etalab.
Les résultats sont par construction mieux ciblés. Néanmoins ils sont toujours décevants puisqu’on ne parvient pas à identifier l’Insee dans les dix meilleurs échos.
specificsearch = es.search(
index="sirus_2020",
body="""{
"query": {
"bool": {
"should":
{ "match": { "rs_denom": "CPCU - CENTRALE DE BERCY"}},
"filter": [
{"geo_distance": {
"distance": "0.5km",
"location": {
"lat": "48.84329",
"lon": "2.37396"
}
}
},
{ "prefix": { "apet": "3530" }}
]
}
}
}""",
)Informations additionnelles
environment files have been tested on.
Latest built version: 2024-04-27
Python version used:
'3.11.6 | packaged by conda-forge | (main, Oct 3 2023, 10:40:35) [GCC 12.3.0]'| Package | Version |
|---|---|
| affine | 2.4.0 |
| aiobotocore | 2.12.2 |
| aiohttp | 3.9.3 |
| aioitertools | 0.11.0 |
| aiosignal | 1.3.1 |
| alembic | 1.13.1 |
| aniso8601 | 9.0.1 |
| annotated-types | 0.6.0 |
| appdirs | 1.4.4 |
| archspec | 0.2.3 |
| astroid | 3.1.0 |
| asttokens | 2.4.1 |
| attrs | 23.2.0 |
| Babel | 2.14.0 |
| bcrypt | 4.1.2 |
| beautifulsoup4 | 4.12.3 |
| black | 24.4.2 |
| blinker | 1.7.0 |
| blis | 0.7.11 |
| bokeh | 3.4.0 |
| boltons | 23.1.1 |
| boto3 | 1.34.51 |
| botocore | 1.34.51 |
| branca | 0.7.1 |
| Brotli | 1.1.0 |
| cachetools | 5.3.3 |
| cartiflette | 0.0.2 |
| Cartopy | 0.23.0 |
| catalogue | 2.0.10 |
| cattrs | 23.2.3 |
| certifi | 2024.2.2 |
| cffi | 1.16.0 |
| charset-normalizer | 3.3.2 |
| chromedriver-autoinstaller | 0.6.4 |
| click | 8.1.7 |
| click-plugins | 1.1.1 |
| cligj | 0.7.2 |
| cloudpathlib | 0.16.0 |
| cloudpickle | 3.0.0 |
| colorama | 0.4.6 |
| comm | 0.2.2 |
| commonmark | 0.9.1 |
| conda | 24.3.0 |
| conda-libmamba-solver | 24.1.0 |
| conda-package-handling | 2.2.0 |
| conda_package_streaming | 0.9.0 |
| confection | 0.1.4 |
| contextily | 1.6.0 |
| contourpy | 1.2.1 |
| cryptography | 42.0.5 |
| cycler | 0.12.1 |
| cymem | 2.0.8 |
| cytoolz | 0.12.3 |
| dask | 2024.4.1 |
| dask-expr | 1.0.10 |
| debugpy | 1.8.1 |
| decorator | 5.1.1 |
| dill | 0.3.8 |
| distributed | 2024.4.1 |
| distro | 1.9.0 |
| docker | 7.0.0 |
| duckdb | 0.10.1 |
| en-core-web-sm | 3.7.1 |
| entrypoints | 0.4 |
| et-xmlfile | 1.1.0 |
| exceptiongroup | 1.2.0 |
| executing | 2.0.1 |
| fastjsonschema | 2.19.1 |
| fiona | 1.9.6 |
| flake8 | 7.0.0 |
| Flask | 3.0.2 |
| folium | 0.16.0 |
| fontawesomefree | 6.5.1 |
| fonttools | 4.51.0 |
| fr-core-news-sm | 3.7.0 |
| frozenlist | 1.4.1 |
| fsspec | 2023.12.2 |
| GDAL | 3.8.4 |
| gensim | 4.3.2 |
| geographiclib | 2.0 |
| geopandas | 0.12.2 |
| geoplot | 0.5.1 |
| geopy | 2.4.1 |
| gitdb | 4.0.11 |
| GitPython | 3.1.43 |
| google-auth | 2.29.0 |
| graphene | 3.3 |
| graphql-core | 3.2.3 |
| graphql-relay | 3.2.0 |
| graphviz | 0.20.3 |
| great-tables | 0.5.0 |
| greenlet | 3.0.3 |
| gunicorn | 21.2.0 |
| h11 | 0.14.0 |
| htmltools | 0.5.1 |
| hvac | 2.1.0 |
| idna | 3.6 |
| imageio | 2.34.1 |
| importlib_metadata | 7.1.0 |
| importlib_resources | 6.4.0 |
| inflate64 | 1.0.0 |
| ipykernel | 6.29.3 |
| ipython | 8.22.2 |
| ipywidgets | 8.1.2 |
| isort | 5.13.2 |
| itsdangerous | 2.1.2 |
| jedi | 0.19.1 |
| Jinja2 | 3.1.3 |
| jmespath | 1.0.1 |
| joblib | 1.3.2 |
| jsonpatch | 1.33 |
| jsonpointer | 2.4 |
| jsonschema | 4.21.1 |
| jsonschema-specifications | 2023.12.1 |
| jupyter-cache | 1.0.0 |
| jupyter_client | 8.6.1 |
| jupyter_core | 5.7.2 |
| jupyterlab_widgets | 3.0.10 |
| kaleido | 0.2.1 |
| kiwisolver | 1.4.5 |
| kubernetes | 29.0.0 |
| langcodes | 3.4.0 |
| language_data | 1.2.0 |
| lazy_loader | 0.4 |
| libmambapy | 1.5.7 |
| llvmlite | 0.42.0 |
| locket | 1.0.0 |
| lxml | 5.2.1 |
| lz4 | 4.3.3 |
| Mako | 1.3.2 |
| mamba | 1.5.7 |
| mapclassify | 2.6.1 |
| marisa-trie | 1.1.0 |
| Markdown | 3.6 |
| MarkupSafe | 2.1.5 |
| matplotlib | 3.8.3 |
| matplotlib-inline | 0.1.6 |
| mccabe | 0.7.0 |
| menuinst | 2.0.2 |
| mercantile | 1.2.1 |
| mizani | 0.11.2 |
| mlflow | 2.11.3 |
| mlflow-skinny | 2.11.3 |
| msgpack | 1.0.7 |
| multidict | 6.0.5 |
| multivolumefile | 0.2.3 |
| munkres | 1.1.4 |
| murmurhash | 1.0.10 |
| mypy | 1.9.0 |
| mypy-extensions | 1.0.0 |
| nbclient | 0.10.0 |
| nbformat | 5.10.4 |
| nest_asyncio | 1.6.0 |
| networkx | 3.3 |
| nltk | 3.8.1 |
| numba | 0.59.1 |
| numpy | 1.26.4 |
| oauthlib | 3.2.2 |
| opencv-python-headless | 4.9.0.80 |
| openpyxl | 3.1.2 |
| outcome | 1.3.0.post0 |
| OWSLib | 0.28.1 |
| packaging | 23.2 |
| pandas | 2.2.1 |
| paramiko | 3.4.0 |
| parso | 0.8.4 |
| partd | 1.4.1 |
| pathspec | 0.12.1 |
| patsy | 0.5.6 |
| Pebble | 5.0.7 |
| pexpect | 4.9.0 |
| pickleshare | 0.7.5 |
| pillow | 10.3.0 |
| pip | 24.0 |
| pkgutil_resolve_name | 1.3.10 |
| platformdirs | 4.2.0 |
| plotly | 5.19.0 |
| plotnine | 0.13.5 |
| pluggy | 1.4.0 |
| polars | 0.20.18 |
| preshed | 3.0.9 |
| prometheus_client | 0.20.0 |
| prometheus-flask-exporter | 0.23.0 |
| prompt-toolkit | 3.0.42 |
| protobuf | 4.25.3 |
| psutil | 5.9.8 |
| ptyprocess | 0.7.0 |
| pure-eval | 0.2.2 |
| py7zr | 0.20.8 |
| pyarrow | 15.0.0 |
| pyarrow-hotfix | 0.6 |
| pyasn1 | 0.5.1 |
| pyasn1-modules | 0.3.0 |
| pybcj | 1.0.2 |
| pycodestyle | 2.11.1 |
| pycosat | 0.6.6 |
| pycparser | 2.21 |
| pycryptodomex | 3.20.0 |
| pydantic | 2.7.1 |
| pydantic_core | 2.18.2 |
| pyflakes | 3.2.0 |
| Pygments | 2.17.2 |
| PyJWT | 2.8.0 |
| pylint | 3.1.0 |
| PyNaCl | 1.5.0 |
| pynsee | 0.1.7 |
| pyOpenSSL | 24.0.0 |
| pyparsing | 3.1.2 |
| pyppmd | 1.1.0 |
| pyproj | 3.6.1 |
| pyshp | 2.3.1 |
| PySocks | 1.7.1 |
| python-dateutil | 2.9.0 |
| python-dotenv | 1.0.1 |
| python-magic | 0.4.27 |
| pytz | 2024.1 |
| pyu2f | 0.1.5 |
| pywaffle | 1.1.0 |
| PyYAML | 6.0.1 |
| pyzmq | 25.1.2 |
| pyzstd | 0.15.10 |
| QtPy | 2.4.1 |
| querystring-parser | 1.2.4 |
| rasterio | 1.3.10 |
| referencing | 0.34.0 |
| regex | 2023.12.25 |
| requests | 2.31.0 |
| requests-cache | 1.2.0 |
| requests-oauthlib | 2.0.0 |
| rpds-py | 0.18.0 |
| rsa | 4.9 |
| Rtree | 1.2.0 |
| ruamel.yaml | 0.18.6 |
| ruamel.yaml.clib | 0.2.8 |
| s3fs | 2023.12.2 |
| s3transfer | 0.10.1 |
| scikit-image | 0.23.2 |
| scikit-learn | 1.4.1.post1 |
| scipy | 1.13.0 |
| seaborn | 0.13.2 |
| selenium | 4.20.0 |
| setuptools | 69.2.0 |
| shapely | 2.0.3 |
| six | 1.16.0 |
| smart-open | 6.4.0 |
| smmap | 5.0.0 |
| sniffio | 1.3.1 |
| snuggs | 1.4.7 |
| sortedcontainers | 2.4.0 |
| soupsieve | 2.5 |
| spacy | 3.7.4 |
| spacy-legacy | 3.0.12 |
| spacy-loggers | 1.0.5 |
| SQLAlchemy | 2.0.29 |
| sqlparse | 0.4.4 |
| srsly | 2.4.8 |
| stack-data | 0.6.2 |
| statsmodels | 0.14.1 |
| tabulate | 0.9.0 |
| tblib | 3.0.0 |
| tenacity | 8.2.3 |
| texttable | 1.7.0 |
| thinc | 8.2.3 |
| threadpoolctl | 3.4.0 |
| tifffile | 2024.4.24 |
| tomli | 2.0.1 |
| tomlkit | 0.12.4 |
| toolz | 0.12.1 |
| topojson | 1.8 |
| tornado | 6.4 |
| tqdm | 4.66.2 |
| traitlets | 5.14.2 |
| trio | 0.25.0 |
| trio-websocket | 0.11.1 |
| truststore | 0.8.0 |
| typer | 0.9.4 |
| typing_extensions | 4.11.0 |
| tzdata | 2024.1 |
| Unidecode | 1.3.8 |
| url-normalize | 1.4.3 |
| urllib3 | 1.26.18 |
| wasabi | 1.1.2 |
| wcwidth | 0.2.13 |
| weasel | 0.3.4 |
| webcolors | 1.13 |
| webdriver-manager | 4.0.1 |
| websocket-client | 1.7.0 |
| Werkzeug | 3.0.2 |
| wheel | 0.43.0 |
| widgetsnbextension | 4.0.10 |
| wordcloud | 1.9.3 |
| wrapt | 1.16.0 |
| wsproto | 1.2.0 |
| xgboost | 2.0.3 |
| xlrd | 2.0.1 |
| xyzservices | 2024.4.0 |
| yarl | 1.9.4 |
| yellowbrick | 1.5 |
| zict | 3.0.0 |
| zipp | 3.17.0 |
| zstandard | 0.22.0 |
View file history
| SHA | Date | Author | Description |
|---|---|---|---|
| 005d89b | 2023-12-20 17:23:04 | Lino Galiana | Finalise l’affichage des statistiques Git (#478) |
| 3fba612 | 2023-12-17 18:16:42 | Lino Galiana | Remove some badges from python (#476) |
| 1f23de2 | 2023-12-01 17:25:36 | Lino Galiana | Stockage des images sur S3 (#466) |
| a06a268 | 2023-11-23 18:23:28 | Antoine Palazzolo | 2ème relectures chapitres ML (#457) |
| b68369d | 2023-11-18 18:21:13 | Lino Galiana | Reprise du chapitre sur la classification (#455) |
| 889a71b | 2023-11-10 11:40:51 | Antoine Palazzolo | Modification TP 3 (#443) |
| 652009d | 2023-10-09 13:56:34 | Lino Galiana | Finalise le cleaning (#430) |
| 154f09e | 2023-09-26 14:59:11 | Antoine Palazzolo | Des typos corrigées par Antoine (#411) |
| 9977c5d | 2023-08-28 10:43:36 | Lino Galiana | Fix bug path pandas (#397) |
| 3bdf3b0 | 2023-08-25 11:23:02 | Lino Galiana | Simplification de la structure 🤓 (#393) |
| 29ff3f5 | 2023-07-07 14:17:53 | linogaliana | description everywhere |
| f10815b | 2022-08-25 16:00:03 | Lino Galiana | Notebooks should now look more beautiful (#260) |
| bacb5a0 | 2022-07-04 19:05:20 | Lino Galiana | Enrichir la partie elastic (#241) |
Footnotes
Concernant la première piste, il aurait fallu mieux définir notre mapping pour autoriser des analyzers. A défaut, nous pourrons utiliser
nltkouspacypour transformer les champs textuels avant d’envoyer la requête. Cette solution présente l’inconvénient de ne pas formatter de la même manière l’ensemble indexé mais pourrait malgré tout améliorer la pertinence des recherches.↩︎Concernant la première piste, il aurait fallu mieux définir notre mapping pour autoriser des analyzers. A défaut, nous pourrons utiliser
nltkouspacypour transformer les champs textuels avant d’envoyer la requête. Cette solution présente l’inconvénient de ne pas formatter de la même manière l’ensemble indexé mais pourrait malgré tout améliorer la pertinence des recherches.↩︎
Citation
BibTeX citation:
@book{galiana2023,
author = {Galiana, Lino},
title = {Python Pour La Data Science},
date = {2023},
url = {https://pythonds.linogaliana.fr/},
doi = {10.5281/zenodo.8229676},
langid = {en}
}
For attribution, please cite this work as:
Galiana, Lino. 2023. Python Pour La Data Science. https://doi.org/10.5281/zenodo.8229676.