Dispatch basé sur les données

Data-driven dispatch

Utilisation de l’apprentissage supervisé pour prédire les appels de service aux collisions de voitures à Chicago

Photo de Sawyer Bengtson sur Unsplash

Introduction

Dans le monde d’aujourd’hui où tout va vite, la nécessité de prendre des décisions basées sur les données dans les systèmes de réponse aux appels est devenue essentielle. Les répartiteurs effectuent une sorte de triage lorsqu’ils écoutent les appels, en donnant la priorité aux cas en fonction de leur gravité et de leur urgence, entre autres facteurs. Il est possible d’optimiser ce processus en exploitant la puissance des modèles d’apprentissage supervisé, afin de faire des prédictions plus précises sur la gravité des cas en collaboration avec l’évaluation d’un répartiteur humain.

Dans cet article, je vais présenter une solution que j’ai développée pour améliorer les prédictions des victimes et/ou des dommages matériels graves dans les collisions de voitures à Chicago. Des facteurs tels que l’emplacement de l’accident, les conditions routières, la limite de vitesse et l’heure de l’incident ont été pris en compte pour répondre à une question simple oui ou non : cet accident de voiture nécessitera-t-il une ambulance ou un dépanneur ?

Photo de Chris Dickens sur Unsplash

En résumé, l’objectif principal de cet outil d’apprentissage automatique est de classer les collisions qui nécessiteront probablement une intervention (médicale, dépannage, ou les deux) en se basant sur d’autres facteurs connus. En utilisant cet outil, les intervenants pourraient allouer efficacement leurs ressources dans différentes parties de la ville, en fonction de diverses conditions telles que la météo et l’heure de la journée.

Pour qu’un tel outil soit précis et efficace, il faudrait disposer d’une grande source de données pour faire des prédictions à partir des données historiques. Heureusement, la ville de Chicago dispose déjà d’une telle ressource (le portail de données de Chicago), donc ces données seront utilisées comme cas de test.

La mise en œuvre de ce type de modèles prédictifs améliorerait certainement la préparation et l’efficacité du temps de réponse lorsqu’il s’agit de collisions dans les rues de la ville. En comprenant les schémas et les tendances sous-jacentes des données sur les collisions, nous pouvons travailler à favoriser des environnements routiers plus sûrs et à optimiser les services d’urgence.

Je décris les détails du nettoyage des données, de la construction du modèle, de l’ajustement fin et de l’évaluation ci-dessous, avant d’analyser les résultats du modèle et de tirer des conclusions. Vous pouvez trouver un lien vers le dossier GitHub de ce projet, qui comprend un notebook Jupyter et un rapport plus complet sur le projet, ici.

Collecte et préparation des données

Configuration initiale

J’ai répertorié ci-dessous les bibliothèques d’analyse de données de base utilisées dans le projet ; des bibliothèques standard telles que pandas et numpy ont été utilisées tout au long du projet, ainsi que pyplot de matplotlib et seaborn pour la visualisation. J’ai également utilisé la bibliothèque missingno pour identifier les lacunes dans les données – je trouve cette bibliothèque incroyablement utile pour visualiser les données manquantes dans un ensemble de données, et je la recommande pour tout projet de science des données impliquant des dataframes :

#analyse de données générique import osimport pandas as pdfrom datetime import dateimport matplotlib.pyplot as pltimport numpy as npimport seaborn as snsimport missingno as msno

Les fonctions du module d’apprentissage automatique SciKit learn (sklearn) ont été importées pour construire le moteur d’apprentissage automatique. Ces fonctions sont présentées ici – je décrirai le but de chacune de ces fonctions dans la section du Modèle de Classification plus tard :

#Prétraitementfrom sklearn.preprocessing import LabelEncoderfrom sklearn.preprocessing import StandardScaler# Modèlesfrom sklearn.neighbors import KNeighborsClassifier# Rapportsfrom sklearn.model_selection import train_test_splitfrom sklearn.model_selection import RandomizedSearchCV#métriquesfrom sklearn.metrics import accuracy_scorefrom sklearn.metrics import f1_scorefrom sklearn.metrics import precision_scorefrom sklearn.metrics import recall_score

