Çıkarım Uç Noktaları

Inference Endpoints, Hugging Face tarafından yönetilen, özel ve otomatik ölçeklendirme özellikli bir altyapıda transformers, sentence-transformers ve diffusers modellerini kolayca dağıtmak için güvenli bir üretim çözümü sunar. Bir Inference Endpoint, Hub üzerindeki bir modelden oluşturulur. Bu kılavuzda, Inference Endpoints'i huggingface_hub ile programatik olarak nasıl yöneteceğimizi öğreneceğiz. Inference Endpoints ürününün kendisi hakkında daha fazla bilgi için resmi dokümantasyonunu inceleyin.

Bu kılavuz, huggingface_hub'ün doğru şekilde yüklendiğini ve makinenizin oturum açmış olduğunu varsayar. Henüz bu şekilde değilse Hızlı Başlangıç kılavuzuna göz atın. Inference Endpoints API'yi destekleyen en az sürüm v0.19.0'dır.

Yeni: artık HF model kataloğu üzerinden bir Inference Endpoint'i basit bir API çağrısıyla dağıtabilirsiniz. Katalog, optimize edilmiş ayarlarla dağıtılabilen modellerin özenle derlenmiş bir listesidir. Hiçbir şey yapılandırmak zorunda değilsiniz, tüm ağır işleri biz üstleniyoruz! Tüm modellerin ve ayarların, en iyi maliyet/performans dengesini sağlamak için test edildiği garanti edilmektedir. create_inference_endpoint_from_catalog(), create_inference_endpoint() ile aynı şekilde çalışır, ancak iletmeniz gereken parametre sayısı çok daha azdır. Kataloğu programatik olarak almak için list_inference_catalog() kullanabilirsiniz.

Bu hâlâ deneysel bir özellik olduğunu unutmayın. Kullanırsanız ne düşündüğünüzü bize bildirin!

Her katalog modeli, bunun için test edilmiş bir donanım ve motor kombinasyonu olan bir tarife üzerinden dağıtılır. list_inference_catalog(), modelleri tarifeleriyle birlikte döndürür ve sunucu tarafı filtreleri alır (accelerator, engine, license, task, search, limit):

>>> from huggingface_hub import list_inference_catalog
>>> catalog = list_inference_catalog(task="text-generation", accelerator="neuron")
>>> catalog[0]
InferenceCatalogModel(repo_id='meta-llama/Llama-3.1-8B-Instruct', name='Llama-3.1-8B-Instruct', ...)
>>> catalog[0].recipes
[InferenceCatalogRecipe(id='sizzling-biryani-g4xsi1ac', accelerator='gpu', engine='vllm', gguf_file=None, revision=None),
 InferenceCatalogRecipe(id='artisanal-quinoa-yz9ynamx', accelerator='neuron', engine='vllmNeuron', gguf_file=None, revision=None)]

Bir modelin varsayılan tarifesini dağıtmak için repo_id değerini create_inference_endpoint_from_catalog() işlevine iletin; gerekirse accelerator ("cpu", "gpu" veya "neuron") ve gguf_file ile daraltın ya da tam bir tarife dağıtmak için recipe_id iletin:

>>> from huggingface_hub import create_inference_endpoint_from_catalog
>>> endpoint = create_inference_endpoint_from_catalog(repo_id="openai/gpt-oss-120b")
>>> endpoint = create_inference_endpoint_from_catalog(recipe_id="artisanal-quinoa-yz9ynamx")

Üzerine dağıtım yapmak için donanım bulun

create_inference_endpoint() tarafından kabul edilen accelerator, vendor, region, instance_type ve instance_size değerleri birbirine bağlıdır. Geçerli kombinasyonları, saatlik fiyatlarını ve ad alanınızın hızlandırıcı kota bilgilerini listelemek için list_inference_endpoints_hardware() kullanın:

>>> from huggingface_hub import list_inference_endpoints_hardware

>>> for hw in list_inference_endpoints_hardware():
...     if hw.accelerator == "gpu" and hw.status == "available":
...         print(hw.vendor, hw.region, hw.instance_type, hw.instance_size, hw.price_per_hour)
aws us-east-1 nvidia-l4 x1 0.8
aws us-east-1 nvidia-l4 x4 3.8
...

