Mobile App AI Integration: Complete Developer Guide 2025

// Install required packages
// npm install react-native-tensorflow-lite
// npm install react-native-fs
// npm install react-native-image-picker

import React, { useState, useEffect } from 'react';
import { View, Text, Image, TouchableOpacity, Alert } from 'react-native';
import TensorFlowLite from 'react-native-tensorflow-lite';
import { launchImageLibrary } from 'react-native-image-picker';
import RNFS from 'react-native-fs';

const AIImageClassifier = () => {
  const [model, setModel] = useState(null);
  const [selectedImage, setSelectedImage] = useState(null);
  const [predictions, setPredictions] = useState([]);
  const [isLoading, setIsLoading] = useState(false);

  useEffect(() => {
    loadModel();
  }, []);

  const loadModel = async () => {
    try {
      // Load pre-trained MobileNet model
      const modelPath = await downloadModel();
      const loadedModel = await TensorFlowLite.loadModel(modelPath);
      setModel(loadedModel);
      console.log('Model loaded successfully');
    } catch (error) {
      console.error('Error loading model:', error);
      Alert.alert('Error', 'Failed to load AI model');
    }
  };

  const downloadModel = async () => {
    const modelUrl = 'https://storage.googleapis.com/download.tensorflow.org/models/mobilenet_v1_1.0_224_quant.tflite';
    const modelPath = `${RNFS.DocumentDirectoryPath}/mobilenet_model.tflite`;
    
    // Check if model already exists
    const exists = await RNFS.exists(modelPath);
    if (!exists) {
      console.log('Downloading model...');
      await RNFS.downloadFile({
        fromUrl: modelUrl,
        toFile: modelPath,
      }).promise;
    }
    
    return modelPath;
  };

  const selectImage = () => {
    const options = {
      mediaType: 'photo',
      quality: 0.8,
      maxWidth: 224,
      maxHeight: 224,
    };

    launchImageLibrary(options, (response) => {
      if (response.assets && response.assets[0]) {
        setSelectedImage(response.assets[0]);
        classifyImage(response.assets[0]);
      }
    });
  };

  const classifyImage = async (imageAsset) => {
    if (!model) {
      Alert.alert('Error', 'Model not loaded yet');
      return;
    }

    setIsLoading(true);
    try {
      // Preprocess image for model input
      const preprocessedImage = await preprocessImage(imageAsset.uri);
      
      // Run inference
      const output = await model.run(preprocessedImage);
      
      // Process predictions
      const processedPredictions = await processPredictions(output);
      setPredictions(processedPredictions);
      
    } catch (error) {
      console.error('Classification error:', error);
      Alert.alert('Error', 'Failed to classify image');
    } finally {
      setIsLoading(false);
    }
  };

  const preprocessImage = async (imageUri) => {
    // Convert image to tensor format expected by MobileNet
    // This is a simplified version - actual implementation would use
    // image processing libraries to resize and normalize the image
    
    const imageData = await RNFS.readFile(imageUri, 'base64');
    
    // Convert to RGB array and normalize to [0, 1]
    // Resize to 224x224 (MobileNet input size)
    // This would typically use a native image processing library
    
    return {
      data: imageData,
      shape: [1, 224, 224, 3], // Batch size, height, width, channels
    };
  };

  const processPredictions = async (modelOutput) => {
    // Load ImageNet labels
    const labels = await loadImageNetLabels();
    
    // Get top 5 predictions
    const predictions = modelOutput.data
      .map((probability, index) => ({
        label: labels[index],
        probability: probability,
        confidence: Math.round(probability * 100)
      }))
      .sort((a, b) => b.probability - a.probability)
      .slice(0, 5);
    
    return predictions;
  };

  const loadImageNetLabels = async () => {
    // In a real app, you'd load this from a bundled file or API
    return [
      'Egyptian cat', 'tabby cat', 'tiger cat', 'Persian cat', 'Siamese cat',
      'Egyptian Mau', 'cougar', 'lynx', 'leopard', 'snow leopard',
      // ... 1000 ImageNet labels
    ];
  };

  return (
    <View style={{ flex: 1, padding: 20 }}>
      <Text style={{ fontSize: 24, fontWeight: 'bold', marginBottom: 20 }}>
        AI Image Classifier
      </Text>
      
      <TouchableOpacity
        onPress={selectImage}
        style={{
          backgroundColor: '#007AFF',
          padding: 15,
          borderRadius: 10,
          alignItems: 'center',
          marginBottom: 20
        }}
      >
        <Text style={{ color: 'white', fontSize: 16 }}>
          Select Image to Classify
        </Text>
      </TouchableOpacity>

      {selectedImage && (
        <Image
          source={{ uri: selectedImage.uri }}
          style={{ width: 200, height: 200, alignSelf: 'center', marginBottom: 20 }}
          resizeMode="cover"
        />
      )}

      {isLoading && (
        <Text style={{ textAlign: 'center', fontSize: 16 }}>
          Classifying image...
        </Text>
      )}

      {predictions.length > 0 && (
        <View>
          <Text style={{ fontSize: 18, fontWeight: 'bold', marginBottom: 10 }}>
            Predictions:
          </Text>
          {predictions.map((prediction, index) => (
            <View key={index} style={{ marginBottom: 5 }}>
              <Text>
                {prediction.label}: {prediction.confidence}%
              </Text>
            </View>
          ))}
        </View>
      )}
    </View>
  );
};

