AWS ve Amazon SageMaker üzerinde Kubeflow'u kullanarak esnek ve ölçeklenebilir dağıtılmış eğitim mimarileri oluşturun

Bu yazıda nasıl olduğunu gösteriyoruz AWS'de Kubeflow (AWS'ye özgü bir Kubeflow dağıtımı) ile birlikte kullanılır AWS Derin Öğrenme Kapları ve Amazon Elastik Dosya Sistemi (Amazon EFS), işbirliğini basitleştirir ve derin öğrenme modellerinin her ikisinde de uygun ölçekte eğitiminde esneklik sağlar Amazon Elastik Kubernetes Hizmeti (Amazon EKS) ve Amazon Adaçayı Yapıcı hibrit bir mimari yaklaşımı kullanıyor.

Makine öğrenimi (ML) geliştirme, karmaşık ve sürekli gelişen açık kaynaklı çerçevelere ve araç setlerine ve ayrıca karmaşık ve sürekli gelişen donanım ekosistemlerine dayanır. Bu, ML geliştirmeyi bir kümeye ölçeklendirirken bir zorluk teşkil eder. Kapsayıcılar bir çözüm sunar, çünkü yalnızca eğitim kodunu değil, tüm bağımlılık yığınını donanım kitaplıklarına kadar tam olarak kapsülleyebilirler. Bu, tutarlı ve taşınabilir bir ML ortamı sağlar ve eğitim kümesinin her bir düğümünde eğitim ortamının yeniden üretilebilirliğini kolaylaştırır.

Kubernetes, altyapı dağıtımını, kaynak ölçeklendirmeyi ve bu kapsayıcılı uygulamaların yönetimini otomatikleştirmek için yaygın olarak benimsenen bir sistemdir. Ancak Kubernetes, makine öğrenimi düşünülerek oluşturulmamıştır, bu nedenle YAML belirtim dosyalarına büyük ölçüde bağımlı olması nedeniyle veri bilimcilerine mantıksız gelebilir. Bir Jupyter deneyimi yoktur ve iş akışı yönetimi ve işlem hatları gibi ML'ye özgü pek çok yetenek ve ML uzmanlarının beklediği hiperparametre ayarlama, model barındırma ve diğerleri gibi diğer yetenekler yoktur. Bu tür yetenekler oluşturulabilir, ancak Kubernetes birincil hedefi olarak bunu yapmak için tasarlanmamıştır.

Açık kaynak topluluğu bunu fark etti ve Kubernetes'in üzerinde Kubeflow adlı bir katman geliştirdi. Kubeflow, Kubernetes'te uçtan uca ML iş akışlarının dağıtımını basit, taşınabilir ve ölçeklenebilir hale getirmeyi amaçlar. ML için türünün en iyisi açık kaynak sistemlerini çeşitli altyapılara dağıtmak için Kubeflow'u kullanabilirsiniz.

Kubeflow ve Kubernetes, veri bilimcisi ekiplerine esneklik ve kontrol sağlar. Bununla birlikte, düşük operasyonel genel giderlerle geniş ölçekte çalışan eğitim kümelerinin yüksek düzeyde kullanımını sağlamak hala zorludur.

Bu gönderi, şirket içi kısıtlamaları veya mevcut Kubernetes yatırımları olan müşterilerin, kendi kendini yöneten bir yaklaşıma dayalı olarak dağıtılmış eğitim için bir ML ardışık düzeni uygulamak üzere Amazon EKS ve Kubeflow on AWS'yi kullanarak bu zorluğun üstesinden nasıl gelebileceğini gösterir. maliyet açısından optimize edilmiş, tam olarak yönetilen ve üretim ölçeğinde eğitim altyapısı. Bu, çalışma zamanında iki yaklaşım arasında seçim yapmanızı sağlayan, dağıtımlarınız için katı ihtiyaçlarla maksimum kontrol ve esneklik sağlayan hibrit dağıtılmış eğitim mimarisinin adım adım uygulanmasını içerir. Derin öğrenme eğitim komut dosyanızda açık kaynak kitaplıkları kullanmaya nasıl devam edebileceğinizi ve onu platformdan bağımsız bir şekilde hem Kubernetes hem de SageMaker üzerinde çalışmaya uyumlu hale getirmeye nasıl devam edebileceğinizi göreceksiniz.

AWS ve SageMaker'da Kubeflow nasıl yardımcı olur?

TensorFlow, PyTorch, MXNet ve diğerleri gibi derin öğrenme çerçeveleriyle oluşturulmuş sinir ağı modelleri, özellikle bilgisayarla görme ve doğal dil işleme kullanım durumlarında önemli ölçüde daha büyük eğitim veri kümelerini kullanarak çok daha yüksek doğruluk sağlar. Ancak, büyük eğitim veri kümeleriyle, derin öğrenme modellerini eğitmek daha uzun sürer ve bu da sonuçta pazara sunma süresini yavaşlatır. Bir kümeyi ölçeklendirebilir ve model eğitim süresini haftalardan günlere veya saatlere indirebilirsek, bunun üretkenlik ve iş hızı üzerinde büyük bir etkisi olabilir.

Amazon EKS, yönetilen Kubernetes kontrol düzleminin sağlanmasına yardımcı olur. Amazon EKS'yi CPU ve GPU örnekleriyle büyük ölçekli eğitim kümeleri oluşturmak için kullanabilir ve Kubeflow araç setini kullanarak makine öğrenimi dostu, açık kaynaklı araçlar sağlayabilir ve ekibinizin üretkenliğini ve pazara sunma süresini kısaltın.

Ancak, bu yaklaşımla ilgili birkaç zorluk olabilir:

• Veri bilimi ekipleri arasında bir kümenin maksimum kullanımını sağlamak. Örneğin, talep üzerine GPU örnekleri sağlamalı ve derin öğrenme eğitimi gibi üretim ölçeğindeki zorlu görevler için yüksek kullanımını sağlamalı ve veri ön işleme gibi daha az zorlu görevler için CPU örneklerini kullanmalısınız.
• Kubernetes küme çalışanı düğümünde dağıtılan veritabanı, depolama ve kimlik doğrulama dahil olmak üzere ağır Kubeflow altyapı bileşenlerinin yüksek düzeyde kullanılabilirliğini sağlama. Örneğin, Kubeflow kontrol düzlemi, zamanla büyüyen ve sürekli izleme özelliklerine sahip yeniden boyutlandırılabilir depolama birimlerine ihtiyaç duyan yapay nesneler (MySQL örnekleri, pod günlükleri veya MinIO depolaması gibi) oluşturur.
• Eğitim veri kümesini, kodu ve bilgi işlem ortamlarını geliştiriciler, eğitim kümeleri ve projeler arasında paylaşmak zordur. Örneğin, kendi kitaplık kümeniz üzerinde çalışıyorsanız ve bu kitaplıkların güçlü karşılıklı bağımlılıkları varsa, aynı kod parçasını aynı ekipteki veri bilimcileri arasında paylaşmak ve çalıştırmak gerçekten zorlaşır. Ayrıca, her eğitim çalıştırması, eğitim veri kümesini indirmenizi ve yeni kod değişiklikleriyle eğitim görüntüsünü oluşturmanızı gerektirir.

