Federe öğrenme nedir?

Federe öğrenme (FL), bir grup merkezi olmayan cihazdan alınan verileri kullanarak küresel model adı verilen bir şeyi eğiten bir makine öğrenimi tekniğidir. Tamam, orada paketini açacak çok şey var. Bunu adım adım parçalayarak başlayalım. FL'de, tüm verilerini cihazlarında depolayan ve tutan yerel cihazlar (tipik olarak telefonlar, bilgisayarlar vb.) vardır. Ayrıca, güncellenen parametreleri alan, güncellemeleri toplayan ve bunları kullanıcılar için daha verimli yeni bir model yapmak için kullanan genel bir model de vardır. İşin güzel yanı, modelin bir grup cihazdan alınan veriler kullanılarak eğitilmiş olması ve bu veriler hiç paylaşılmadan! Deli değil mi?

Yerel cihazlar, modeli kendi cihazlarında çalıştırmak için yerel verilerini kullanır ve bunu yaparak parametreleri (ağırlıklar ve eğilimler) günceller. Bu güncellenmiş parametreler, onları bir araya getiren ve onları tüketmek ve organize etmek için süslü bir kelime olan küresel modele gönderilir.

Tüm bunlar aslında oldukça yeni, Google bu modeli 2016'da çıkardı. Yani bu teknoloji için çok fazla potansiyel var. Bu makalede, TensorFlow Federated kullanarak görüntü sınıflandırma kodunu derinlemesine inceleyeceğim.

TensorFlow Birleşik (TFF) nedir?

Tff, birçok cihaza yayılmış merkezi olmayan verilerin üzerinde eğitim alınmasına izin veren açık kaynaklı bir çerçevedir. Temel olarak, birleştirilmiş verilerle çalışmak ve birleştirilmiş modelleri eğitmek için birçok yararlı araç sağlar. Birleştirilmiş veriler, farklı kaynaklardan geldiği ve çok fazla bilgi içerdiği için yapay zeka modelleri için kullanılan normal verilerden farklıdır.

TFF hangi araçları sağlıyor?

Koda dalmadan önce, tff'nin sağladığı ve birleşik modelleri eğitmeyi mükemmel kılan "araçlara" kısa bir genel bakış yapmak istedim.

• tff.learning.build_federated_averaging_process: Bu işlev, kullanıcıların birleştirilmiş ortalama alma (FedAvg) ile çalışmasına olanak tanır. FedAvg, en yaygın kullanılan birleşik öğrenme modelidir. Burası, global modelin mevcut parametreleri cihazlara gönderdiği, cihazların modeli çalıştırdığı ve parametreleri güncellediği, ardından tekrar global modele gönderdiği yerdir. Global model tüm bu güncellemeleri alır ve ortalamasını alır, modeli günceller ve ardından yerel cihazlara geri gönderir. Bu, model belirli bir kriteri karşılayana kadar yapılır ve buna yakınsama denir.
• tff.learning.build_federated_evaluation_process : Bu işlev, programcıların birleştirilmiş modelin verimliliğini değerlendirmesine olanak tanır. Değerlendirme süreci, doğruluk, kesinlik ve geri çağırma gibi belirli ölçümleri hesaplamak için tff'nin çalışma zamanı sistemi kullanılarak yapılabilir.
• tff.learning.build_federated_sgd_process : Bu işlev, ağı verimli kılmak için çok önemlidir. Neural Networks'teki geri yayılımdaki kullanımına benzer şekilde, birleştirilmiş stokastik gradyan inişini kullanan bir modeli eğitmek için bir süreç oluşturur.

Süreç

Süreci parçalayalım

1. TFF kitaplıklarının yüklenmesi
2. Verileri önceden işler
3. Verileri eğitmek için model oluşturun
4. Birleşik bir ortalama alma işlemi ayarlama
5. Metrikleri analiz edin
6. Değerlendirme hesaplamalarını ayarlayın
7. Değerlendirme metriklerini analiz edin

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

from tensorflow.python.keras.optimizer_v2 import gradient_descent 
from tensorflow_federated import python as tff

NUM_EPOCHES = 5
BATCH_SIZE = 20 
SHUFFLE_BUFFER = 500 
NUM_CLIENTS = 3

tf.compact.v1.enable_v2_behavior()
emnist_train, emnist_test = tff.simulation.datasets.emnist.load_data()

       
                

                    
                    
                
            

def preprocess(dataset):
    def element_fn(element):
        return collections.OrderedDict([
        ('x', tf.reshape(element['pixels'], [-1])),
        ('y', tf.reshape(element['label'], [1])),
        ])
    return dataset.repeat(NUM_EPOCHES).map(element_fn).shuffle(
        SHUFFLE_BUFFER).batch(BATCH_SIZE)

def make_federated_data(client_data, client_ids):
    return[preprocess(client_data.create_tf_dataset_for_client(x))
    for x in client_ids]

sample_clients = emnist_train.client_ids[0: NUM_CLIENTS]

federated_train_data = make_federated_data(emnist_train, sample_clients)
print(f'Number of clinet datasets:{len(federated_train_data)}')
print(f'First dataset:{federated_train_data[0]}')

def create_keras_model():
    return tf.keras.models.Sequntial([
        tf.keras.layers.Input.Layer(input_shapre=(784,)),
        tf.keras.layers.Dense(10, kernel_initializer= 'zeros'),
        tf.keras.layers.Softmax(),
    ])

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

iterative_process = tff.learning.build_federated_averaging_process(
    client_optimizer_fn = lambda: tf.keras.optimizers.SDG(learning_rate=0.2),
)
server_optimizer_fn=lambda: tf.keras.optimizers.SDG(learning_rate=0.5)

state = iterative_process.initialize()
state,metrics = iterative_process.next(state, federated_train_data)
print('round 1, metrics={}'.format(metrics['train']))

NUM_ROUNDS = 11 
for round_num in range(2,NUM_ROUNDS):
    state, metrics = iterative_process.next(state,federated_train_data)
    print('round{:2d}, metrics{}'.format(round_num,metrics['train']))

evaluation = tff.learning.build_federated_evaluation(model_fn)
shuffled_ids = emnist_test.client_ids.copy()
random.shuffle(shuffled_ids)
sample_clients - shuffled_ids[0:NUM_CLIENTS]

federated_test_data = make_federated_data(emnist_test, sample_clients)

len(federated_test_data), federated_test_data[0]