Les données pour ce projet ont toutes été importées à partir du portail de données de Chicago, à partir de deux sources :

  1. Accidents de la route : Jeu de données en direct sur les collisions de véhicules dans la région de Chicago. Les caractéristiques de cet ensemble de données sont des conditions enregistrées au moment de la collision, telles que les conditions météorologiques, l’alignement de la route, les données de latitude et de longitude, entre autres détails.
  2. Limites des districts de police : Un ensemble de données statique indiquant les limites des districts de la police de Chicago ; cet ensemble de données est utilisé pour compléter les informations sur les districts dans l’ensemble de données des accidents de la route. Il peut être joint à l’ensemble de données d’origine pour effectuer une analyse sur les districts avec le plus grand nombre de collisions.

Nettoyage des données

Avec les deux ensembles de données importés, ils peuvent maintenant être fusionnés pour ajouter les données de district à l’analyse finale. Cela est fait en utilisant la fonction .merge() de pandas — j’ai utilisé une jointure interne sur les deux dataframes pour capturer toutes les informations des deux, en utilisant les données de beat dans les deux comme clé de jointure (listées comme beat_of_occurrence dans l’ensemble de données des accidents de la circulation, et BEAT_NUM dans l’ensemble de données des zones de police) :

#joindre les données de collision aux données de beat - jointure interne
collisions = collision_raw.merge(beat_data, how='inner',
                                left_on='beat_of_occurrence',
                                right_on='BEAT_NUM'
                                )

Un coup d’œil rapide aux informations fournies par la fonction .info() montre un certain nombre de colonnes avec des données rares. Cela peut être visualisé en utilisant la fonction de matrice missingno :

#visualiser les données manquantes
#tri des valeurs par date de réception du rapport
collisions = collisions.sort_values(by='crash_date', ascending=True)
#tracé de la matrice des données manquantes
msno.matrix(collisions)
plt.show()
#informations sur les données triées
print(collisions.info())

Cela affiche une matrice des données manquantes dans toutes les colonnes, comme on peut le voir ici :

Ensemble de données non raffiné, avec plusieurs colonnes contenant un grand nombre de valeurs nulles

En supprimant les colonnes avec des données rares, un ensemble de données beaucoup plus propre peut être extrait ; les colonnes à supprimer sont définies dans une liste, puis supprimées de l’ensemble de données à l’aide de la fonction .drop() :

#définition des colonnes inutiles
drop_cols = ['location', 'crash_date_est_i','report_type', 'intersection_related_i',
             'hit_and_run_i', 'photos_taken_i', 'crash_date_est_i', 'injuries_unknown',
             'private_property_i', 'statements_taken_i', 'dooring_i', 'work_zone_i',
             'work_zone_type', 'workers_present_i','lane_cnt','the_geom','rd_no',
             'SECTOR','BEAT','BEAT_NUM']
#suppression des colonnes
collisions=collisions.drop(columns=drop_cols)
#tracé de la matrice des données manquantes
msno.matrix(collisions)
plt.show()
#informations sur les données triées
print(collisions.info())

Cela conduit à une matrice msno beaucoup plus propre :

Matrice msno de l'ensemble de données élagué

En examinant les données de latitude et de longitude, un petit nombre de lignes avaient des valeurs nulles, et d’autres avaient par erreur des valeurs nulles (probablement une erreur de saisie) :

Les colonnes de latitude et de longitude contiennent des valeurs nulles (voir min et max de chaque colonne)

Cela causerait des erreurs lors de l’entraînement du modèle, donc je les ai supprimées :

#Suppression des données incorrectes de lat/long - besoin de supprimer ces lignes
collisions = collisions[collisions['longitude']<-80]
collisions = collisions[collisions['latitude']>40]

Avec les données correctement nettoyées, j’ai pu avancer dans le développement du modèle de classification.

Modèle de classification

Analyse exploratoire des données

Avant de procéder au modèle d’apprentissage automatique, il est nécessaire de réaliser une analyse exploratoire des données (EDA) — chaque colonne du dataframe est représentée sous forme d’histogramme, avec des intervalles de 50 pour montrer la distribution des données. Les histogrammes sont utiles à l’étape de l’EDA pour plusieurs raisons, notamment parce qu’ils donnent un aperçu de la distribution des données, aident à identifier les valeurs aberrantes et finalement aident à prendre des décisions sur l’ingénierie des caractéristiques :

#tracé des histogrammes des valeurs numériques
collisions.hist(bins=50,figsize=(16,12))
plt.show()
Histogrammes des colonnes dans l'ensemble de données final