AWS'de Kubeflow, bu zorlukların üstesinden gelmeye yardımcı olur ve kurumsal düzeyde yarı yönetilen bir Kubeflow ürünü sağlar. AWS'de Kubeflow ile veritabanı, depolama, izleme ve kullanıcı yönetimi gibi bazı Kubeflow kontrol düzlemi hizmetlerini, aşağıdakiler gibi AWS tarafından yönetilen hizmetlerle değiştirebilirsiniz: Amazon İlişkisel Veritabanı Hizmeti (Amazon RDS), Amazon Basit Depolama Hizmeti (Amazon S3), Amazon Elastik Dosya Sistemi (Amazon EFS'si), Amazon FSx, Amazon Bulut İzleme, ve Amazon Cognito'su.

Bu Kubeflow bileşenlerinin değiştirilmesi, Kubeflow kontrol düzleminin kritik parçalarını Kubernetes'ten ayırarak güvenli, ölçeklenebilir, esnek ve uygun maliyetli bir tasarım sağlar. Bu yaklaşım ayrıca, dağıtılmış model eğitimi veya kullanıcı dizüstü bilgisayar sunucuları gibi uygulamalar tarafından ihtiyaç duyulabilecek EKS veri düzlemindeki depolama ve hesaplama kaynaklarını da serbest bırakır. AWS'de Kubeflow ayrıca Jupyter not defterlerinin, önceden paketlenmiş ve PyTorch ve TensorFlow gibi eğitim kodunuzu herhangi bir işlem yapmadan hemen yazmaya başlamanıza olanak tanıyan AWS için optimize edilmiş derin öğrenme çerçeveleriyle önceden yapılandırılmış Derin Öğrenme Kapsayıcısı (DLC) görüntüleri ile yerel entegrasyonunu sağlar. bağımlılık çözünürlükleri ve çerçeve optimizasyonları ile. Ayrıca, eğitim kümeleri ve geliştirme ortamıyla Amazon EFS entegrasyonu, kodunuzu ve işlenmiş eğitim veri kümenizi paylaşmanıza olanak tanır; bu da her kod değişikliğinden sonra kapsayıcı görüntüsü oluşturmayı ve çok büyük veri kümelerini yüklemeyi önler. AWS'de Kubeflow ile yapılan bu entegrasyonlar, model oluşturma ve eğitim süresini hızlandırmanıza yardımcı olur ve daha kolay veri ve kod paylaşımıyla daha iyi işbirliğine olanak tanır.

AWS'deki Kubeflow, yüksek oranda erişilebilir ve sağlam bir makine öğrenimi platformu oluşturmaya yardımcı olur. Bu platform, derin öğrenme modelleri oluşturmak ve eğitmek için esneklik sağlar ve birçok açık kaynaklı araç setine, günlüklere ilişkin içgörülere ve deneyler için etkileşimli hata ayıklamaya erişim sağlar. Bununla birlikte, yüzlerce GPU üzerinde derin öğrenme modellerini eğitirken altyapı kaynaklarından maksimum düzeyde yararlanmaya ulaşmak, yine de çok fazla operasyonel genel gider gerektirir. Bu sorun, yalnızca istendiğinde sağlanan, gerektiği gibi ölçeklenen ve işler tamamlandığında otomatik olarak kapatılan, böylece 100'e yakın performans sağlayan ve maliyet açısından optimize edilmiş eğitim kümelerini işlemek için tasarlanmış ve optimize edilmiş tam olarak yönetilen bir hizmet olan SageMaker kullanılarak çözülebilir. % kaynak kullanımı. Yönetilen SageMaker bileşenlerini kullanarak SageMaker'ı Kubeflow Pipelines ile entegre edebilirsiniz. Bu, ML iş akışlarını, yerel eğitim için Kubernetes'i ve hibrit bir mimaride ürün ölçeğinde eğitim için SageMaker'ı kullanabileceğiniz Kubeflow ardışık düzenlerinin bir parçası olarak çalıştırmanıza olanak tanır.

Çözüme genel bakış

Aşağıdaki mimari, çalışma zamanı parametresine dayalı olarak Kubeflow eğitimini veya SageMaker'ı kullanarak Kubernetes'te koşullu olarak dağıtılmış eğitimi çalıştırmak için taşınabilir ve ölçeklenebilir uçtan uca ML iş akışları oluşturmak ve dağıtmak için Kubeflow Pipelines'ı nasıl kullandığımızı açıklar.

Kubeflow eğitimi, Kubeflow'a TensorFlow, PyTorch ve diğerleri gibi farklı çerçeveler kullanan ML modellerinin dağıtılmış eğitimi için destek ekleyen bir Kubernetes Operatörü grubudur. pytorch-operator Kubernetes'in Kubeflow uygulamasıdır özel kaynak (PyTorchJob) Kubernetes'te dağıtılmış PyTorch eğitim işlerini çalıştırmak için.

Etkileşimli hata ayıklama ve analiz için esnekliğe ve temel tüm kaynaklara erişime ihtiyacımız olduğunda, deneme aşamasında PyTorch dağıtılmış eğitimini çalıştırmak için Kubeflow ardışık düzeninin bir parçası olarak PyTorchJob Başlatıcı bileşenini kullanırız.

Model eğitimimizi üretim ölçeğinde yürütmek için Kubeflow Pipelines için SageMaker bileşenlerini de kullanıyoruz. Bu, tam olarak yönetilen hizmetler, maksimum GPU kullanımına sahip dağıtılmış eğitim işleri ve aşağıdakiler aracılığıyla uygun maliyetli eğitim gibi güçlü SageMaker özelliklerinden yararlanmamızı sağlar. Amazon Elastik Bilgi İşlem Bulutu (Amazon EC2) Spot Bulut Sunucuları.

İş akışı oluşturma sürecinin bir parçası olarak, bu ardışık düzeni oluşturmak için aşağıdaki adımları (önceki şemada gösterildiği gibi) tamamlarsınız:

1. Bir Kubeflow panosu oluşturmak ve Kubeflow merkezi panosundan Jupyter not defterlerine erişmek için Kubeflow bildirim dosyasını kullanın.
2. Python kodunu kullanarak Kubeflow ardışık düzenleri oluşturmak ve derlemek için Kubeflow ardışık düzen SDK'sını kullanın. İşlem hattı derlemesi, Python işlevini Argo uyumlu bir YAML biçimi olan bir iş akışı kaynağına dönüştürür.
3. İşlem hattını çalıştırmak için işlem hattı hizmeti uç noktasını çağırmak için Kubeflow Pipelines SDK istemcisini kullanın.
4. İşlem hattı, koşullu çalıştırma zamanı değişkenlerini değerlendirir ve hedef çalıştırma ortamı olarak SageMaker veya Kubernetes arasında karar verir.
5. Yerel Kubernetes ortamında dağıtılmış eğitimi çalıştırmak için Kubeflow PyTorch Launcher bileşenini kullanın veya eğitimi SageMaker tarafından yönetilen platformda göndermek için SageMaker bileşenini kullanın.

Aşağıdaki şekil, bize Kubernetes veya SageMaker dağıtılmış ortamları arasında seçim yapma esnekliği sağlayan mimaride yer alan Kubeflow Pipelines bileşenlerini göstermektedir.

Vaka İş Akışını Kullan

Amazon EKS ve AWS'de Kubeflow kullanarak SageMaker kullanarak dağıtılmış eğitim için kullanım senaryosunu yüklemek ve çalıştırmak için aşağıdaki adım adım yaklaşımı kullanıyoruz.

Önkoşullar

Bu izlenecek yol için aşağıdaki ön koşullara sahip olmalısınız:

• An AWS hesabı.
• Docker'lı bir makine ve AWS Komut Satırı Arayüzü (AWS CLI) yüklü.
• İsteğe bağlı olarak kullanabilirsiniz AWS Bulut9, tüm işleri web tarayıcınızdan tamamlamayı sağlayan bulut tabanlı bir entegre geliştirme ortamı (IDE). Kurulum talimatları için bkz. Cloud9 IDE'yi kurun. Cloud9 ortamınızdan artı işaretini seçin ve yeni terminali açın.
• Bir rol oluşturun isimle sagemakerrole. Yönetilen politikalar ekle AmazonSageMakerFullAccess ve AmazonS3FullAccess SageMaker'ın S3 kovalarına erişmesini sağlamak için. Bu rol, Kubeflow Pipelines adımının bir parçası olarak gönderilen SageMaker işi tarafından kullanılır.
• Hesabınızın SageMaker Eğitimi kaynak türü sınırına sahip olduğundan emin olun. ml.p3.2xlarge kullanarak 2'ye yükseldi Hizmet Kotaları Konsolu

1. Amazon EKS ve Kubeflow'u AWS'ye yükleyin

Bir Kubernetes kümesi oluşturmak ve Kubeflow'u dağıtmak için birkaç farklı yaklaşım kullanabilirsiniz. Bu yazıda, sürece basitlik getirdiğine inandığımız bir yaklaşıma odaklanıyoruz. Önce bir EKS kümesi oluşturuyoruz, ardından üzerinde Kubeflow'u AWS v1.5 üzerinde dağıtıyoruz. Bu görevlerin her biri için, aşağıdaki ilkeleri izleyen ilgili açık kaynaklı bir proje kullanıyoruz. Çerçeve Yap. Her görev için bir dizi önkoşul yüklemek yerine, gerekli tüm araçlara sahip Docker kapsayıcıları oluşturuyor ve görevleri kapsayıcıların içinden gerçekleştiriyoruz.

Bu gönderide, bir eklenti olarak Amazon EFS ile Kubeflow dağıtımını otomatikleştiren Do Çerçevesini kullanıyoruz. Üretim dağıtımlarına yönelik resmi Kubeflow on AWS dağıtım seçenekleri için bkz. açılma.

Geçerli çalışma dizinini ve AWS CLI'yi yapılandırın

Bir çalışma dizini yapılandırırız, böylece onu takip eden adımlar için başlangıç ​​noktası olarak görebiliriz:

export working_dir=$PWD

Ayrıca bir AWS CLI profili yapılandırıyoruz. Bunu yapmak için, bir erişim anahtarı kimliğine ve bir erişim anahtarının gizli erişim anahtarına ihtiyacınız vardır. AWS Kimlik ve Erişim Yönetimi (BEN) kullanıcı yönetici ayrıcalıklarına (mevcut yönetilen politikayı ekleyin) ve programlı erişime sahip hesap. Aşağıdaki koda bakın:

aws configure --profile=kubeflow
AWS Access Key ID [None]: 
AWS Secret Access Key [None]: 
Default region name [None]: us-west-2
Default output format [None]: json

# (In Cloud9, select “Cancel” and “Permanently disable” when the AWS managed temporary credentials dialog pops up)

export AWS_PROFILE=kubeflow

1.1 Bir EKS kümesi oluşturun

Halihazırda bir EKS kümeniz varsa, bir sonraki bölüme geçebilirsiniz. Bu gönderi için, aws-do-eks projesi kümemizi oluşturmak için.

1. İlk önce projeyi çalışma dizininizde klonlayın

   cd ${working_dir}
   git clone https://github.com/aws-samples/aws-do-eks
   cd aws-do-eks/

2. Sonra derleyin ve çalıştırın aws-do-eks konteyner:

   ./build.sh
   ./run.sh

   The build.sh komut dosyası, EKS kümelerinin sağlanması ve çalıştırılması için gerekli tüm araçlara ve komut dosyalarına sahip bir Docker kapsayıcı görüntüsü oluşturur. bu run.sh script, oluşturulan Docker imajını kullanarak bir kapsayıcı başlatır ve bunu devam ettirir, böylece onu EKS yönetim ortamımız olarak kullanabiliriz. durumunuzu görmek için aws-do-eks konteyner, çalıştırabilirsiniz ./status.sh. Kapsayıcı Exited durumundaysa, şunu kullanabilirsiniz: ./start.sh kapsayıcıyı açmak veya kapsayıcıyı yeniden başlatmak için komut dosyası çalıştırabilirsiniz ./stop.sh ardından ./run.sh.

3. Koşuda bir kabuk açın aws-do-eks konteyner:
4. KubeFlow dağıtımımız için EKS kümesi yapılandırmasını gözden geçirmek için aşağıdaki komutu çalıştırın:

   vi ./eks-kubeflow.yaml

   Varsayılan olarak, bu yapılandırma adlı bir küme oluşturur. eks-kubeflow içinde us-west-2 Altı m5.xlarge düğümü olan bölge. Ayrıca, EBS birimleri şifrelemesi varsayılan olarak etkin değildir. ekleyerek etkinleştirebilirsiniz. "volumeEncrypted: true" düğüm grubuna ve varsayılan anahtarı kullanarak şifreleyecektir. Gerekirse diğer yapılandırma ayarlarını değiştirin.

5. Kümeyi oluşturmak için aşağıdaki komutu çalıştırın:

   export AWS_PROFILE=kubeflow
   eksctl create cluster -f ./eks-kubeflow.yaml

   Küme sağlama işlemi 30 dakika kadar sürebilir.

6. Kümenin başarıyla oluşturulduğunu doğrulamak için aşağıdaki komutu çalıştırın:

   kubectl get nodes

   Başarıyla oluşturulmuş bir küme için önceki komutun çıktısı aşağıdaki koda benzer:

   root@cdf4ecbebf62:/eks# kubectl get nodes
   NAME                                           STATUS   ROLES    AGE   VERSION
   ip-192-168-0-166.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-13-28.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-45-240.us-west-2.compute.internal   Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-63-84.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-75-56.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-85-226.us-west-2.compute.internal   Ready       23m   v1.21.14-eks-ba74326

SageMaker eğitim işi için bir EFS birimi oluşturun

Bu kullanım örneğinde, Amazon EFS'de depolanan verilerden derin öğrenme modellerini eğiterek SageMaker eğitim işini hızlandırırsınız. Bu seçim, eğitim işlerinizi veri hareketi gerektirmeden Amazon EFS'deki verilerden doğrudan başlatma avantajına sahiptir ve bu da daha hızlı eğitim başlangıç ​​süreleri sağlar.

Bir EFS birimi oluşturuyoruz ve EFS Container Storage Interface (CSI) sürücüsünü dağıtıyoruz. Bu, içinde bulunan bir dağıtım komut dosyası tarafından gerçekleştirilir. /eks/deployment/csi/efs içinde aws-do-eks konteyner.

Bu komut dosyası, hesabınızda bir EKS kümeniz olduğunu varsayar. Ayarlamak CLUSTER_NAME= birden fazla EKS kümeniz olması durumunda.

cd /eks/deployment/csi/efs
./deploy.sh

Bu komut dosyası bir EFS birimi sağlar ve küme VPC'sinin alt ağları için bağlama hedefleri oluşturur. Daha sonra EFS CSI sürücüsünü dağıtır ve efs-sc depolama sınıfı ve efs-pv EKS kümesindeki kalıcı birim.

Komut dosyasının başarıyla tamamlanmasının ardından aşağıdaki gibi bir çıktı görmelisiniz:

Generating efs-sc.yaml ...

Applying efs-sc.yaml ...
storageclass.storage.k8s.io/efs-sc created
NAME            PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
efs-sc          efs.csi.aws.com         Delete          Immediate              false                  1s
gp2 (default)   kubernetes.io/aws-ebs   Delete          WaitForFirstConsumer   false                  36m

Generating efs-pv.yaml ...
Applying efs-pv.yaml ...
persistentvolume/efs-pv created
NAME     CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS      CLAIM   STORAGECLASS   REASON   AGE
efs-pv   5Gi        RWX            Retain           Available           efs-sc                  10s

Done ...

Amazon S3 VPC uç noktası oluşturun

SageMaker eğitim işinizin ve EFS dosya sisteminizin erişebildiği özel bir VPC kullanıyorsunuz. SageMaker eğitim kümesine özel VPC'nizden S3 klasörlerine erişim vermek için bir VPC uç noktası oluşturursunuz:

cd /eks/vpc 
export CLUSTER_NAME= 
export REGION= 
./vpc-endpoint-create.sh

şimdi çıkış yapabilirsiniz aws-do-eks konteyner kabuğu ve sonraki bölüme geçin:

exit

root@cdf4ecbebf62:/eks/deployment/csi/efs# exit
exit
TeamRole:~/environment/aws-do-eks (main) $

1.2 Kubeflow'u Amazon EKS'de AWS'ye Dağıtma

Kubeflow'u Amazon EKS üzerinde dağıtmak için aws-do-kubeflow projesi.

1. Aşağıdaki komutları kullanarak depoyu klonlayın:

   cd ${working_dir}
   git clone https://github.com/aws-samples/aws-do-kubeflow
   cd aws-do-kubeflow

2. Ardından projeyi yapılandırın:

   ./config.sh

   Bu komut dosyası, proje yapılandırma dosyasını bir metin düzenleyicide açar. için önemlidir AWS_REGION kümenizin bulunduğu Bölgeye ayarlanacak ve ayrıca AWS_CLUSTER_NAME daha önce oluşturduğunuz kümenin adıyla eşleştirmek için. Varsayılan olarak, yapılandırmanız zaten doğru şekilde ayarlanmıştır, bu nedenle herhangi bir değişiklik yapmanız gerekmiyorsa düzenleyiciyi kapatmanız yeterlidir.

   ./build.sh
   ./run.sh
   ./exec.sh

   The build.sh komut dosyası, mevcut bir Kubernetes kümesinde Kubeflow'u dağıtmak ve yönetmek için gerekli tüm araçlara sahip bir Docker kapsayıcı görüntüsü oluşturur. bu run.sh komut dosyası, Docker görüntüsünü kullanarak bir kapsayıcı başlatır ve exec.sh betiği, Kubeflow yönetim ortamımız olarak kullanabileceğimiz kapsayıcıya bir komut kabuğu açar. kullanabilirsiniz ./status.sh olup olmadığını görmek için komut dosyası aws-do-kubeflow konteyner çalışıyor ve çalışıyor ve ./stop.sh ve ./run.sh gerektiği gibi yeniden başlatmak için komut dosyaları.

3. Bir kabuk açtıktan sonra aws-do-eks kapsayıcı, yapılandırılmış küme bağlamının beklendiği gibi olduğunu doğrulayabilirsiniz:

   root@ip-172-31-43-155:/kubeflow# kubectx
   kubeflow@eks-kubeflow.us-west-2.eksctl.io

4. Kubeflow'u EKS kümesine dağıtmak için şunu çalıştırın: deploy.sh senaryo:

   ./kubeflow-deploy.sh

   kubeflow ad alanındaki tüm bölmeler Çalışıyor durumuna girdiğinde dağıtım başarılı olur. Tipik bir çıktı aşağıdaki koda benzer:

   Waiting for all Kubeflow pods to start Running ...
   
   Waiting for all Kubeflow pods to start Running ...
   
   Restarting central dashboard ...
   pod "centraldashboard-79f489b55-vr6lp" deleted
   /kubeflow/deploy/distro/aws/kubeflow-manifests /kubeflow/deploy/distro/aws
   /kubeflow/deploy/distro/aws
   
   Kubeflow deployment succeeded
   Granting cluster access to kubeflow profile user ...
   Argument not provided, assuming default user namespace kubeflow-user-example-com ...
   clusterrolebinding.rbac.authorization.k8s.io/kubeflow-user-example-com-cluster-admin-binding created
   Setting up access to Kubeflow Pipelines ...
   Argument not provided, assuming default user namespace kubeflow-user-example-com ...
   
   Creating pod-default for namespace kubeflow-user-example-com ...
   poddefault.kubeflow.org/access-ml-pipeline created

5. KubeFlow bölmelerinin durumunu ayrı bir pencerede izlemek için aşağıdaki komutu kullanabilirsiniz:

   watch kubectl -n kubeflow get pods

6. Basın Ctrl + C tüm bölmeler Çalışırken, aşağıdaki komutu çalıştırarak Kubeflow panosunu kümenin dışına gösterin:

   ./kubeflow-expose.sh

Aşağıdaki koda benzeyen bir çıktı görmelisiniz:

root@ip-172-31-43-155:/kubeflow# ./kubeflow-expose.sh
root@ip-172-31-43-155:/kubeflow# Forwarding from 127.0.0.1:8080 -> 8080
Forwarding from [::1]:8080 -> 8080

Bu komut, Istio giriş ağ geçidi hizmetini kümenizden yerel bağlantı noktanız 8080'e iletir. Kubeflow panosuna erişmek için adresini ziyaret edin. http://localhost:8080 ve varsayılan kullanıcı kimlik bilgilerini kullanarak oturum açın (kullanıcı@example.com/12341234). çalıştırıyorsanız aws-do-kubeflow AWS Cloud9'da kapsayıcı, ardından seçebilirsiniz Önizleme, Daha sonra seçmek Çalışan Uygulamayı Önizle. Docker Desktop üzerinde çalışıyorsanız, aşağıdakileri çalıştırmanız gerekebilir. ./kubeflow-expose.sh dışında komut dosyası aws-do-kubeflow konteyner.

2. Kubeflow on AWS ortamını kurun

Kubeflow'unuzu AWS ortamında kurmak için bir EFS birimi ve bir Jupyter not defteri oluşturuyoruz.

2.1 Bir EFS birimi oluşturun

Bir EFS birimi oluşturmak için aşağıdaki adımları tamamlayın:

• Kubeflow kontrol panelinde, Hacimler Gezinti bölmesinde.
• seçti Yeni cilt.
• İçin Name, girmek efs-sc-claim.
• İçin Hacim boyutu, girmek 10.
• İçin Depolama sınıfı, seçmek efs-sc.
• İçin Giriş türü, seçmek OkuYazBir Kez.
• Klinik oluşturmak.

2.2 Bir Jupyter not defteri oluşturun

Yeni bir not defteri oluşturmak için aşağıdaki adımları tamamlayın:

• Kubeflow kontrol panelinde, Defterler Gezinti bölmesinde.
• Klinik Yeni not defteri.
• İçin Name, girmek aws-hybrid-nb.
• İçin Jüpiter Docket Görüntüsü, resmi seç c9e4w0g3/notebook-servers/jupyter-pytorch:1.11.0-cpu-py38-ubuntu20.04-e3-v1.1 (mevcut en son jupyter-pytorch DLC görüntüsü).
• İçin işlemci, girmek 1.
• İçin Bellek, girmek 5.
• İçin GPU'lar, bırak Hayır.
• üzerinde herhangi bir değişiklik yapmayın. Çalışma Alanı Hacmi Bölüm.
• içinde Veri Hacimleri bölümü, seçim Mevcut birimi ekle ve Mevcut birim bölümünü genişletin
• İçin Name, seçmek efs-sc-claim.
• İçin Montaj yolu, girmek /home/jovyan/efs-sc-claim.
  Bu, EFS birimini Jupyter notebook bölmenize bağlar ve klasörü görebilirsiniz. efs-sc-claim Jupyter laboratuvar arayüzünüzde. Eğitim veri kümesini ve eğitim kodunu, eğitim kümelerinin test için kapsayıcı görüntülerini yeniden oluşturmaya gerek kalmadan erişebilmesi için bu klasöre kaydedersiniz.
• seç Kubeflow Pipelines'a erişime izin ver Yapılandırma bölümünde.
• Klinik Başlatmak.
  Not defterinizin başarıyla oluşturulduğunu doğrulayın (birkaç dakika sürebilir).
• Üzerinde Defterler sayfasını seçin Sosyal medya JupyterLab ortamında oturum açmak için.
• Üzerinde Git menü seç Bir Depoyu Klonla.
• İçin Bir depoyu klonla, girmek https://github.com/aws-samples/aws-do-kubeflow.
  

3. Dağıtılmış eğitim çalıştırın

Jupyter not defterini kurduktan sonra, klasörden aşağıdaki üst düzey adımları kullanarak tüm demoyu çalıştırabilirsiniz. aws-do-kubeflow/workshop klonlanmış depoda:

• PyTorch Dağıtılmış Veri Paralel (DDP) eğitim Komut Dosyası: Çok düğümlü bir CPU ve GPU kümesinde eğitim dağıtmak için örnek bir evrişimli sinir ağı ve mantığı içeren PyTorch DDP eğitim komut dosyası cifar10-distributed-gpu-final.py'ye bakın. (Ayrıntılar için 3.1'e bakın)
• Kitaplıkları yükleyin: Not defterini çalıştırın 0_initialize_dependencies.ipynb tüm bağımlılıkları başlatmak için. (Ayrıntılar için 3.2'e bakın)
• Kubernetes'te dağıtılmış PyTorch iş eğitimi çalıştırın: Not defterini çalıştırın 1_submit_pytorchdist_k8s.ipynb Python kodunu kullanarak Kubernetes özel kaynağı PyTorchJob YAML dosyasını kullanarak bir birincil ve iki çalışan kapsayıcısında dağıtılmış eğitim oluşturmak ve göndermek. (Ayrıntılar için 3.3'e bakın)
• Karma bir Kubeflow ardışık düzeni oluşturun: Not defterini çalıştırın 2_create_pipeline_k8s_sagemaker.ipynb çalışma zamanı değişkenini kullanarak SageMaker veya Amazon EKS üzerinde dağıtılmış eğitim çalıştıran hibrit Kubeflow ardışık düzeni oluşturmak için training_runtime. (Ayrıntılar için 3.4'e bakın)

Not defterini çalıştırdığınızdan emin olun 1_submit_pytorchdist_k8s.ipynb not defterine başlamadan önce 2_create_pipeline_k8s_sagemaker.ipynb.

Sonraki bölümlerde, bu adımların her birini ayrıntılı olarak tartışacağız.

3.1 PyTorch Dağıtılmış Veri Paralel(DDP) eğitim komut dosyası

Dağıtılmış eğitimin bir parçası olarak, CIFAR10 veri seti üzerinde çalışan basit bir evrişimsel sinir ağı tarafından oluşturulan bir sınıflandırma modeli eğitiyoruz. eğitim komut dosyası cifar10-distributed-gpu-final.py yalnızca açık kaynak kitaplıkları içerir ve hem Kubernetes hem de SageMaker eğitim kümelerinde GPU cihazlarında veya CPU örneklerinde çalışmak üzere uyumludur. Not defteri örneklerimizi çalıştırmadan önce eğitim komut dosyasının birkaç önemli yönüne bakalım.

Biz kullanın torch.distributed kümedeki düğümler arasında çok işlemli paralellik için PyTorch desteği ve iletişim temellerini içeren modül:

...
import torch
import torch.distributed as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision
from torchvision import datasets, transforms
...

Model eğitiminin ileri geçişinde bir relu aktivasyon fonksiyonunun uygulandığı evrişimli, maksimum havuzlama ve doğrusal katmanların bir kombinasyonunu kullanarak basit bir görüntü sınıflandırma modeli oluşturuyoruz:

# Define models
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)

