Flutter

Utiliser l'IA avec Flutter

Un cours complet pour maîtriser Utiliser l'IA avec Flutter.

0 chapitres 0 QCM Accès gratuit

Objectif
Utiliser l'IA avec Flutter - Cours Complet Table des Matières Introduction à l'IA dans Flutter Architecture et Approches Intégration d'APIs Cloud Modèles On-Device avec TensorFlow Lite Cas Pratiques et Exemples Bonnes Pratiques et Optimisation
Introduction à l'IA dans Flutter
1. Pourquoi l'IA dans les applications mobiles ?
  - Personnalisation : Adapter l'expérience utilisateur et le contenu en temps réel.
  - Reconnaissance: Traitement et identification des **Images** (objets, visages), du **texte** (NLP, sentiment), et de la **voix** (transcription, commandes).
  - Prédiction: Générer des **Recommandations** de produits/contenus et effectuer des **analyses** comportementales ou de tendances.
  - Automatisation: Exécuter des **Tâches répétitives** ou complexes (ex: tri de photos, modération de contenu).
  - Optimisation: Réduction de la latence et de l'utilisation de la bande passante par le traitement local.
2. Options disponibles :
  - APIs Cloud (OpenAI, Google ML Kit, AWS SageMaker/Rekognition) :
    - Avantage : Puissance de calcul illimitée, modèles régulièrement mis à jour.
    - Inconvénient : Nécessite une connexion Internet, coûts de service, latence réseau.
  - Modèles On-Device (TensorFlow Lite, Google ML Kit On-Device) :
    - Avantage : Exécution rapide (faible latence), fonctionnement hors ligne, confidentialité des données.
    - Inconvénient : Modèles plus petits et moins précis, dépend de la puissance du matériel mobile.
  - Solutions hybrides: Combinaison de modèles légers On-Device pour les tâches rapides et d'APIs Cloud pour les requêtes complexes ou l'entraînement.

Architecture et Approches

Architecture recommandée :


lib/
├── models/          # Modèles de données
├── services/        # Services IA
├── repositories/    # Gestion des données
├── widgets/         UI avec résultats IA
└── utils/           # Utilitaires

Pattern BLoC avec IA ::


// État
abstract class AIState {}
class AIInitial extends AIState {}
class AILoading extends AIState {}
class AIResult extends AIState {
  final dynamic result;
  AIResult(this.result);
}
class AIError extends AIState {
  final String message;
  AIError(this.message);
}

// Événements
abstract class AIEvent {}
class AnalyzeImage extends AIEvent {
  final String imagePath;
  AnalyzeImage(this.imagePath);
}
class GenerateText extends AIEvent {
  final String prompt;
  GenerateText(this.prompt);
}

Intégration d'APIs Cloud et Modèles On-Device dans Flutter

OpenAI GPT Integration

Configuration des Dépendances :


# pubspec.yaml
dependencies:
  http: ^1.1.0
  dart_openai: ^2.1.0

Service OpenAI (Requêtes HTTP REST) :


import 'package:http/http.dart' as http;
import 'dart:convert';

class OpenAIService {
  static const String _apiKey = 'YOUR_OPENAI_KEY';
  static const String _baseUrl = 'https://api.openai.com/v1';
  
  Future<String> generateText(String prompt) async {
    try {
      final response = await http.post(
        Uri.parse('$_baseUrl/chat/completions'),
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer $_apiKey',
        },
        body: jsonEncode({
          'model': 'gpt-3.5-turbo',
          'messages': [
            {'role': 'user', 'content': prompt}
          ],
          'max_tokens': 500,
        }),
      );
      
      if (response.statusCode == 200) {
        final data = jsonDecode(response.body);
        return data['choices'][0]['message']['content'];
      } else {
        throw Exception('Erreur API: ${response.statusCode}');
      }
    } catch (e) {
      throw Exception('Erreur: $e');
    }
  }
  
  Future<String> generateImage(String prompt) async {
    final response = await http.post(
      Uri.parse('$_baseUrl/images/generations'),
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer $_apiKey',
      },
      body: jsonEncode({
        'prompt': prompt,
        'n': 1,
        'size': '256x256',
      }),
    );
    
    if (response.statusCode == 200) {
      final data = jsonDecode(response.body);
      return data['data'][0]['url'];
    } else {
      throw Exception('Erreur génération image');
    }
  }
}