export default AIImageClassifier;

// Voice recognition component using react-native-voice
import React, { useState, useEffect } from 'react';
import { View, Text, TouchableOpacity, Alert } from 'react-native';
import Voice from '@react-native-voice/voice';

const VoiceRecognitionComponent = () => {
  const [isListening, setIsListening] = useState(false);
  const [recognizedText, setRecognizedText] = useState('');
  const [isAvailable, setIsAvailable] = useState(false);

  useEffect(() => {
    // Set up voice recognition event listeners
    Voice.onSpeechStart = onSpeechStart;
    Voice.onSpeechRecognized = onSpeechRecognized;
    Voice.onSpeechEnd = onSpeechEnd;
    Voice.onSpeechError = onSpeechError;
    Voice.onSpeechResults = onSpeechResults;
    Voice.onSpeechPartialResults = onSpeechPartialResults;

    // Check if voice recognition is available
    checkVoiceAvailability();

    return () => {
      // Clean up event listeners
      Voice.destroy().then(Voice.removeAllListeners);
    };
  }, []);

  const checkVoiceAvailability = async () => {
    try {
      const available = await Voice.isAvailable();
      setIsAvailable(available);
    } catch (error) {
      console.error('Voice availability check failed:', error);
    }
  };

  const onSpeechStart = (e) => {
    console.log('Speech started:', e);
    setIsListening(true);
  };

  const onSpeechRecognized = (e) => {
    console.log('Speech recognized:', e);
  };

  const onSpeechEnd = (e) => {
    console.log('Speech ended:', e);
    setIsListening(false);
  };

  const onSpeechError = (e) => {
    console.error('Speech error:', e);
    setIsListening(false);
    Alert.alert('Error', 'Speech recognition failed');
  };

  const onSpeechResults = (e) => {
    console.log('Speech results:', e);
    if (e.value && e.value.length > 0) {
      setRecognizedText(e.value[0]);
      processVoiceCommand(e.value[0]);
    }
  };

  const onSpeechPartialResults = (e) => {
    console.log('Partial results:', e);
    if (e.value && e.value.length > 0) {
      setRecognizedText(e.value[0]);
    }
  };

  const startListening = async () => {
    try {
      setRecognizedText('');
      await Voice.start('en-US');
    } catch (error) {
      console.error('Start listening error:', error);
      Alert.alert('Error', 'Failed to start voice recognition');
    }
  };

  const stopListening = async () => {
    try {
      await Voice.stop();
    } catch (error) {
      console.error('Stop listening error:', error);
    }
  };

  const processVoiceCommand = async (command) => {
    // Process the recognized voice command
    const lowerCommand = command.toLowerCase();
    
    // Simple command processing
    if (lowerCommand.includes('hello')) {
      speakResponse('Hello! How can I help you?');
    } else if (lowerCommand.includes('weather')) {
      speakResponse('Let me check the weather for you.');
      // Integrate with weather API
    } else if (lowerCommand.includes('time')) {
      const currentTime = new Date().toLocaleTimeString();
      speakResponse(`The current time is ${currentTime}`);
    } else {
      // Send to AI service for more complex processing
      processWithAI(command);
    }
  };

  const processWithAI = async (text) => {
    try {
      // Send to OpenAI or other AI service
      const response = await fetch('https://api.openai.com/v1/chat/completions', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer YOUR_API_KEY',
        },
        body: JSON.stringify({
          model: 'gpt-3.5-turbo',
          messages: [
            {
              role: 'user',
              content: text
            }
          ],
          max_tokens: 150
        })
      });

      const data = await response.json();
      const aiResponse = data.choices[0].message.content;
      
      speakResponse(aiResponse);
    } catch (error) {
      console.error('AI processing error:', error);
      speakResponse('Sorry, I could not process that request.');
    }
  };

  const speakResponse = (text) => {
    // Use text-to-speech to respond
    // This would integrate with react-native-tts or similar library
    console.log('Speaking:', text);
    // Tts.speak(text);
  };

  if (!isAvailable) {
    return (
      <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
        <Text>Voice recognition is not available on this device</Text>
      </View>
    );
  }

  return (
    <View style={{ flex: 1, padding: 20 }}>
      <Text style={{ fontSize: 24, fontWeight: 'bold', marginBottom: 20 }}>
        Voice Assistant
      </Text>
      
      <TouchableOpacity
        onPress={isListening ? stopListening : startListening}
        style={{
          backgroundColor: isListening ? '#FF3B30' : '#007AFF',
          padding: 20,
          borderRadius: 50,
          alignItems: 'center',
          marginBottom: 20
        }}
      >
        <Text style={{ color: 'white', fontSize: 16 }}>
          {isListening ? 'Stop Listening' : 'Start Listening'}
        </Text>
      </TouchableOpacity>

      {isListening && (
        <Text style={{ textAlign: 'center', fontSize: 16, color: '#007AFF' }}>
          Listening...
        </Text>
      )}

      {recognizedText ? (
        <View style={{ marginTop: 20 }}>
          <Text style={{ fontSize: 16, fontWeight: 'bold' }}>
            Recognized Text:
          </Text>
          <Text style={{ fontSize: 14, marginTop: 5 }}>
            {recognizedText}
          </Text>
        </View>
      ) : null}
    </View>
  );
};

