# Çıkarım Uç Noktaları

Inference Endpoints, Hugging Face tarafından yönetilen, özel ve otomatik ölçeklendirme özellikli bir altyapıda herhangi bir `transformers`, `sentence-transformers` ve `diffusers` modelini kolayca dağıtmak için güvenli bir üretim çözümü sunar. Bir Inference Endpoint, [Hub](https://huggingface.co/models) ü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](https://huggingface.co/docs/inference-endpoints/index) 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](https://huggingface.co/docs/huggingface_hub/quick-start#quickstart) göz atın. Inference Endpoints API'yi destekleyen en az sürüm `v0.19.0`'dır.

> [!TIP]
> **Yeni:** artık [HF model kataloğu](https://endpoints.huggingface.co/catalog) ü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()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.create_inference_endpoint_from_catalog), [create_inference_endpoint()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.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()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.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()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.list_inference_catalog), modelleri tarifeleriyle birlikte döndürür ve sunucu tarafı filtreleri alır (`accelerator`, `engine`, `license`, `task`, `search`, `limit`):

```py
>>> 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()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.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:

```py
>>> 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()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.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()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.list_inference_endpoints_hardware) kullanın:

```py
>>> 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):

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

Veya CLI üzerinden:

```bash
hf endpoints hardware --accelerator gpu
```

## Inference Endpoint Oluştur

İlk adım, [create_inference_endpoint()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.create_inference_endpoint) kullanarak bir Inference Endpoint oluşturmaktır:

```py
>>> 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:

```bash
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](https://huggingface.co/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](https://api.endpoints.huggingface.cloud/#/v2%3A%3Aprovider/list_vendors) bakabilirsiniz. Alternatif olarak, kolaylık için [Web interface](https://ui.endpoints.huggingface.co) 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](https://huggingface.co/docs/inference-endpoints/guides/advanced) başvurun.

[create_inference_endpoint()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.create_inference_endpoint) tarafından döndürülen değer bir [InferenceEndpoint](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint) nesnesidir:

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

Veya CLI üzerinden:

```bash
hf endpoints describe my-endpoint-name
```

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](https://ui.endpoints.huggingface.co/) bulabilirsiniz.

![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/huggingface_hub/inference_endpoints_created.png)

#### Ö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](https://github.com/huggingface/text-generation-inference) çerçevesiyle çalıştırmaktır. Bu şu şekilde yapılabilir:

```python
# 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](https://api.endpoints.huggingface.cloud/#/v2%3A%3Aendpoint/create_endpoint) 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:

```python
>>> 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:

```bash
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:

```python
# 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 (endpoint) örneğindeki tüm hızlandırıcıları tahsis eder; bu nedenle paralellik ayarını boş 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:

```py
>>> 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:

```bash
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()](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint.update) veya `hf endpoints update` komutuna iletin. `model.image` bütünüyle gönderilir ve `url` parametresini gerektirir; bu nedenle uç noktanın mevcut görüntüsü alınır ve yerinde güncellenir:

```py
>>> 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ına göre doğruladığı `model.image` yapılandırması yerine, motorun komut satırı bayrağı olarak ulaşır. Görsel 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()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.get_inference_endpoint) kullanarak alabilirsiniz; bu yöntem bir [InferenceEndpoint](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint) nesnesi döndürür. Alternatif olarak, tüm Inference Endpoints'lerin listesini almak için [list_inference_endpoints()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.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.

```py
>>> 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:

```bash
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](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint) nesnesine sahip olduğumuzu varsayacağız. Uç noktanın [InferenceEndpointStatus](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.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:

```py
>>> 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()](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint.fetch) çalıştırarak alabilirsiniz. [InferenceEndpoint](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint)'den sunucuya istek yapan diğer tüm yöntemler gibi, `endpoint`'in iç öznitelikleri de yerinde değiştirilir:

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

Veya CLI üzerinden:

```bash
hf endpoints describe my-endpoint-name
```

Çalışmasını beklerken Inference Endpoint durumunu almak yerine, doğrudan [wait()](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint.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.

```py
# 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](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint) `client` ve `async_client` olmak üzere iki özelliğe sahiptir ve bunlar sırasıyla bir [InferenceClient](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_client#huggingface_hub.InferenceClient) ve bir [AsyncInferenceClient](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_client#huggingface_hub.AsyncInferenceClient) nesnesi döndürür.

```py
# 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](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpointError) istisnası fırlatılır:

```py
>>> 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](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_client#huggingface_hub.InferenceClient)'in nasıl kullanılacağına dair daha fazla ayrıntı için [Inference kılavuzu](../guides/inference)'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.

> [!TIP]
> Bu bölümde [pause()](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint.pause), [resume()](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint.resume), [scale_to_zero()](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint.scale_to_zero), [update()](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint.update) ve [delete()](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint.delete) gibi yöntemleri inceleyeceğiz. Bu yöntemlerin tümü, kullanım kolaylığı için [InferenceEndpoint](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint) sınıfına eklenen takma adlardır. Dilerseniz, `HfApi` içinde tanımlanan genel yöntemleri de kullanabilirsiniz: [pause_inference_endpoint()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.pause_inference_endpoint), [resume_inference_endpoint()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.resume_inference_endpoint), [scale_to_zero_inference_endpoint()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.scale_to_zero_inference_endpoint), [update_inference_endpoint()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.update_inference_endpoint) ve [delete_inference_endpoint()](/docs/huggingface_hub/v2.4.0/tr/package_reference/hf_api#huggingface_hub.HfApi.delete_inference_endpoint).

### Duraklat veya sıfıra ölçekle

Inference Endpoint kullanılmadığında maliyetleri azaltmak için [pause()](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint.pause) ile duraklatabilir veya [scale_to_zero()](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint.scale_to_zero) ile sıfıra ölçekleyebilirsiniz.

> [!TIP]
> *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()](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint.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.

```py
# 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:

```bash
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()](/docs/huggingface_hub/v2.4.0/tr/package_reference/inference_endpoints#huggingface_hub.InferenceEndpoint.update) kullanarak yapabilirsiniz:

```py
# 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:

```bash
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, Inference Endpoint'ı artık kullanmayacaksanız, `~InferenceEndpoint.delete()` fonksiyonunu çağırmanız yeterlidir.

> [!WARNING]
> 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:

```py
>>> 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:

```py
>>> 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()
```