Google ML Kit

Configuration des Dépendances :


dependencies:
  google_ml_kit: ^0.16.0
  image_picker: ^1.0.4

Service de reconnaissance de Texte (OCR) et d'Objets :


import 'package:google_ml_kit/google_ml_kit.dart';
import 'package:image_picker/image_picker.dart';

class MLKitService {
  final TextRecognizer _textRecognizer = GoogleMlKit.vision.textRecognizer();
  final ImagePicker _picker = ImagePicker();
  
  Future<String> recognizeTextFromImage() async {
    try {
      final XFile? image = await _picker.pickImage(source: ImageSource.camera);
      if (image == null) throw Exception('Aucune image sélectionnée');
      
      final inputImage = InputImage.fromFilePath(image.path);
      final RecognizedText recognizedText = 
          await _textRecognizer.processImage(inputImage);
      
      await _textRecognizer.close();
      return recognizedText.text;
    } catch (e) {
      throw Exception('Erreur reconnaissance: $e');
    }
  }
  
  Future<List<String>> detectObjects() async {
    final XFile? image = await _picker.pickImage(source: ImageSource.gallery);
    if (image == null) throw Exception('Aucune image sélectionnée');
    
    final inputImage = InputImage.fromFilePath(image.path);
    final objectDetector = GoogleMlKit.vision.objectDetector();
    
    final List<DetectedObject> objects = 
        await objectDetector.processImage(inputImage);
    
    List<String> labels = [];
    for (var object in objects) {
      for (var label in object.labels) {
        labels.add(label.text);
      }
    }
    
    await objectDetector.close();
    return labels;
  }
}

Modèles On-Device avec TensorFlow Lite

Configuration TFLite :


dependencies:
  tflite_flutter: ^0.10.1
  image: ^4.0.17
  camera: ^0.10.5

flutter:
  assets:
    - assets/models/

Service TFLite de Base (Chargement et Exécution) :


import 'package:tflite_flutter/tflite_flutter.dart';
import 'package:image/image.dart' as img;

class TFLiteService {
  late Interpreter _interpreter;
  bool _isLoaded = false;
  
  Future<void> loadModel() async {
    try {
      final options = InterpreterOptions();
      
      _interpreter = await Interpreter.fromAsset(
        'assets/models/modele.tflite',
        options: options,
      );
      
      _isLoaded = true;
      print('Modèle chargé avec succès');
    } catch (e) {
      print('Erreur chargement modèle: $e');
    }
  }
  
  Future<List<double>> classifyImage(String imagePath) async {
    if (!_isLoaded) await loadModel();
    
    // Préparation de l'image (Redimensionnement, Prétraitement)
    // ...
    // Execution du modèle
    // ...
    // return output[0];
  }
  
  void dispose() {
    _interpreter.close();
  }
}

Classification d'Images Complète :


import 'package:tflite_flutter/tflite_flutter.dart';
import 'package:flutter/services.dart';
import 'dart:typed_data'; // Nécessaire pour Float32List

class ImageClassifier {
  late Interpreter _interpreter;
  List<String> _labels = [];
  
  Future<void> loadModelAndLabels() async {
    // Chargement modèle
    _interpreter = await Interpreter.fromAsset('assets/model.tflite');
    
    // Chargement labels
    String labelContent = await rootBundle.loadString('assets/labels.txt');
    _labels = labelContent.split('\n');
  }
  
  Map<String, double> classify(img.Image image) {
    // Redimensionnement
    img.Image resizedImage = img.copyResize(image, width: 224, height: 224);
    
    // Préparation input
    var input = _imageToByteList(resizedImage);
    var output = List<double>.filled(_labels.length, 0).reshape([1, _labels.length]);
    
    // Exécution
    _interpreter.run(input, output);
    
    // Traitement résultats (extraction du label avec le meilleur score)
    Map<String, double> results = {};
    for (int i = 0; i < output[0].length; i++) {
      if (output[0][i] > 0.5) { // Seuil de confiance
        results[_labels[i]] = output[0][i];
      }
    }
    
    return results;
  }
  