def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x

Veri kümesini birleştiren torç DataLoader'ı kullanıyoruz ve DistributedSampler (kullanarak dağıtılmış bir şekilde bir veri alt kümesini yükler torch.nn.parallel.DistributedDataParallel) ve veriler üzerinde tek işlemli veya çok işlemli bir yineleyici sağlar:

# Define data loader for training dataset
def _get_train_data_loader(batch_size, training_dir, is_distributed):
logger.info("Get train data loader")

train_set = torchvision.datasets.CIFAR10(root=training_dir,
train=True,
download=False,
transform=_get_transforms())

train_sampler = (
torch.utils.data.distributed.DistributedSampler(train_set) if is_distributed else None
)

return torch.utils.data.DataLoader(
train_set,
batch_size=batch_size,
shuffle=train_sampler is None,
sampler=train_sampler)
...

Eğitim kümesinde GPU'lar varsa komut dosyası eğitimi CUDA cihazlarında çalıştırır ve cihaz değişkeni varsayılan CUDA cihazını tutar:

device = "cuda" if torch.cuda.is_available() else "cpu"
...

PyTorch kullanarak dağıtılmış eğitimi çalıştırmadan önce DistributedDataParallel dağıtılmış işlemeyi birden çok düğümde çalıştırmak için, dağıtılmış ortamı çağırarak başlatmanız gerekir. init_process_group. Bu, eğitim kümesinin her makinesinde başlatılır.

dist.init_process_group(backend=args.backend, rank=host_rank, world_size=world_size)
...

Sınıflandırıcı modelini somutlaştırıyoruz ve modeli hedef cihaza kopyalıyoruz. Dağıtılmış eğitimin birden çok düğümde çalışması etkinleştirilirse, DistributedDataParallel class, birden çok makine arasında senkronize dağıtılmış eğitime izin veren, model nesnesinin etrafında bir sarmalayıcı nesne olarak kullanılır. Girdi verileri parti boyutuna bölünür ve her makineye ve her cihaza modelin bir kopyası yerleştirilir.

model = Net().to(device)

if is_distributed:
model = torch.nn.parallel.DistributedDataParallel(model)

...

3.2 Kitaplıkları kurun

PyTorch dağıtılmış eğitim örneğini çalıştırmak için gerekli tüm kitaplıkları kuracaksınız. Buna Kubeflow Pipelines SDK, Training Operator Python SDK, Kubernetes için Python istemcisi ve Amazon SageMaker Python SDK dahildir.

#Please run the below commands to install necessary libraries

!pip install kfp==1.8.4

!pip install kubeflow-training

!pip install kubernetes

!pip install sagemaker

3.3 Kubernetes'te dağıtılmış PyTorch iş eğitimi çalıştırın

