# Özel katmanlar ve yardımcılar

Bu sayfa, kütüphanenin kullandığı tüm özel katmanları ile modelleme için sağladığı yardımcı işlevleri ve sınıfları listeler.

Bunların çoğu, kütüphanedeki modellerin kodunu inceliyorsanız işe yarar.

## WeightRenaming[[transformers.GroupWeightRename]]

#### transformers.GroupWeightRename[[transformers.GroupWeightRename]]

```python
transformers.GroupWeightRename(source_patterns: list[str], target_patterns: list[str])
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/core_model_loading.py#L1087)

İlk ("guard") kaynak deseni tarafından tembelce etkinleştirilen, eşleşmiş WeightRenaming dönüşümlerinin bir listesini uygular. İki yeniden adlandırmanın ara bir adı paylaştığı durumlarda (ör. `norm0→norm1` ve `norm1→norm2`) bunu kullanın; böylece zaten dönüştürülmüş bir checkpoint'in (içinde `norm1` ve `norm2` olan ama `norm0` bulunmayan) yüklenmesi sırasında yeniden adlandırmaların yanlışlıkla tekrar uygulanması önlenir.

NOT: `source_patterns` listesini, dönüştürülmüş checkpoint'te bulunmayan desenin başta geleceği şekilde sıralayın. State dict, sıralı anahtar sırasına göre işlenir; bu nedenle koruyucu desen, bağımlı desenlerden sözlük sırasına göre daha küçük olmalıdır. Aksi halde bağımlılar ilk geçişte atlanır ve asla yeniden denenmez.

## WeightConverter[[transformers.WeightConverter]]

#### transformers.WeightConverter[[transformers.WeightConverter]]

```python
transformers.WeightConverter(source_patterns: str | list[str], target_patterns: str | list[str], operations: list[ConversionOps], force_cpu: bool = False)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/core_model_loading.py#L1231)

### Dönüşüm işlemleri[[transformers.ConversionOps]]

#### transformers.ConversionOps[[transformers.ConversionOps]]

