El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

TensorFlow Federated

Següent ►
►

Introducció a TensorFlow Federated

TensorFlow Federated (TFF) és una biblioteca de codi obert per a l'aprenentatge federat (FL) i altres computacions distribuïdes en dispositius. L'aprenentatge federat permet entrenar models de machine learning en dades distribuïdes en múltiples dispositius sense necessitat de centralitzar les dades. Això és especialment útil en escenaris on la privacitat de les dades és crítica, com en aplicacions mòbils o de salut.

Objectius del Tema

  • Entendre què és TensorFlow Federated i els seus avantatges.
  • Aprendre a configurar un entorn de treball amb TFF.
  • Explorar els conceptes bàsics de l'aprenentatge federat.
  • Implementar un exemple pràctic d'aprenentatge federat amb TFF.

Què és TensorFlow Federated?

TensorFlow Federated és una extensió de TensorFlow que permet la implementació d'algoritmes d'aprenentatge federat. Els principals avantatges de TFF són:

  • Privacitat de les dades: Les dades romanen en els dispositius dels usuaris, reduint el risc de filtracions de dades.
  • Escalabilitat: Permet entrenar models en milers o milions de dispositius.
  • Eficiència: Redueix la necessitat de transferir grans volums de dades a un servidor central.

Configuració de TensorFlow Federated

Requisits previs

Abans de començar, assegura't de tenir instal·lats els següents components:

  • Python 3.6 o superior
  • TensorFlow 2.x
  • TensorFlow Federated

Instal·lació

Pots instal·lar TensorFlow Federated utilitzant pip:

pip install tensorflow tensorflow-federated

Conceptes bàsics de l'aprenentatge federat

Arquitectura de l'aprenentatge federat

L'aprenentatge federat es basa en una arquitectura client-servidor:

  • Clients: Dispositius que contenen les dades locals i entrenen models localment.
  • Servidor: Coordina l'entrenament, agregant els models locals dels clients per actualitzar el model global.

Flux de treball de l'aprenentatge federat

  1. Inicialització: El servidor inicialitza el model global.
  2. Distribució: El model global es distribueix als clients.
  3. Entrenament local: Els clients entrenen el model amb les seves dades locals.
  4. Agregació: Els models locals es retornen al servidor, que els agrega per actualitzar el model global.
  5. Iteració: El procés es repeteix fins que el model global convergeix.

Exemple pràctic: Classificació de dígits amb MNIST

Pas 1: Importar les biblioteques necessàries

import tensorflow as tf
import tensorflow_federated as tff
import numpy as np

Pas 2: Preparar les dades

Utilitzarem el dataset MNIST per a aquest exemple. Primer, carreguem i preprocessem les dades.

def preprocess(dataset):
    def batch_format_fn(element):
        return (tf.reshape(element['pixels'], [-1, 784]), element['label'])
    return dataset.repeat(10).shuffle(1000).batch(20).map(batch_format_fn)

mnist_train, mnist_test = tf.keras.datasets.mnist.load_data()
mnist_train = tf.data.Dataset.from_tensor_slices({
    'pixels': mnist_train[0].astype(np.float32) / 255.0,
    'label': mnist_train[1].astype(np.int32)
}).apply(preprocess)

Pas 3: Definir el model

Definim un model simple de xarxa neuronal per a la classificació de dígits.

def create_keras_model():
    return tf.keras.models.Sequential([
        tf.keras.layers.InputLayer(input_shape=(784,)),
        tf.keras.layers.Dense(10, activation='softmax')
    ])

def model_fn():
    keras_model = create_keras_model()
    return tff.learning.from_keras_model(
        keras_model,
        input_spec=mnist_train.element_spec,
        loss=tf.keras.losses.SparseCategoricalCrossentropy(),
        metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]
    )

Pas 4: Configurar l'entrenament federat

iterative_process = tff.learning.build_federated_averaging_process(model_fn)
state = iterative_process.initialize()

Pas 5: Entrenar el model

for round_num in range(1, 11):
    state, metrics = iterative_process.next(state, [mnist_train])
    print(f'Round {round_num}, Metrics={metrics}')

Exercici pràctic

Exercici 1: Modificar el model

Modifica el model de xarxa neuronal per afegir una capa oculta amb 128 neurones i activació ReLU. Entrena el model modificat i compara els resultats amb el model original.

Solució

def create_keras_model():
    return tf.keras.models.Sequential([
        tf.keras.layers.InputLayer(input_shape=(784,)),
        tf.keras.layers.Dense(128, activation='relu'),
        tf.keras.layers.Dense(10, activation='softmax')
    ])

Conclusió

En aquest tema, hem explorat TensorFlow Federated i els seus avantatges per a l'aprenentatge federat. Hem après a configurar un entorn de treball amb TFF, a preparar dades i a definir un model simple de xarxa neuronal. Finalment, hem implementat un exemple pràctic d'aprenentatge federat utilitzant el dataset MNIST. Amb aquests coneixements, estàs preparat per explorar aplicacions més avançades d'aprenentatge federat amb TensorFlow Federated.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats