Nvdia

“Flower ve NVIDIA FLARE’ı Birleştirerek Federated Learning Ekosistemini Güçlendirme”

0
Paylaşımlar

Son yıllarda, Flower ve NVIDIA FLARE gibi açık kaynak sistemleri, federated learning (FL) alanında önemli araçlar haline geldi. **Flower**, FL’yi teşvik eden birleşik bir yaklaşımı savunarak, araştırmacılar ve geliştiricilerin FL uygulamalarını tasarlayıp analiz etmelerini kolaylaştırıyor. Zamanla, bu platform, sağlam bir strateji ve algoritma yelpazesi sunarak akademi ve endüstride canlı bir topluluk oluşturdu.

Buna karşılık, **NVIDIA FLARE**, üretim seviyesindeki uygulamalara odaklanarak güvenilirlik ve ölçeklenebilirlik için tasarlanmış bir çalışma ortamı sunuyor. Güçlü altyapısı sayesinde, FLARE, gerçek dünya koşullarının gereksinimlerini karşılamak üzere FL dağıtımlarını sorunsuz bir şekilde destekliyor.

Bu yazı, bu iki çerçevenin entegrasyonuna dair çabalarımızı açıklıyor ve bu birleşimin FL ekosistemini nasıl yükseltebileceğini gösteriyor. Bu entegrasyon, **Flower**’da geliştirilen uygulamaların, herhangi bir kod değişikliği gerektirmeden FLARE çalışma ortamında yerel olarak çalışmasını sağlıyor. Flower’ın yaygın kullanılan, kullanıcı dostu tasarım araçları ve API’leri ile FLARE’ın endüstriyel düzeydeki çalışma ortamını birleştirerek, uçtan uca dağıtım sürecini sadeleştiriyor.

Sonuç? Araştırmacılar ve uygulayıcılar için federatif öğrenmeyi güçlendiren, sorunsuz, verimli ve erişilebilir bir FL iş akışı!

Entegrasyon Hedefleri: FLARE Üzerinden Flower Uygulamaları Dağıtma

Vizyon basit: Kullanıcıların **Flower ServerApps** ve **ClientApps**’i doğrudan FLARE çalışma ortamında kod değişikliğine gerek kalmadan dağıtabilmelerini sağlamak.

İşte nasıl çalıştığı. Hem Flower hem de FLARE, istemci/sunucu iletişimine dayanan benzer bir mimari temele sahiptir. Her iki sistem de istemciler ve sunucu arasında iletişim için gRPC kullanmakta ve çoklu iş desteği sunarak birden fazla işin istemci ve sunucuları paylaşmasını sağlamakta. Bu mimari benzerlik, iki çerçevenin entegrasyonunu oldukça basit hale getiriyor. FLARE’ı **Flower** uygulamaları için bir iletişim aracı olarak kullanarak, herhangi bir **Flower** uygulamasını bir FLARE işine dönüştürmek mümkün.

Bu süreçte, **Flower**’ın SuperNode’ları doğrudan **SuperLink** üzerinden iletişim kurmaktan vazgeçip, FLARE’ın çalışma ortamına yönlendirilmesidir (Şekil 1).

A diagram shows a Flower ServerApp icon and three Flower ClientApp icons connected through the NVIDIA FLARE Runtime.
Şekil 1. Flower ve NVIDIA FLARE entegrasyonu

Bu entegrasyon sadece sorunsuz değil, aynı zamanda güçlü. İşte sunduğu faydalar:

  • Kolayca sağlama: FLARE, başlatma kitleri ve sertifikalar sağlayarak başlangıcı basitleştiriyor.
  • Özel kod dağıtımı: Flower’ın kullanıcı dostu API’leri ve geliştirici ortamı sayesinde özelleştirilmiş kodlara zahmetsizce ulaşabilirsiniz.
  • Test edilmiş uygulamalar: Flower topluluğu tarafından sağlanan gelişmiş federatif algoritma kütüphanesi üzerinde geliştirme yapabilirsiniz.
  • Geliştirilmiş güvenlik: Yerleşik kimlik doğrulama ve yetkilendirme mekanizmaları güvenli erişim ve kontrol sağlar.
  • Güvenilir iletişim: FLARE’un ReliableMessage özelliği, bağlantı kararlılığı sorunlarını çözüyor.
  • Protokol esnekliği: gRPC, HTTP, TCP ve Redis dahil olmak üzere birden fazla iletişim protokolünü destekleyen adaptif uygulama sağlar.
  • Peer-to-peer iletişim: P2P yetenekleri, taraflar arasında doğrudan etkileşim imkanı tanır.
  • Çoklu iş verimliliği: FLARE çalışma ortamı, ek port gerektirmeden aynı anda birden fazla **Flower** uygulamasını yönetebilir.

**Flower**’ın kullanıcı dostu geliştirme araçları ve API’lerini **FLARE**’ın sağlam çalışma ortamı ile birleştirerek, bu entegrasyon, FL araştırmaları ile üretim arasındaki boşluğu kapatarak, denemeden dağıtıma sorunsuz ve ölçeklenebilir bir ekosistem yaratıyor.

