Amazon SageMaker ve Amazon DocumentDB'de (MongoDB uyumluluğuyla) milyonlarca protein için grafik sinir ağları eğitin

Belirlenen 180,000 boyutlu yapılara sahip 3'den fazla benzersiz protein vardır. her yıl on binlerce yeni yapı çözümleniyor. Bu sadece küçük bir kısmı Ayırt edici dizilere sahip 200 milyon bilinen protein. gibi son derin öğrenme algoritmaları AlfaKatlama dizilerini kullanarak proteinlerin 3B yapılarını doğru bir şekilde tahmin edebilir, bu da protein 3B yapı verilerini milyonlara ölçeklendirmeye yardımcı olur. Grafik sinir ağı (GNN), amino asit kalıntılarının grafikleriyle temsil edilebilen protein yapılarından bilgi çıkarmak için etkili bir derin öğrenme yaklaşımı olarak ortaya çıkmıştır. Bireysel protein grafikleri genellikle boyut olarak yönetilebilir birkaç yüz düğüm içerir. On binlerce protein grafiği, aşağıdakiler gibi serileştirilmiş veri yapılarında kolayca saklanabilir: TFkayıt GNN'leri eğitmek için. Ancak, GNN'yi milyonlarca protein yapısı üzerinde eğitmek zordur. Veri serileştirme, tüm terabayt ölçekli veri kümesinin belleğe yüklenmesini gerektirdiğinden milyonlarca protein yapısına ölçeklenebilir değildir.

Bu gönderide, GNN'leri içinde depolanan milyonlarca protein üzerinde eğitmenize olanak tanıyan ölçeklenebilir bir derin öğrenme çözümünü tanıtıyoruz. Amazon DocumentDB (MongoDB uyumluluğu ile) kullanma Amazon Adaçayı Yapıcı.

Açıklama amacıyla, halka açık deneysel olarak belirlenmiş protein yapılarını kullanıyoruz. Protein Veri Bankası ve hesaplamalı olarak tahmin edilen protein yapıları AlphaFold Protein Yapısı Veritabanı. Makine öğrenimi (ML) problemi, 3B yapılarından oluşturulan protein grafiklerine dayalı deneysel ve tahmin edilen yapıları ayırt etmek için bir ayrımcı GNN modeli geliştirmektir.

Çözüme genel bakış

Önce protein yapılarını, proteinlerin atomik koordinatlarını, özelliklerini ve tanımlayıcılarını depolamak için n-boyutlu bir dizi ve iç içe nesne gibi birden çok veri yapısı türüyle JSON kayıtlarına ayrıştırırız. Bir proteinin yapısı için bir JSON kaydının saklanması ortalama 45 KB alır; 100 milyon protein depolamanın yaklaşık 4.2 TB alacağını tahmin ediyoruz. Amazon DocumentDB depolama verilerle otomatik olarak ölçeklenir 10 TB'a kadar 64 GB'lik artışlarla küme hacminizde. Bu nedenle, JSON veri yapısı ve ölçeklenebilirlik desteği, Amazon DocumentDB'yi doğal bir seçim haline getirir.

Daha sonra, yapılarından oluşturulan amino asit kalıntılarının grafiklerini kullanarak protein özelliklerini tahmin etmek için bir GNN modeli oluşturuyoruz. GNN modeli, SageMaker kullanılarak eğitilir ve veri tabanından protein yapılarını verimli bir şekilde almak için yapılandırılır.

Son olarak, tahminlere ilişkin bazı içgörüler elde etmek için eğitilmiş GNN modelini analiz ediyoruz.

Bu eğitim için aşağıdaki adımları izliyoruz:

1. kullanarak kaynaklar oluşturun AWS CloudFormation şablonu.
2. Protein yapılarını ve özelliklerini hazırlayın ve verileri Amazon DocumentDB'ye alın.
3. SageMaker kullanarak protein yapıları üzerinde bir GNN eğitin.
4. Eğitilmiş GNN modelini yükleyin ve değerlendirin.

Bu gönderide kullanılan kod ve not defterleri şurada mevcuttur: GitHub repo.

Önkoşullar

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

Bu öğreticiyi bir saat çalıştırmanın maliyeti 2.00 dolardan fazla olmamalıdır.

Kaynak oluştur

Bir CloudFormation şablonu bu gönderi için gerekli AWS kaynaklarını, gönderidekine benzer bir mimariyle oluşturmak Amazon SageMaker kullanarak Amazon DocumentDB'de (MongoDB uyumluluğuyla) depolanan verileri analiz etme. CloudFormation yığını oluşturmaya ilişkin talimatlar için videoya bakın AWS CloudFormation kullanarak Altyapı Yönetiminizi basitleştirin.

CloudFormation yığını aşağıdakileri sağlar:

• Sırasıyla Amazon DocumentDB için üç özel alt ağa ve SageMaker not defteri örneği ve makine öğrenimi eğitim kapsayıcılarına yönelik iki genel alt ağa sahip bir VPC.
• Her özel alt ağda bir tane olmak üzere üç düğüme sahip bir Amazon DocumentDB kümesi.
• Amazon DocumentDB için oturum açma kimlik bilgilerini depolamak için bir Secrets Manager sırrı. Bu, SageMaker örneğimizde düz metin kimlik bilgilerini saklamaktan kaçınmamızı sağlar.
• Veri hazırlamak, eğitim işlerini düzenlemek ve etkileşimli analizler çalıştırmak için bir SageMaker not defteri örneği.

CloudFormation yığınını oluştururken aşağıdakileri belirtmeniz gerekir:

• CloudFormation yığınınız için ad
• Amazon DocumentDB kullanıcı adı ve parolası (Sırlar Yöneticisinde saklanacak)
• Amazon DocumentDB bulut sunucusu türü (varsayılan db.r5.large)
• SageMaker örnek türü (varsayılan ml.t3.xlarge)

CloudFormation yığınını oluşturmak yaklaşık 15 dakika sürmelidir. Aşağıdaki şema kaynak mimarisini göstermektedir.

Protein yapılarını ve özelliklerini hazırlayın ve verileri Amazon DocumentDB'ye alın

Bu bölümdeki sonraki tüm kodlar Jupyter not defterindedir. Hazırla_veri.ipynb CloudFormation yığınınızda oluşturulan SageMaker örneğinde.

Bu not defteri, protein yapısı verilerinin hazırlanması ve Amazon DocumentDB'ye alınması için gereken prosedürleri ele alır.

1. İlk önce tahmin edilen protein yapılarını şuradan indiriyoruz: AlphaFold Veritabanı PDB formatında ve eşleşen deneysel yapılar Protein Veri Bankası.

Gösteri amacıyla, sadece termofilik arkelerden proteinler kullanıyoruz. Methanocaldococcus jannaschii, birlikte çalışmamız için 1,773 proteinin en küçük proteomuna sahip olan. Diğer türlerden proteinleri kullanmayı deneyebilirsiniz.

2. Secrets Manager'da depolanan kimlik bilgilerini alarak bir Amazon DocumentDB kümesine bağlanırız:

def get_secret(stack_name): # Create a Secrets Manager client session = boto3.session.Session() client = session.client( service_name="secretsmanager", region_name=session.region_name ) secret_name = f"{stack_name}-DocDBSecret" get_secret_value_response = client.get_secret_value(SecretId=secret_name) secret = get_secret_value_response["SecretString"] return json.loads(secret) secrets = get_secret("gnn-proteins") # connect to DocDB uri = "mongodb://{}:{}@{}:{}/?tls=true&tlsCAFile=rds-combined-ca-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false" .format(secrets["username"], secrets["password"], secrets["host"], secrets["port"]) client = MongoClient(uri) db = client["proteins"] # create a database
collection = db["proteins"] # create a collection

3. Amazon DocumentDB bağlantısını kurduktan sonra, veritabanına almak için PDB dosyalarını JSON kayıtlarına ayrıştırırız.

PDB dosyalarını ayrıştırmak için gerekli olan yardımcı işlevleri sağlıyoruz. pdb_parse.py. parse_pdb_file_to_json_record işlevi, bir PDB dosyasındaki bir veya daha fazla peptit zincirinden atomik koordinatları çıkarmanın ağır yükünü kaldırır ve bir belge olarak doğrudan Amazon DocumentDB koleksiyonuna alınabilen bir veya bir JSON belgesi listesi döndürür. Aşağıdaki koda bakın:

recs = parse_pdb_file_to_json_record(pdb_parser, pdb_file, pdb_id)
collection.insert_many(recs)

Ayrıştırılmış protein verilerini Amazon DocumentDB'ye aldıktan sonra protein belgelerinin içeriğini güncelleyebiliriz. Örneğin, eğitim, doğrulama veya test setlerinde bir protein yapısının kullanılması gerekip gerekmediğini gösteren bir alan eklersek model eğitim lojistiğimizi kolaylaştırır.

4. İlk önce tüm belgeleri alanla birlikte alıyoruz is_AF bir toplama ardışık düzeni kullanarak belgeleri katmanlaştırmak için:

match = {"is_AF": {"$exists": True}}
project = {"y": "$is_AF"} pipeline = [ {"$match": match}, {"$project": project},
]
# aggregation pipeline
cur = collection.aggregate(pipeline)
# retrieve documents from the DB cursor
docs = [doc for doc in cur]
# convert to a data frame:
df = pd.DataFrame(docs)
# stratified split: full -> train/test
df_train, df_test = train_test_split( df, test_size=0.2, stratify=df["y"], random_state=42
)
# stratified split: train -> train/valid
df_train, df_valid = train_test_split( df_train, test_size=0.2, stratify=df_train["y"], random_state=42
)

5. Sonra, kullanıyoruz update_many bölünmüş bilgileri Amazon DocumentDB'ye geri depolama işlevi:

for split, df_split in zip( ["train", "valid", "test"], [df_train, df_valid, df_test]
): result = collection.update_many( {"_id": {"$in": df_split["_id"].tolist()}}, {"$set": {"split": split}}
)
print("Number of documents modified:", result.modified_count)

SageMaker kullanarak protein yapıları üzerinde bir GNN eğitin

Bu bölümdeki sonraki tüm kodlar Train_and_eval.ipynb CloudFormation yığınınızda oluşturulan SageMaker örneğindeki not defteri.

Bu not defteri, Amazon DocumentDB'de depolanan protein yapısı veri kümeleri üzerinde bir GNN modeli eğitir.

Önce Amazon DocumentDB'den mini protein belgeleri yığını alabilen protein veri kümemiz için bir PyTorch veri kümesi sınıfı uygulamamız gerekiyor. Toplu belgeleri yerleşik birincil kimliğe göre almak daha verimlidir (_id).

1. Genişleterek yinelenebilir stil veri kümesini kullanırız. Yinelenebilir Veri Kümesi, hangi _id ve başlatma sırasında belgelerin etiketleri:

class ProteinDataset(data.IterableDataset): """ An iterable-style dataset for proteins in DocumentDB Args: pipeline: an aggregation pipeline to retrieve data from DocumentDB db_uri: URI of the DocumentDB db_name: name of the database collection_name: name of the collection k: k used for kNN when creating a graph from atomic coordinates """ def __init__( self, pipeline, db_uri="", db_name="", collection_name="", k=3 ): self.db_uri = db_uri self.db_name = db_name self.collection_name = collection_name self.k = k client = MongoClient(self.db_uri, connect=False) collection = client[self.db_name][self.collection_name] # pre-fetch the metadata as docs from DocumentDB self.docs = [doc for doc in collection.aggregate(pipeline)] # mapping document '_id' to label self.labels = {doc["_id"]: doc["y"] for doc in self.docs}

2. The ProteinDataset içinde bir veritabanı okuma işlemi gerçekleştirir. __iter__ yöntem. Birden fazla çalışan varsa iş yükünü eşit olarak bölmeye çalışır:

def __iter__(self): worker_info = torch.utils.data.get_worker_info() if worker_info is None: # single-process data loading, return the full iterator protein_ids = [doc["_id"] for doc in self.docs] else: # in a worker process # split workload start = 0 end = len(self.docs) per_worker = int( math.ceil((end - start) / float(worker_info.num_workers)) ) worker_id = worker_info.id iter_start = start + worker_id * per_worker iter_end = min(iter_start + per_worker, end) protein_ids = [ doc["_id"] for doc in self.docs[iter_start:iter_end] ] # retrieve a list of proteins by _id from DocDB with MongoClient(self.db_uri) as client: collection = client[self.db_name][self.collection_name] cur = collection.find( {"_id": {"$in": protein_ids}}, projection={"coords": True, "seq": True}, ) return ( ( convert_to_graph(protein, k=self.k), self.labels[protein["_id"]], ) for protein in cur )

3. Önceki __iter__ yöntem ayrıca proteinlerin atomik koordinatlarını DGLGrafik nesneler aracılığıyla Amazon DocumentDB'den yüklendikten sonra convert_to_graph işlev. Bu işlev, C-alfa atomlarının 3B koordinatlarını kullanarak amino asit kalıntıları için bir k-en yakın komşu (kNN) grafiği oluşturur ve kalıntı kimliklerini temsil etmek için bir sıcak kodlanmış düğüm özellikleri ekler:

def convert_to_graph(protein, k=3): """ Convert a protein (dict) to a dgl graph using kNN. """ coords = torch.tensor(protein["coords"]) X_ca = coords[:, 1] # construct knn graph from C-alpha coordinates g = dgl.knn_graph(X_ca, k=k) seq = protein["seq"] node_features = torch.tensor([d1_to_index[residue] for residue in seq]) node_features = F.one_hot(node_features, num_classes=len(d1_to_index)).to( dtype=torch.float ) # add node features g.ndata["h"] = node_features return g

4. İle ProteinDataset uygulandığında, tren, doğrulama ve test veri kümeleri için örnekleri başlatabilir ve eğitim örneğini şu şekilde sarabiliriz: BufferedShuffleDataset karıştırmayı etkinleştirmek için.
5. Onları daha da sarıyoruz torch.utils.data.DataLoader diğer bileşenlerle çalışmak için SageMaker PyTorch Tahmincisi eğitim senaryosu.
6. Ardından, yorumlama kolaylığı için küresel bir dikkat havuzu katmanına sahip iki katmanlı basit bir grafik evrişim ağı (GCN) uyguluyoruz:

class GCN(nn.Module): """A two layer Graph Conv net with Global Attention Pooling over the nodes. Args: in_feats: int, dim of input node features h_feats: int, dim of hidden layers num_classes: int, number of output units """ def __init__(self, in_feats, h_feats, num_classes): super(GCN, self).__init__() self.conv1 = GraphConv(in_feats, h_feats) self.conv2 = GraphConv(h_feats, h_feats) # the gate layer that maps node feature to outputs self.gate_nn = nn.Linear(h_feats, num_classes) self.gap = GlobalAttentionPooling(self.gate_nn) # the output layer making predictions self.output = nn.Linear(h_feats, num_classes) def _conv_forward(self, g): """forward pass through the GraphConv layers""" in_feat = g.ndata["h"] h = self.conv1(g, in_feat) h = F.relu(h) h = self.conv2(g, h) h = F.relu(h) return h def forward(self, g): h = self._conv_forward(g) h = self.gap(g, h) return self.output(h) def attention_scores(self, g): """Calculate attention scores""" h = self._conv_forward(g) with g.local_scope(): gate = self.gap.gate_nn(h) g.ndata["gate"] = gate gate = dgl.softmax_nodes(g, "gate") g.ndata.pop("gate") return gate

7. Daha sonra, bu GCN'yi şu konularda eğitebiliriz: ProteinDataset Örneğin, bir protein yapısının AlphaFold tarafından tahmin edilip edilmediğini tahmin eden ikili bir sınıflandırma görevi için. Amaç fonksiyonu olarak ikili çapraz entropiyi ve stokastik gradyan optimizasyonu için Adam optimize ediciyi kullanıyoruz. Tam eğitim betiği şurada bulunabilir: kaynak/main.py.

Ardından, eğitim işini halletmek için SageMaker PyTorch Tahmincisi'ni kurduk. SageMaker tarafından başlatılan yönetilen Docker kapsayıcısının Amazon DocumentDB'ye bağlanmasına izin vermek için Estimator için alt ağ ve güvenlik grubunu yapılandırmamız gerekir.

8. Alt ağ kimliğini alırız. Ağ Adresi Çevirisi (NAT) ağ geçidi şu adla Amazon DocumentDB kümemizin güvenlik grubu kimliğinin yanı sıra bulunur:

ec2 = boto3.client("ec2")
# find the NAT gateway's subnet ID resp = ec2.describe_subnets( Filters=[{"Name": "tag:Name", "Values": ["{}-NATSubnet".format(stack_name)]}]
)
nat_subnet_id = resp["Subnets"][0]["SubnetId"]
# find security group id of the DocumentDB
resp = ec2.describe_security_groups( Filters=[{ "Name": "tag:Name", "Values": ["{}-SG-DocumentDB".format(stack_name)] }])
sg_id = resp["SecurityGroups"][0]["GroupId"]
Finally, we can kick off the training of our GCN model using SageMaker: from sagemaker.pytorch import PyTorch CODE_PATH = "main.py" params = { "patience": 5, "n-epochs": 200, "batch-size": 64, "db-host": secrets["host"], "db-username": secrets["username"], "db-password": secrets["password"], "db-port": secrets["port"], "knn": 4,
} estimator = PyTorch( entry_point=CODE_PATH, source_dir="src", role=role, instance_count=1, instance_type="ml.p3.2xlarge", # 'ml.c4.2xlarge' for CPU framework_version="1.7.1", py_version="py3", hyperparameters=params, sagemaker_session=sess, subnets=[nat_subnet_id], security_group_ids=[sg_id],
)
# run the training job:
estimator.fit()

Eğitilmiş GNN modelini yükleyin ve değerlendirin

Eğitim işi tamamlandığında, eğitilmiş GCN modelini yükleyebilir ve bazı derinlemesine değerlendirmeler yapabiliriz.

Aşağıdaki adımların kodları not defterinde de mevcuttur. Train_and_eval.ipynb.

SageMaker eğitim işleri, model yapılarını, URI'sine şuradan erişilebilen varsayılan S3 klasörüne kaydeder. estimator.model_data bağlanmak. Ayrıca şuraya da gidebiliriz: Eğitim işleri Değerlendirilecek eğitimli modeli bulmak için SageMaker konsolundaki sayfa.

1. Araştırma amacıyla, model yapıtını (öğrenilen parametreler) bir PyTorch'a yükleyebiliriz. durum_dict aşağıdaki işlevi kullanarak:

def load_sagemaker_model_artifact(s3_bucket, key): """Load a PyTorch model artifact (model.tar.gz) produced by a SageMaker Training job. Args: s3_bucket: str, s3 bucket name (s3://bucket_name) key: object key: path to model.tar.gz from within the bucket Returns: state_dict: dict representing the PyTorch checkpoint """ # load the s3 object s3 = boto3.client("s3") obj = s3.get_object(Bucket=s3_bucket, Key=key) # read into memory model_artifact = BytesIO(obj["Body"].read()) # parse out the state dict from the tar.gz file tar = tarfile.open(fileobj=model_artifact) for member in tar.getmembers(): pth = tar.extractfile(member).read() state_dict = torch.load(BytesIO(pth), map_location=torch.device("cpu"))
return state_dict state_dict = load_sagemaker_model_artifact(
bucket, key=estimator.model_data.split(bucket)[1].lstrip("/")
) # initialize a GCN model
model = GCN(dim_nfeats, 16, n_classes)
# load the learned parameters
model.load_state_dict(state_dict["model_state_dict"])

2. Ardından, doğruluğu hesaplayarak tam test setinde nicel model değerlendirmesi yapıyoruz:

device = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu")
num_correct = 0
num_tests = 0
model.eval()
with torch.no_grad(): for batched_graph, labels in test_loader: batched_graph = batched_graph.to(device) labels = labels.to(device) logits = model(batched_graph) preds = (logits.sigmoid() > 0.5).to(labels.dtype) num_correct += (preds == labels).sum().item() num_tests += len(labels) print('Test accuracy: {:.6f}'.format(num_correct / num_tests))

GCN modelimizin %74.3'lük bir doğruluğa ulaştığını, oysa sınıf önceliklerine dayalı tahminler yapan kukla temel modelin yalnızca %56.3'e ulaştığını bulduk.

GCN modelimizin yorumlanabilirliğiyle de ilgileniyoruz. Küresel bir dikkat havuzu katmanı uyguladığımız için, model tarafından yapılan belirli tahminleri açıklamak için düğümler arasındaki dikkat puanlarını hesaplayabiliriz.

3. Daha sonra, dikkat puanlarını hesaplıyoruz ve aynı peptitten bir çift yapı (AlphaFold tarafından tahmin edilen ve deneysel) için protein grafiklerinin üzerine yerleştiriyoruz:

pair = ["AF-Q57887", "1JT8-A"]
cur = collection.find( {"id": {"$in": pair}},
) for doc in cur: # convert to dgl.graph object graph = convert_to_graph(doc, k=4) with torch.no_grad(): # make prediction pred = model(graph).sigmoid() # calculate attention scores for a protein graph attn = model.attention_scores(graph) pred = pred.item() attn = attn.numpy() # convert to networkx graph for visualization graph = graph.to_networkx().to_undirected() # calculate graph layout pos = nx.spring_layout(graph, iterations=500) fig, ax = plt.subplots(figsize=(8, 8)) nx.draw( graph, pos, node_color=attn.flatten(), cmap="Reds", with_labels=True, font_size=8, ax=ax ) ax.set(title="{}, p(is_predicted)={:.6f}".format(doc["id"], pred))
plt.show()

Önceki kodlar, düğümler üzerinde dikkat puanları ile kaplanmış aşağıdaki protein grafiklerini üretir. Modelin global özenli havuzlama katmanının, protein yapısının AlphaFold tarafından tahmin edilip edilmediğinin tahminini yapmak için önemli olarak protein grafiğindeki belirli kalıntıları vurgulayabildiğini görüyoruz. Bu, bu kalıntıların tahmin edilen ve deneysel protein yapılarında farklı grafik topolojilerine sahip olabileceğini gösterir.

Özetle, GNN'leri Amazon DocumentDB'de depolanan protein yapıları üzerinde eğitmek için ölçeklenebilir bir derin öğrenme çözümü sergiliyoruz. Öğretici, eğitim için yalnızca binlerce protein kullansa da, bu çözüm milyonlarca proteine ​​ölçeklenebilir. Tüm protein veri setini seri hale getirmek gibi diğer yaklaşımlardan farklı olarak, yaklaşımımız bellek ağırlıklı iş yüklerini veritabanına aktararak eğitim işleri için bellek karmaşıklığını artırır. O(batch_size), eğitilecek toplam protein sayısından bağımsızdır.

Temizlemek

Gelecekte ücret alınmasını önlemek için oluşturduğunuz CloudFormation yığınını silin. Bu, VPC, Amazon DocumentDB kümesi ve SageMaker örneği dahil olmak üzere CloudFormation şablonunu kullanarak sağladığınız tüm kaynakları kaldırır. Talimatlar için bkz. AWS CloudFormation konsolunda bir yığını silme.

Sonuç

Amazon DocumentDB'de depolayarak ve SageMaker'dan mini veri kümelerini verimli bir şekilde alarak milyonlarca protein yapısına ölçeklenebilen bulut tabanlı bir derin öğrenme mimarisini tanımladık.

GNN'nin protein özelliği tahminlerinde kullanımı hakkında daha fazla bilgi edinmek için son yayınımıza göz atın. LM-GVP, Dizi ve Yapıdan Protein Özelliği Tahmini için Genelleştirilebilir Bir Derin Öğrenme Çerçevesi.

Yazarlar Hakkında

Zichen Wang, PhD, Amazon Makine Öğrenimi Çözümleri Laboratuvarı'nda Uygulamalı Bilim Adamıdır. Biyolojik ve tıbbi verileri kullanarak makine öğrenimi ve istatistiksel yöntemler geliştirme konusunda birkaç yıllık araştırma deneyimiyle, makine öğrenimi sorunlarını çözmek için çeşitli sektörlerde müşterilerle birlikte çalışır.

Selvan Senthivel AWS'deki Amazon ML Çözümleri Laboratuvarı'nda Kıdemli Makine Öğrenimi Mühendisidir ve müşterilere makine öğrenimi, derin öğrenme sorunları ve uçtan uca makine öğrenimi çözümleri konusunda yardımcı olmaya odaklanır. Amazon Comprehend Medical'in kurucu mühendislik lideriydi ve birden fazla AWS AI hizmetinin tasarımına ve mimarisine katkıda bulundu.

Kaynak: https://aws.amazon.com/blogs/machine-learning/train-graph-neural-nets-for-millions-of-proteins-on-amazon-sagemaker-and-amazon-documentdb-with-mongodb- uyumluluk/