Applications de l'apprentissage automatique
Les applications de l'apprentissage automatique peuvent être divisées en plusieurs grands domaines, chacun ayant ses propres scénarios d'application et défis uniques :
- Vision par ordinateur: Permettre aux machines de « voir » le monde
- Traitement du langage naturel: Permettre aux machines de « comprendre » le langage humain
- Systèmes de recommandation: Recommandations de contenu personnalisées
- Analyse prédictive: Prédire les tendances et les résultats futurs
- Détection d'anomalies: Découvrir des motifs inhabituels
Pourquoi ces applications ont-elles besoin de l'apprentissage automatique ?
Imaginez utiliser des méthodes de programmation traditionnelles pour résoudre ces problèmes :
- Reconnaissance faciale: Nécessiterait d'écrire d'innombrables règles pour décrire les diverses variations des visages (angle, éclairage, expression, etc.)
- Traduction de langues: Nécessiterait de compiler d'énormes dictionnaires et règles de grammaire pour chaque paire de langues
- Systèmes de recommandation: Nécessiterait d'analyser manuellement les préférences de chaque utilisateur et les caractéristiques de chaque produit
L'apprentissage automatique permet aux ordinateurs d'apprendre automatiquement ces motifs complexes à partir de grandes quantités de données, ce qui simplifie grandement le processus de résolution de problèmes.
Applications de vision par ordinateur
Reconnaissance faciale
Scénarios d'application: Déverrouillage du téléphone, systèmes de contrôle d'accès, vérification d'identité
Fonctionnement：
- Détecter les positions des visages dans les images
- Extraire les caractéristiques faciales (distance entre les yeux, forme du nez, etc.)
- Comparer avec les caractéristiques faciales dans la base de données
Conduite autonome
Scénarios d'application: Tesla Autopilot, Baidu Apollo, Google Waymo
Tâches principales：
- Détection d'objets: Identifier les véhicules, les piétons, les panneaux de signalisation
- Détection de voies: Déterminer les limites de voie
- Planification de trajectoire: Décider des itinéraires de conduite
Exemples
# Exemple de détection d'objets en conduite autonome (code conceptuel)
import cv2
import numpy as np
def detect_objects(image):
"""
Détecter des objets dans les images (véhicules, piétons, panneaux de signalisation, etc.)
"""
# 1. Prétraiter l'image
processed_image = preprocess_image(image)
# 2. Utiliser un modèle d'apprentissage profond entraîné pour détecter des objets
# Ici, un modèle YOLO pré-entraîné est utilisé à titre d'exemple
boxes, classes, scores = yolo_model.detect(processed_image)
# 3. Filtrer les résultats de détection à faible confiance
valid_detections = filter_detections(boxes, classes, scores)
# 4. Dessiner les résultats de détection sur l'image
result_image = draw_detections(image, valid_detections)
return result_image, valid_detections
# En pratique, ce n'est qu'un seul composant de l'ensemble du système de conduite autonome
# Il doit également intégrer plusieurs modules tels que la fusion de capteurs et la planification de trajectoire
import cv2
import numpy as np
def detect_objects(image):
"""
Détecter des objets dans les images (véhicules, piétons, panneaux de signalisation, etc.)
"""
# 1. Prétraiter l'image
processed_image = preprocess_image(image)
# 2. Utiliser un modèle d'apprentissage profond entraîné pour détecter des objets
# Ici, un modèle YOLO pré-entraîné est utilisé à titre d'exemple
boxes, classes, scores = yolo_model.detect(processed_image)
# 3. Filtrer les résultats de détection à faible confiance
valid_detections = filter_detections(boxes, classes, scores)
# 4. Dessiner les résultats de détection sur l'image
result_image = draw_detections(image, valid_detections)
return result_image, valid_detections
# En pratique, ce n'est qu'un seul composant de l'ensemble du système de conduite autonome
# Il doit également intégrer plusieurs modules tels que la fusion de capteurs et la planification de trajectoire
Diagnostic d'imagerie médicale
Scénarios d'application: analyse par rayons X, scanners CT, analyse de lames pathologiques
Avantages：
- Moins de fatigue que les médecins humains
- Peut détecter des changements subtils que l'œil humain a du mal à remarquer
- Peut traiter rapidement de grands volumes d'images
Applications de traitement du langage naturel
Assistants intelligents
Scénarios d'application: Siri, Xiao Ai, Tmall Genie
Fonctionnalités principales：
- Reconnaissance vocale: Convertir la parole en texte
- Compréhension de l'intention: Comprendre ce que l'utilisateur veut
- Gestion du dialogue: Maintenir des conversations cohérentes
Exemples
# Flux de travail d'un assistant intelligent (exemple simplifié)
import speech_recognition as sr
from textblob import TextBlob
class SmartAssistant:
def __init__(self):
self.recognizer = sr.Recognizer()
def listen_and_respond(self):
"""Écouter la parole de l'utilisateur et répondre"""
with sr.Microphone() as source:
print("Écoute...")
audio = self.recognizer.listen(source)
try:
# 1. Reconnaissance vocale
text = self.recognizer.recognize_google(audio, language='zh-CN')
print(f"L'utilisateur a dit : {text}")
# 2. Compréhension de l'intention
intent = self.understand_intent(text)
# 3. Génération de la réponse
response = self.generate_response(intent, text)
print(f"Réponse de l'assistant : {response}")
return response
except sr.UnknownValueError:
return "Désolé, je ne vous ai pas bien entendu, veuillez le répéter"
def understand_intent(self, text):
"""Comprendre l'intention de l'utilisateur"""
# Reconnaissance d'intention simplifiée
if "weather" in text:
return "weather"
elif "time" in text:
return "time"
elif "joke" in text:
return "joke"
else:
return "unknown"
def generate_response(self, intent, text):
"""Générer une réponse en fonction de l'intention"""
if intent == "weather":
return "Il y a du soleil aujourd'hui, 25 degrés"
elif intent == "time":
from datetime import datetime
return f"L'heure actuelle est {datetime.now().strftime('%H:%M')}"
elif intent == "joke":
return "Pourquoi les programmeurs aiment-ils l'obscurité ? Parce qu'il n'y a pas de bugs !"
else:
return "Désolé, j'apprends encore et je ne comprends pas cette question"
# Exemple d'utilisation
assistant = SmartAssistant()
# assistant.listen_and_respond() # Décommenter lors de l'exécution réelle
import speech_recognition as sr
from textblob import TextBlob
class SmartAssistant:
def __init__(self):
self.recognizer = sr.Recognizer()
def listen_and_respond(self):
"""Écouter la parole de l'utilisateur et répondre"""
with sr.Microphone() as source:
print("Écoute...")
audio = self.recognizer.listen(source)
try:
# 1. Reconnaissance vocale
text = self.recognizer.recognize_google(audio, language='zh-CN')
print(f"L'utilisateur a dit : {text}")
# 2. Compréhension de l'intention
intent = self.understand_intent(text)
# 3. Génération de la réponse
response = self.generate_response(intent, text)
print(f"Réponse de l'assistant : {response}")
return response
except sr.UnknownValueError:
return "Désolé, je ne vous ai pas bien entendu, veuillez le répéter"
def understand_intent(self, text):
"""Comprendre l'intention de l'utilisateur"""
# Reconnaissance d'intention simplifiée
if "weather" in text:
return "weather"
elif "time" in text:
return "time"
elif "joke" in text:
return "joke"
else:
return "unknown"
def generate_response(self, intent, text):
"""Générer une réponse en fonction de l'intention"""
if intent == "weather":
return "Il y a du soleil aujourd'hui, 25 degrés"
elif intent == "time":
from datetime import datetime
return f"L'heure actuelle est {datetime.now().strftime('%H:%M')}"
elif intent == "joke":
return "Pourquoi les programmeurs aiment-ils l'obscurité ? Parce qu'il n'y a pas de bugs !"
else:
return "Désolé, j'apprends encore et je ne comprends pas cette question"
# Exemple d'utilisation
assistant = SmartAssistant()
# assistant.listen_and_respond() # Décommenter lors de l'exécution réelle
Traduction automatique
Scénarios d'application: Google Translate, Baidu Translate, Youdao Translate
Fonctionnement：
- Encoder le texte de la langue source en représentations numériques
- Apprendre les relations de correspondance entre les langues via des réseaux de neurones
- Décoder en texte de langue cible
Analyse de sentiments
Scénarios d'application: analyse d'avis produits, surveillance des médias sociaux, traitement des retours clients
Exemples
# Exemple d'analyse de sentiment
from textblob import TextBlob
import jieba
def analyze_sentiment_chinese(text):
"""
Exemple d'analyse de sentiment en chinois
"""
# Utilisation de jieba pour la segmentation des mots
words = jieba.cut(text)
word_list = " ".join(words)
# Simplifié ici ; les applications réelles nécessitent des modèles dédiés d'analyse de sentiment en chinois
# On peut utiliser des bibliothèques comme SnowNLP, BERT-Chinese, etc.
# Simuler les résultats d'analyse de sentiment
positive_words = ["good", "great", "like", "satisfait", "recommande"]
negative_words = ["médiocre", "mauvais", "déteste", "déçu", "non recommandé"]
pos_count = sum(1 for word in positive_words if word in text)
neg_count = sum(1 for word in negative_words if word in text)
if pos_count > neg_count:
return "sentiment positif"
elif neg_count > pos_count:
return "sentiment négatif"
else:
return "sentiment neutre"
# Exemples de tests
reviews = [
"Ce produit est vraiment génial, je l'aime vraiment!",
"La qualité est trop mauvaise, cela ne vaut absolument pas l'achat.",
"C'est correct, rien de spécial."
]
for review in reviews:
sentiment = analyze_sentiment_chinese(review)
print(f"Avis: {review}")
print(f"Sentiment: {sentiment}")
print("---")
from textblob import TextBlob
import jieba
def analyze_sentiment_chinese(text):
"""
Exemple d'analyse de sentiment en chinois
"""
# Utilisation de jieba pour la segmentation des mots
words = jieba.cut(text)
word_list = " ".join(words)
# Simplifié ici ; les applications réelles nécessitent des modèles dédiés d'analyse de sentiment en chinois
# On peut utiliser des bibliothèques comme SnowNLP, BERT-Chinese, etc.
# Simuler les résultats d'analyse de sentiment
positive_words = ["good", "great", "like", "satisfait", "recommande"]
negative_words = ["médiocre", "mauvais", "déteste", "déçu", "non recommandé"]
pos_count = sum(1 for word in positive_words if word in text)
neg_count = sum(1 for word in negative_words if word in text)
if pos_count > neg_count:
return "sentiment positif"
elif neg_count > pos_count:
return "sentiment négatif"
else:
return "sentiment neutre"
# Exemples de tests
reviews = [
"Ce produit est vraiment génial, je l'aime vraiment!",
"La qualité est trop mauvaise, cela ne vaut absolument pas l'achat.",
"C'est correct, rien de spécial."
]
for review in reviews:
sentiment = analyze_sentiment_chinese(review)
print(f"Avis: {review}")
print(f"Sentiment: {sentiment}")
print("---")
Applications des systèmes de recommandation
Recommandations e-commerce
Scénarios d'application: recommandations de produits Taobao, recommandations Amazon
Stratégies de recommandation：
- Filtrage collaboratif: Recommander en fonction de la similarité du comportement des utilisateurs
- Recommandation basée sur le contenu: Recommander en fonction de la similarité des caractéristiques des produits
- Recommandation hybride: Combiner plusieurs stratégies
Exemples
# Exemple simple de recommandation par filtrage collaboratif
import numpy as np
# Matrice de notes utilisateur-article (les lignes sont les utilisateurs, les colonnes sont les articles)
ratings = np.array([
[5, 3, 0, 1], # Notes de l'utilisateur 1 pour les articles 1, 2, 4
[4, 0, 0, 1], # Notes de l'utilisateur 2 pour les articles 1, 4
[1, 1, 0, 5], # Notes de l'utilisateur 3 pour les articles 1, 2, 4
[1, 0, 0, 4], # Notes de l'utilisateur 4 pour les articles 1, 4
[0, 1, 5, 4], # Notes de l'utilisateur 5 pour les articles 2, 3, 4
])
def user_similarity(user1, user2):
"""Calcule la similarité entre deux utilisateurs (similarité cosinus)"""
# Trouver les éléments que les deux utilisateurs ont notés
common_items = np.where((user1 > 0) & (user2 > 0))[0]
if len(common_items) == 0:
return 0
# Calculer la similarité cosinus
user1_ratings = user1[common_items]
user2_ratings = user2[common_items]
dot_product = np.dot(user1_ratings, user2_ratings)
norm1 = np.linalg.norm(user1_ratings)
norm2 = np.linalg.norm(user2_ratings)
if norm1 == 0 or norm2 == 0:
return 0
return dot_product / (norm1 * norm2)
def recommend_items(user_id, ratings_matrix, k=2):
"""Recommander des éléments pour un utilisateur spécifié"""
user_ratings = ratings_matrix[user_id]
# Calculer les similarités entre cet utilisateur et les autres utilisateurs
similarities = []
for i, other_user in enumerate(ratings_matrix):
if i != user_id:
sim = user_similarity(user_ratings, other_user)
similarities.append((i, sim))
# Trier par similarité
similarities.sort(key=lambda x: x[1], reverse=True)
# Trouver les éléments non notés par l'utilisateur
unrated_items = np.where(user_ratings == 0)[0]
# Prédire les notes de l'utilisateur pour les éléments non notés
prédictions = []
for item_id in unrated_items:
weighted_sum = 0
similarity_sum = 0
for similar_user_id, similarity in similarities[:k]:
if similarity > 0 and ratings_matrix[similar_user_id][item_id] > 0:
weighted_sum += similarity * ratings_matrix[similar_user_id][item_id]
similarity_sum += similarity
if similarity_sum > 0:
predicted_rating = weighted_sum / similarity_sum
predictions.append((item_id, predicted_rating))
# Trier par note prédite
predictions.sort(key=lambda x: x[1], reverse=True)
return predictions[:3] # Renvoyer les 3 meilleures recommandations
# Recommander des éléments pour l'utilisateur 0
user_id = 0
recommendations = recommend_items(user_id, ratings)
print(f"Éléments recommandés pour l'utilisateur {user_id} :")
for item_id, predicted_rating in recommendations:
print(f"Élément {item_id + 1}, note prédite : {predicted_rating:.2f}")
import numpy as np
# Matrice de notes utilisateur-article (les lignes sont les utilisateurs, les colonnes sont les articles)
ratings = np.array([
[5, 3, 0, 1], # Notes de l'utilisateur 1 pour les articles 1, 2, 4
[4, 0, 0, 1], # Notes de l'utilisateur 2 pour les articles 1, 4
[1, 1, 0, 5], # Notes de l'utilisateur 3 pour les articles 1, 2, 4
[1, 0, 0, 4], # Notes de l'utilisateur 4 pour les articles 1, 4
[0, 1, 5, 4], # Notes de l'utilisateur 5 pour les articles 2, 3, 4
])
def user_similarity(user1, user2):
"""Calcule la similarité entre deux utilisateurs (similarité cosinus)"""
# Trouver les éléments que les deux utilisateurs ont notés
common_items = np.where((user1 > 0) & (user2 > 0))[0]
if len(common_items) == 0:
return 0
# Calculer la similarité cosinus
user1_ratings = user1[common_items]
user2_ratings = user2[common_items]
dot_product = np.dot(user1_ratings, user2_ratings)
norm1 = np.linalg.norm(user1_ratings)
norm2 = np.linalg.norm(user2_ratings)
if norm1 == 0 or norm2 == 0:
return 0
return dot_product / (norm1 * norm2)
def recommend_items(user_id, ratings_matrix, k=2):
"""Recommander des éléments pour un utilisateur spécifié"""
user_ratings = ratings_matrix[user_id]
# Calculer les similarités entre cet utilisateur et les autres utilisateurs
similarities = []
for i, other_user in enumerate(ratings_matrix):
if i != user_id:
sim = user_similarity(user_ratings, other_user)
similarities.append((i, sim))
# Trier par similarité
similarities.sort(key=lambda x: x[1], reverse=True)
# Trouver les éléments non notés par l'utilisateur
unrated_items = np.where(user_ratings == 0)[0]
# Prédire les notes de l'utilisateur pour les éléments non notés
prédictions = []
for item_id in unrated_items:
weighted_sum = 0
similarity_sum = 0
for similar_user_id, similarity in similarities[:k]:
if similarity > 0 and ratings_matrix[similar_user_id][item_id] > 0:
weighted_sum += similarity * ratings_matrix[similar_user_id][item_id]
similarity_sum += similarity
if similarity_sum > 0:
predicted_rating = weighted_sum / similarity_sum
predictions.append((item_id, predicted_rating))
# Trier par note prédite
predictions.sort(key=lambda x: x[1], reverse=True)
return predictions[:3] # Renvoyer les 3 meilleures recommandations
# Recommander des éléments pour l'utilisateur 0
user_id = 0
recommendations = recommend_items(user_id, ratings)
print(f"Éléments recommandés pour l'utilisateur {user_id} :")
for item_id, predicted_rating in recommendations:
print(f"Élément {item_id + 1}, note prédite : {predicted_rating:.2f}")
Recommandations de vidéos
Scénarios d'application: Douyin, YouTube, Netflix
Fonctionnalités：
- Recommandation en temps réel (ajustée en fonction du comportement actuel de l'utilisateur)
- Données multimodales (contenu vidéo, comportement de l'utilisateur, temps, etc.)
- Gestion du problème de démarrage à froid
Applications d'analyse prédictive
Contrôle des risques financiers
Scénarios d'application: Détection de fraude par carte de crédit, octroi de prêt
Exemples
# Exemple simple de détection de fraude
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
# Simuler des données de transaction
# Caractéristiques : montant de la transaction, heure de la transaction, type de marchand, emplacement, etc.
# Étiquettes : 0=normal, 1=fraude
np.random.seed(42)
# Générer des données simulées
n_samples = 1000
n_features = 4
# Transactions normales
normal_transactions = np.random.normal(loc=[100, 14, 2, 3], scale=[50, 4, 1, 1],
size=(int(n_samples * 0.95), n_features))
# Transactions frauduleuses (généralement des montants anormaux, des horaires anormaux, etc.)
fraud_transactions = np.random.normal(loc=[500, 3, 4, 1], scale=[200, 2, 1, 0.5],
size=(int(n_samples * 0.05), n_features))
# Fusionner les données et ajouter des étiquettes
X = np.vstack([normal_transactions, fraud_transactions])
y = np.hstack([np.zeros(len(normal_transactions)), np.ones(len(fraud_transactions))])
# Diviser les 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)
# Entraîner le modèle de forêt aléatoire
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
# Évaluer le modèle
accuracy = model.score(X_test, y_test)
print(f"Exactitude du modèle : {accuracy:.2f}")
# Prédire de nouvelles transactions
new_transaction = np.array([[450, 2, 4, 1]]) # Transaction anormale
fraud_probability = model.predict_proba(new_transaction)[0][1]
print(f"Probabilité que la nouvelle transaction soit frauduleuse : {fraud_probability:.2f}")
if fraud_probability > 0.5:
print("Avertissement : Transaction suspecte détectée !")
else:
print("La transaction est normale.")
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
# Simuler des données de transaction
# Caractéristiques : montant de la transaction, heure de la transaction, type de marchand, emplacement, etc.
# Étiquettes : 0=normal, 1=fraude
np.random.seed(42)
# Générer des données simulées
n_samples = 1000
n_features = 4
# Transactions normales
normal_transactions = np.random.normal(loc=[100, 14, 2, 3], scale=[50, 4, 1, 1],
size=(int(n_samples * 0.95), n_features))
# Transactions frauduleuses (généralement des montants anormaux, des horaires anormaux, etc.)
fraud_transactions = np.random.normal(loc=[500, 3, 4, 1], scale=[200, 2, 1, 0.5],
size=(int(n_samples * 0.05), n_features))
# Fusionner les données et ajouter des étiquettes
X = np.vstack([normal_transactions, fraud_transactions])
y = np.hstack([np.zeros(len(normal_transactions)), np.ones(len(fraud_transactions))])
# Diviser les 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)
# Entraîner le modèle de forêt aléatoire
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
# Évaluer le modèle
accuracy = model.score(X_test, y_test)
print(f"Exactitude du modèle : {accuracy:.2f}")
# Prédire de nouvelles transactions
new_transaction = np.array([[450, 2, 4, 1]]) # Transaction anormale
fraud_probability = model.predict_proba(new_transaction)[0][1]
print(f"Probabilité que la nouvelle transaction soit frauduleuse : {fraud_probability:.2f}")
if fraud_probability > 0.5:
print("Avertissement : Transaction suspecte détectée !")
else:
print("La transaction est normale.")
Prédiction du cours des actions
Scénarios d'application: Trading quantitatif, décisions d'investissement
Défis：
- Bruit de marché élevé
- Série temporelle non stationnaire
- Affecté par de multiples facteurs
Applications de détection d'anomalies
Cybersécurité
Scénarios d'application: Détection d'intrusion, identification de logiciels malveillants
Fonctionnement：
- Apprendre les schémas normaux de trafic réseau
- Détecter les comportements qui dévient des schémas normaux
- Déclencher des alertes ou bloquer
Inspection de la qualité industrielle
Scénarios d'application: Détection de défauts de produit, prédiction de défaillance d'équipement
Exemples
# Exemple simple de détection d'anomalies
import numpy as np
from sklearn.ensemble import IsolationForest
import matplotlib.pyplot as plt
# Simuler des données de capteur (données normales + quelques anomalies)
np.random.seed(42)
# Données normales : relevés de capteurs lorsque l'appareil fonctionne normalement
normal_data = np.random.normal(loc=10, scale=1, size=(200, 2))
# Données anormales : relevés de capteurs lorsque l'appareil est en panne
anomaly_data = np.random.normal(loc=[15, 5], scale=[1, 1], size=(10, 2))
# Fusionner les données
all_data = np.vstack([normal_data, anomaly_data])
# Utiliser Isolation Forest pour la détection d'anomalies
model = IsolationForest(contamination=0.05, random_state=42)
predictions = model.fit_predict(all_data)
# Visualiser les résultats
plt.figure(figsize=(10, 6))
normal_points = all_data[predictions == 1]
anomaly_points = all_data[predictions == -1]
plt.scatter(normal_points[:, 0], normal_points[:, 1],
c='blue', label='Données normales')
plt.scatter(anomaly_points[:, 0], anomaly_points[:, 1],
c='red', label='Données anormales')
plt.xlabel('Lecture du capteur 1')
plt.ylabel('Lecture du capteur 2')
plt.title('Détection d'anomalies de l'état de fonctionnement de l'appareil')
plt.legend()
plt.grid(True)
plt.show()
print(f"{len(anomaly_points)} points d'anomalie détectés")
import numpy as np
from sklearn.ensemble import IsolationForest
import matplotlib.pyplot as plt
# Simuler des données de capteur (données normales + quelques anomalies)
np.random.seed(42)
# Données normales : relevés de capteurs lorsque l'appareil fonctionne normalement
normal_data = np.random.normal(loc=10, scale=1, size=(200, 2))
# Données anormales : relevés de capteurs lorsque l'appareil est en panne
anomaly_data = np.random.normal(loc=[15, 5], scale=[1, 1], size=(10, 2))
# Fusionner les données
all_data = np.vstack([normal_data, anomaly_data])
# Utiliser Isolation Forest pour la détection d'anomalies
model = IsolationForest(contamination=0.05, random_state=42)
predictions = model.fit_predict(all_data)
# Visualiser les résultats
plt.figure(figsize=(10, 6))
normal_points = all_data[predictions == 1]
anomaly_points = all_data[predictions == -1]
plt.scatter(normal_points[:, 0], normal_points[:, 1],
c='blue', label='Données normales')
plt.scatter(anomaly_points[:, 0], anomaly_points[:, 1],
c='red', label='Données anormales')
plt.xlabel('Lecture du capteur 1')
plt.ylabel('Lecture du capteur 2')
plt.title('Détection d'anomalies de l'état de fonctionnement de l'appareil')
plt.legend()
plt.grid(True)
plt.show()
print(f"{len(anomaly_points)} points d'anomalie détectés")