Defter 1_submit_pytorchdist_k8s.ipynb Kubeflow eğitimini ve Kubernetes istemcisi Python SDK'sını kullanarak Kubernetes özel kaynağı PyTorchJob YAML dosyasını oluşturur. Aşağıdakiler bu not defterinden birkaç önemli parçadır.

Aşağıdaki kodda gösterildiği gibi birincil ve çalışan kapsayıcılarla PyTorchJob YAML'yi oluşturuyoruz:

# Define PyTorchJob custom resource manifest
pytorchjob = V1PyTorchJob(
api_version="kubeflow.org/v1",
kind="PyTorchJob",
metadata=V1ObjectMeta(name=pytorch_distributed_jobname,namespace=user_namespace),
spec=V1PyTorchJobSpec(
run_policy=V1RunPolicy(clean_pod_policy="None"),
pytorch_replica_specs={"Master": master,
"Worker": worker}
)
)

Bu, kullanılarak Kubernetes kontrol düzlemine gönderilir. PyTorchJobClient:

# Creates and Submits PyTorchJob custom resource file to Kubernetes
pytorchjob_client = PyTorchJobClient()

pytorch_job_manifest=pytorchjob_client.create(pytorchjob):

Kubernetes eğitim günlüklerini görüntüleyin

Eğitim günlüklerini Python kodunu kullanarak aynı Jupyter not defterinden veya Kubernetes istemci kabuğundan görüntüleyebilirsiniz.

