Update api/ltx_server.py

api/ltx_server.py

@@ -13,7 +13,8 @@ from huggingface_hub import logging
 logging.set_verbosity_error()
 logging.set_verbosity_warning()
 logging.set_verbosity_info()
-logging.set_verbosity_debug()
+logging.set_verbosity_debu
+g()
 
 
 LTXV_DEBUG=1
@@ -399,53 +400,58 @@ class VideoService:
     def _dividir_latentes_em_partes(self, latents_brutos, quantidade: int):
         """
         Divide um tensor de latentes em `quantidade` partes e retorna uma lista de clones.
-        
-        Args:
-            latents_brutos: tensor [B, C, T, H, W]
-            quantidade: número de partes que queremos dividir
-        
+        Args: latents_brutos: tensor [B, C, T, H, W]
+              quantidade: número de partes que queremos dividir
         Returns:
             List[Tensor]: lista de `quantidade` partes, cada uma cloneada
         """
-        total = latents_brutos.shape[2]  # dimensão temporal
-        partes = []
-    
-        if quantidade <= 1 or quantidade > total:
-            return [latents_brutos.clone()]
+        sum_latent = latents_brutos.shape[2]  # dimensão temporal (latentes)
+        chunks = []
+
+        # minimo 5 latentes para dividir 
+        #min = 5
+        #if sum_latent < min or sum_latent//quantidade < min :
+        #    return [latents_brutos.clone()]
     
         # calcular tamanho aproximado de cada parte
-        step = total // quantidade
-        overlap = 0  # sobreposição mínima de 1 frame entre partes
-    
+        step = sum_latent // quantidade
+        overlap = 1  
+        
+        print(f"================PODA CAUSAL=================")
+        print(f"[DEBUG] TOTAL LATENTES A DIVIDIR /{quantidade}  = {sum_latent}")
+        
         for i in range(quantidade):
             start = i * step
             end = start + step
             if i == quantidade - 1:
-                end = total  # última parte vai até o final
+                end = total
             else:
-                end += overlap  # sobreposição
-            parte = latents_brutos[:, :, start-1:end+1, :, :].clone()
-            partes.append(parte)
-    
-        return partes
+                end += overlap  
+            chunk = latents_brutos[:, :, start:end, :, :].clone()
+            chunks.append(chunk)
+            chunk_sum = chunk.shape[2]  
+            print(f"[DEBUG] chunk{i+1}[:, :, start:end, :, :]  = {chunk_sum}")
+            
+        return chunks
     
 
-    def _dividir_latentes(self, latents_brutos):
-        total = latents_brutos.shape[2]  # dimensão temporal (número de latentes)
-        
-        if total % 2 == 1:  # ÍMPAR
-            # Ex: 11 → primeira 0..5, segunda 5..10
-            cut = total // 2
-            primeira = latents_brutos[:, :, :cut+1, :, :].clone()
-            segunda  = latents_brutos[:, :, cut:, :, :].clone()
-        
-        else:  # PAR
-            # Ex: 12 → primeira 0..5, segunda 5..11
-            cut = total // 2
-            primeira = latents_brutos[:, :, :cut, :, :].clone()
-            segunda  = latents_brutos[:, :, cut-1:, :, :].clone()
-        
-        return primeira, segunda
+    def dividir_latentes(latents_brutos):
+        sum_latent = latents_brutos.shape[2]  # dimensão temporal (latentes)
+        cut1 = sum_latent // 2
+        cut2 = sum_latent-cut1-1
+        chunk1 = latents_brutos[:, :, :cut1, :, :].clone()
+        chunk2 = latents_brutos[:, :, cut2:, :, :].clone()
+        chunk1_sum = primeir.shape[2]  # dimensão temporal (latentes1)
+        chunk2_sum = segunda.shape[2]  # dimensão temporal (latentes2)
+     
+        print(f"==============PODA CAUSAL==================")
+        print(f"[DEBUG] TOTAL LATENTES A DIVIDIR    = {sum_latent}")
+        print(f"[DEBUG] chunk1[:, :, :{cut1}, :, :] = {chunk1_sum}")
+        print(f"[DEBUG] chunk2[:, :, :{cut2}, :, :] = {chunk2_sum}")
+        print(f"===========================================")
+ 
+    return primeira, segunda
+
         
     def _concat_mp4s_no_reencode(self, mp4_list: List[str], out_path: str):
         """
@@ -654,11 +660,11 @@ class VideoService:
                 pass
                 
             # 2) Divide em duas partes
-            lat_a, lat_b = self._dividir_latentes(latents_cpu)
-            lat_a1, lat_a2 = self._dividir_latentes(lat_a)
-            lat_b1, lat_b2 = self._dividir_latentes(lat_b)
-            
-            latents_parts = [lat_a1, lat_a2, lat_b1, lat_b2]
+            #lat_a, lat_b = self._dividir_latentes(latents_cpu)
+            #lat_a1, lat_a2 = self._dividir_latentes(lat_a)
+            #lat_b1, lat_b2 = self._dividir_latentes(lat_b)
+            #latents_parts = [lat_a1, lat_a2, lat_b1, lat_b2]
+            latents_parts = self._dividir_latentes_em_partes(latents_cpu,4)
             
             temp_dir = tempfile.mkdtemp(prefix="ltxv_"); self._register_tmp_dir(temp_dir)
             results_dir = "/app/output"; os.makedirs(results_dir, exist_ok=True)