# Sıfır atışlı nesne algılama

Geleneksel olarak, [nesne algılama](object_detection) için kullanılan modeller eğitim için etiketli görüntü veri kümeleri gerektirir ve yalnızca eğitim verisindeki sınıf kümesini algılamakla sınırlıdır.

Zero-shot nesne algılama, sınıflar hakkında herhangi bir önceden eğitim veya bilgi olmadan, görüntülerdeki nesneleri ve sınıflarını tespit etmeyi içeren bir bilgisayarla görme görevidir. Zero-shot nesne algılama modelleri girdi olarak bir görüntü ve aday sınıfların bir listesini alır; çıktı olarak ise nesnelerin algılandığı konumlardaki sınırlayıcı kutuları (bounding box) ve etiketleri üretir.

> [!NOTE]
> Hugging Face, birçok [açık sözlük sıfır atış nesne dedektörü](https://huggingface.co/models?pipeline_tag=zero-shot-object-detection) barındırır.

Bu kılavuzda, bu tür modelleri nasıl kullanacağınızı öğreneceksiniz:

- metin istemlerine dayalı nesne algılama
- batch nesne tespiti için
- görsel yönlendirmeli nesne tespiti için

Başlamadan önce, gerekli tüm kütüphanelerin yüklendiğinden emin olun:

```bash
pip install -q transformers
```

## Sıfır atışlı nesne algılama hattı

Modellerle çıkarımı denemenin en basit yolu, bunu bir [pipeline()](/docs/transformers/v5.23.0/tr/main_classes/pipelines#transformers.pipeline) içinde kullanmaktır. [Hugging Face Hub'daki bir kontrol noktasından](https://huggingface.co/models?pipeline_tag=zero-shot-object-detection) sıfır atıflı nesne tespiti için bir pipeline örneği oluşturun:

```python
>>> from transformers import pipeline

>>> # Use any checkpoint from the hf.co/models?pipeline_tag=zero-shot-object-detection
>>> checkpoint = "iSEE-Laboratory/llmdet_large"
>>> detector = pipeline(model=checkpoint, task="zero-shot-object-detection")
```

Ardından, içinde nesne algılama yapmak istediğiniz bir görüntü seçin. Burada, [NASA](https://www.nasa.gov/multimedia/imagegallery/index.html) Great Images veri setinin bir parçası olan astronot Eileen Collins'in görüntüsünü kullanacağız.

```py
>>> from transformers.image_utils import load_image

>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/zero-sh-obj-detection_1.png"
>>> image = load_image(url)
>>> image
```

     

Görseli ve aranacak aday nesne etiketlerini pipeline'a iletin. Burada görsel doğrudan iletilir; uygun diğer seçenekler arasında görselin yerel yolu veya bir görsel URL'si bulunur. Ayrıca, görselde sorgulamak istediğimiz tüm öğeler için metin açıklamaları da iletiriz.

```py
>>> predictions = detector(
...     image,
...     candidate_labels=["human face", "rocket", "nasa badge", "star-spangled banner"],
...     threshold=0.45,
... )
>>> predictions
[{'score': 0.8409242033958435,
  'label': 'human face',
  'box': {'xmin': 179, 'ymin': 74, 'xmax': 272, 'ymax': 179}},
 {'score': 0.7380027770996094,
  'label': 'rocket',
  'box': {'xmin': 353, 'ymin': 0, 'xmax': 466, 'ymax': 284}},
 {'score': 0.5850900411605835,
  'label': 'star-spangled banner',
  'box': {'xmin': 0, 'ymin': 0, 'xmax': 96, 'ymax': 511}},
 {'score': 0.5697067975997925,
  'label': 'human face',
  'box': {'xmin': 18, 'ymin': 15, 'xmax': 366, 'ymax': 511}},
 {'score': 0.47813931107521057,
  'label': 'star-spangled banner',
  'box': {'xmin': 353, 'ymin': 0, 'xmax': 459, 'ymax': 274}},
 {'score': 0.46597740054130554,
  'label': 'nasa badge',
  'box': {'xmin': 353, 'ymin': 0, 'xmax': 462, 'ymax': 279}},
 {'score': 0.4585932493209839,
  'label': 'nasa badge',
  'box': {'xmin': 132, 'ymin': 348, 'xmax': 208, 'ymax': 423}}]
```

Tahminleri görselleştirelim:

```py
>>> from PIL import ImageDraw

>>> draw = ImageDraw.Draw(image)

>>> for prediction in predictions:
...     box = prediction["box"]
...     label = prediction["label"]
...     score = prediction["score"]

...     xmin, ymin, xmax, ymax = box.values()
...     draw.rectangle((xmin, ymin, xmax, ymax), outline="red", width=1)
...     draw.text((xmin, ymin), f"{label}: {round(score,2)}", fill="white")

>>> image
```

     

## Metin komutlu sıfır atış nesne algılama elle

Sıfır atış nesne algılama hattını nasıl kullanacağınızı gördüğünüze göre, şimdi aynı sonucu manuel olarak yeniden oluşturalım.

[Hugging Face Hub'daki bir kontrol noktasından](https://hf.co/iSEE-Laboratory/llmdet_large) modeli ve ilişkili işlemciyi yükleyerek başlayın. Burada daha öncekiyle aynı kontrol noktasını kullanacağız:

```py
>>> from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection

>>> model = AutoModelForZeroShotObjectDetection.from_pretrained(checkpoint, device_map="auto")
>>> processor = AutoProcessor.from_pretrained(checkpoint)
```

İşleri değiştirmek için farklı bir görsel alalım.

```py
>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/zero-sh-obj-detection_3.png"
>>> image = load_image(url)
>>> image
```

     

Girdileri model için hazırlamak için processor kullanın.

```py
>>> text_labels = ["hat", "book", "sunglasses", "camera"]
>>> inputs = processor(text=text_labels, images=image, return_tensors="pt").to(model.device)
```

Girdileri modelden geçirip ardından sonuçları işleyin ve görselleştirin. Görüntü işleyici, görüntüleri modele göndermeden önce yeniden boyutlandırdığı için, tahmin edilen sınırlayıcı kutuların orijinal görüntüye göre doğru koordinatlara sahip olduğundan emin olmak için `post_process_object_detection` yöntemini kullanmanız gerekir:

```py
>>> import torch

>>> with torch.inference_mode():
...     outputs = model(**inputs)

>>> results = processor.post_process_grounded_object_detection(
...    outputs, threshold=0.50, target_sizes=[(image.height, image.width)], text_labels=text_labels,
... )[0]

>>> draw = ImageDraw.Draw(image)

>>> scores = results["scores"]
>>> text_labels = results["text_labels"]
>>> boxes = results["boxes"]

>>> for box, score, text_label in zip(boxes, scores, text_labels):
...     xmin, ymin, xmax, ymax = box
...     draw.rectangle((xmin, ymin, xmax, ymax), outline="red", width=1)
...     draw.text((xmin, ymin), f"{text_label}: {round(score.item(),2)}", fill="white")

>>> image
```

     

## Toplu işleme

Birden fazla görsel ve metin sorgusu kümesi geçirerek birden fazla görselde farklı (veya aynı) nesneleri arayabilirsiniz. Hem astronot görselini hem de plaj görselini birlikte kullanalım. Toplu işleme için, metin sorgularını işlemciye iç içe geçmiş bir liste olarak, görselleri ise PIL görselleri, PyTorch tensörleri veya NumPy dizileri listeleri olarak geçmelisiniz.

```py
>>> url1 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/zero-sh-obj-detection_1.png"
>>> url2 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/zero-sh-obj-detection_3.png"
>>> images = [load_image(url1), load_image(url2)]
>>> text_queries = [
...     ["human face", "rocket", "nasa badge", "star-spangled banner"],
...     ["hat", "book", "sunglasses", "camera", "can"],
... ]
>>> inputs = processor(text=text_queries, images=images, return_tensors="pt", padding=True)
```

Daha önce son işleme için tek bir görüntünün boyutunu bir tensör olarak geçiriyordunuz, ancak bir demet (tuple) da geçirebilirsiniz; birden fazla görüntü olması durumunda ise demetlerin bir listesini geçirebilirsiniz. İki örnek için tahminler oluşturalım ve ikincisini görselleştirelim (`image_idx = 1`).

```py
>>> with torch.no_grad():
>>>     outputs = model(**inputs)

>>> target_sizes = [(image.height, image.width) for image in images]
>>> results = processor.post_process_grounded_object_detection(
...     outputs, threshold=0.3, target_sizes=target_sizes, text_labels=text_labels,
... )
```

Sonuçları görselleştirelim:

```py
>>> image_idx = 1
>>> draw = ImageDraw.Draw(images[image_idx])

>>> scores = results[image_idx]["scores"].tolist()
>>> text_labels = results[image_idx]["text_labels"]
>>> boxes = results[image_idx]["boxes"].tolist()

>>> for box, score, text_label in zip(boxes, scores, text_labels):
>>>     xmin, ymin, xmax, ymax = box
>>>     draw.rectangle((xmin, ymin, xmax, ymax), outline="red", width=1)
>>>     draw.text((xmin, ymin), f"{text_label}: {round(score,2)}", fill="white")

>>> images[image_idx]
```

     

## Görsel yönlendirmeli nesne algılama

Metin sorguları ile sıfır atışlı nesne algılamanın yanı sıra, [OWL-ViT](https://huggingface.co/collections/ariG23498/owlvit-689b0d0872a7634a6ea17ae7) ve [OWLv2](https://huggingface.co/collections/ariG23498/owlv2-689b0d27bd7d96ba3c7f7530) gibi modeller görüntü yönlendirmeli nesne algılama da sunar. Bu, hedef görüntüdeki benzer nesneleri bulmak için bir görüntü sorgusu kullanabileceğiniz anlamına gelir.

```py
>>> from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection

>>> checkpoint = "google/owlv2-base-patch16-ensemble"
>>> model = AutoModelForZeroShotObjectDetection.from_pretrained(checkpoint, device_map="auto")
>>> processor = AutoProcessor.from_pretrained(checkpoint)
```

Metin sorgularının aksine, yalnızca tek bir örnek görüntüye izin verilir.

İki kedinin bir koltukta olduğu bir görüntüyü hedef görüntü olarak, tek bir kedinin olduğu bir görüntüyü ise sorgu olarak alalım:

```py
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image_target = Image.open(requests.get(url, stream=True).raw)

>>> query_url = "http://images.cocodataset.org/val2017/000000524280.jpg"
>>> query_image = Image.open(requests.get(query_url, stream=True).raw)
```

Görsellere hızlıca bir bakalım:

```py
>>> import matplotlib.pyplot as plt

>>> fig, ax = plt.subplots(1, 2)
>>> ax[0].imshow(image_target)
>>> ax[1].imshow(query_image)
>>> fig.show()
```

     

Ön işleme adımında, metin sorguları yerine artık `query_images` kullanmanız gerekir:

```py
>>> inputs = processor(images=image_target, query_images=query_image, return_tensors="pt")
```

Tahminler için girdileri modele değil, [image_guided_detection()](/docs/transformers/v5.23.0/tr/model_doc/owlvit#transformers.OwlViTForObjectDetection.image_guided_detection) fonksiyonuna iletin. Tahminleri daha önceki gibi çizin; ancak bu sefer etiketler yoktur.

```py
>>> with torch.no_grad():
...     outputs = model.image_guided_detection(**inputs)
...     target_sizes = torch.tensor([image_target.size[::-1]])
...     results = processor.post_process_image_guided_detection(outputs=outputs, target_sizes=target_sizes)[0]

>>> draw = ImageDraw.Draw(image_target)

>>> scores = results["scores"].tolist()
>>> boxes = results["boxes"].tolist()

>>> for box, score in zip(boxes, scores):
...     xmin, ymin, xmax, ymax = box
...     draw.rectangle((xmin, ymin, xmax, ymax), outline="white", width=4)

>>> image_target
```