3.4 Karma Kubeflow ardışık düzen oluşturma

Defter 2_create_pipeline_k8s_sagemaker.ipynb koşullu çalışma zamanı değişkenine dayalı hibrit bir Kubeflow ardışık düzeni oluşturur training_runtime, aşağıdaki kodda gösterildiği gibi. Dizüstü bilgisayar şunları kullanır: Kubeflow Boru Hatları SDK'sı ve ML iş akışı işlem hatlarını belirtmek ve çalıştırmak için bir dizi Python paketi sağlanır. Bu SDK'nın bir parçası olarak aşağıdaki paketleri kullanıyoruz:

• Etki alanına özgü dil (DSL) paket dekoratörü dsl.pipeline, bir boru hattı döndürmek için Python işlevlerini süsleyen
• The dsl.Condition kontrol etmek gibi yalnızca belirli bir koşul karşılandığında çalıştırılan bir grup işlemi temsil eden paket. training_runtime değer olarak sagemaker or kubernetes

Aşağıdaki koda bakın:

# Define your training runtime value with either 'sagemaker' or 'kubernetes'
training_runtime='sagemaker'

# Create Hybrid Pipeline using Kubeflow PyTorch Training Operators and Amazon SageMaker Service
@dsl.pipeline(name="PyTorch Training pipeline", description="Sample training job test")
def pytorch_cnn_pipeline():

# Pipeline Step 1: to evaluate the condition. You can enter any logic here. For demonstration we are checking if GPU is needed for training
condition_result = check_condition_op(training_runtime)

# Pipeline Step 2: to run training on Kuberentes using PyTorch Training Operators. This will be executed if gpus are not needed
with dsl.Condition(condition_result.output == 'kubernetes', name="PyTorch_Comp"):
train_task = pytorch_job_op(
name=training_job_name,
namespace=user_namespace,
master_spec=json.dumps(master_spec_loaded), # Please refer file at pipeline_yaml_specifications/pipeline_master_spec.yml
worker_spec=json.dumps(worker_spec_loaded), # Please refer file at pipeline_yaml_specifications/pipeline_worker_spec.yml
delete_after_done=False
).after(condition_result)

# Pipeline Step 3: to run training on SageMaker using SageMaker Components for Pipeline. This will be executed if gpus are needed
with dsl.Condition(condition_result.output == 'sagemaker', name="SageMaker_Comp"):
training = sagemaker_train_op(
region=region,
image=train_image,
job_name=training_job_name,
training_input_mode=training_input_mode,
hyperparameters='{ 
"backend": "'+str(pytorch_backend)+'", 
"batch-size": "64", 
"epochs": "3", 
"lr": "'+str(learning_rate)+'", 
"model-type": "custom", 
"sagemaker_container_log_level": "20", 
"sagemaker_program": "cifar10-distributed-gpu-final.py", 
"sagemaker_region": "us-west-2", 
"sagemaker_submit_directory": "'+source_s3+'" 
}',
channels=channels,
instance_type=instance_type,
instance_count=instance_count,
volume_size=volume_size,
max_run_time=max_run_time,
model_artifact_path=f's3://{bucket_name}/jobs',
network_isolation=network_isolation,
traffic_encryption=traffic_encryption,
role=role,
vpc_subnets=subnet_id,
vpc_security_group_ids=security_group_id
).after(condition_result)

SageMaker dağıtılmış eğitimini iki ml.p3.2xlarge örneği kullanarak yapılandırıyoruz.

İşlem hattı tanımlandıktan sonra, Kubeflow Pipelines SDK'larını kullanarak işlem hattını bir Argo YAML belirtimine göre derleyebilirsiniz. kfp.compiler paket. Bu işlem hattını, Pipelines hizmeti uç noktasını çağıran ve doğrudan not defterinden uygun kimlik doğrulama başlıklarında geçen Kubeflow Pipeline SDK istemcisini kullanarak çalıştırabilirsiniz. Aşağıdaki koda bakın:

# DSL Compiler that compiles pipeline functions into workflow yaml.
kfp.compiler.Compiler().compile(pytorch_cnn_pipeline, "pytorch_cnn_pipeline.yaml")

# Connect to Kubeflow Pipelines using the Kubeflow Pipelines SDK client
client = kfp.Client()

experiment = client.create_experiment(name="kubeflow")

# Run a specified pipeline
my_run = client.run_pipeline(experiment.id, "pytorch_cnn_pipeline", "pytorch_cnn_pipeline.yaml")

# Please click “Run details” link generated below this cell to view your pipeline. You can click every pipeline step to see logs.

Eğer alırsan sagemaker import hatası, !pip install sagemaker'ı çalıştırın ve çekirdeği yeniden başlatın ( çekirdek menü seç Çekirdeği yeniden başlatın).

Seçin Ayrıntıları çalıştır Kubeflow ardışık düzenini görüntülemek için son hücrenin altındaki bağlantı.