Un simple coup d’œil aux histogrammes des colonnes indique que les données de latitude sont bimodales, tandis que les données de longitude sont asymétriques à droite. Cela devra être normalisé afin de pouvoir être mieux appliqué à des fins d’apprentissage automatique.

Données de latitude-longitude sans mise à l'échelle

De plus, il semble que la colonne des heures de collision soit cyclique en nature – cela peut être transformé à l’aide d’une fonction trigonométrique (par exemple le sinus).

Données d'heure de collision non mises à l'échelle

Mise à l’échelle et transformation

La mise à l’échelle est une technique utilisée dans le prétraitement des données pour standardiser les caractéristiques afin qu’elles aient des magnitudes similaires. Cela est particulièrement important pour les modèles d’apprentissage automatique, car les modèles sont généralement sensibles à l’échelle des caractéristiques d’entrée. J’ai défini la fonction StandardScaler() pour agir en tant que mise à l’échelle dans ce modèle – cette fonction de mise à l’échelle transforme les données de manière à ce qu’elles aient une moyenne de 0 et un écart type de 1.

Pour les données présentant une distribution asymétrique ou bimodale, la mise à l’échelle peut être réalisée à l’aide de fonctions logarithmiques. Les fonctions logarithmiques rendent les données asymétriques plus symétriques et réduisent la queue des données – cela est utile lors de la manipulation de valeurs aberrantes. J’ai mis à l’échelle les données de latitude et de longitude de cette manière ; comme les données de longitude sont toutes négatives, le logarithme négatif a été calculé puis mis à l’échelle.

#mise à l'échelle des données de latitude et de longitudescaler = StandardScaler()# Transformation logarithmique sur la longitudecollisions_ml['neg_log_longitude'] = scaler.fit_transform(np.log1p(-collisions_ml['longitude']).                                                          values.reshape(-1,1))# Normalisation sur la latitudecollisions_ml['norm_latitude'] = scaler.fit_transform(np.log1p(collisions['latitude']).                                                      values.reshape(-1, 1))

Cela produit l’effet souhaité, comme on peut le voir ci-dessous :

Données de latitude-longitude mises à l'échelle

En comparaison, les données cycliques sont généralement mises à l’échelle à l’aide de fonctions trigonométriques telles que le sinus et le cosinus. Les données d’heure de collision semblent être approximativement cycliques d’après les observations précédentes, donc j’ai appliqué une fonction sinus aux données comme suit – puisque la fonction sin() de numpy est en radians, j’ai d’abord converti l’entrée en radians avant de calculer le sinus de l’entrée :

#transformation de l'heure de collision#les données sont cycliques, peuvent être encodées à l'aide de transformations trigonométriques#transformation trigonométrique - sin(crash_hr)collisions_ml['sin_hr'] = np.sin(2*np.pi*collisions_ml['crash_hour']/24)

L’histogramme des données transformées peut être vu ci-dessous :

Données d'heure de collision mises à l'échelle

Enfin, j’ai supprimé les données non mises à l’échelle du modèle pour éviter toute interférence avec les prédictions du modèle :

#suppression des colonnes de latitude/longitude précédenteslat_long_drop_cols = ['longitude','latitude']collisions_ml.drop(lat_long_drop_cols,axis=1,inplace=True)#suppression de la colonne crash_hourcollisions_ml.drop('crash_hour',axis=1,inplace=True)

Encodage des données

Une autre étape importante dans le prétraitement des données est l’encodage des données – il s’agit de représenter les données non numériques (par exemple les catégories) sous forme numérique, afin de les rendre compatibles avec les algorithmes d’apprentissage automatique. Pour les données catégorielles de ce modèle, j’ai utilisé une méthode appelée encodage par étiquettes – chaque catégorie dans une colonne se voit attribuer une valeur numérique avant d’être entrée dans le modèle. Un diagramme de ce processus est présenté ci-dessous :

Un exemple d'encodage par étiquettes (crédits à Zach M—source)

J’ai encodé les colonnes dans l’ensemble de données, en segmentant d’abord les colonnes que je voulais conserver à partir de l’ensemble de données d’origine et en créant une copie du dataframe (collisions_ml). J’ai ensuite défini les colonnes catégorielles dans une liste, et j’ai utilisé la fonction LabelEncoder() de sklearn pour ajuster et transformer les colonnes catégorielles :

