Utiliser l’IA avec Flutter

Utiliser l’IA avec Flutter

Utiliser l’IA avec Flutter

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

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.

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)
}

6. Bonnes Pratiques et Optimisation {#bonnes-pratiques}
A. Gestion d’état optimisée
dart
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();
}
}
B. Cache et optimisation réseau
dart
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;
}
}
C. Gestion des erreurs robuste
dart
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'); } } D. Performance et monitoring dart 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

Flutter

Utiliser l’IA avec Flutter