export default VoiceRecognitionComponent;

import UIKit
import CoreML
import Vision
import AVFoundation

class AIImageAnalyzer: UIViewController {
    
    @IBOutlet weak var imageView: UIImageView!
    @IBOutlet weak var resultLabel: UILabel!
    @IBOutlet weak var confidenceLabel: UILabel!
    
    private var model: VNCoreMLModel?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupCoreMLModel()
    }
    
    private func setupCoreMLModel() {
        guard let modelURL = Bundle.main.url(forResource: "MobileNetV2", withExtension: "mlmodelc") else {
            print("Failed to find model file")
            return
        }
        
        do {
            let mlModel = try MLModel(contentsOf: modelURL)
            model = try VNCoreMLModel(for: mlModel)
        } catch {
            print("Failed to load Core ML model: \(error)")
        }
    }
    
    @IBAction func selectImageTapped(_ sender: UIButton) {
        let imagePickerController = UIImagePickerController()
        imagePickerController.delegate = self
        imagePickerController.sourceType = .photoLibrary
        present(imagePickerController, animated: true)
    }
    
    @IBAction func takePictureTapped(_ sender: UIButton) {
        guard UIImagePickerController.isSourceTypeAvailable(.camera) else {
            showAlert(message: "Camera not available")
            return
        }
        
        let imagePickerController = UIImagePickerController()
        imagePickerController.delegate = self
        imagePickerController.sourceType = .camera
        present(imagePickerController, animated: true)
    }
    
    private func analyzeImage(_ image: UIImage) {
        guard let model = model else {
            showAlert(message: "Model not loaded")
            return
        }
        
        guard let ciImage = CIImage(image: image) else {
            showAlert(message: "Failed to convert image")
            return
        }
        
        let request = VNCoreMLRequest(model: model) { [weak self] request, error in
            DispatchQueue.main.async {
                self?.processResults(request.results)
            }
        }
        
        // Configure request
        request.imageCropAndScaleOption = .centerCrop
        
        let handler = VNImageRequestHandler(ciImage: ciImage, orientation: .up)
        
        do {
            try handler.perform([request])
        } catch {
            showAlert(message: "Failed to perform analysis: \(error.localizedDescription)")
        }
    }
    
    private func processResults(_ results: [VNObservation]?) {
        guard let results = results as? [VNClassificationObservation],
              let topResult = results.first else {
            resultLabel.text = "No results"
            confidenceLabel.text = ""
            return
        }
        
        resultLabel.text = topResult.identifier
        confidenceLabel.text = String(format: "Confidence: %.2f%%", topResult.confidence * 100)
        
        // Log top 5 results
        print("Top 5 predictions:")
        for (index, result) in results.prefix(5).enumerated() {
            print("\(index + 1). \(result.identifier): \(result.confidence)")
        }
    }
    
    private func showAlert(message: String) {
        let alert = UIAlertController(title: "Error", message: message, preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "OK", style: .default))
        present(alert, animated: true)
    }
}