#segmentation des colonnes en listes
ml_cols = ['posted_speed_limit','traffic_control_device', 'device_condition', 'weather_condition', 'lighting_condition', 'first_crash_type', 'trafficway_type','alignment', 'roadway_surface_cond', 'road_defect', 'crash_type','damage','prim_contributory_cause', 'sec_contributory_cause','street_direction','num_units', 'DISTRICT','crash_hour','crash_day_of_week','latitude', 'longitude']
cat_cols = ['traffic_control_device', 'device_condition', 'weather_condition', 'DISTRICT', 'lighting_condition', 'first_crash_type', 'trafficway_type','alignment', 'roadway_surface_cond', 'road_defect', 'crash_type','damage','prim_contributory_cause', 'sec_contributory_cause','street_direction','num_units']
#copie du dataset
collisions_ml = collisions[ml_cols].copy()
#encodage des valeurs catégorielles
label_encoder = LabelEncoder()
for col in collisions_ml[cat_cols].columns:
    collisions_ml[col] = label_encoder.fit_transform(collisions_ml[col])

Avec les données désormais suffisamment prétraitées, les données peuvent maintenant être divisées en données d’entraînement et de test, et un modèle de classification peut être ajusté aux données.

Division des données d’entraînement et de test

Il est important de séparer les données en ensembles d’entraînement et de test lors de la construction d’un modèle d’apprentissage automatique ; l’ensemble d’entraînement est une fraction des données initiales qui est utilisée pour entraîner le modèle sur les bonnes réponses, tandis que l’ensemble de test est utilisé pour évaluer les performances du modèle. Les maintenir séparés est nécessaire pour réduire le risque de surajustement et de biais du modèle.

J’ai séparé la colonne crash_type en utilisant la fonction drop() (les autres caractéristiques seront utilisées comme variables pour prédire crash_type), et j’ai défini crash_type comme le résultat y à prédire à l’aide du modèle. La fonction train_test_split de sklearn a été utilisée pour prendre 20% de l’ensemble de données initial comme données d’entraînement, le reste étant utilisé pour les tests du modèle.

#Création de l'ensemble de test
#définition des valeurs X et y
X = collisions_ml.drop('crash_type', axis=1)
y = collisions_ml['crash_type']
#division en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Classification des k-plus proches voisins

Pour ce projet, un modèle de classification des k-plus proches voisins (KNN) est utilisé pour prédire les résultats à partir des caractéristiques. Les modèles KNN fonctionnent en vérifiant la valeur des k valeurs connues les plus proches autour d’un point de données inconnu, puis en classifiant le point de données en fonction des valeurs de ces points “voisins”. C’est un classificateur non paramétrique, ce qui signifie qu’il ne fait aucune hypothèse sur la distribution des données sous-jacentes ; cependant, il est calculatoirement coûteux et peut être sensible aux valeurs aberrantes dans les données.

J’ai instancié le classificateur KNN avec un nombre initial de voisins (n_neighbors) égal à 3, en utilisant des mesures euclidiennes, avant d’ajuster le modèle aux données d’entraînement :

#Classificateur - K Plus Proches Voisins
#instanciation du classificateur KNN
KNNClassifier = KNeighborsClassifier(n_neighbors=3, metric = 'euclidean')
KNNClassifier.fit(X_train,y_train)

Une fois que le modèle a été ajusté aux données d’entraînement, j’ai effectué des prédictions sur les données de test comme suit :

#Prédictions
#prédictions sur l'ensemble d'entraînement
y_train_pred = KNNClassifier.predict(X_train)
#prédictions sur l'ensemble de test
y_test_pred = KNNClassifier.predict(X_test)

Évaluation

L’évaluation d’un modèle d’apprentissage automatique est généralement réalisée à l’aide de quatre mesures : l’exactitude (accuracy), la précision (precision), le rappel (recall) et le score F1. Les différences entre ces mesures sont très subtiles, mais en termes simples, ces termes peuvent être définis comme suit :

  1. Exactitude : le pourcentage de prédictions vraies positives parmi toutes les prédictions du modèle. En général, l’exactitude des données d’entraînement et de test doit être mesurée pour évaluer l’ajustement du modèle.
  2. Précision : le pourcentage de prédictions vraies positives parmi toutes les prédictions positives du modèle.
  3. Rappel : le pourcentage de prédictions vraies positives parmi tous les cas positifs dans l’ensemble de données.
  4. Score F1 : une mesure globale de la capacité du modèle à identifier les instances positives dans les données, combinant les scores de précision et de rappel.