  Float32List _imageToByteList(img.Image image) {
    // ... (Implémentation de la conversion image vers Float32List)
    return Float32List(0);
  }
}

Cas Pratiques et Exemples

Chatbot avec GPT (Génération de Texte) :


class ChatBotScreen extends StatefulWidget {
  // ... (Implémentation de l'interface utilisateur, de la logique _sendMessage)
  // ... (Utilisation de OpenAIService.generateText)
}

Reconnaissance d'Objets en Temps Réel (avec Caméra) :


class ObjectDetectionScreen extends StatefulWidget {
  // ... (Initialisation de la caméra, _processCameraImage)
  // ... (Utilisation de MLKitService.detectObjectsInImage ou TFLite)
}

Génération d'images avec DALL-E :


class ImageGeneratorScreen extends StatefulWidget {
  // ... (Implémentation de l'interface utilisateur, de la logique _generateImage)
  // ... (Utilisation de OpenAIService.generateImage)
}

Bonnes Pratiques et Optimisation {#bonnes-pratiques}

Gestion d'état optimisée

class AIProvider

class AIProvider with ChangeNotifier { final OpenAIService _aiService; AIState _state = AIInitial(); String? _lastResult; AIState get state => _state; String? get lastResult => _lastResult; AIProvider(this._aiService); Future generateContent(String prompt) async { _state = AILoading(); notifyListeners(); try { _lastResult = await _aiService.generateText(prompt); _state = AIResult(_lastResult!); } catch (e) { _state = AIError(e.toString()); } notifyListeners(); } }

Cache et optimisation réseau

class CachedAIService

class CachedAIService { final OpenAIService _aiService; final Map _cache = {}; CachedAIService(this._aiService); Future generateText(String prompt) async { if (_cache.containsKey(prompt)) { return _cache[prompt]!; } final result = await _aiService.generateText(prompt); _cache[prompt] = result; return result; } }

Gestion des erreurs robuste

class ErrorHandlingAIService

class ErrorHandlingAIService { final OpenAIService _aiService; ErrorHandlingAIService(this._aiService); Future generateTextWithRetry( String prompt, { int maxRetries = 3, }) async { for (int i = 0; i < maxRetries; i++) { try { return await _aiService.generateText(prompt); } catch (e) { if (i == maxRetries - 1) rethrow; await Future.delayed(Duration(seconds: 1 << i)); // Backoff exponentiel } } throw Exception('Échec après $maxRetries tentatives'); } }

Performance et monitoring

class PerformanceAIService

class PerformanceAIService { final OpenAIService _aiService; PerformanceAIService(this._aiService); Future generateTextWithMetrics(String prompt) async { final stopwatch = Stopwatch()..start(); try { final result = await _aiService.generateText(prompt); stopwatch.stop(); print('Temps de réponse: ${stopwatch.elapsedMilliseconds}ms'); // Envoyer les métriques à votre service de monitoring _sendMetrics(stopwatch.elapsedMilliseconds); return result; } catch (e) { stopwatch.stop(); // Logger l'erreur avec les métriques _logError(e, stopwatch.elapsedMilliseconds); rethrow; } } void _sendMetrics(int responseTime) { // Implémentation d'envoi de métriques } void _logError(Object error, int responseTime) { // Implémentation de logging } }

Conclusion
- Ce cours vous a présenté les principales méthodes pour intégrer l'IA dans vos applications Flutter :
- APIs Cloud pour des modèles puissants mais nécessitant une connexion
- TFLite pour l'exécution locale et la confidentialité
- Architectures solides pour une maintenance facile
- Cas pratiques concrets avec code complet

Utiliser l'IA avec Flutter

Sommaire du cours

Autres catégories

Objectif

Introduction à l'IA dans Flutter

Pourquoi l'IA dans les applications mobiles ?

Options disponibles :