Entegrasyon Tasarımı: Flower’ı FLARE Üzerinden Yönlendirme

FL, istemciler ile sunucular arasında etkili bir iletişimle beslenir. **Flower**, önde gelen bir FL çerçevesidir ve iletişim protokolü olarak gRPC kullanır. FLARE ile entegrasyon sırasında, **Flower**’ın gRPC mesajları, **FLARE** çalışma ortamı üzerinden yönlendirilir.

Burada ana değişiklik. **Flower** istemcilerinin mesajları doğrudan sunucuya göndermesi yerine, **FLARE** istemcisi içinde bulunan yerel bir gRPC sunucusuna (LGS) yönlendirilir. Bu basit yönlendirme, **Flower** uygulamalarının, orijinal kodunu değiştirmeden, **FLARE** içinde sorunsuz çalışmasını sağlar (Şekil 2).

Şekil 2. Flower uygulamalarının FLARE içindeki entegrasyonu

**Flower** SuperNode ile **Flower** SuperLink arasındaki iletişim yolu şu şekildedir:

  1. Bir **Flower** SuperNode, bir gRPC mesajı oluşturur ve bunu FLARE istemcisinde barındırılan LGS’ye gönderir.
  2. **FLARE** istemcisi, bu mesajı güvenilir bir **FLARE** mesajı olarak **FLARE** sunucusuna iletir.
  3. **FLARE** sunucusu içinde, yerel bir gRPC istemcisi (LGC), mesajı hedefine yönlendirmek üzere **Flower** SuperLink ile etkileşimde bulunur.
  4. **SuperLink**, mesajı işler ve yanıtı FLARE sunucusundaki LGC’ye gönderir.
  5. **FLARE** sunucusu, yanıtı tekrar **FLARE** istemcisine yönlendirir.
  6. **FLARE** istemcisi, yanıtı LGS üzerinden **Flower** SuperNode’a gönderir.

Bu tasarım, **Flower**’ın SuperNode ve SuperLink’i arasında sorunsuz bir iletişim sağlar. SuperNode, bağımsız bir işlem olarak veya **FLARE** istemcisi ile aynı işlemde çalışabilir, bu da dağıtım için esneklik sunar.

Bu kurulum sayesinde, **FLARE**’ın güçlü çalışma ortamı yeteneklerinden faydalanırken, uygulamalarınızın basitliğini ve modülerliğini koruyarak, gerçek dünya FL dağıtımlarında kullanılabilirliği ve ölçeklenebilirliği artırabilirsiniz.

Kod Değişikliği Yapmadan Entegrasyon

Bu entegrasyonu göstermek için, **Flower**’ın PyTorch-Quickstart örneğini doğrudan **FLARE** içinde çalıştırabilirsiniz.

İlk olarak, bir **Flower ServerApp** oluşturun:

# Stratejiyi tanımla
strategy = FedAvg(...)

# Flower ServerApp
def server_fn(context: Context):
    # Ayarlamaları yapılandır
    num_rounds = context.run_config["num-server-rounds"]

    # Yapılandırmayı tanımla
    config = ServerConfig(num_rounds=num_rounds)

    return ServerAppComponents(strategy=strategy, config=config)


# ServerApp'i oluştur
app = ServerApp(server_fn=server_fn)

Sonraki adımda, **Flower ClientApp**’i tanımlayın:

# FlowerClient ve client_fn'i tanımla
class FlowerClient(NumPyClient):
    def fit(self, parameters, config):
        set_weights(net, parameters)
        results = train(net, trainloader, testloader, epochs=1, device=DEVICE)
        return get_weights(net), len(trainloader.dataset), results

    def evaluate(self, parameters, config):
        set_weights(net, parameters)
        loss, accuracy = test(net, testloader)
        return loss, len(testloader.dataset), {"accuracy": accuracy}


def client_fn(context: Context):
    """Flower 'Client' örneğini yarat ve döndür."""
    return FlowerClient().to_client()


# Flower ClientApp
app = ClientApp(
    client_fn=client_fn,
)

**Flower** ve **FLARE** entegrasyonu sayesinde, **Flower** çerçevesiyle geliştirilen uygulamalar, herhangi bir değişiklik yapmadan **FLARE** çalışma ortamında sorunsuz bir şekilde çalışır.

Uçtan uca bir örnek için NVIDIA FLARE içindeki Flower Uygulaması (PyTorch) sayfasına göz atabilirsiniz.

Tekrar Edilebilirlik Sağlama: **FLARE** ile **Flower** Uygulamalarını Çalıştırma

Çerçevelerin entegrasyonunda en kritik unsurlardan biri, işlevselliğin ve sonuçların değişmeden kalmasını sağlamaktır. **Flower** uygulamalarını **FLARE** ortamına entegre ederken, bağımsız **Flower** kurulumundaki sonuçların tamamen aynı kalmasını hedefledik.

Bunu göstermek için bir deney gerçekleştirdik:

  1. Her iki ortamda (bağımsız **Flower** ve **FLARE** içindeki **Flower**) istemcileri için aynı rastgele tohumları (random seeds) kullanarak **Flower** uygulamasını başlattık.
  2. Her senaryonun eğitim eğrilerini izledik ve çizdik (Şekil 3).