// MARK: - UIImagePickerControllerDelegate
extension AIImageAnalyzer: UIImagePickerControllerDelegate, UINavigationControllerDelegate {
    
    func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
        
        picker.dismiss(animated: true)
        
        guard let image = info[.originalImage] as? UIImage else {
            showAlert(message: "Failed to get image")
            return
        }
        
        imageView.image = image
        analyzeImage(image)
    }
    
    func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
        picker.dismiss(animated: true)
    }
}

// MARK: - Real-time Camera Analysis
class RealTimeCameraAnalyzer: UIViewController {
    
    private var captureSession: AVCaptureSession!
    private var previewLayer: AVCaptureVideoPreviewLayer!
    private var model: VNCoreMLModel?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupCamera()
        setupCoreMLModel()
    }
    
    private func setupCamera() {
        captureSession = AVCaptureSession()
        captureSession.sessionPreset = .photo
        
        guard let backCamera = AVCaptureDevice.default(for: .video) else {
            print("Unable to access back camera")
            return
        }
        
        do {
            let input = try AVCaptureDeviceInput(device: backCamera)
            captureSession.addInput(input)
        } catch {
            print("Error creating camera input: \(error)")
            return
        }
        
        let videoOutput = AVCaptureVideoDataOutput()
        videoOutput.setSampleBufferDelegate(self, queue: DispatchQueue(label: "videoQueue"))
        captureSession.addOutput(videoOutput)
        
        previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
        previewLayer.frame = view.bounds
        previewLayer.videoGravity = .resizeAspectFill
        view.layer.addSublayer(previewLayer)
        
        captureSession.startRunning()
    }
    
    private func setupCoreMLModel() {
        // Same as previous example
        guard let modelURL = Bundle.main.url(forResource: "MobileNetV2", withExtension: "mlmodelc") else {
            return
        }
        
        do {
            let mlModel = try MLModel(contentsOf: modelURL)
            model = try VNCoreMLModel(for: mlModel)
        } catch {
            print("Failed to load Core ML model: \(error)")
        }
    }
}

// MARK: - AVCaptureVideoDataOutputSampleBufferDelegate
extension RealTimeCameraAnalyzer: AVCaptureVideoDataOutputSampleBufferDelegate {
    
    func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
        
        guard let model = model,
              let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
            return
        }
        
        let request = VNCoreMLRequest(model: model) { request, error in
            guard let results = request.results as? [VNClassificationObservation],
                  let topResult = results.first else {
                return
            }
            
            DispatchQueue.main.async {
                // Update UI with real-time results
                print("Real-time prediction: \(topResult.identifier) (\(topResult.confidence))")
            }
        }
        
        let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer, orientation: .up)
        
        do {
            try handler.perform([request])
        } catch {
            print("Failed to perform real-time analysis: \(error)")
        }
    }
}

import android.graphics.Bitmap
import android.net.Uri
import androidx.camera.core.*
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.core.content.ContextCompat
import com.google.mlkit.vision.common.InputImage
import com.google.mlkit.vision.text.TextRecognition
import com.google.mlkit.vision.text.latin.TextRecognizerOptions
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors

class TextRecognitionActivity : AppCompatActivity() {
    
    private lateinit var cameraExecutor: ExecutorService
    private lateinit var imageCapture: ImageCapture
    private val textRecognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_text_recognition)
        
        cameraExecutor = Executors.newSingleThreadExecutor()
        startCamera()
    }
    
    private fun startCamera() {
        val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
        
        cameraProviderFuture.addListener({
            val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
            
            val preview = Preview.Builder().build().also {
                it.setSurfaceProvider(viewFinder.surfaceProvider)
            }
            
            imageCapture = ImageCapture.Builder().build()
            
            val imageAnalyzer = ImageAnalysis.Builder()
                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
                .build()
                .also {
                    it.setAnalyzer(cameraExecutor, TextAnalyzer())
                }
            
            val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
            
            try {
                cameraProvider.unbindAll()
                cameraProvider.bindToLifecycle(
                    this, cameraSelector, preview, imageCapture, imageAnalyzer
                )
            } catch (exc: Exception) {
                Log.e(TAG, "Use case binding failed", exc)
            }
            
        }, ContextCompat.getMainExecutor(this))
    }
    
    private inner class TextAnalyzer : ImageAnalysis.Analyzer {
        
        override fun analyze(imageProxy: ImageProxy) {
            val mediaImage = imageProxy.image
            if (mediaImage != null) {
                val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
                
                textRecognizer.process(image)
                    .addOnSuccessListener { visionText ->
                        processTextRecognitionResult(visionText)
                    }
                    .addOnFailureListener { e ->
                        Log.e(TAG, "Text recognition failed", e)
                    }
                    .addOnCompleteListener {
                        imageProxy.close()
                    }
            }
        }
    }
    
    private fun processTextRecognitionResult(visionText: Text) {
        val resultText = visionText.text
        
        if (resultText.isNotEmpty()) {
            runOnUiThread {
                // Update UI with recognized text
                textResultView.text = resultText
                
                // Process specific text patterns
                processRecognizedText(resultText)
            }
        }
        
        // Process text blocks for more detailed analysis
        for (block in visionText.textBlocks) {
            val blockText = block.text
            val blockCornerPoints = block.cornerPoints
            val blockFrame = block.boundingBox
            
            for (line in block.lines) {
                val lineText = line.text
                val lineCornerPoints = line.cornerPoints
                val lineFrame = line.boundingBox
                
                for (element in line.elements) {
                    val elementText = element.text
                    val elementCornerPoints = element.cornerPoints
                    val elementFrame = element.boundingBox
                }
            }
        }
    }
    
    private fun processRecognizedText(text: String) {
        // Extract specific information patterns
        val emailPattern = Regex("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}")
        val phonePattern = Regex("\+?[1-9]\d{1,14}")
        val urlPattern = Regex("https?://[\w\-._~:/?#\[\]@!$&'()*+,;=%]+")
        
        val emails = emailPattern.findAll(text).map { it.value }.toList()
        val phones = phonePattern.findAll(text).map { it.value }.toList()
        val urls = urlPattern.findAll(text).map { it.value }.toList()
        
        // Process extracted information
        if (emails.isNotEmpty()) {
            Log.d(TAG, "Found emails: $emails")
            // Handle email extraction
        }
        
        if (phones.isNotEmpty()) {
            Log.d(TAG, "Found phone numbers: $phones")
            // Handle phone number extraction
        }
        
        if (urls.isNotEmpty()) {
            Log.d(TAG, "Found URLs: $urls")
            // Handle URL extraction
        }
    }
    
    fun captureAndAnalyzeImage() {
        val outputFileOptions = ImageCapture.OutputFileOptions.Builder(photoFile).build()
        
        imageCapture.takePicture(
            outputFileOptions,
            ContextCompat.getMainExecutor(this),
            object : ImageCapture.OnImageSavedCallback {
                override fun onError(error: ImageCaptureException) {
                    Log.e(TAG, "Photo capture failed: ${error.message}", error)
                }
                
                override fun onImageSaved(output: ImageCapture.OutputFileResults) {
                    val savedUri = Uri.fromFile(photoFile)
                    analyzeStaticImage(savedUri)
                }
            }
        )
    }
    
    private fun analyzeStaticImage(imageUri: Uri) {
        try {
            val image = InputImage.fromFilePath(this, imageUri)
            
            textRecognizer.process(image)
                .addOnSuccessListener { visionText ->
                    processTextRecognitionResult(visionText)
                }
                .addOnFailureListener { e ->
                    Log.e(TAG, "Static image text recognition failed", e)
                }
        } catch (e: Exception) {
            Log.e(TAG, "Error analyzing static image", e)
        }
    }
    
    override fun onDestroy() {
        super.onDestroy()
        cameraExecutor.shutdown()
        textRecognizer.close()
    }
    
    companion object {
        private const val TAG = "TextRecognitionActivity"
    }
}