```python
transformers.ConversionOps()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/core_model_loading.py#L81)

Ağırlık dönüştürme işlemleri için temel sınıf.

#### transformers.Chunk[[transformers.Chunk]]

```python
transformers.Chunk(dim: int = 0, num_shards_attribute: str | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/core_model_loading.py#L116)

Bir tensörü `dim` boyutu boyunca eşit boyutlu parçalara ayırır. Ayrıca, kaç tane tensörün parçalanacağı bilgisini okumak için `num_shards_attribute` yapılandırma alanı kullanılır. Belirsiz sayıda tensörü birleştirirken faydalıdır.

#### transformers.Concatenate[[transformers.Concatenate]]

```python
transformers.Concatenate(dim: int = 0, num_shards_attribute: str | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/core_model_loading.py#L187)

Girdi tensörlerini `dim` boyutu boyunca birleştirir. Ayrıca, keyfi sayıda tensör birleştiriliyorsa, `num_shards_attribute`, zıt Ops kullanılırken yeniden oluşturulacak tensör sayısını öğrenmek için okunacak bir yapılandırma alanıdır.

#### transformers.MergeModulelist[[transformers.MergeModulelist]]

```python
transformers.MergeModulelist(dim: int = 0)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/core_model_loading.py#L259)

Bir tensör listesini, ilk boyut boyunca tek bir tensöre birleştirir. EP veya TP için bunu açıkça tanımlıyoruz çünkü ne yaptığınızı bilmenizden emin olmanız gerekir!

#### transformers.SplitModulelist[[transformers.SplitModulelist]]

```python
transformers.SplitModulelist(dim: int = 0)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/core_model_loading.py#L310)

Her grup için açık bölme boyutları kullanarak `MergeModulelist`'in tersi.

#### transformers.PermuteForRope[[transformers.PermuteForRope]]

```python
transformers.PermuteForRope(subconfig_key: str | None = None, permute_layer_names: list[str] | None = None, inverse: bool = False)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/core_model_loading.py#L465)

Karmaşık RoPE ağırlıklarını bölünmüş sin/cos biçimine dönüştürmek için gereken permütasyonu uygular.

#### transformers.VisionFuseAndPermuteForRope[[transformers.VisionFuseAndPermuteForRope]]

```python
transformers.VisionFuseAndPermuteForRope(dim: int = 0, permute_layer_names: list[str] | None = None, inverse: bool = True)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/core_model_loading.py#L537)

Füzyonlu QKV üzerinde karmaşık RoPE ağırlıklarını bölünmüş sin/cos biçimine dönüştürmek için gereken permütasyonu uygular. `PermuteForRope() + Concatenate()` çağrısına eşdeğerdir ancak `Permute` işleminin yalnızca parçalanmış tensörlerin bir alt kümesine uygulanmasına olanak tanır.

NOT: bu dönüştürme, yalnızca çok modlu modellerdeki bir görme omurgasına uygulanır, çünkü `config.vision_config` alanını kontrol eder

#### transformers.VisionUnfuseAndPermuteForRope[[transformers.VisionUnfuseAndPermuteForRope]]

```python
transformers.VisionUnfuseAndPermuteForRope(dim: int = 0, permute_layer_names: list[str] | None = None, inverse: bool = False)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/core_model_loading.py#L591)

Füzyonlu QKV üzerinde karmaşık RoPE ağırlıklarını bölünmüş sin/cos biçimine dönüştürmek için gereken permütasyonu uygular. `Chunk() + PermuteForRope()` çağrısıyla aynıdır ancak `Permute` işleminin yalnızca parçalanmış tensörlerin bir alt kümesine uygulanmasını sağlar.

NOT: bu dönüştürme, yalnızca çok modlu modellerdeki bir görme omurgasına uygulanır, çünkü `config.vision_config` alanını kontrol eder

## Katmanlar[[transformers.GradientCheckpointingLayer]]

#### transformers.GradientCheckpointingLayer[[transformers.GradientCheckpointingLayer]]

```python
transformers.GradientCheckpointingLayer(*args, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_layers.py#L54)

Gradyan denetleme noktası (gradient checkpointing) içeren katmanlar için temel sınıf.

Bu sınıf, bir katman için gradyan kontrol noktası (gradient checkpointing) işlevselliğini etkinleştirir. Varsayılan olarak gradyan kontrol noktası devre dışıdır (`gradient_checkpointing = False`). `model.set_gradient_checkpointing()` çağrıldığında, `gradient_checkpointing = True` olarak ayarlanarak ve `_gradient_checkpointing_func` öğesine bir kontrol noktası işlevi atanarak gradyan kontrol noktası etkinleştirilir.

Önemli:

`use_reentrant=True` ile gradient checkpointing kullanıldığında, gradyan gerektiren girdilerin (ör. hidden states) gradyanların doğru şekilde iletilmesi için anahtar kelime argümanları yerine konumsal argümanlar (`*args`) olarak geçirilmesi gerekir.

Örnek:

```python
>>> # Correct - hidden_states passed as positional arg
>>> out = self.layer(hidden_states, attention_mask=attention_mask)

>>> # Incorrect - hidden_states passed as keyword arg
>>> out = self.layer(hidden_states=hidden_states, attention_mask=attention_mask)
```

## Dikkat Fonksiyonları[[transformers.AttentionInterface]]

#### transformers.AttentionInterface[[transformers.AttentionInterface]]

```python
transformers.AttentionInterface()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_utils.py#L5234)

İzin verilen dikkat işlevlerini takip eden, sözlük benzeri bir nesne. `register()` çağrısıyla yeni bir dikkat işlevi kolayca ekleyebilirsiniz. Bir model, örneğin `sdpa` gibi mevcut bir dikkat işlevini yerel olarak geçersiz kılmak gerekiyorsa, `modeling_<model>.py` içinde bu sınıfın yeni bir örneğini tanımlayıp bu işlevi o örnekte beyan etmelidir.

#### kayıt[[transformers.AttentionInterface.register]]

```python
register(key: str, value: Callable)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/generic.py#L1143)

## Dikkat Maskesi Fonksiyonları[[transformers.AttentionMaskInterface]]

#### transformers.AttentionMaskInterface[[transformers.AttentionMaskInterface]]

```python
transformers.AttentionMaskInterface()
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/masking_utils.py#L733)

#### kayıt[[transformers.AttentionMaskInterface.register]]

```python
register(key: str, value: Callable)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/generic.py#L1143)

## Rotary Konum Gömme İşlevleri[[transformers.dynamic_rope_update]]

#### transformers.dynamic_rope_update[[transformers.dynamic_rope_update]]

```python
transformers.dynamic_rope_update(rope_forward)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/modeling_rope_utils.py#L34)

**Parametreler:**

rope_forward (Callable) : RoPE uygulamasının ileri geçişi.

**Dönüş:**

Süslenmiş ileri geçiş.

Model dinamik bir RoPE kullanıyorsa (yani ileri yönlü geçişte frekanslarını yeniden hesaplayabilen bir RoPE uygulaması) ileri yönlü geçişte RoPE parametrelerini güncellemek için dekoratör işlevi.

## Pytorch özel modülleri[[transformers.Conv1D]]

#### transformers.Conv1D[[transformers.Conv1D]]

```python
transformers.Conv1D(nf, nx)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pytorch_utils.py#L95)

**Parametreler:**

nf (`int`) : Çıktı özelliklerinin sayısı.

nx (`int`) : Girdi özelliklerinin sayısı.

Radford ve ark. tarafından OpenAI GPT için tanımlanan (ve GPT-2'de de kullanılan) 1D konvolüsyon katmanı.

Temel olarak bir doğrusal katman gibi çalışır ancak ağırlıklar transpoze edilmiştir.

## PyTorch Yardımcı İşlevleri[[transformers.apply_chunking_to_forward]]

#### transformers.apply_chunking_to_forward[[transformers.apply_chunking_to_forward]]

```python
transformers.apply_chunking_to_forward(forward_fn: Callable[..., torch.Tensor], chunk_size: int, chunk_dim: int, *input_tensors)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pytorch_utils.py#L124)

**Parametreler:**

forward_fn (`Callable[..., torch.Tensor]`) : Modelin ileri (forward) fonksiyonu.

chunk_size (`int`) : Parçalı bir tensörün parça boyutu: `num_chunks = len(input_tensors[0]) / chunk_size`.

chunk_dim (`int`) : `input_tensors`'in parçalanacağı boyut.

input_tensors (`tuple[torch.Tensor]`) : `forward_fn`'in parçalanacak girdi tensörleri

**Dönüş:** `torch.Tensor`

`forward_fn` uygulansaydı vereceği şekle sahip bir tensör`.

Bu fonksiyon, `input_tensors` girdisini `chunk_dim` boyutu boyunca `chunk_size` boyutunda daha küçük girdi tensörü parçalarına böler. Ardından, bellek tasarrufu sağlamak için her parçaya bağımsız olarak `forward_fn` katmanını uygular.

`forward_fn`, `chunk_dim` boyunca bağımsızsa bu fonksiyon, `forward_fn`'in `input_tensors` üzerine doğrudan uygulanmasıyla aynı sonucu verir.

Örnekler:

```python
# rename the usual forward() fn to forward_chunk()
def forward_chunk(self, hidden_states):
    hidden_states = self.decoder(hidden_states)
    return hidden_states

# implement a chunked forward function
def forward(self, hidden_states):
    return apply_chunking_to_forward(self.forward_chunk, self.chunk_size_lm_head, self.seq_len_dim, hidden_states)
```

#### transformers.pytorch_utils.prune_linear_layer[[transformers.pytorch_utils.prune_linear_layer]]

```python
transformers.pytorch_utils.prune_linear_layer(layer: nn.Linear, index: torch.LongTensor, dim: int = 0)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pytorch_utils.py#L61)

**Parametreler:**

layer (`torch.nn.Linear`) : Budanacak katman.

index (`torch.LongTensor`) : Katmanda tutulacak indeksler.

dim (`int`, *opsiyonel*, varsayılan 0) : İndekslerin korunacağı boyut.

**Dönüş:** `torch.nn.Linear`

`requires_grad=True` ile yeni bir katman olarak budanmış katman.

Doğrusal bir katmanı budayın ve yalnızca index içindeki girişleri koruyun.

Başları kaldırmak için kullanılır.

