Kemas dan terapkan ML dan LLM klasik dengan mudah menggunakan Amazon SageMaker, bagian 1: Peningkatan PySDK | Layanan Web Amazon

Amazon SageMaker adalah layanan terkelola sepenuhnya yang memungkinkan pengembang dan ilmuwan data dengan cepat dan mudah membangun, melatih, dan menerapkan model pembelajaran mesin (ML) pada skala apa pun. SageMaker mempermudah penerapan model ke dalam produksi secara langsung melalui panggilan API ke layanan. Model dikemas ke dalam container untuk penerapan yang kuat dan skalabel. Meskipun menyediakan berbagai titik masuk seperti SageMaker Python SDK, AWS SDK, konsol SageMaker, dan Studio Amazon SageMaker notebook untuk menyederhanakan proses pelatihan dan penerapan model ML dalam skala besar, pelanggan masih mencari cara yang lebih baik untuk menerapkan model mereka untuk pengujian di lapangan dan untuk mengoptimalkan penerapan produksi.

Kami meluncurkan dua cara baru untuk menyederhanakan proses pengemasan dan penerapan model menggunakan SageMaker.

Dalam postingan ini, kami memperkenalkan SageMaker Python SDK baru ModelBuilder pengalaman, yang bertujuan untuk meminimalkan kurva pembelajaran bagi pengguna baru SageMaker seperti ilmuwan data, sekaligus membantu teknisi MLOps berpengalaman memaksimalkan pemanfaatan layanan hosting SageMaker. Hal ini mengurangi kerumitan penyiapan dan penerapan awal, dan dengan memberikan panduan tentang praktik terbaik untuk memanfaatkan kemampuan penuh SageMaker. Kami memberikan informasi rinci dan contoh GitHub untuk kemampuan SageMaker baru ini.

Peluncuran baru lainnya adalah menggunakan pengalaman penerapan interaktif baru di SageMaker Studio. Kami membahas ini di Bagian 2.

Menyebarkan model ke titik akhir SageMaker memerlukan serangkaian langkah untuk menyiapkan model untuk dihosting di titik akhir SageMaker. Hal ini melibatkan mendapatkan artefak model dalam format dan struktur yang benar, membuat kode inferensi, dan menentukan detail penting seperti URL gambar model, Layanan Penyimpanan Sederhana Amazon (Amazon S3) lokasi artefak model, langkah serialisasi dan deserialisasi, dan diperlukan Identitas AWS dan Manajemen Akses (IAM) berperan untuk memfasilitasi izin akses yang sesuai. Setelah itu, konfigurasi titik akhir memerlukan penentuan jenis inferensi dan konfigurasi parameter terkait seperti jenis instans, jumlah, dan distribusi lalu lintas di antara varian model.

Untuk lebih membantu pelanggan kami saat menggunakan hosting SageMaker, kami memperkenalkan yang baru ModelBuilder kelas di SageMaker Python SDK, yang memberikan manfaat utama berikut saat menerapkan model ke titik akhir SageMaker:

• Menyatukan pengalaman penerapan di seluruh kerangka kerja – Pengalaman baru ini memberikan alur kerja yang konsisten untuk menerapkan model yang dibangun menggunakan kerangka kerja berbeda seperti PyTorch, TensorFlow, dan XGBoost. Ini menyederhanakan proses penerapan.
• Mengotomatiskan penerapan model – Tugas seperti memilih container yang sesuai, menangkap dependensi, dan menangani serialisasi/deserialisasi dilakukan secara otomatis, sehingga mengurangi upaya manual yang diperlukan untuk penerapan.
• Memberikan transisi yang lancar dari titik akhir lokal ke titik akhir yang dihosting SageMaker – Dengan sedikit perubahan kode, model dapat dengan mudah dialihkan dari pengujian lokal ke penerapan pada titik akhir SageMaker. Log langsung membuat proses debug menjadi lancar.

Secara keseluruhan, SageMaker ModelBuilder menyederhanakan dan menyederhanakan proses pengemasan model untuk inferensi SageMaker dengan menangani detail tingkat rendah dan menyediakan alat untuk pengujian, validasi, dan optimalisasi titik akhir. Hal ini meningkatkan produktivitas pengembang dan mengurangi kesalahan.

Di bagian berikut, kami mendalami detail fitur baru ini. Kami juga membahas cara menerapkan model ke hosting SageMaker menggunakan ModelBuilder, yang menyederhanakan prosesnya. Kemudian kami memandu Anda melalui beberapa contoh kerangka kerja yang berbeda untuk menerapkan model ML tradisional dan model dasar yang mendukung kasus penggunaan AI generatif.

Mengenal SageMaker ModelBuilder

Baru ModelBuilder adalah kelas Python yang berfokus pada pengambilan model ML yang dibuat menggunakan kerangka kerja, seperti XGBoost atau PyTorch, dan mengonversinya menjadi model yang siap diterapkan di SageMaker. ModelBuilder menyediakan build() fungsi, yang menghasilkan artefak sesuai model server, dan a deploy() berfungsi untuk diterapkan secara lokal atau ke titik akhir SageMaker. Pengenalan fitur ini menyederhanakan integrasi model dengan lingkungan SageMaker, mengoptimalkan kinerja dan skalabilitasnya. Diagram berikut menunjukkan caranya ModelBuilder bekerja pada tingkat tinggi.

kelas ModelBuilder

Grafik Pembuat Model kelas memberikan opsi berbeda untuk penyesuaian. Namun, untuk menerapkan model kerangka kerja, pembuat model hanya mengharapkan model, masukan, keluaran, dan peran:

class ModelBuilder( model, # model id or model object role_arn, # IAM role schema_builder, # defines the input and output mode, # select between local deployment and depoy to SageMaker Endpoints ...
)

Pembuat Skema

Grafik Pembuat Skema kelas memungkinkan Anda menentukan input dan output untuk titik akhir Anda. Hal ini memungkinkan pembuat skema untuk menghasilkan fungsi marshaling yang sesuai untuk membuat serialisasi dan deserialisasi input dan output. File kelas berikut menyediakan semua opsi untuk penyesuaian:

class SchemaBuilder( sample_input: Any, sample_output: Any, input_translator: CustomPayloadTranslator = None, output_translator: CustomPayloadTranslator = None
)

Namun, dalam banyak kasus, hanya sampel input dan output saja yang bisa digunakan. Misalnya:

input = "How is the demo going?"
output = "Comment la démo va-t-elle?"
schema = SchemaBuilder(input, output)

Dengan memberikan contoh input dan output, SchemaBuilder dapat secara otomatis menentukan transformasi yang diperlukan, membuat proses integrasi menjadi lebih mudah. Untuk kasus penggunaan lebih lanjut, terdapat fleksibilitas untuk menyediakan fungsi terjemahan khusus untuk input dan output, memastikan bahwa struktur data yang lebih kompleks juga dapat ditangani secara efisien. Kami mendemonstrasikan hal ini di bagian berikut dengan menerapkan model berbeda dengan berbagai kerangka kerja yang digunakan ModelBuilder.

Pengalaman mode lokal

Dalam contoh ini, kami menggunakan ModelBuilder untuk menerapkan model XGBoost secara lokal. Anda dapat menggunakan Mode untuk beralih antara pengujian lokal dan penerapan ke titik akhir SageMaker. Pertama-tama kita melatih model XGBoost (secara lokal atau di SageMaker) dan menyimpan artefak model di direktori kerja:

# Train the model
model = XGBClassifier()
model.fit(X_train, y_train)
model.save_model(model_dir + "/my_model.xgb")

Kemudian kita membuat objek ModelBuilder dengan meneruskan objek model sebenarnya, yaitu SchemaBuilder yang menggunakan objek input dan output pengujian sampel (input dan output yang sama yang kita gunakan saat melatih dan menguji model) untuk menyimpulkan serialisasi yang diperlukan. Perhatikan bahwa kami menggunakan Mode.LOCAL_CONTAINER untuk menentukan penerapan lokal. Setelah itu, kami menelepon membangun berfungsi untuk secara otomatis mengidentifikasi gambar kontainer kerangka kerja yang didukung serta memindai dependensi. Lihat kode berikut:

model_builder_local = ModelBuilder( model=model, schema_builder=SchemaBuilder(X_test, y_pred), role_arn=execution_role, mode=Mode.LOCAL_CONTAINER
)
xgb_local_builder = model_builder_local.build()

Akhirnya, kita bisa memanggil deploy fungsi di objek model, yang juga menyediakan logging langsung untuk memudahkan proses debug. Anda tidak perlu menentukan jenis atau jumlah instans karena model akan diterapkan secara lokal. Jika Anda memberikan parameter ini, parameter tersebut akan diabaikan. Fungsi ini akan mengembalikan objek prediktor yang dapat kita gunakan untuk membuat prediksi dengan data uji:

# note: all the serialization and deserialization is handled by the model builder.
predictor_local = xgb_local_builder.deploy(
# instance_type='ml.c5.xlarge',
# initial_instance_count=1
) # Make prediction for test data. predictor_local.predict(X_test)

Secara opsional, Anda juga dapat mengontrol pemuatan model dan prapemrosesan serta pascapemrosesan menggunakan InferenceSpec. Kami memberikan detail lebih lanjut nanti di posting ini. Menggunakan LOCAL_CONTAINER adalah cara terbaik untuk menguji skrip Anda secara lokal sebelum diterapkan ke titik akhir SageMaker.

Mengacu kepada pembuat model-xgboost.ipynb contoh untuk menguji penerapan secara lokal dan ke titik akhir SageMaker menggunakan ModelBuilder.

Terapkan model tradisional ke titik akhir SageMaker

Dalam contoh berikut, kami menunjukkan cara menggunakannya ModelBuilder untuk menerapkan model ML tradisional.

Model XGBoost

Mirip dengan bagian sebelumnya, Anda dapat menerapkan model XGBoost ke titik akhir SageMaker dengan mengubah mode parameter saat membuat ModelBuilder obyek:

model_builder = ModelBuilder( model=model, schema_builder=SchemaBuilder(sample_input=sample_input, sample_output=sample_output), role_arn=execution_role, mode=Mode.SAGEMAKER_ENDPOINT
)
xgb_builder = model_builder.build()
predictor = xgb_builder.deploy( instance_type='ml.c5.xlarge', initial_instance_count=1
)

Perhatikan bahwa saat menerapkan ke titik akhir SageMaker, Anda perlu menentukan jenis instans dan jumlah instans saat memanggil deploy fungsi.

Mengacu kepada pembuat model-xgboost.ipynb contoh untuk menerapkan model XGBoost.

Model Triton

Anda dapat menggunakan ModelBuilder untuk menyajikan model PyTorch Server Inferensi Triton. Untuk itu, Anda perlu menentukan model_server parameter sebagai ModelServer.TRITON, lulus model, dan memiliki a SchemaBuilder objek, yang memerlukan sampel input dan output dari model. ModelBuilder akan mengurus sisanya untuk Anda.

model_builder = ModelBuilder( model=model, schema_builder=SchemaBuilder(sample_input=sample_input, sample_output=sample_output), role_arn=execution_role, model_server=ModelServer.TRITON, mode=Mode.SAGEMAKER_ENDPOINT
) triton_builder = model_builder.build() predictor = triton_builder.deploy( instance_type='ml.g4dn.xlarge', initial_instance_count=1
)

Lihat pembuat model-triton.ipynb untuk menyebarkan model dengan Triton.

Model Wajah Memeluk

Dalam contoh ini, kami menunjukkan kepada Anda cara menerapkan model transformator terlatih yang disediakan oleh Hugging Face ke SageMaker. Kami ingin menggunakan Wajah Memeluk pipeline untuk memuat model, jadi kami membuat spesifikasi inferensi khusus untuknya ModelBuilder:

# custom inference spec with hugging face pipeline
class MyInferenceSpec(InferenceSpec): def load(self, model_dir: str): return pipeline("translation_en_to_fr", model="t5-small") def invoke(self, input, model): return model(input) inf_spec = MyInferenceSpec()

Kami juga menentukan masukan dan keluaran beban kerja inferensi dengan mendefinisikan SchemaBuilder objek berdasarkan model input dan output:

schema = SchemaBuilder(value,output)

Lalu kami membuat ModelBuilder objek dan terapkan model ke titik akhir SageMaker dengan mengikuti logika yang sama seperti yang ditunjukkan dalam contoh lainnya:

builder = ModelBuilder( inference_spec=inf_spec, mode=Mode.SAGEMAKER_ENDPOINT, # you can change it to Mode.LOCAL_CONTAINER for local testing schema_builder=schema, image_uri=image,
)
model = builder.build( role_arn=execution_role, sagemaker_session=sagemaker_session,
)
predictor = model.deploy( initial_instance_count=1, instance_type='ml.g5.2xlarge'
)

Lihat model-pembangun-huggingface.ipynb untuk menerapkan model saluran Hugging Face.

Terapkan model dasar ke titik akhir SageMaker

Dalam contoh berikut, kami menunjukkan cara menggunakannya ModelBuilder untuk menyebarkan model dasar. Sama seperti model yang disebutkan sebelumnya, yang diperlukan hanyalah ID model.

Memeluk Wajah Hub

Jika Anda ingin menerapkan model fondasi dari Memeluk Wajah Hub, yang perlu Anda lakukan hanyalah meneruskan ID model terlatih. Misalnya, cuplikan kode berikut menyebarkan meta-llama/Llama-2-7b-hf model secara lokal. Anda dapat mengubah mode menjadi Mode.SAGEMAKER_ENDPOINT untuk diterapkan ke titik akhir SageMaker.

model_builder = ModelBuilder( model="meta-llama/Llama-2-7b-hf", schema_builder=SchemaBuilder(sample_input, sample_output), model_path="/home/ec2-user/SageMaker/LoadTestResources/meta-llama2-7b", #local path where artifacts will be saved mode=Mode.LOCAL_CONTAINER, env_vars={ # Llama 2 is a gated model and requires a Hugging Face Hub token. "HUGGING_FACE_HUB_TOKEN": "<YourHuggingFaceToken>" }
)
model = model_builder.build()
local_predictor = model.deploy()

Untuk model yang terjaga keamanannya di Hugging Face Hub, Anda perlu meminta akses melalui Hugging Face Hub dan menggunakan kunci terkait dengan meneruskannya sebagai variabel lingkungan HUGGING_FACE_HUB_TOKEN. Beberapa model Hugging Face mungkin memerlukan kode jarak jauh yang dapat dipercaya. Itu dapat ditetapkan sebagai variabel lingkungan juga menggunakan HF_TRUST_REMOTE_CODE. Secara default, ModelBuilder akan menggunakan Inferensi Pembuatan Teks Wajah Memeluk (TGI) wadah sebagai wadah dasar untuk model Hugging Face. Jika Anda ingin menggunakan Inferensi Model Besar AWS (LMI) wadah, Anda dapat mengatur model_server parameter sebagai ModelServer.DJL_SERVING saat Anda mengonfigurasi ModelBuilder obyek.

Fitur rapi dari ModelBuilder adalah kemampuan untuk menjalankan penyetelan lokal parameter kontainer saat Anda menggunakannya LOCAL_CONTAINER mode. Fitur ini dapat digunakan hanya dengan menjalankannya tuned_model = model.tune().

Lihat demo-model-pembangun-memelukwajah-llama2.ipynb untuk menerapkan model Hugging Face Hub.

SageMaker JumpStart

Mulai Lompatan Amazon SageMaker juga menawarkan sejumlah model pondasi terlatih. Sama seperti proses penerapan model dari Hugging Face Hub, ID model diperlukan. Menyebarkan model SageMaker JumpStart ke titik akhir SageMaker semudah menjalankan kode berikut:

model_builder = ModelBuilder( model="huggingface-llm-falcon-7b-bf16", schema_builder=SchemaBuilder(sample_input, sample_output), role_arn=execution_role
) sm_ep_model = model_builder.build() predictor = sm_ep_model.deploy()

Untuk semua ID model SageMaker JumpStart yang tersedia, lihat Algoritma bawaan dengan Tabel Model yang telah dilatih sebelumnya. Mengacu pada pembuat model-jumpstart-falcon.ipynb untuk menyebarkan model SageMaker JumpStart.

Komponen inferensi

ModelBulder memungkinkan Anda menggunakan kemampuan komponen inferensi baru di SageMaker untuk menerapkan model. Untuk informasi lebih lanjut tentang komponen inferensi, lihat Kurangi Biaya Penerapan Model Rata-rata sebesar 50% Menggunakan Fitur Terbaru SageMaker. Anda dapat menggunakan komponen inferensi untuk penerapan ModelBuilder dengan menentukan endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED dalam deploy() metode. Anda juga dapat menggunakan tune() metode, yang mengambil jumlah akselerator optimal, dan memodifikasinya jika diperlukan.

resource_requirements = ResourceRequirements( requests={ "num_accelerators": 4, "memory": 1024, "copies": 1, }, limits={},
) goldfinch_predictor_2 = model_2.deploy( mode=Mode.SAGEMAKER_ENDPOINT, endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED, ... )

Lihat model-pembangun-inferensi-komponen.ipynb untuk menyebarkan model sebagai komponen inferensi.

Sesuaikan Kelas ModelBuilder

Grafik ModelBuilder kelas memungkinkan Anda untuk menyesuaikan pemuatan model menggunakan InferenceSpec.

Selain itu, Anda dapat mengontrol serialisasi dan deserialisasi payload dan respons serta menyesuaikan prapemrosesan dan pascapemrosesan menggunakan CustomPayloadTranslator. Selain itu, ketika Anda perlu memperluas kontainer bawaan kami untuk penerapan model di SageMaker, Anda dapat menggunakannya ModelBuilder untuk menangani proses pengemasan model. Di bagian berikut ini, kami memberikan rincian lebih lanjut tentang kemampuan ini.

Spesifikasi Inferensi

Spesifikasi Inferensi menawarkan lapisan penyesuaian tambahan. Hal ini memungkinkan Anda menentukan cara model dimuat dan cara model menangani permintaan inferensi yang masuk. Melalui InferenceSpec, Anda dapat menentukan prosedur pemuatan khusus untuk model Anda, dengan melewati mekanisme pemuatan default. Fleksibilitas ini sangat bermanfaat ketika bekerja dengan model non-standar atau saluran inferensi khusus. Metode pemanggilan dapat dikustomisasi, memberi Anda kemampuan untuk menyesuaikan cara model memproses permintaan masuk (prapemrosesan dan pascapemrosesan). Penyesuaian ini penting untuk memastikan bahwa proses inferensi selaras dengan kebutuhan spesifik model. Lihat kode berikut:

class InferenceSpec(abc.ABC): @abc.abstractmethod def load(self, model_dir: str): pass @abc.abstractmethod def invoke(self, input_object: object, model: object): pass

Kode berikut menunjukkan contoh penggunaan kelas ini:

class MyInferenceSpec(InferenceSpec): def load(self, model_dir: str): return // model object def invoke(self, input, model): return model(input)

Penerjemah Muatan Khusus

Saat memanggil titik akhir SageMaker, data dikirim melalui muatan HTTP dengan tipe MIME berbeda. Misalnya, gambar yang dikirim ke titik akhir untuk inferensi perlu dikonversi menjadi byte di sisi klien dan dikirim melalui payload HTTP ke titik akhir. Saat titik akhir menerima payload, titik akhir perlu melakukan deserialisasi string byte kembali ke tipe data yang diharapkan oleh model (juga dikenal sebagai deserialisasi sisi server). Setelah model selesai memprediksi, hasilnya perlu diserialkan menjadi byte yang dapat dikirim kembali melalui payload HTTP ke pengguna atau klien. Saat klien menerima data byte respons, klien perlu melakukan deserialisasi sisi klien untuk mengonversi data byte kembali ke format data yang diharapkan, seperti JSON. Minimal, Anda perlu mengonversi data untuk yang berikut ini (seperti yang diberi nomor pada diagram berikut):

1. Serialisasi permintaan inferensi (ditangani oleh klien)
2. Deserialisasi permintaan inferensi (ditangani oleh server atau algoritma)
3. Memanggil model terhadap payload
4. Mengirim payload respons kembali
5. Serialisasi respons inferensi (ditangani oleh server atau algoritma)
6. Deserialisasi respons inferensi (ditangani oleh klien)

Diagram berikut menunjukkan proses serialisasi dan deserialisasi selama proses pemanggilan.

Dalam cuplikan kode berikut, kami menampilkan contoh CustomPayloadTranslator ketika penyesuaian tambahan diperlukan untuk menangani serialisasi dan deserialisasi di sisi klien dan server:

from sagemaker.serve import CustomPayloadTranslator # request translator
class MyRequestTranslator(CustomPayloadTranslator): # This function converts the payload to bytes - happens on client side def serialize_payload_to_bytes(self, payload: object) -> bytes: # converts the input payload to bytes ... ... return //return object as bytes # This function converts the bytes to payload - happens on server side def deserialize_payload_from_stream(self, stream) -> object: # convert bytes to in-memory object ... ... return //return in-memory object # response translator class MyResponseTranslator(CustomPayloadTranslator): # This function converts the payload to bytes - happens on server side def serialize_payload_to_bytes(self, payload: object) -> bytes: # converts the response payload to bytes ... ... return //return object as bytes # This function converts the bytes to payload - happens on client side def deserialize_payload_from_stream(self, stream) -> object: # convert bytes to in-memory object ... ... return //return in-memory object

Dalam majalah demo-model-pembangun-pytorch.ipynb notebook, kami mendemonstrasikan cara menerapkan model PyTorch dengan mudah ke titik akhir SageMaker menggunakan ModelBuilder pada pengatur terkenal. Pengatur ini menawarkan bantuan hukum kepada traderapabila trader berselisih dengan broker yang terdaftar dengan mereka. CustomPayloadTranslator dan InferenceSpec kelas.

Model panggung untuk penerapan

Jika Anda ingin menampilkan model untuk inferensi atau dalam registri model, Anda dapat menggunakan model.create() or model.register(). Model yang diaktifkan dibuat pada layanan, dan kemudian Anda dapat menyebarkannya nanti. Lihat kode berikut:

model_builder = ModelBuilder( model=model, schema_builder=SchemaBuilder(X_test, y_pred), role_arn=execution_role, )
deployable_model = model_builder.build() deployable_model.create() # deployable_model.register() for model registry

Gunakan wadah khusus

SageMaker menyediakan gambar Docker yang sudah dibuat sebelumnya untuk algoritme bawaannya dan kerangka pembelajaran mendalam yang didukung yang digunakan untuk pelatihan dan inferensi. Jika kontainer SageMaker yang dibuat sebelumnya tidak memenuhi semua kebutuhan Anda, Anda dapat memperluas image yang ada untuk mengakomodasi kebutuhan Anda. Dengan memperluas gambar yang dibuat sebelumnya, Anda dapat menggunakan perpustakaan dan pengaturan pembelajaran mendalam yang disertakan tanpa harus membuat gambar dari awal. Untuk detail selengkapnya tentang cara memperluas kontainer siap pakai, lihat dokumen SageMaker. ModelBuilder mendukung kasus penggunaan saat membawa container Anda sendiri yang merupakan perluasan dari container Docker kami yang telah dibuat sebelumnya.

Untuk menggunakan gambar kontainer Anda sendiri dalam kasus ini, Anda perlu mengatur kolomnya image_uri dan model_server saat mendefinisikan ModelBuilder:

model_builder = ModelBuilder( model=model, # Pass in the actual model object. its "predict" method will be invoked in the endpoint. schema_builder=SchemaBuilder(X_test, y_pred), # Pass in a "SchemaBuilder" which will use the sample test input and output objects to infer the serialization needed. role_arn=execution_role, image_uri=image_uri, # REQUIRED FOR BYOC: Passing in image hosted in personal ECR Repo model_server=ModelServer.TORCHSERVE, # REQUIRED FOR BYOC: Passing in model server of choice mode=Mode.SAGEMAKER_ENDPOINT, dependencies={"auto": True, "custom": ["protobuf==3.20.2"]}
)

