1te

model_index.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b7b617daaaefac820f302b5222a5cbc9aeb7b926c676b01e67fa3924ee95bdc6
-size 557
+oid sha256:f1b6ce208190165975458f502eb3e7ad6d4a5dd54a507f8dd727e636e363ae93
+size 428

pipeline_sdxs-Copy1.py

@@ -0,0 +1,372 @@
+import torch
+import numpy as np
+from PIL import Image
+from typing import List, Union, Optional, Tuple
+from dataclasses import dataclass
+
+from diffusers import DiffusionPipeline
+from diffusers.utils import BaseOutput
+from tqdm import tqdm
+from transformers import Qwen3ForCausalLM, Qwen2Tokenizer
+
+@dataclass
+class SdxsPipelineOutput(BaseOutput):
+    images: Union[List[Image.Image], np.ndarray]
+    prompt: Optional[Union[str, List[str]]] = None  # Возврат улучшенного промпта
+
+class SdxsPipeline(DiffusionPipeline):
+    def __init__(self, vae, text_encoder, text_encoder2, tokenizer, tokenizer2, unet, scheduler):
+        super().__init__()
+        self.register_modules(
+            vae=vae, 
+            text_encoder=text_encoder,
+            text_encoder2=text_encoder2, 
+            tokenizer=tokenizer,
+            tokenizer2=tokenizer2,
+            unet=unet, 
+            scheduler=scheduler
+        )
+        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)            
+        mean = getattr(self.vae.config, "latents_mean", None)
+        std = getattr(self.vae.config, "latents_std", None)
+        if mean is not None and std is not None:
+            self.vae_latents_std = torch.tensor(std, device=self.unet.device, dtype=self.unet.dtype).view(1, len(std), 1, 1)
+            self.vae_latents_mean = torch.tensor(mean, device=self.unet.device, dtype=self.unet.dtype).view(1, len(mean), 1, 1)
+        
+    def preprocess_image(self, image: Image.Image, width: int, height: int):
+        """Ресайз и центрированный кроп изображения для асимметричного VAE."""
+        # Для энкодера с масштабом 8
+        target_height = ((height // self.vae_scale_factor) * self.vae_scale_factor)
+        target_width = ((width // self.vae_scale_factor) * self.vae_scale_factor)
+        
+        w, h = image.size
+        aspect_ratio = target_width / target_height
+        
+        if w / h > aspect_ratio:
+            new_w = int(h * aspect_ratio)
+            left = (w - new_w) // 2
+            image = image.crop((left, 0, left + new_w, h))
+        else:
+            new_h = int(w / aspect_ratio)
+            top = (h - new_h) // 2
+            image = image.crop((0, top, w, top + new_h))
+        
+        image = image.resize((target_width, target_height), resample=Image.LANCZOS)
+        image = np.array(image).astype(np.float32) / 255.0
+        image = image[None].transpose(0, 3, 1, 2)  # [1, C, H, W]
+        image = torch.from_numpy(image)
+        return 2.0 * image - 1.0  # [-1, 1]
+
+
+    def encode_prompt(self, prompt, negative_prompt, device, dtype):
+        def get_single_encode(texts):
+            if not texts:
+                texts = [""]
+            elif isinstance(texts, str):
+                texts = [texts]
+
+            with torch.no_grad():
+                toks = self.tokenizer(
+                    texts,
+                    padding="max_length",
+                    max_length=self.text_encoder.config.max_position_embeddings,
+                    truncation=True,
+                    return_tensors="pt"
+                ).to(device)
+
+                outputs = self.text_encoder(
+                    input_ids=toks.input_ids, 
+                    attention_mask=toks.attention_mask,
+                    output_hidden_states=True
+                )
+
+                # 1. Берем -2 слой [Batch, Seq, Dim]
+                hidden = outputs.hidden_states[-2]
+
+                # 2. Достаем pooled вектор (последний токен) [Batch, Dim]
+                seq_lens = toks.attention_mask.sum(dim=1) - 1
+                pooled = hidden[torch.arange(hidden.shape[0]), seq_lens.clamp(min=0)]
+
+                # 3. Нормализация
+                norm = self.text_encoder.text_model.final_layer_norm
+                hidden = norm(hidden)
+                pooled = norm(pooled)
+
+                # 4. Объединяем в матрицу: Пулед (как 1-й токен) + остальные токены
+                # pooled.unsqueeze(1) делает [Batch, 1, Dim]
+                embeds = torch.cat([pooled.unsqueeze(1), hidden], dim=1)
+
+                # 5. Расширяем маску для нового токена (добавляем единицы спереди)
+                ones = torch.ones((toks.attention_mask.shape[0], 1), dtype=toks.attention_mask.dtype, device=device)
+                mask = torch.cat([ones, toks.attention_mask], dim=1)
+
+                return embeds, mask, pooled
+                
+        def get_pooled_encode(texts):
+            if texts is None:
+                texts = ""
+
+            if isinstance(texts, str):
+                texts = [texts]
+
+            with torch.no_grad():
+                # 1. Собираем текстовые промпты оборачивая их в Chat Template
+                formatted_prompts = []
+                for t in texts:
+                    messages = [{"role": "user", "content": [{"type": "text", "text": t}]}]
+                    res_text = self.tokenizer2.apply_chat_template(
+                        messages, 
+                        add_generation_prompt=True, 
+                        tokenize=False 
+                    )
+                    formatted_prompts.append(res_text)
+
+                # 2. Токенизируем, режем и добавляем паддинг за один раз
+                toks = self.tokenizer2(
+                    formatted_prompts,
+                    padding="max_length",
+                    max_length=self.text_encoder.config.max_position_embeddings,
+                    truncation=True, # Не забываем обрезать, если вдруг длиннее
+                    return_tensors="pt"
+                ).to(device)
+
+                # 3. Прогоняем через модель
+                outputs = self.text_encoder2(
+                    input_ids=toks.input_ids, 
+                    attention_mask=toks.attention_mask,
+                    output_hidden_states=True
+                )
+
+                layer_index = -2
+                last_hidden = outputs.hidden_states[layer_index]
+                seq_len = toks.attention_mask.sum(dim=1) - 1
+                pooled = last_hidden[torch.arange(len(last_hidden)), seq_len.clamp(min=0)]
+
+                return pooled
+        def get_encode(texts):
+            if texts is None:
+                texts = ""
+
+            if isinstance(texts, str):
+                texts = [texts]
+
+            with torch.no_grad():
+                # 1. Собираем текстовые промпты оборачивая их в Chat Template
+                formatted_prompts = []
+                for t in texts:
+                    messages = [{"role": "user", "content": [{"type": "text", "text": t}]}]
+                    res_text = self.tokenizer2.apply_chat_template(
+                        messages, 
+                        add_generation_prompt=True, 
+                        tokenize=False 
+                    )
+                    formatted_prompts.append(res_text)
+
+                # 2. Токенизируем, режем и добавляем паддинг за один раз
+                toks = self.tokenizer2(
+                    formatted_prompts,
+                    padding="max_length",
+                    max_length=self.text_encoder.config.max_position_embeddings,
+                    truncation=True, # Не забываем обрезать, если вдруг длиннее
+                    return_tensors="pt"
+                ).to(device)
+
+                # 3. Прогоняем через модель
+                outputs = self.text_encoder2(
+                    input_ids=toks.input_ids, 
+                    attention_mask=toks.attention_mask,
+                    output_hidden_states=True
+                )
+
+                layer_index = -2
+                last_hidden = outputs.hidden_states[layer_index]
+                seq_len = toks.attention_mask.sum(dim=1) - 1
+                pooled = last_hidden[torch.arange(len(last_hidden)), seq_len.clamp(min=0)]
+
+                return last_hidden, toks.attention_mask, pooled
+
+        #pos_embeds, pos_mask, pooled_pos = get_single_encode(prompt)
+        #neg_embeds, neg_mask, pooled_neg = get_single_encode(negative_prompt)
+        # 768 + 2048
+        #pos_pooled = get_pooled_encode(prompt) #torch.cat([pooled_pos, get_pooled_encode(prompt)], dim=1)
+        #neg_pooled = get_pooled_encode(negative_prompt) #torch.cat([pooled_neg, get_pooled_encode(negative_prompt)], dim=1)
+        pos_embeds, pos_mask, pos_pooled = get_encode(prompt)
+        neg_embeds, neg_mask, neg_pooled = get_encode(negative_prompt)
+
+        batch_size = pos_embeds.shape[0]
+        if neg_embeds.shape[0] != batch_size:
+            neg_embeds = neg_embeds.repeat(batch_size, 1, 1)
+            neg_mask = neg_mask.repeat(batch_size, 1)
+            neg_pooled = neg_pooled.repeat(batch_size, 1)
+
+        if pos_pooled.shape[0] != batch_size:
+            pos_pooled = pos_pooled.repeat(batch_size, 1)
+
+        text_embeddings = torch.cat([neg_embeds, pos_embeds], dim=0)
+        final_mask = torch.cat([neg_mask, pos_mask], dim=0)
+        pooled_embeds = torch.cat([neg_pooled, pos_pooled], dim=0)
+
+        return text_embeddings.to(dtype=dtype), final_mask.to(dtype=torch.int64), pooled_embeds.to(dtype=dtype)
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        prompt: Union[str, List[str]],
+        image: Optional[Union[Image.Image, List[Image.Image]]] = None,
+        coef: float = 0.97,                    # ← strength (0.0 = оригинал, 1.0 = полный шум)
+        negative_prompt: Optional[Union[str, List[str]]] = None,
+        height: int = 1024,
+        width: int = 1024,
+        num_inference_steps: int = 40,
+        guidance_scale: float = 4.0,
+        generator: Optional[torch.Generator] = None,
+        seed: Optional[int] = None,
+        output_type: str = "pil",
+        return_dict: bool = True,
+        refine_prompt: bool = False, # Флаг рефайна!
+        # structure_preservation оставляем для совместимости, но теперь он почти не нужен
+        structure_preservation: float = 0.0,   # 0.0 = стандартный линейный путь (лучше всего)
+        **kwargs,
+    ):
+        device = self.device
+        dtype = self.unet.dtype
+    
+        if generator is None and seed is not None:
+            generator = torch.Generator(device=device).manual_seed(seed)
+            
+        # ==================== REFINE PROMPT (INLINE) ====================
+        if refine_prompt and prompt:
+            sys_msg = (
+                "You are a skilled text-to-image prompt engineer whose sole function is to transform the user's input into an aesthetically optimized, detailed, and visually descriptive three-sentence output. "
+                "**The primary subject (e.g., 'girl', 'dog', 'house') MUST be the main focus of the revised prompt and MUST be described in rich detail within the first sentence or two.** "
+                "Output **only** the final revised prompt in **English**, with absolutely no commentary.\n Don't use cliches like warm,soft,vibrant, wildflowers. Be creative "
+                "User input prompt: "
+            )
+            prompts_list = [prompt] if isinstance(prompt, str) else prompt
+            refined_list = []
+            
+            for p in prompts_list:
+                messages = [{"role": "user", "content": [{"type": "text", "text": sys_msg + p}]}]
+                
+                # Используем Qwen-Instruct формат (apply_chat_template сам подставит system/user/assistant токены)
+                inputs = self.tokenizer2.apply_chat_template(
+                    messages,
+                    tokenize=True,
+                    add_generation_prompt=True,
+                    return_dict=True,
+                    return_tensors="pt"
+                ).to(device)
+                
+                generated_ids = self.text_encoder2.generate(
+                    **inputs, max_new_tokens=self.text_encoder.config.max_position_embeddings, do_sample=True,temperature = 0.7
+                )
+                
+                # Обрезаем входные токены из ответа
+                generated_ids_trimmed = [
+                    out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+                ]
+                output_text = self.tokenizer2.batch_decode(
+                    generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
+                )
+                refined_list.append(output_text)
+                
+            prompt = refined_list[0] if isinstance(prompt, str) else refined_list
+
+        # ==================== ENCODE PROMPTS ====================
+        text_embeddings, attention_mask, pooled_embeds = self.encode_prompt(
+            prompt, negative_prompt, device, dtype
+        )
+        batch_size = 1 if isinstance(prompt, str) else len(prompt)
+    
+        # 2. Scheduler timesteps
+        self.scheduler.set_timesteps(num_inference_steps, device=device)
+        timesteps = self.scheduler.timesteps
+
+        # ==================== TIME IDS =======================================
+        # time_ids должен иметь ТОТ ЖЕ batch-размер, что и pooled_embeds и text_embeddings
+        # (в твоём encode_prompt они всегда удваиваются из-за CFG)
+        time_ids = torch.zeros(
+            pooled_embeds.shape[0],   # ← вот это главное
+            6, 
+            device=device, 
+            dtype=torch.long
+        )
+    
+        # ==================== IMG2IMG БЛОК (НОВАЯ ВЕРСИЯ) ====================
+        if image is not None:
+            # --- Подготовка изображения ---
+            if isinstance(image, Image.Image):
+                image_tensor = self.preprocess_image(image, width, height).to(device, self.vae.dtype)
+            else:
+                image_tensor = self.preprocess_image(image[0], width, height).to(device, self.vae.dtype)
+    
+            # --- Кодируем в latent ---
+            latents_clean = self.vae.encode(image_tensor).latent_dist.sample(generator=generator)
+            latents_clean = (latents_clean - self.vae_latents_mean.to(device, self.vae.dtype)) / self.vae_latents_std.to(device, self.vae.dtype)
+            latents_clean = latents_clean.to(dtype)
+    
+            # --- Добавляем шум по Rectified Flow формуле ---
+            noise = torch.randn_like(latents_clean)
+    
+            # coef = strength (0.0 → оригинал, 1.0 → чистый шум)
+            sigma = coef                                      # в Flow Matching sigma = t
+            if hasattr(self.scheduler, "sigma_shift"):        # если есть shift (Flux-style)
+                sigma = self.scheduler.sigma_shift(sigma)
+    
+            latents = (1.0 - sigma) * latents_clean + sigma * noise
+    
+            # Обрезаем timesteps начиная с текущего sigma
+            init_timestep = int(num_inference_steps * coef)
+            t_start = max(num_inference_steps - init_timestep, 0)
+            timesteps = timesteps[t_start:]
+    
+        else:
+            # txt2img
+            latent_h = height // self.vae_scale_factor
+            latent_w = width // self.vae_scale_factor
+    
+            latents = torch.randn(
+                (batch_size, self.unet.config.in_channels, latent_h, latent_w),
+                generator=generator, device=device, dtype=dtype
+            )
+    
+        # ==================== DENOISING LOOP (одинаковый для txt2img и img2img) ====================
+        for i, t in enumerate(tqdm(timesteps, desc="Sampling")):
+            latent_model_input = torch.cat([latents] * 2) if guidance_scale > 1.0 else latents
+    
+            model_out = self.unet(
+                latent_model_input,
+                t,
+                encoder_hidden_states=text_embeddings,
+                encoder_attention_mask=attention_mask,
+                #added_cond_kwargs=added_cond_kwargs,
+                added_cond_kwargs={"text_embeds": pooled_embeds,"time_ids": time_ids},
+                return_dict=False,
+            )[0]
+    
+            if guidance_scale > 1.0:
+                flow_uncond, flow_cond = model_out.chunk(2)
+                model_out = flow_uncond + guidance_scale * (flow_cond - flow_uncond)
+    
+            # Важно: используем scheduler.step — он сам знает, что делать с velocity
+            latents = self.scheduler.step(model_out, t, latents, return_dict=False)[0]
+    
+        # ==================== DECODE ====================
+        if output_type == "latent":
+            if not return_dict: return (latents, prompt)
+            return SdxsPipelineOutput(images=latents, prompt=prompt)
+    
+        latents = latents * self.vae_latents_std.to(device, self.vae.dtype) + self.vae_latents_mean.to(device, self.vae.dtype)
+        image_output = self.vae.decode(latents.to(self.vae.dtype), return_dict=False)[0]
+    
+        image_output = (image_output.clamp(-1, 1) + 1) / 2
+        image_np = image_output.cpu().permute(0, 2, 3, 1).float().numpy()
+    
+        if output_type == "pil":
+            images = [(Image.fromarray((img * 255).round().astype("uint8"))) for img in image_np]
+        else:
+            images = image_np
+    
+        if not return_dict:
+            return (images, prompt)
+        return SdxsPipelineOutput(images=images, prompt=prompt)

pipeline_sdxs.py

@@ -7,22 +7,20 @@ from dataclasses import dataclass
 from diffusers import DiffusionPipeline
 from diffusers.utils import BaseOutput
 from tqdm import tqdm
-from transformers import Qwen3ForCausalLM, Qwen2Tokenizer
+from transformers import Qwen3_5ForConditionalGeneration, Qwen3_5Tokenizer
 
 @dataclass
 class SdxsPipelineOutput(BaseOutput):
     images: Union[List[Image.Image], np.ndarray]
-    prompt: Optional[Union[str, List[str]]] = None  # Возврат улучшенного промпта
+    prompt: Optional[Union[str, List[str]]] = None
 
 class SdxsPipeline(DiffusionPipeline):
-    def __init__(self, vae, text_encoder, text_encoder2, tokenizer, tokenizer2, unet, scheduler):
+    def __init__(self, vae, text_encoder, tokenizer, unet, scheduler):
         super().__init__()
         self.register_modules(
             vae=vae, 
             text_encoder=text_encoder,
-            text_encoder2=text_encoder2, 
             tokenizer=tokenizer,
-            tokenizer2=tokenizer2,
             unet=unet, 
             scheduler=scheduler
         )
@@ -59,90 +57,6 @@ class SdxsPipeline(DiffusionPipeline):
 
 
     def encode_prompt(self, prompt, negative_prompt, device, dtype):
-        def get_single_encode(texts):
-            if not texts:
-                texts = [""]
-            elif isinstance(texts, str):
-                texts = [texts]
-
-            with torch.no_grad():
-                toks = self.tokenizer(
-                    texts,
-                    padding="max_length",
-                    max_length=self.text_encoder.config.max_position_embeddings,
-                    truncation=True,
-                    return_tensors="pt"
-                ).to(device)
-
-                outputs = self.text_encoder(
-                    input_ids=toks.input_ids, 
-                    attention_mask=toks.attention_mask,
-                    output_hidden_states=True
-                )
-
-                # 1. Берем -2 слой [Batch, Seq, Dim]
-                hidden = outputs.hidden_states[-2]
-
-                # 2. Достаем pooled вектор (последний токен) [Batch, Dim]
-                seq_lens = toks.attention_mask.sum(dim=1) - 1
-                pooled = hidden[torch.arange(hidden.shape[0]), seq_lens.clamp(min=0)]
-
-                # 3. Нормализация
-                norm = self.text_encoder.text_model.final_layer_norm
-                hidden = norm(hidden)
-                pooled = norm(pooled)
-
-                # 4. Объединяем в матрицу: Пулед (как 1-й токен) + остальные токены
-                # pooled.unsqueeze(1) делает [Batch, 1, Dim]
-                embeds = torch.cat([pooled.unsqueeze(1), hidden], dim=1)
-
-                # 5. Расширяем маску для нового токена (добавляем единицы спереди)
-                ones = torch.ones((toks.attention_mask.shape[0], 1), dtype=toks.attention_mask.dtype, device=device)
-                mask = torch.cat([ones, toks.attention_mask], dim=1)
-
-                return embeds, mask, pooled
-                
-        def get_pooled_encode(texts):
-            if texts is None:
-                texts = ""
-
-            if isinstance(texts, str):
-                texts = [texts]
-
-            with torch.no_grad():
-                # 1. Собираем текстовые промпты оборачивая их в Chat Template
-                formatted_prompts = []
-                for t in texts:
-                    messages = [{"role": "user", "content": [{"type": "text", "text": t}]}]
-                    res_text = self.tokenizer2.apply_chat_template(
-                        messages, 
-                        add_generation_prompt=True, 
-                        tokenize=False 
-                    )
-                    formatted_prompts.append(res_text)
-
-                # 2. Токенизируем, режем и добавляем паддинг за один раз
-                toks = self.tokenizer2(
-                    formatted_prompts,
-                    padding="max_length",
-                    max_length=self.text_encoder.config.max_position_embeddings,
-                    truncation=True, # Не забываем обрезать, если вдруг длиннее
-                    return_tensors="pt"
-                ).to(device)
-
-                # 3. Прогоняем через модель
-                outputs = self.text_encoder2(
-                    input_ids=toks.input_ids, 
-                    attention_mask=toks.attention_mask,
-                    output_hidden_states=True
-                )
-
-                layer_index = -2
-                last_hidden = outputs.hidden_states[layer_index]
-                seq_len = toks.attention_mask.sum(dim=1) - 1
-                pooled = last_hidden[torch.arange(len(last_hidden)), seq_len.clamp(min=0)]
-
-                return pooled
         def get_encode(texts):
             if texts is None:
                 texts = ""
@@ -155,7 +69,7 @@ class SdxsPipeline(DiffusionPipeline):
                 formatted_prompts = []
                 for t in texts:
                     messages = [{"role": "user", "content": [{"type": "text", "text": t}]}]
-                    res_text = self.tokenizer2.apply_chat_template(
+                    res_text = self.tokenizer.apply_chat_template(
                         messages, 
                         add_generation_prompt=True, 
                         tokenize=False 
@@ -163,16 +77,16 @@ class SdxsPipeline(DiffusionPipeline):
                     formatted_prompts.append(res_text)
 
                 # 2. Токенизируем, режем и добавляем паддинг за один раз
-                toks = self.tokenizer2(
+                toks = self.tokenizer(
                     formatted_prompts,
                     padding="max_length",
-                    max_length=self.text_encoder.config.max_position_embeddings,
+                    max_length=255,
                     truncation=True, # Не забываем обрезать, если вдруг длиннее
                     return_tensors="pt"
                 ).to(device)
 
                 # 3. Прогоняем через модель
-                outputs = self.text_encoder2(
+                outputs = self.text_encoder(
                     input_ids=toks.input_ids, 
                     attention_mask=toks.attention_mask,
                     output_hidden_states=True
@@ -185,11 +99,6 @@ class SdxsPipeline(DiffusionPipeline):
 
                 return last_hidden, toks.attention_mask, pooled
 
-        #pos_embeds, pos_mask, pooled_pos = get_single_encode(prompt)
-        #neg_embeds, neg_mask, pooled_neg = get_single_encode(negative_prompt)
-        # 768 + 2048
-        #pos_pooled = get_pooled_encode(prompt) #torch.cat([pooled_pos, get_pooled_encode(prompt)], dim=1)
-        #neg_pooled = get_pooled_encode(negative_prompt) #torch.cat([pooled_neg, get_pooled_encode(negative_prompt)], dim=1)
         pos_embeds, pos_mask, pos_pooled = get_encode(prompt)
         neg_embeds, neg_mask, neg_pooled = get_encode(negative_prompt)
 
@@ -223,7 +132,7 @@ class SdxsPipeline(DiffusionPipeline):
         seed: Optional[int] = None,
         output_type: str = "pil",
         return_dict: bool = True,
-        refine_prompt: bool = False, # Флаг рефайна!
+        refine_prompt: bool = False,
         # structure_preservation оставляем для совместимости, но теперь он почти не нужен
         structure_preservation: float = 0.0,   # 0.0 = стандартный линейный путь (лучше всего)
         **kwargs,

test.ipynb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ae07d83aedfac9040cb0169a0aa14f1b2185254882f7862b78e52aabd0a95821
-size 5492219
+oid sha256:5b1dc22c65c672008be6159c53028670acace729df6e26c3d1199a8929a07060
+size 6130032

text_encoder/config.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7c06cbeeddf5d93f5c7abc16b17a251b2a9ba6a6f08d7114fd8a269efeab1975
-size 563
+oid sha256:199bacf59248a05c934c618cacd62b6cc2f60e1637563f037206c2b09330a4ff
+size 2613

text_encoder/model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1b38361773a76fe3d7e717ed36206b112be1aa110567a465e377896114394fdb
-size 246406816
+oid sha256:020f49a22fe87e482485f27e57a01782f1faf7d0f312cc740d83faac36babcba
+size 4426558248

text_encoder2/config.json

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:199bacf59248a05c934c618cacd62b6cc2f60e1637563f037206c2b09330a4ff
-size 2613

text_encoder2/model.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:020f49a22fe87e482485f27e57a01782f1faf7d0f312cc740d83faac36babcba
-size 4426558248

tmp/config.json

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7d9d2485cfbdfe8c4a3d350907422ade854ffa1c8b06bd39b896ff45fc444cda
-size 1858

tmp/diffusion_pytorch_model.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4ef8fd48bd3075eae7202915c3b05b3ed8e90c70c41625f3f70a2d868a1013c9
-size 3159550424

tokenizer/special_tokens_map.json

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2cdb3b8331a60c92fc1e55a13e9fd61fd2293c5a51275fdcccd62b780052530e
-size 588

tokenizer/tokenizer_config.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0ae623b1013846a4edb4e2206a09ea3f7a4a92b3215f6f840f3706ccfedcef2d
-size 737
+oid sha256:a4f52c2103a685c3d9f3022b3954246fbab865abd709ac69d8b8a98f79580564
+size 1140

tokenizer/vocab.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e089ad92ba36837a0d31433e555c8f45fe601ab5c221d4f607ded32d9f7a4349
-size 1059962
+oid sha256:ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003
+size 6722759

tokenizer2/tokenizer_config.json

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a4f52c2103a685c3d9f3022b3954246fbab865abd709ac69d8b8a98f79580564
-size 1140

tokenizer2/vocab.json

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003
-size 6722759

train.py

@@ -149,10 +149,8 @@ if accelerator.is_main_process:
 # --------------------------- Загрузка моделей ---------------------------
 #vae = AutoencoderKLFlux2.from_pretrained("black-forest-labs/FLUX.2-dev",subfolder="vae",torch_dtype=dtype).to(device).eval()
 vae = AutoencoderKL.from_pretrained("vae", torch_dtype=dtype).to(device).eval()
-tokenizer = CLIPTokenizer.from_pretrained("tokenizer")
-text_encoder = CLIPTextModel.from_pretrained("text_encoder", torch_dtype=torch.float16).to(device).eval()
-tokenizer2 = Qwen3_5Tokenizer.from_pretrained("tokenizer2")
-text_encoder2 = Qwen3_5ForConditionalGeneration.from_pretrained("text_encoder2", torch_dtype=torch.float16).to(device).eval()
+tokenizer = Qwen3_5Tokenizer.from_pretrained("tokenizer2")
+text_encoder = Qwen3_5ForConditionalGeneration.from_pretrained("text_encoder2", torch_dtype=torch.float16).to(device).eval()
 scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained("scheduler")
 
 def encode_texts(texts, max_length=max_length):
@@ -168,7 +166,7 @@ def encode_texts(texts, max_length=max_length):
         formatted_prompts = []
         for t in texts:
             messages = [{"role": "user", "content": [{"type": "text", "text": t}]}]
-            res_text = tokenizer2.apply_chat_template(
+            res_text = tokenizer.apply_chat_template(
                 messages, 
                 add_generation_prompt=True, 
                 tokenize=False 
@@ -176,7 +174,7 @@ def encode_texts(texts, max_length=max_length):
             formatted_prompts.append(res_text)
 
         # 2. Токенизируем, режем и добавляем паддинг за один раз
-        toks = tokenizer2(
+        toks = tokenizer(
             formatted_prompts,
             padding="max_length",
             max_length=max_length,
@@ -185,7 +183,7 @@ def encode_texts(texts, max_length=max_length):
         ).to(device)
 
         # 3. Прогоняем через модель
-        outputs = text_encoder2(
+        outputs = text_encoder(
             input_ids=toks.input_ids, 
             attention_mask=toks.attention_mask,
             output_hidden_states=True

unet/diffusion_pytorch_model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:57210292c170ad4efb88279bd06e8aa3c12d4c9a8582c5f4f1b90f7285d4ab59
+oid sha256:a1a8e5563a08991becd74bb41292f800b383fb757cafe97ce5b87b6004dfb87a
 size 6318956752

unet_old/config.json

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e0c1f603d4dfb8d759010daf7d83df29ff148ba48693400fb14c0f4dbd9b7d2f
-size 1884

unet_old/diffusion_pytorch_model.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4fc036a58605f5073498525bf4f8af44552ad1f57fcb7f545863d45bf95d5ce2
-size 5960474736