# LoHa

    

Metinden Görsele Özelleştirme Yolculuğu: LyCORIS İnce Ayarından Model Değerlendirmesine

Düşük Sıralı Hadamard Çarpımı ([LoHa](https://huggingface.co/papers/2108.06098)), büyük ağırlık matrisini daha fazla düşük sıralı matrisle yaklaşık olarak ifade edip bunları Hadamard çarpımıyla birleştirmesi bakımından LoRA'ya benzer. Bu yöntem, LoRA'dan bile daha parametre verimlidir ve benzer performans elde eder. LoHa, başlangıçta federated learning (FedPara) için önerilmiş olmakla birlikte, genel amaçlı bir PEFT yöntemi olarak da iyi çalışır ve Stable Diffusion gibi görüntü üretim modellerinin ince ayarı için özellikle popülerdir.

> **Not:** LoHa, [LyCORIS](./adapter_utils) adaptör ailesinin bir parçasıdır. Yakın akrabası olan [LoKr](./lokr), Hadamard çarpımı yerine Kronecker çarpımını kullanır.

Makalenin özeti şudur:

*Bu çalışmada, sık model yüklemeleri ve indirmelerinin getirdiği yükleri aşmak için federatif öğrenmede (FL) iletişim verimli bir parametrelendirme olan FedPara'yı öneriyoruz. Yöntemimiz, katmanların ağırlık parametrelerini, Hadamard çarpımını takiben düşük rütbeli ağırlıklar kullanarak yeniden parametrelendirir. Geleneksel düşük rütbeli parametrelendirmeye kıyasla, FedPara yöntemimiz düşük rütbeli kısıtlamalara bağlı değildir ve bu sayede çok daha büyük bir kapasiteye sahiptir. Bu özellik, orijinal katmanlara sahip modele kıyasla 3 ila 10 kat daha düşük iletişim maliyeti gerektirirken karşılaştırılabilir performans elde etmeyi mümkün kılar; bu, geleneksel düşük rütbeli yöntemlerle sağlanamaz. Yöntemimizin verimliliği, diğer verimli FL optimizatörleriyle birleştirilerek daha da artırılabilir. Ayrıca, parametreleri küresel ve yerel olanlara ayıran, yöntemimizi kişiselleştirilmiş bir FL uygulaması olan pFedPara'ya genişletiyoruz. pFedPara'nın, üç kat daha az parametreyle rakip kişiselleştirilmiş FL yöntemlerinden daha iyi performans gösterdiğini gösteriyoruz.*

Düşük rütbeli ayrıştırma, ağırlık güncellemelerinin düşük rütbeli uzaya kısıtlanması nedeniyle modelin ifade gücünü sınırlayabileceğinden performansı etkileyebilir. Ancak, eğitilebilir parametre sayısını artırdığı için daha büyük bir rütbe kullanmak her zaman istenmeyebilir. Bu sorunu ele almak için LoHa, çeşitli görseller üretme yeteneğinin önemli bir husus olduğu difüzyon modellerine uygulandı. LoHa'nın genel model türleriyle de çalışması beklenir, ancak gömme katmanları için destek şu anda PEFT'te uygulanmamıştır.

LoHa, matris çarpımı yerine [Hadamard çarpımı](https://en.wikipedia.org/wiki/Hadamard_product_(matrices)) (öğe bazlı çarpım) kullanır. $\Delta W$, LoRA'daki gibi iki yerine dört küçük matrisle temsil edilir ve bu düşük rütbeli matrislerin her çifti Hadamard çarpımıyla birleştirilir. Sonuç olarak, $\Delta W$ aynı sayıda eğitilebilir parametreye sahip olabilirken daha yüksek bir rütbe ve ifade gücüne sahip olabilir.

## LoHa ne zaman kullanılmalı

LoHa şu durumlarda iyi bir seçimdir:

- En yaygın olarak kullanıldığı yer olan **görsel üretim modellerini** (Stable Diffusion UNet veya metin kodlayıcı) ince ayarlıyorsunuz.
- Aynı sayıda eğitilebilir parametre için LoRA'dan **daha yüksek etkili sıra** istiyorsunuz, çünkü iki düşük sıralı matrisin Hadamard çarpımı, tek bir düşük sıralı çarpımdan daha büyük bir alt uzay kapsar.
- **PEFT yöntemlerini birleştirmek** istiyorsunuz, örneğin LoHa'yı LoKr ile birlikte kullanarak, çıkarım sırasında [`PeftMixedModel`](./peft_model#peft.PeftMixedModel) kullanmak istiyorsunuz.

LoHa, lineer ve Conv2d katmanlarını destekler. Görevler ayrıca gömme katmanı uyarlama gerektiriyorsa, bunun yerine [LoRA](./lora) düşünün.

## Kullanım

```python
from diffusers import StableDiffusionPipeline
from peft import LoHaConfig, get_peft_model

config_unet = LoHaConfig(
    r=8,
    alpha=8,
    target_modules=[
        "to_k",
        "to_q",
        "to_v",
        "to_out.0",
        "proj_in",
        "proj_out",
    ],
    rank_dropout=0.0,
    module_dropout=0.0,
    use_effective_conv2d=True,
)

pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
pipeline.unet = get_peft_model(pipeline.unet, config_unet)
pipeline.unet.print_healthcheck()
```

## Karma performans değerlendirmesi genel bakış

<iframe src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=LOHA" frameborder="0" width="850" height="1000"
>

# API

## LoHaConfig[[peft.LoHaConfig]]

#### peft.LoHaConfig[[peft.LoHaConfig]]

```python
peft.LoHaConfig(task_type: Optional[Union[str, TaskType]] = None, peft_type: Optional[Union[str, PeftType]] = None, auto_mapping: Optional[dict] = None, peft_version: Optional[str] = None, base_model_name_or_path: Optional[str] = None, revision: Optional[str] = None, inference_mode: bool = False, rank_pattern: Optional[dict] = <factory>, alpha_pattern: Optional[dict] = <factory>, r: int = 8, alpha: int = 8, rank_dropout: float = 0.0, module_dropout: float = 0.0, use_effective_conv2d: bool = False, target_modules: Optional[Union[list[str], str]] = None, exclude_modules: Optional[Union[list[str], str]] = None, init_weights: bool = True, layers_to_transform: Optional[Union[list[int], int]] = None, layers_pattern: Optional[Union[list[str], str]] = None, modules_to_save: Optional[list[str]] = None)
```

[Kaynak](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/loha/config.py#L24)

**Parametreler:**

r (`int`) : LoHa rütbesi.

alpha (`int`) : LoHa ölçeklendirme için alpha parametresi.

rank_dropout (`float`) : Eğitim sırasında rank boyutu için dropout olasılığı.

module_dropout (`float`) : Eğitim sırasında LoHa modüllerini devre dışı bırakmak için kullanılan dropout olasılığı.

use_effective_conv2d (`bool`) : ksize > 1 olan Conv2d (ve Conv1d) için parametre etkili ayrıştırma kullanın (FedPara makalesindeki "Proposition 3").

target_modules (`Optional[Union[List[str], str]]`) : Adaptörün uygulanacağı modüllerin adları. Bu alan belirtilirse, yalnızca belirtilen adlara sahip modüller değiştirilir. Bir dize geçirildiğinde, bir regex eşleşmesi yapılır. Dize listesi geçirildiğinde, tam bir eşleşme yapılır veya modül adının, geçirilen dizelerden herhangi biriyle sonlanıp sonlanmadığı kontrol edilir. Bu alan 'all-linear' olarak belirtilirse, çıktı katmanı hariç tüm linear/Conv1D modülleri seçilir. Bu alan belirtilmezse, modüller model mimarisine göre seçilir. Mimari bilinmiyorsa bir hata oluşturulur -- bu durumda, hedef modülleri manuel olarak belirtmelisiniz.

exclude_modules (`Optional[Union[List[str], str]]`) : Uygulanmayacak modüllerin adları. Bir dize geçirildiğinde, bir regex eşleşmesi yapılır. Bir dize listesi geçirildiğinde, tam bir eşleşme yapılır veya modül adının, geçirilen dizelerden herhangi biriyle sona erip ermediği kontrol edilir.

init_weights (`bool`) : Adaptör ağırlıklarının başlatılmasının yapılıp yapılmayacağını belirtir. Bu varsayılan olarak `True`'dur, `False` geçilmesi önerilmez.

layers_to_transform (`Union[List[int], int]`) : Dönüştürülecek katman indeksleri. Bir int listesi geçirilirse, adaptör bu listede belirtilen katman indekslerine uygulanır. Tek bir tamsayı geçirilirse, dönüşümler bu indeksteki katmana uygulanır.

layers_pattern (`Optional[Union[List[str], str]]`) : Katman desen adı, yalnızca `layers_to_transform` `None`'den farklıysa kullanılır. Bu, genellikle `'layers'` veya `'h'` olarak adlandırılan modelin `nn.ModuleList`'ini hedeflemelidir.

rank_pattern (`dict`) : `r` tarafından belirtilen varsayılan sıradan farklı olan, katman adlarından veya regexp ifadelerinden sıralara yapılan eşleme. Örneğin, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`.

alpha_pattern (`dict`) : `alpha` tarafından belirtilen varsayılan alfa'dan farklı olan alfaların, katman adlarına veya regexp ifadesine eşlenmesi. Örneğin, `{'^model.decoder.layers.0.encoder_attn.k_proj': 16}`.

modules_to_save (`Optional[List[str]]`) : Son kontrol noktasında eğilebilir olarak ayarlanacak ve kaydedilecek, adaptör katmanları dışındaki modüllerin listesi.

Bu, bir [LoHaModel](/docs/peft/v0.22.0/tr/package_reference/loha#peft.LoHaModel) yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır.

## LoHaModel[[peft.LoHaModel]]

#### peft.LoHaModel[[peft.LoHaModel]]

```python
peft.LoHaModel(model, peft_config: Union[PeftConfig, dict[str, PeftConfig]], adapter_name: str, low_cpu_mem_usage: bool = False, state_dict: Optional[dict[str, torch.Tensor]] = None)
```

[Kaynak](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/loha/model.py#L27)

**Parametreler:**

model (`torch.nn.Module`) : Adapter tuner katmanlarının bağlanacağı model.

config ([LoHaConfig](/docs/peft/v0.22.0/tr/package_reference/loha#peft.LoHaConfig)) : LoHa modelinin yapılandırması.

adapter_name (`str`) : Adaptörün adı, varsayılan olarak `"default"`'tur.

low_cpu_mem_usage (`bool`, `optional`, varsayılan `False`) : Meta cihazında boş adaptör ağırlıkları oluşturur. Yükleme sürecini hızlandırmak için faydalıdır.

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

LoHa modeli.

Önceden eğitilmiş bir modelden Düşük Sıralı Hadamard Çarpımı modelini oluşturur. Yöntem kısmen https://huggingface.co/papers/2108.06098 adresinde açıklanmıştır. Mevcut uygulama büyük ölçüde https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/loha.py adresinden ödünç alınmıştır.

Örnek:
```py
>>> from diffusers import StableDiffusionPipeline
>>> from peft import LoHaConfig, get_peft_model

>>> config_te = LoHaConfig(
...     r=8,
...     alpha=32,
...     target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
...     rank_dropout=0.0,
...     module_dropout=0.0,
...     init_weights=True,
... )
>>> config_unet = LoHaConfig(
...     r=8,
...     alpha=32,
...     target_modules=[
...         "proj_in",
...         "proj_out",
...         "to_k",
...         "to_q",
...         "to_v",
...         "to_out.0",
...         "ff.net.0.proj",
...         "ff.net.2",
...     ],
...     rank_dropout=0.0,
...     module_dropout=0.0,
...     init_weights=True,
...     use_effective_conv2d=True,
... )

>>> model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
>>> model.text_encoder = get_peft_model(model.text_encoder, config_te)
>>> model.unet = get_peft_model(model.unet, config_unet)
```

**Öznitelikler**:
- **model** (`~torch.nn.Module`) -- Uyarlanacak model.
- **peft_config** ([LoHaConfig](/docs/peft/v0.22.0/tr/package_reference/loha#peft.LoHaConfig)): LoHa modelinin yapılandırması.