Ini, image_uri akan menjadi ARN gambar kontainer yang disimpan di akun Anda Registry Kontainer Elastis Amazon Repositori (Amazon ECR). Salah satu contohnya ditunjukkan sebagai berikut:

# Pulled the xgboost:1.7-1 DLC and pushed to personal ECR repo
image_uri = "<your_account_id>.dkr.ecr.us-west-2.amazonaws.com/my-byoc:xgb"

Ketika image_uri diatur, selama ModelBuilder proses pembuatan, itu akan melewati deteksi otomatis gambar karena URI gambar disediakan. Jika model_server tidak disetel di ModelBuilder, Anda akan menerima pesan kesalahan validasi, misalnya:

ValueError: Model_server must be set when image_uri is set. Supported model servers: {<ModelServer.TRITON: 5>, <ModelServer.DJL_SERVING: 4>, <ModelServer.TORCHSERVE: 1>}

Pada saat postingan ini diterbitkan, ModelBuilder mendukung membawa wadah Anda sendiri yang diperpanjang dari kami gambar kontainer DLC yang sudah dibuat sebelumnya atau wadah yang dibangun dengan server model sejenisnya Perpustakaan Jawa Dalam (DJL), Inferensi Pembuatan Teks (TGI), Layanan obor, dan Server inferensi Triton.

Ketergantungan khusus

Saat berlari ModelBuilder.build(), secara default secara otomatis menangkap lingkungan Python Anda ke dalam a requirements.txt file dan menginstal ketergantungan yang sama dalam wadah. Namun, terkadang lingkungan Python lokal Anda akan bertentangan dengan lingkungan di dalam container. ModelBuilder menyediakan cara sederhana bagi Anda untuk memodifikasi dependensi yang diambil untuk memperbaiki konflik ketergantungan tersebut dengan memungkinkan Anda menyediakan konfigurasi khusus ke dalam ModelBuilder. Perhatikan bahwa ini hanya untuk TorchServe dan Triton dengan InferenceSpec. Misalnya, Anda dapat menentukan dependensi parameter input, yang merupakan kamus Python, di ModelBuilder sebagai berikut:

dependency_config = { "auto" = True, "requirements" = "/path/to/your/requirements.txt" "custom" = ["module>=1.2.3,<1.5", "boto3==1.16.*", "some_module@http://some/url"]
} ModelBuilder( # Other params dependencies=dependency_config,
).build()

Kami mendefinisikan bidang-bidang berikut:

• mobil – Apakah akan mencoba menangkap dependensi di lingkungan Anda secara otomatis.
• Persyaratan – Serangkaian jalan menuju milik Anda sendiri requirements.txt mengajukan. (Ini opsional.)
• adat – Daftar dependensi khusus lainnya yang ingin Anda tambahkan atau modifikasi. (Ini opsional.)

Jika modul yang sama ditentukan di beberapa tempat, custom akan mendapat prioritas tertinggi requirements, dan auto akan memiliki prioritas terendah. Misalnya, selama deteksi otomatis, ModelBuilder mendeteksi numpy==1.25, Dan requirements.txt file disediakan yang menentukan numpy>=1.24,<1.26. Selain itu, ada ketergantungan khusus: custom = ["numpy==1.26.1"]. Pada kasus ini, numpy==1.26.1 akan diambil saat kita menginstal dependensi di container.

Membersihkan

Setelah Anda selesai menguji model, sebagai praktik terbaik, hapus titik akhir untuk menghemat biaya jika titik akhir tidak lagi diperlukan. Anda dapat mengikuti Membersihkan bagian di setiap buku catatan demo atau gunakan kode berikut untuk menghapus model dan titik akhir yang dibuat oleh demo:

predictor.delete_model()
predictor.delete_endpoint()

Kesimpulan