Kota, namespace başına tanımlanır, bu nedenle dağıtım yapacağınız namespace değerini iletin (varsayılan olarak kendi hesabınız kullanılır):

>>> list_inference_endpoints_hardware(namespace="my-org")

Veya CLI üzerinden:

hf endpoints hardware --accelerator gpu

Inference Endpoint Oluştur

İlk adım, create_inference_endpoint() kullanarak bir Inference Endpoint oluşturmaktır:

>>> from huggingface_hub import create_inference_endpoint

>>> endpoint = create_inference_endpoint(
...     "my-endpoint-name",
...     repository="gpt2",
...     framework="pytorch",
...     task="text-generation",
...     accelerator="cpu",
...     vendor="aws",
...     region="us-east-1",
...     type="authenticated",
...     instance_size="x2",
...     instance_type="intel-icl"
... )

Veya CLI üzerinden:

hf endpoints deploy my-endpoint-name --repo gpt2 --framework pytorch --accelerator cpu --vendor aws --region us-east-1 --instance-size x2 --instance-type intel-icl --task text-generation

# Deploy from the catalog with a single command
hf endpoints catalog deploy --repo openai/gpt-oss-120b

# Deploy from the catalog with a specific accelerator
hf endpoints catalog deploy --repo openai/gpt-oss-120b --accelerator gpu

# Deploy an exact catalog recipe, as listed by 'hf endpoints catalog ls'
hf endpoints catalog deploy --recipe artisanal-quinoa-yz9ynamx

Bu örnekte, text-generation için gpt2 sunmak üzere "my-endpoint-name" adında bir authenticated Inference Endpoint oluşturduk. authenticated bir Inference Endpoint, API'ye erişim için token'ınızın gerekli olduğu anlamına gelir. Donanım gereksinimlerini yapılandırmak için tedarikçi, bölge, hızlandırıcı, örnek tipi ve boyut gibi ek bilgiler de sağlamamız gerekir. Kullanılabilir kaynakların listesine buradan bakabilirsiniz. Alternatif olarak, kolaylık için Web interface kullanarak bir Inference Endpoint'i manuel olarak oluşturabilirsiniz. Gelişmiş ayarlar ve kullanımlarıyla ilgili ayrıntılar için bu kılavuza başvurun.

create_inference_endpoint() tarafından döndürülen değer bir InferenceEndpoint nesnesidir:

>>> endpoint
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2', status='pending', url=None)

Veya CLI üzerinden:

hf endpoints describe my-endpoint-name

Bu, uç nokta hakkında bilgi tutan bir dataclass'tır. name, repository, status, task, created_at, updated_at gibi önemli özniteliklere erişebilirsiniz. Gerekirse, endpoint.raw ile sunucudan gelen ham yanıtı da erişebilirsiniz.

Inference Endpoint oluşturulduktan sonra, onu kişisel panelinizde bulabilirsiniz.

Özel bir görüntü kullanma

Varsayılan olarak Inference Endpoint, Hugging Face tarafından sağlanan bir docker görüntüsünden oluşturulur. Ancak, custom_image parametresi kullanılarak herhangi bir docker görüntüsü belirtilebilir. Yaygın bir kullanım senaryosu, LLM'leri text-generation-inference çerçevesiyle çalıştırmaktır. Bu şu şekilde yapılabilir:

# Start an Inference Endpoint running Zephyr-7b-beta on TGI
>>> from huggingface_hub import create_inference_endpoint
>>> endpoint = create_inference_endpoint(
...     "aws-zephyr-7b-beta-0486",
...     repository="HuggingFaceH4/zephyr-7b-beta",
...     framework="pytorch",
...     task="text-generation",
...     accelerator="gpu",
...     vendor="aws",
...     region="us-east-1",
...     type="authenticated",
...     instance_size="x1",
...     instance_type="nvidia-a10g",
...     custom_image={
...         "healthRoute": "/health",
...         "env": {
...             "MAX_BATCH_PREFILL_TOKENS": "2048",
...             "MAX_INPUT_LENGTH": "1024",
...             "MAX_TOTAL_TOKENS": "1512",
...             "MODEL_ID": "/repository"
...         },
...         "url": "ghcr.io/huggingface/text-generation-inference:1.1.0",
...     },
... )