Şekil 3. Bağımsız **Flower** (a) veya **FLARE** (b) içinde çalıştırılan **Flower** uygulamasının karşılaştırması

Eğitim eğrilerini her iki kurulumda üst üste koyduğumuzda, tam olarak aynı hizaya geldiğini gördük. Bu, **FLARE** üzerinden yönlendirmenin sonuçları etkilemediğini kanıtladı.

Bu tutarlılık, **Flower** ile **FLARE** entegrasyonunun, eğitim sürecinin bütünlüğünü koruduğunu kanıtlayarak önemli bir gelişme. Artık, **FLARE**’ın çalışma ortamına sorunsuz bir geçiş yapabilir ve performans veya sonuçlarda sapma olmayacağından emin olabilirsiniz.

Yeni Olanakların Kilidini Açma: **FLARE**’ın Deney Takibi ile Hibrit Entegrasyon

İki güçlü çerçevenin en iyi yanlarını bir araya getirdiğinizi hayal edin: **Flower**’ın sezgisel FL geliştirme araçları ile **FLARE**’ın sağlam çalışma ortamı özellikleri. Bu hibrit entegrasyon, bu vizyonu gerçeğe dönüştürüyor.

Bir **Flower** uygulamasını **FLARE** çalışma ortamında dağıtarak, artık **FLARE**’ın deney takibi özelliklerinden yararlanabilirsiniz. **FLARE**’ın SummaryWriter özelliğini **Flower** istemci kodunuza entegre ederken bunu kolayca gerçekleştirebilirsiniz. İşte bu işlem için **FLARE**’ın SummaryWriter‘ını **Flower**’ın istemci uygulamasına ekleyin:

# NVFlare arayüzünü başlatır
from nvflare.client.tracking import SummaryWriter


# FlowerClient ve client_fn'i tanımla
class FlowerClient(NumPyClient):
    def __init__(self, context: Context):
        super().__init__()
        self.writer = SummaryWriter()
        self.flwr_context = context

        if "step" not in context.state.metrics_records:
            self.set_step(0)

    def set_step(self, step: int):
        self.flwr_context.state = RecordSet(metrics_records={"step": MetricsRecord({"step": step})})

    def get_step(self):
        return int(self.flwr_context.state.metrics_records["step"]["step"])

    def fit(self, parameters, config):
        step = self.get_step()
        set_weights(net, parameters)
        results = train(net, trainloader, testloader, epochs=1, device=DEVICE)

        self.writer.add_scalar("train_loss", results["train_loss"], step)
        self.writer.add_scalar("train_accuracy", results["train_accuracy"], step)
        self.writer.add_scalar("val_loss", results["val_loss"], step)
        self.writer.add_scalar("val_accuracy", results["val_accuracy"], step)

        self.set_step(step + 1)

        return get_weights(net), len(trainloader.dataset), results
…

Yukarıdaki kod örneğinde, mevcut eğitim adımını **Flower**’ın metrics_records özelliği ile takip edebilirsiniz.

Şekil 4. **Flower ClientApps** **FLARE**’ın deney takibi ile çalışır ve merkezi sunucuda görselleştirilir.

Bu entegrasyon sayesinde araştırmacılar ve geliştiriciler:

  • Gelişmeleri zahmetsizce izleme: Deneylerini, tanıdık **Flower** iş akışında hassas bir biçimde takip edebilirler.
  • Birlikte çalışma gücünden yararlanma: **FLARE**’ın endüstriyel düzeydeki özelliklerinden, **Flower**’ın sadeliğinden ödün vermeden faydalanabilirler.

Daha fazla bilgi için TensorBoard akışı ile bir simülasyon çalıştırma sayfasını ziyaret edebilirsiniz.

Özet

Bu, iki çarpıcı FL çerçevesinin bir araya gelmesiyle nelerin mümkün olduğunu ortaya koyan bir başlangıç. **Flower** ve **NVIDIA FLARE** entegrasyonu, daha verimli, ölçeklenebilir ve özellik zenginliği taşıyan federatif öğrenme uygulamalarının kapılarını açıyor!

Araştırmacılar ve geliştiriciler için, FL ortamları arasında tekrar edilebilirliğin sağlanması büyük önem taşıyor. Bu entegrasyonla, deneyler ve sonuçlar güvence altına alınıyor, **FLARE**’ı kuruluş seviyesindeki dağıtımlarda kullanmanın engelleri kaldırılıyor.

Tam sonuçları koruyarak **FLARE**’ın sağlam çalışma ortamında güvenle uygulamalarınızı kullanmanızı sağladık.

Daha fazla bilgi için şu kaynaklara göz atabilirsiniz:

Herhangi bir sorunuz veya yorumunuz mu var? Bizimle federatedlearning@nvidia.com adresinden irtibata geçebilirsiniz.

Kaynak

Nvdia Blog

0
Paylaşımlar
Yorumlar

Benzer Haberler

Exit mobile version