TensorFlow Lite és una versió de TensorFlow optimitzada per a dispositius mòbils i integrats. Permet executar models d'aprenentatge automàtic en dispositius amb recursos limitats, com telèfons intel·ligents, tauletes i dispositius IoT. TensorFlow Lite està dissenyat per ser lleuger i eficient, oferint una latència baixa i un rendiment alt.

1. Entendre què és TensorFlow Lite i per què és útil.
2. Aprendre a convertir un model de TensorFlow a TensorFlow Lite.
3. Executar models de TensorFlow Lite en dispositius mòbils.
4. Optimitzar models per a TensorFlow Lite.

TensorFlow Lite és una biblioteca que permet executar models de TensorFlow en dispositius mòbils i integrats. Està dissenyat per ser lleuger i eficient, amb l'objectiu de proporcionar una latència baixa i un alt rendiment en dispositius amb recursos limitats.

• Lleugeresa: Optimitzat per a dispositius amb recursos limitats.
• Latència baixa: Dissenyat per a aplicacions en temps real.
• Compatibilitat: Suporta una àmplia gamma de dispositius i sistemes operatius.
• Facilitat d'ús: Proporciona eines per convertir i optimitzar models de TensorFlow.

Per utilitzar TensorFlow Lite, primer hem de convertir un model de TensorFlow a un format compatible amb TensorFlow Lite. Aquest procés es coneix com a "quantització" i implica la reducció de la precisió dels pesos del model per fer-lo més lleuger i eficient.

1. Crear o carregar un model de TensorFlow:

   import tensorflow as tf
   
   # Crear un model simple
   model = tf.keras.models.Sequential([
       tf.keras.layers.Dense(10, activation='relu', input_shape=(784,)),
       tf.keras.layers.Dense(10, activation='softmax')
   ])
   
   # Compilar el model
   model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
   
   # Entrenar el model
   # model.fit(x_train, y_train, epochs=5)
   

2. Convertir el model a TensorFlow Lite:

   # Convertir el model a TensorFlow Lite
   converter = tf.lite.TFLiteConverter.from_keras_model(model)
   tflite_model = converter.convert()
   
   # Guardar el model convertit
   with open('model.tflite', 'wb') as f:
       f.write(tflite_model)
   

• Crear un model: Utilitzem tf.keras per crear un model simple amb dues capes Dense.
• Compilar el model: Compilem el model amb l'optimitzador adam i la funció de pèrdua sparse_categorical_crossentropy.
• Convertir el model: Utilitzem TFLiteConverter per convertir el model de Keras a un model de TensorFlow Lite.
• Guardar el model: Guardem el model convertit en un fitxer .tflite.

Un cop hem convertit el model, podem executar-lo en un dispositiu mòbil utilitzant l'API de TensorFlow Lite. A continuació es mostra un exemple de com fer-ho en Android.

1. Afegir la dependència de TensorFlow Lite al build.gradle:

   implementation 'org.tensorflow:tensorflow-lite:2.5.0'
   

2. Carregar el model en l'aplicació Android:

   try {
       Interpreter tflite = new Interpreter(loadModelFile());
   } catch (Exception e) {
       e.printStackTrace();
   }
   
   private MappedByteBuffer loadModelFile() throws IOException {
       AssetFileDescriptor fileDescriptor = this.getAssets().openFd("model.tflite");
       FileInputStream inputStream = new FileInputStream(fileDescriptor.getFileDescriptor());
       FileChannel fileChannel = inputStream.getChannel();
       long startOffset = fileDescriptor.getStartOffset();
       long declaredLength = fileDescriptor.getDeclaredLength();
       return fileChannel.map(FileChannel.MapMode.READ_ONLY, startOffset, declaredLength);
   }
   

3. Executar el model:

   float[][] input = new float[1][784]; // Exemple d'entrada
   float[][] output = new float[1][10]; // Exemple de sortida
   
   tflite.run(input, output);
   

• Afegir la dependència: Afegim la dependència de TensorFlow Lite al fitxer build.gradle.
• Carregar el model: Utilitzem Interpreter per carregar el model .tflite des dels recursos de l'aplicació.
• Executar el model: Utilitzem el mètode run per executar el model amb una entrada i obtenir la sortida.

Per millorar el rendiment dels models en dispositius mòbils, podem aplicar diverses tècniques d'optimització, com la quantització.

La quantització redueix la precisió dels pesos del model, disminuint la mida del model i millorant el rendiment.

Exemple de quantització:

• Quantització: Utilitzem l'opció optimizations per aplicar la quantització al model durant la conversió.

1. Crea o carrega un model de TensorFlow.
2. Converteix el model a TensorFlow Lite.
3. Guarda el model convertit en un fitxer .tflite.

1. Crea una aplicació Android.
2. Afegeix la dependència de TensorFlow Lite.
3. Carrega i executa el model en l'aplicació.

Solució a l'Exercici 1:

Solució a l'Exercici 2:

En aquest tema, hem après què és TensorFlow Lite i com ens pot ajudar a executar models d'aprenentatge automàtic en dispositius mòbils i integrats. Hem vist com convertir un model de TensorFlow a TensorFlow Lite, com executar-lo en un dispositiu mòbil i com optimitzar-lo per millorar el rendiment. A més, hem proporcionat exercicis pràctics per reforçar els conceptes apresos. En el següent tema, explorarem TensorFlow.js i com portar models d'aprenentatge automàtic al navegador web.