custom_image olarak geçirilecek değer, docker konteynerine giden bir url ve onu çalıştırmak için yapılandırmayı içeren bir sözlüktür. Bununla ilgili daha fazla ayrıntı için Swagger belgelerini inceleyin.

Özel bir konteyner kayıt defterinde barındırılan bir görüntü için container_registry_username ve kayıt defteri tarafından gerekli görüldüğünde container_registry_password parametrelerini iletin. Kimlik bilgileri yalnızca düz özel bir konteyner için desteklenir:

>>> endpoint = create_inference_endpoint(
...     # Other endpoint and hardware arguments omitted for brevity.
...     custom_image={"url": "private.registry.example/my-image:latest", "port": 8080},
...     container_registry_username="user",
...     container_registry_password="password",
... )

Eşdeğer CLI seçenekleri --container-registry-username ve --container-registry-password'dir:

hf endpoints deploy my-endpoint ... --custom-image private.registry.example/my-image:latest \
  --container-registry-username user --container-registry-password password

custom_image, API tarafından desteklenen motor özel konteyner türlerini de kabul eder; bunun için sözlüğü düz bırakmak yerine motor adıyla (vLLM, vLLMNeuron, sGLang, tgi, tgiNeuron, tei, llamacpp, hfServe, …) anahtarlanır. Her motor, standart konteyner alanlarını (url, port, healthRoute) kendi ayar seçenekleriyle birlikte alır. Üst düzey bir url içermeyen herhangi bir sözlük, API'ye olduğu gibi iletildiğinden, API'ye daha sonra eklenecek motorlar huggingface_hub sürüm güncellemesi gerektirmeden çalışır:

# Start an Inference Endpoint running the vLLM engine image
>>> endpoint = create_inference_endpoint(
...     "llama-3-1-8b-instruct-vllm",
...     repository="meta-llama/Llama-3.1-8B-Instruct",
...     framework="pytorch",
...     task="text-generation",
...     accelerator="gpu",
...     vendor="aws",
...     region="us-east-1",
...     instance_size="x1",
...     instance_type="nvidia-l4",
...     custom_image={
...         "vLLM": {
...             "url": "vllm/vllm-openai:v0.23.0",
...             "healthRoute": "/health",
...             "port": 8000,
...             "tensorParallelSize": 1,
...         }
...     },
... )

Motor anahtarı olmadan, aynı sözlük düz bir özel kapsayıcı olarak gönderilir, bu nedenle motora özgü seçenekler (burada tensorParallelSize) düşer.

Özel bir giriş noktası (entrypoint) veya çalışma zamanı bayraklarına ihtiyaç duyan konteynerler için container_command ve/veya container_args (her biri bir token listesi) parametrelerini iletin. Bunlar API yüklemesinde (payload) model.command ve model.args alanlarına eşlenir. Özel görüntülerle (image) sınırlı değildirler: yönetilen motor görüntüleri (ör. vLLM, SGLang) motor bayraklarını container_args üzerinden de kabul eder. Aynı özellik, CLI üzerinden hf endpoints deploy ... --container-command "..." --container-args "..." komutuyla da kullanılabilir.

Çoklu hızlandırıcı örneklerinde paralellik

vLLM ve SGLang varsayılan olarak tek bir hızlandırıcı kullanırken uç nokta, örneğindeki tüm hızlandırıcıları tahsis eder; bu nedenle paralelliği ayarlanmamış bırakmak, modeli tek bir hızlandırıcıya yüklerken diğerlerini boşta bırakır ve yine de sağlıklı olarak raporlanır. Böylece tümü için ödeme yapar ancak tek bir hızlandırıcının verimliliğini elde edersiniz. API'nin bu tür bir dağıtımı artık reddetmesinin nedeni budur. (TGI, shard sayısını örnekten türetir ve bundan etkilenmez.) Bir model kopyasını hızlandırıcılar arasında shard etmek için tensorParallelSize'i ayarlayın veya (yalnızca vLLM) her hızlandırıcıda bir kopya çalıştırmak için dataParallelSize'i kullanın:

>>> endpoint = create_inference_endpoint(
...     "gpt-oss-120b-vllm",
...     repository="openai/gpt-oss-120b",
...     framework="custom",
...     accelerator="gpu",
...     instance_size="x8",
...     instance_type="nvidia-h200",
...     region="us-east-1",
...     vendor="aws",
...     custom_image={"vLLM": {"url": "vllm/vllm-openai:v0.23.0", "tensorParallelSize": 8}},
... )

CLI'den, --engine yönetilen motor görüntüsünü seçer ve bu iki bayrak yapılandırmasına yazılır:

hf endpoints deploy gpt-oss-120b-vllm --repo openai/gpt-oss-120b --framework custom \
  --accelerator gpu --instance-size x8 --instance-type nvidia-h200 --region us-east-1 --vendor aws \
  --engine vllm --custom-image vllm/vllm-openai:v0.23.0 --tensor-parallel-size 8

Dağıtılmış bir uç noktanın yeniden ayarlanması için tensor_parallel_size parametresini tek başına update() veya hf endpoints update komutuna iletin. model.image bütünüyle gönderilir ve url alanını gerektirir; bu nedenle uç noktanın mevcut görüntüsü alınır ve yerinde güncellenir:

>>> endpoint.update(tensor_parallel_size=4)

container_args (--tp 8) eşdeğer değildir: API'nin örneğin hızlandırıcı sayısıyla doğruladığı model.image yapılandırması yerine, motorun komut satırı bayrağı olarak iletilir. Görüntü alanı olmayan motor bayrakları ve paralellik alanları olmayan düz özel konteynerler için kullanın.

Mevcut Inference Endpoint'leri getir veya listele

Bazı durumlarda, daha önce oluşturduğunuz Inference Endpoints'leri yönetmeniz gerekebilir. Adını biliyorsanız, get_inference_endpoint() kullanarak alabilirsiniz; bu yöntem bir InferenceEndpoint nesnesi döndürür. Alternatif olarak, tüm Inference Endpoints'lerin listesini almak için list_inference_endpoints() kullanabilirsiniz. Her iki yöntem de isteğe bağlı bir namespace parametresi kabul eder. namespace değerini, üyesi olduğunuz herhangi bir organizasyon olarak ayarlayabilirsiniz. Aksi takdirde, varsayılan olarak kullanıcı adınız kullanılır.

>>> from huggingface_hub import get_inference_endpoint, list_inference_endpoints

# Get one
>>> get_inference_endpoint("my-endpoint-name")
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2', status='pending', url=None)

# List all endpoints from an organization
>>> list_inference_endpoints(namespace="huggingface")
[InferenceEndpoint(name='aws-starchat-beta', namespace='huggingface', repository='HuggingFaceH4/starchat-beta', status='paused', url=None), ...]

# List all endpoints from all organizations the user belongs to
>>> list_inference_endpoints(namespace="*")
[InferenceEndpoint(name='aws-starchat-beta', namespace='huggingface', repository='HuggingFaceH4/starchat-beta', status='paused', url=None), ...]

Veya CLI üzerinden:

hf endpoints describe my-endpoint-name
hf endpoints ls --namespace huggingface
hf endpoints ls --namespace '*'

Dağıtım durumunu kontrol edin

Bu rehberin geri kalanında, endpoint adında bir InferenceEndpoint nesnesine sahip olduğumuzu varsayacağız. Uç noktanın InferenceEndpointStatus türünde bir status özniteliğine sahip olduğunu fark etmiş olabilirsiniz. Inference Endpoint dağıtıldığında ve erişilebilir olduğunda, durum "running" olmalı ve url özniteliği ayarlanmalıdır:

>>> endpoint
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2', status='running', url='https://jpj7k2q4j805b727.us-east-1.aws.endpoints.huggingface.cloud')

"running" durumuna ulaşmadan önce, Inference Endpoint genellikle "initializing" veya "pending" aşamasından geçer. Uç noktanın yeni durumunu fetch() çalıştırarak alabilirsiniz. InferenceEndpoint'den sunucuya istek yapan diğer tüm yöntemler gibi, endpoint'in iç öznitelikleri de yerinde değiştirilir:

>>> endpoint.fetch()
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2', status='pending', url=None)

Veya CLI üzerinden:

hf endpoints describe my-endpoint-name

Çalışmasını beklerken Inference Endpoint durumunu almak yerine, doğrudan wait() çağrısını yapabilirsiniz. Bu yardımcı, girdi olarak timeout ve fetch_every parametrelerini (saniye cinsinden) alır ve Inference Endpoint dağıtılana kadar iş parçacığını bloklar. Varsayılan değerler sırasıyla None (zaman aşımı yok) ve 5 saniyedir.

# Pending endpoint
>>> endpoint
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2', status='pending', url=None)

# Wait 10s => raises a InferenceEndpointTimeoutError
>>> endpoint.wait(timeout=10)
    raise InferenceEndpointTimeoutError("Timeout while waiting for Inference Endpoint to be deployed.")
huggingface_hub._inference_endpoints.InferenceEndpointTimeoutError: Timeout while waiting for Inference Endpoint to be deployed.

# Wait more
>>> endpoint.wait()
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2', status='running', url='https://jpj7k2q4j805b727.us-east-1.aws.endpoints.huggingface.cloud')

timeout ayarlanmışsa ve Inference Endpoint yüklenmek için çok fazla zaman alırsa, InferenceEndpointTimeoutError zaman aşımı hatası oluşturulur.

Çıkarım çalıştır

Inference Endpoint'iniz çalışmaya başladığında, üzerinde nihayet çıkarım (inference) çalıştırabilirsiniz!

InferenceEndpoint client ve async_client olmak üzere iki özelliğe sahiptir ve bunlar sırasıyla bir InferenceClient ve bir AsyncInferenceClient nesnesi döndürür.

# Run text_generation task:
>>> endpoint.client.text_generation("I am")
' not a fan of the idea of a "big-budget" movie. I think it\'s a'

# Or in an asyncio context:
>>> await endpoint.async_client.text_generation("I am")

Inference Endpoint çalışmıyorsa, bir InferenceEndpointError istisnası fırlatılır:

>>> endpoint.client
huggingface_hub._inference_endpoints.InferenceEndpointError: Cannot create a client for this Inference Endpoint as it is not yet deployed. Please wait for the Inference Endpoint to be deployed using `endpoint.wait()` and try again.

InferenceClient'in nasıl kullanılacağına dair daha fazla ayrıntı için Inference kılavuzu'na göz atın.

Yaşam döngüsünü yönet

Bir Inference Endpoint oluşturmayı ve üzerinde çıkarım (inference) çalıştırmayı gördükten sonra, şimdi yaşam döngüsünü nasıl yöneteceğimize bakalım.

Bu bölümde pause(), resume(), scale_to_zero(), update() ve delete() gibi yöntemleri inceleyeceğiz. Bu yöntemlerin tümü, kullanım kolaylığı için InferenceEndpoint sınıfına eklenen takma adlardır. Dilerseniz, HfApi içinde tanımlanan genel yöntemleri de kullanabilirsiniz: pause_inference_endpoint(), resume_inference_endpoint(), scale_to_zero_inference_endpoint(), update_inference_endpoint() ve delete_inference_endpoint().

Duraklat veya sıfıra ölçekle

Inference Endpoint kullanılmadığında maliyetleri azaltmak için pause() ile duraklatabilir veya scale_to_zero() ile sıfıra ölçekleyebilirsiniz.

Duraklatılmış veya sıfıra ölçeklendirilmiş bir Inference Endpoint hiçbir maliyet oluşturmaz. Bu ikisi arasındaki fark, duraklatılmış bir endpoint'in resume() kullanılarak açıkça devam ettirilmesi gerektiğidir. Buna karşılık, sıfıra ölçeklendirilmiş bir endpoint, kendisine bir inference çağrısı yapıldığında ek bir soğuk başlatma gecikmesiyle otomatik olarak başlar. Bir Inference Endpoint, belirli bir süre hareketsizlikten sonra otomatik olarak sıfıra ölçeklenmesi için yapılandırılabilir.