import tensorflow as tf
import numpy as np

def quantize_model_for_mobile(model_path, output_path):
    """
    Quantize a TensorFlow model for mobile deployment
    """
    # Load the model
    model = tf.keras.models.load_model(model_path)
    
    # Create a representative dataset for quantization
    def representative_dataset():
        for _ in range(100):
            # Generate representative data (replace with actual data)
            data = np.random.random((1, 224, 224, 3)).astype(np.float32)
            yield [data]
    
    # Convert to TensorFlow Lite with quantization
    converter = tf.lite.TFLiteConverter.from_keras_model(model)
    
    # Enable optimizations
    converter.optimizations = [tf.lite.Optimize.DEFAULT]
    
    # Set representative dataset for full integer quantization
    converter.representative_dataset = representative_dataset
    
    # Ensure all ops are quantized
    converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
    converter.inference_input_type = tf.int8
    converter.inference_output_type = tf.int8
    
    # Convert the model
    quantized_model = converter.convert()
    
    # Save the quantized model
    with open(output_path, 'wb') as f:
        f.write(quantized_model)
    
    # Compare model sizes
    original_size = os.path.getsize(model_path)
    quantized_size = len(quantized_model)
    
    print(f"Original model size: {original_size / 1024 / 1024:.2f} MB")
    print(f"Quantized model size: {quantized_size / 1024 / 1024:.2f} MB")
    print(f"Size reduction: {(1 - quantized_size / original_size) * 100:.1f}%")
    
    return quantized_model

def benchmark_model_performance(model_path, test_data):
    """
    Benchmark model performance on mobile
    """
    import time
    
    # Load the TensorFlow Lite model
    interpreter = tf.lite.Interpreter(model_path=model_path)
    interpreter.allocate_tensors()
    
    # Get input and output details
    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()
    
    # Benchmark inference time
    inference_times = []
    
    for i in range(100):  # Run 100 inferences
        start_time = time.time()
        
        # Set input tensor
        interpreter.set_tensor(input_details[0]['index'], test_data[i:i+1])
        
        # Run inference
        interpreter.invoke()
        
        # Get output
        output = interpreter.get_tensor(output_details[0]['index'])
        
        end_time = time.time()
        inference_times.append(end_time - start_time)
    
    # Calculate statistics
    avg_time = np.mean(inference_times)
    min_time = np.min(inference_times)
    max_time = np.max(inference_times)
    std_time = np.std(inference_times)
    
    print(f"Average inference time: {avg_time * 1000:.2f} ms")
    print(f"Min inference time: {min_time * 1000:.2f} ms")
    print(f"Max inference time: {max_time * 1000:.2f} ms")
    print(f"Standard deviation: {std_time * 1000:.2f} ms")
    print(f"Throughput: {1 / avg_time:.2f} FPS")
    
    return {
        'avg_time': avg_time,
        'min_time': min_time,
        'max_time': max_time,
        'std_time': std_time,
        'throughput': 1 / avg_time
    }

# Usage example
if __name__ == "__main__":
    # Quantize model
    quantized_model = quantize_model_for_mobile(
        'original_model.h5',
        'quantized_model.tflite'
    )
    
    # Generate test data
    test_data = np.random.random((100, 224, 224, 3)).astype(np.float32)
    
    # Benchmark performance
    performance = benchmark_model_performance(
        'quantized_model.tflite',
        test_data
    )