İle işlem hattı oluşturma adımını tekrarlayın training_runtime='kubernetes' bir Kubernetes ortamında çalışan işlem hattını test etmek için. bu training_runtime değişkeni, bir üretim senaryosunda CI/CD işlem hattınızda da geçirilebilir.

SageMaker bileşeni için Kubeflow ardışık düzen çalıştırma günlüklerini görüntüleyin

Aşağıdaki ekran görüntüsü, SageMaker bileşeni için işlem hattı ayrıntılarımızı göstermektedir.

Eğitim işi adımını seçin ve Kayıtlar sekmesinde, SageMaker günlüklerine erişmek için CloudWatch günlükleri bağlantısını seçin.

Aşağıdaki ekran görüntüsü, iki ml.p3.2xlarge örneğinin her biri için CloudWatch günlüklerini gösterir.

Günlükleri görmek için gruplardan herhangi birini seçin.

Kubeflow PyTorchJob Launcher bileşeni için Kubeflow ardışık düzen çalıştırma günlüklerini görüntüleyin

Aşağıdaki ekran görüntüsü, Kubeflow bileşenimiz için işlem hattı ayrıntılarını göstermektedir.

kullanarak aşağıdaki komutları çalıştırın Kubectl Günlükleri görmek için Kubernetes kümesine bağlı Kubernetes istemci kabuğunuzda (ad alanınızı ve bölme adlarınızı değiştirin):

kubectl get pods -n kubeflow-user-example-com
kubectl logs  -n kubeflow-user-example-com -f

4.1 Temizleme

Hesapta oluşturduğumuz tüm kaynakları temizlemek için bunları ters sırada kaldırmamız gerekiyor.

1. Çalıştırarak Kubeflow kurulumunu silin ./kubeflow-remove.sh içinde aws-do-kubeflow konteyner. İlk komut seti isteğe bağlıdır ve halihazırda bir komut kabuğunuz yoksa kullanılabilir. aws-do-kubeflow konteyner açık.

   cd aws-do-kubeflow
   ./status.sh
   ./start.sh
   ./exec.sh
   
   ./kubeflow-remove.sh

2. itibaren aws-do-eks konteyner klasörü, EFS birimini kaldırın. İlk komut seti isteğe bağlıdır ve halihazırda bir komut kabuğunuz yoksa kullanılabilir. aws-do-eks konteyner açık.

   cd aws-do-eks
   ./status.sh
   ./start.sh
   ./exec.sh
   
   cd /eks/deployment/csi/efs
   ./delete.sh
   ./efs-delete.sh

   Kümemiz için oluşturduğumuz VPC ile ilişkili ağ arabirimini serbest bırakmak için Amazon EFS'nin silinmesi gereklidir. EFS birimini silmenin, üzerinde depolanan tüm verileri yok edeceğini unutmayın.

3. itibaren aws-do-eks konteyner, çalıştırın eks-delete.sh kümeyi ve onunla ilişkili VPC dahil diğer kaynakları silmek için komut dosyası:

   cd /eks
   ./eks-delete.sh

Özet

Bu yazıda, dağıtılmış model eğitimi ve makine öğrenimi iş akışlarının tipik zorluklarından bazılarını tartıştık. AWS dağıtımında Kubeflow'a genel bir bakış sağladık ve iki açık kaynaklı proje paylaştık (aws-do-eks ve aws-do-kubeflow) bu, altyapının sağlanmasını ve üzerinde Kubeflow'un dağıtımını basitleştirir. Son olarak, iş yüklerinin kendi kendini yöneten bir Kubernetes üzerinde çalışma ile tamamen yönetilen SageMaker altyapısı arasında sorunsuz bir şekilde geçiş yapmasını sağlayan bir hibrit mimariyi tanımladık ve gösterdik. Bu hibrit mimariyi kendi kullanım durumlarınız için kullanmanızı öneririz.

Sen takip edebilirsiniz AWS Labs deposu Kubeflow'a yapılan tüm AWS katkılarını izlemek için. Ayrıca bizi şu adreste de bulabilirsiniz: Kubeflow #AWS Slack Kanalı; buradaki geri bildiriminiz, Kubeflow projesine katkıda bulunmak için sonraki özelliklere öncelik vermemize yardımcı olacaktır.

Bu yazının başlatılmasına verdikleri destek için Sree Arasanagatta'ya (Yazılım Geliştirme Müdürü AWS ML) ve Suraj Kota'ya (Yazılım Geliştirme Mühendisi) özel teşekkürler.

yazarlar hakkında

Kanwaljit Khurmi Amazon Web Services'de AI/ML Uzman Çözüm Mimarıdır. AWS'yi kullanırken hibrit ML çözümlerinin değerini artırmalarına yardımcı olan rehberlik ve teknik yardım sağlamak için AWS ürünü, mühendisliği ve müşterileri ile birlikte çalışır. Kanwaljit, kapsayıcılı ve makine öğrenimi uygulamaları konusunda müşterilere yardımcı olma konusunda uzmanlaşmıştır.

Gautama Kumar AWS AI Deep Learning'e sahip bir Yazılım Mühendisidir. AWS Deep Learning Containers ve AWS Deep Learning AMI'yi geliştirdi. AI için araçlar ve sistemler oluşturma konusunda tutkulu. Boş zamanlarında bisiklete binmeyi ve kitap okumayı sever.

Alex Iankoulski derin, uygulamalı işler yapmayı seven tam donanımlı bir yazılım ve altyapı mimarıdır. Şu anda AWS'de Kendi Kendini Yöneten Makine Öğrenimi için Baş Çözüm Mimarıdır. Görevinde, konteyner destekli AWS hizmetlerinde ML ve AI iş yüklerinin konteynerleştirilmesi ve düzenlenmesi konusunda müşterilere yardımcı olmaya odaklanıyor. Aynı zamanda açık kaynak kitabının da yazarıdır. çerçeve yap ve dünyanın en büyük zorluklarını çözerken inovasyon hızını hızlandırmak için konteyner teknolojilerini uygulamayı seven bir Docker kaptanı. Alex, geçtiğimiz 10 yıl boyunca iklim değişikliğiyle mücadele, yapay zeka ve makine öğrenimini demokratikleştirme, seyahati daha güvenli, sağlık hizmetlerini daha iyi hale getirme ve enerjiyi daha akıllı hale getirme konularında çalıştı.