# Pause and resume endpoint
>>> endpoint.pause()
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2', status='paused', url=None)
>>> endpoint.resume()
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2', status='pending', url=None)
>>> endpoint.wait().client.text_generation(...)
...

# Scale to zero
>>> endpoint.scale_to_zero()
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2', status='scaledToZero', url='https://jpj7k2q4j805b727.us-east-1.aws.endpoints.huggingface.cloud')
# Endpoint is not 'running' but still has a URL and will restart on first call.

Veya CLI üzerinden:

hf endpoints pause my-endpoint-name
hf endpoints resume my-endpoint-name
hf endpoints scale-to-zero my-endpoint-name

Model veya donanım gereksinimlerini güncelle

Bazı durumlarda, yeni bir Inference Endpoint oluşturmadan mevcut Inference Endpoint'inizi güncellemek isteyebilirsiniz. Modeli barındıran modeli veya modeli çalıştırmak için gerekli donanım gereksinimlerini güncelleyebilirsiniz. Bunu update() kullanarak yapabilirsiniz:

# Change target model
>>> endpoint.update(repository="gpt2-large")
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2-large', status='pending', url=None)

# Update number of replicas
>>> endpoint.update(min_replica=2, max_replica=6)
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2-large', status='pending', url=None)

# Update to larger instance
>>> endpoint.update(accelerator="cpu", instance_size="x4", instance_type="intel-icl")
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2-large', status='pending', url=None)

# Update the container arguments, e.g. engine flags on an endpoint running vLLM or SGLang.
# Replaces the current value, it is not appended.
>>> endpoint.update(container_args=["--enable-auto-tool-choice", "--tool-call-parser", "lfm2"])
InferenceEndpoint(name='my-endpoint-name', namespace='Wauplin', repository='gpt2-large', status='pending', url=None)

Veya CLI üzerinden:

hf endpoints update my-endpoint-name --repo gpt2-large
hf endpoints update my-endpoint-name --min-replica 2 --max-replica 6
hf endpoints update my-endpoint-name --accelerator cpu --instance-size x4 --instance-type intel-icl
hf endpoints update my-endpoint-name --container-args "--enable-auto-tool-choice --tool-call-parser lfm2"
# Merged into the image currently configured on the endpoint.
hf endpoints update my-endpoint-name --tensor-parallel-size 8
# Or replace the image entirely, in which case pass back the settings you want to keep.
hf endpoints update my-endpoint-name --engine vllm --custom-image vllm/vllm-openai:v0.23.0 --port 8000

Uç nokta sil

Son olarak, ~InferenceEndpoint.delete() çağrısını yaparak Inference Endpoint'i artık kullanmayacaksanız silebilirsiniz.

Bu, yapılandırması, günlükleri ve kullanım metrikleri dahil olmak üzere uç noktasını tamamen kaldıracak geri alınamaz bir eylemdir. Silinen bir Inference Endpoint geri yüklenemez.

Uçtan uca bir örnek

Inference Endpoints'ın tipik bir kullanım senaryosu, altyapı maliyetlerini sınırlamak için bir iş yığınınu aynı anda işlemektir. Bu süreci, bu kılavuzda gördüğümüz yöntemle otomatikleştirebilirsiniz:

>>> import asyncio
>>> from huggingface_hub import create_inference_endpoint

# Start endpoint + wait until initialized
>>> endpoint = create_inference_endpoint(name="batch-endpoint",...).wait()

# Run inference
>>> client = endpoint.client
>>> results = [client.text_generation(...) for job in jobs]

# Or with asyncio
>>> async_client = endpoint.async_client
>>> results = await asyncio.gather(*[async_client.text_generation(...) for job in jobs])

# Pause endpoint
>>> endpoint.pause()

Veya Inference Endpoint zaten mevcut ve duraklatılmışsa:

>>> import asyncio
>>> from huggingface_hub import get_inference_endpoint

# Get endpoint + wait until initialized
>>> endpoint = get_inference_endpoint("batch-endpoint").resume().wait()

# Run inference
>>> async_client = endpoint.async_client
>>> results = await asyncio.gather(*[async_client.text_generation(...) for job in jobs])

# Pause endpoint
>>> endpoint.pause()