Kemampuan SageMaker ModelBuilder yang baru menyederhanakan proses penerapan model ML ke dalam produksi di SageMaker. Dengan menangani banyak detail kompleks di balik layar, ModelBuilder mengurangi kurva pembelajaran bagi pengguna baru dan memaksimalkan pemanfaatan bagi pengguna berpengalaman. Hanya dengan beberapa baris kode, Anda dapat menerapkan model dengan kerangka kerja bawaan seperti XGBoost, PyTorch, Triton, dan Hugging Face, serta model yang disediakan oleh SageMaker JumpStart ke titik akhir yang kuat dan dapat diskalakan di SageMaker.

Kami mendorong semua pengguna SageMaker untuk mencoba kemampuan baru ini dengan mengacu pada Pembuat Model halaman dokumentasi. ModelBuilder kini tersedia untuk semua pengguna SageMaker tanpa biaya tambahan. Manfaatkan alur kerja yang disederhanakan ini untuk menerapkan model Anda lebih cepat. Kami menantikan bagaimana ModelBuilder mempercepat siklus pengembangan model Anda!

Terima kasih khusus kepada Sirisha Upadhyayala, Raymond Liu, Gary Wang, Dhawal Patel, Deepak Garg dan Ram Vegiraju.

Tentang penulis

Melani Li, PhD, adalah TAM Spesialis AI/ML Senior di AWS yang berbasis di Sydney, Australia. Dia membantu pelanggan perusahaan membangun solusi menggunakan alat AI/ML canggih di AWS dan memberikan panduan tentang merancang dan mengimplementasikan solusi ML dengan praktik terbaik. Di waktu luangnya, dia suka menjelajahi alam dan menghabiskan waktu bersama keluarga dan teman.

Marc Karpa adalah Arsitek ML dengan tim Layanan Amazon SageMaker. Dia berfokus untuk membantu pelanggan merancang, menerapkan, dan mengelola beban kerja ML dalam skala besar. Di waktu luangnya, ia senang bepergian dan menjelajahi tempat-tempat baru.

Sam Edwards, adalah Cloud Engineer (AI/ML) di AWS Sydney yang berspesialisasi dalam pembelajaran mesin dan Amazon SageMaker. Dia bersemangat membantu pelanggan memecahkan masalah terkait alur kerja pembelajaran mesin dan menciptakan solusi baru untuk mereka. Di luar pekerjaan, dia menikmati bermain olahraga raket dan jalan-jalan.

Raghu Ramesha adalah Arsitek Solusi ML Senior di tim Layanan Amazon SageMaker. Dia berfokus membantu pelanggan membangun, menerapkan, dan memigrasikan beban kerja produksi ML ke SageMaker dalam skala besar. Ia berspesialisasi dalam pembelajaran mesin, AI, dan domain visi komputer, serta meraih gelar master di bidang Ilmu Komputer dari UT Dallas. Di waktu luangnya, ia menikmati jalan-jalan dan fotografi.

Shiva Raaj Kotini bekerja sebagai Manajer Produk Utama dalam portofolio produk inferensi Amazon SageMaker. Dia berfokus pada penerapan model, penyesuaian kinerja, dan pengoptimalan di SageMaker untuk inferensi.

Mohan Gandhi adalah Insinyur Perangkat Lunak Senior di AWS. Dia telah bersama AWS selama 10 tahun terakhir dan telah bekerja di berbagai layanan AWS seperti EMR, EFA, dan RDS. Saat ini, dia berfokus pada peningkatan Pengalaman Inferensi SageMaker. Di waktu luangnya, ia menikmati hiking dan maraton.

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• PlatoData.Jaringan Vertikal Generatif Ai. Berdayakan Diri Anda. Akses Di Sini.
• PlatoAiStream. Intelijen Web3. Pengetahuan Diperkuat. Akses Di Sini.
• PlatoESG. Karbon, teknologi bersih, energi, Lingkungan Hidup, Tenaga surya, Penanganan limbah. Akses Di Sini.
• PlatoHealth. Kecerdasan Uji Coba Biotek dan Klinis. Akses Di Sini.
• Sumber: https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-1-pysdk-improvements/