J’ai calculé les métriques du modèle KNN en utilisant le code ci-dessous – j’ai également calculé la différence entre la précision du modèle sur l’ensemble d’entraînement et l’ensemble de test, pour évaluer l’ajustement :

#Évaluer le modèle# Calculer la précision du modèle# Calcul de la précision du modèle sur les données d'entraînementtrain_accuracy = accuracy_score(y_train, y_train_pred)# Calcul de la précision du modèle sur les données de testtest_accuracy = accuracy_score(y_test, y_test_pred)# Calcul des scores f1, de la précision et du rappelf1 = f1_score(y_test, y_test_pred)precision = precision_score(y_test, y_test_pred)recall = recall_score(y_test, y_test_pred)# Comparaison des performancesprint("Précision de l'entraînement :", train_accuracy)print("Précision du test :", test_accuracy)print("Différence de précision entre l'entraînement et le test :", train_accuracy-test_accuracy)# Affichage du score de précisionprint("Score de précision :", precision)# Affichage du score de rappelprint("Score de rappel :", recall)# Affichage du score f1print("Score f1 :", f1)

Les métriques initiales du modèle KNN sont les suivantes :

Métriques du modèle KNN lors de la 1ère itération

Le modèle a obtenu de bons résultats en termes de précision du test (79,6 %), de précision (82,1 %), de rappel (91,1 %) et de score f1 (86,3 %) – cependant, la précision du test était nettement supérieure à la précision de l’entraînement à 93,1 %, soit une différence de 13,5 %. Cela indique que le modèle surajuste les données, ce qui signifie qu’il aurait du mal à faire des prédictions précises sur des données inconnues. Par conséquent, le modèle doit être ajusté pour un meilleur ajustement – cela peut être fait en utilisant un processus appelé ajustement des hyperparamètres.

Ajustement des hyperparamètres

L’ajustement des hyperparamètres est le processus de sélection de l’ensemble optimal d’hyperparamètres pour un modèle d’apprentissage automatique. J’ai affiné le modèle en utilisant la validation croisée k-fold – il s’agit d’une technique de rééchantillonnage où les données sont divisées en k sous-ensembles (ou plis), puis chaque pli est utilisé à tour de rôle comme ensemble de validation tandis que les données restantes sont utilisées comme ensemble d’entraînement. Cette méthode est efficace pour réduire les risques de biais introduits dans le modèle par un choix particulier d’ensemble d’entraînement/test.

Les hyperparamètres du modèle KNN sont le nombre de voisins (n_neighbors) et la métrique de distance. Il existe plusieurs façons de mesurer la distance dans un classifieur KNN, mais ici j’ai examiné deux options :

  1. Euclidienne : Cela peut être considéré comme la distance en ligne droite entre deux points – c’est la métrique de distance la plus couramment utilisée.
  2. Manhattan : Aussi appelée distance “distance de bloc de la ville”, elle correspond à la somme des différences absolues entre les coordonnées de 2 points. Si vous imaginez vous tenir à un coin d’un immeuble de la ville et essayer de vous rendre à l’angle opposé – vous ne traverseriez pas l’immeuble pour vous rendre de l’autre côté, mais vous monteriez d’un bloc, puis traverseriez d’un bloc.

Notez que j’aurais également pu affiner le paramètre de poids (qui détermine si tous les voisins votent de manière égale ou si les voisins les plus proches sont plus importants), mais j’ai décidé de conserver un poids de vote uniforme.

J’ai défini une grille de paramètres avec n_neighbors à 3, 7 et 10, ainsi que les métriques Euclidienne ou Manhattan. J’ai ensuite instancié un algorithme RandomizedSearchCV, en passant le classifieur KNN en tant qu’estimateur, ainsi que la grille de paramètres. J’ai réglé l’algorithme pour diviser les données en 5 plis en définissant le paramètre cv sur 5 ; cela a ensuite été ajusté à l’ensemble d’entraînement. Un extrait du code pour cela peut être vu ci-dessous :

#Ajustement fin (RandomizedSearchCV)# Définir la grille de paramètresparam_grid = {    'n_neighbors': [3, 7, 10],    'metric': ['euclidean','manhattan']}# Instancier RandomizedSearchCVrandom_search = RandomizedSearchCV(estimator=KNeighborsClassifier(), param_distributions=param_grid, cv=5)# Ajustement des données d'entraînementrandom_search.fit(X_train, y_train)# Récupération du meilleur modèle et de ses performancesbest_classifier = random_search.best_estimator_best_accuracy = random_search.best_score_print("Meilleure précision :", best_accuracy)print("Meilleur modèle :", best_classifier)

La meilleure précision et le meilleur classifieur ont été récupérés à partir de l’algorithme, ce qui indique que le classifieur fonctionne mieux avec n_neighbors réglé sur 10 en utilisant la métrique de distance Manhattan, et que cela conduirait à un score de précision de 74,0 % :

Résultats de la validation croisée - le classificateur de recherche aléatoire recommande n_neighbors=10 en utilisant la distance de Manhattan

En tant que tels, ces paramètres ont été entrés dans le classificateur, et le modèle a été réentraîné :

#Classificateur - K plus proches voisins#instancier le classificateur KNNKNNClassifier = KNeighborsClassifier(n_neighbors=10, metric = 'manhattan')KNNClassifier.fit(X_train,y_train)

Les métriques de performance ont de nouveau été extraites du classificateur, de la même manière qu’auparavant – une capture d’écran des métriques pour cette itération peut être vue ci-dessous :

Métriques du modèle KNN ajusté

La validation croisée a conduit à des résultats légèrement moins bons pour toutes les métriques ; la précision du test a diminué de 2,6 %, la précision de 1,5 %, le rappel de 0,5 % et le score F1 de 1 %. Cependant, la différence entre l’exactitude de l’entraînement et du test est passée à 3,8 %, alors qu’elle était initialement de 13,5 %. Cela indique que le modèle ne surentraîne plus les données et est donc plus adapté à la prédiction de données invisibles.

Conclusion

En résumé, le classificateur KNN a bien fonctionné pour prédire si une collision nécessiterait un remorquage ou une ambulance. Les métriques initiales de la première itération du modèle étaient impressionnantes, cependant, la disparité entre l’exactitude du test et de l’entraînement indiquait un surentraînement. L’optimisation des hyperparamètres a permis d’améliorer le modèle, ce qui a réduit de manière significative l’écart entre les précisions des deux ensembles de données. Bien que les métriques de performance aient légèrement diminué pendant ce processus, l’avantage d’un modèle mieux ajusté l’emporte sur ces préoccupations.

Références

  1. Levy, J. (s.d.). Traffic Crashes – Crashes [Ensemble de données]. Récupéré depuis le Chicago Data Portal. Disponible sur : https://data.cityofchicago.org/Transportation/Traffic-Crashes-Crashes/85ca-t3if (Consulté le 14 mai 2023).
  2. Chicago Police Department. (s.d.). Boundaries – Police Beats (current) [Ensemble de données]. Récupéré depuis le Chicago Data Portal. Disponible sur : https://data.cityofchicago.org/Public-Safety/Boundaries-Police-Beats-current-/aerh-rz74 (Consulté le 14 mai 2023).
  3. Zach M. (2022). “Comment effectuer le codage des étiquettes en Python (avec exemple).” [En ligne]. Disponible sur : https://www.statology.org/label-encoding-in-python/ (Consulté le 19 juillet 2023).

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

AI

Maîtriser l'exécution des coroutines Yielding, Flow et cas d'utilisation pratique dans Unity

Explorez l'utilisation avancée des coroutines dans Unity à travers ce guide complet. Plongez dans les techniques de r...

AI

Exploration des services d'IA/ML basés sur le Cloud pour les dispositifs IoT Edge

L'IA et l'apprentissage automatique ont permis des avancées dans les voitures autonomes, les recherches sur le web et...

AI

Llama 2 Une plongée approfondie dans le challenger open-source de ChatGPT

Les grands modèles de langage (LLMs) capables de tâches de raisonnement complexe ont montré des promesses dans des do...

AI

10 Outils d'IA Qui Peuvent Générer du Code Pour Aider les Programmeurs

Dans une ère de possibilités infinies, l’utilisation généralisée et l’accessibilité révolutionnée des sol...

AI

Rédaction personnalisée de marketing utilisant LLMS pour le commerce électronique

Introduction Dans une ère définie par l’innovation technologique et la numérisation rapide, le commerce électro...

AI

Comment faire en sorte que l'IA écrive comme vous (Tutoriel Claude 2)

Vous pouvez rendre les réponses de Claude 2 bien plus humaines que celles de ChatGPT.