Update models/model_manager.py

models/model_manager.py

@@ -331,4 +331,311 @@ class ModelManager:
             result = self.sd_pipeline(
                 prompt=prompt,
                 negative_prompt=negative_prompt,
-                num_inference_steps=num_inference_steps,
+                num_inference_steps=num_inference_steps,
+                guidance_scale=guidance_scale,
+                height=height,
+                width=width,
+                generator=torch.Generator(device=self.device).manual_seed(random.randint(0, 2**32-1))
+            )
+            
+            # 清理显存
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            
+            return result.images[0]
+            
+        except Exception as e:
+            logger.error(f"图像生成失败: {e}")
+            return self.create_placeholder_image(width, height)
+
+    @torch.no_grad()
+    def generate_controlnet_image(self, image, prompt, reference_image=None, negative_prompt=None, num_inference_steps=30, guidance_scale=8.0, **kwargs):
+        """使用ControlNet生成3D试穿效果"""
+        if self.controlnet_pipeline is None:
+            self.load_controlnet_pipeline()
+            if self.controlnet_pipeline is None:
+                logger.error("无法生成3D试穿：ControlNet 模型未加载")
+                return self.create_placeholder_image(512, 768)
+        
+        try:
+            # 预处理控制图像
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            
+            # 调整图像尺寸
+            control_image = image.resize((512, 768), Image.Resampling.LANCZOS)
+            
+            # 创建简单的姿态控制图（人体轮廓）
+            control_image = self.create_pose_control_image(control_image)
+            
+            if negative_prompt is None:
+                negative_prompt = "blurry, distorted, low quality, unrealistic, extra limbs, deformed, bad anatomy, multiple people"
+            
+            # 如果有参考设计，增强提示词
+            if reference_image is not None:
+                prompt = f"{prompt}, based on reference design"
+            
+            # 生成3D试穿效果
+            result = self.controlnet_pipeline(
+                prompt=prompt,
+                image=control_image,
+                negative_prompt=negative_prompt,
+                num_inference_steps=num_inference_steps,
+                guidance_scale=guidance_scale,
+                controlnet_conditioning_scale=1.0,
+                generator=torch.Generator(device=self.device).manual_seed(random.randint(0, 2**32-1))
+            )
+            
+            # 清理显存
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            
+            return result.images[0]
+            
+        except Exception as e:
+            logger.error(f"ControlNet图像生成失败: {e}")
+            return self.create_placeholder_image(512, 768)
+
+    def create_pose_control_image(self, image):
+        """创建简单的姿态控制图"""
+        try:
+            # 转换为numpy数组
+            img_array = np.array(image)
+            
+            # 创建简单的人体轮廓控制图
+            # 这里使用边缘检测作为简化的姿态控制
+            from scipy import ndimage
+            gray = np.mean(img_array, axis=2)
+            edges = ndimage.sobel(gray)
+            
+            # 归一化到0-255范围
+            edges = ((edges - edges.min()) / (edges.max() - edges.min()) * 255).astype(np.uint8)
+            
+            # 转换回PIL图像
+            control_image = Image.fromarray(edges, mode='L').convert('RGB')
+            
+            return control_image
+            
+        except Exception as e:
+            logger.warning(f"创建姿态控制图失败: {e}")
+            # 返回原图的边缘检测版本
+            return image.convert('L').convert('RGB')
+
+    def create_placeholder_image(self, width, height):
+        """创建占位图像"""
+        colors = [(220, 220, 220), (200, 220, 240), (240, 220, 200), (220, 240, 200)]
+        color = random.choice(colors)
+        return Image.new('RGB', (width, height), color=color)
+
+    def cleanup(self):
+        """清理显存缓存，保持模型加载状态"""
+        logger.info("清理GPU显存缓存...")
+        try:
+            if torch.cuda.is_available():
+                # 强制垃圾回收
+                gc.collect()
+                # 清理CUDA缓存
+                torch.cuda.empty_cache()
+                torch.cuda.ipc_collect()
+                
+                # 显示显存使用情况
+                allocated = torch.cuda.memory_allocated() / 1024**3
+                cached = torch.cuda.memory_reserved() / 1024**3
+                logger.info(f"显存使用: {allocated:.2f}GB (分配) / {cached:.2f}GB (缓存)")
+            
+            logger.info("显存清理完成")
+            
+        except Exception as e:
+            logger.error(f"显存��理失败: {e}")
+
+    def move_models_to_cpu(self):
+        """将模型移至CPU释放GPU显存"""
+        try:
+            logger.info("将所有模型移至CPU...")
+            
+            models_to_move = [
+                ('caption_model', self.caption_model),
+                ('clip_model', self.clip_model),
+                ('sd_pipeline', self.sd_pipeline),
+                ('controlnet_pipeline', self.controlnet_pipeline),
+                ('controlnet', self.controlnet)
+            ]
+            
+            for model_name, model in models_to_move:
+                if model is not None:
+                    try:
+                        if hasattr(model, 'to'):
+                            model.to('cpu')
+                        logger.info(f"{model_name} 已移至CPU")
+                    except Exception as e:
+                        logger.warning(f"移动 {model_name} 到CPU失败: {e}")
+            
+            # 清理GPU缓存
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+                torch.cuda.ipc_collect()
+                
+                allocated = torch.cuda.memory_allocated() / 1024**3
+                logger.info(f"移至CPU后GPU显存使用: {allocated:.2f}GB")
+            
+            logger.info("所有模型已移至CPU")
+            
+        except Exception as e:
+            logger.error(f"移动模型到CPU失败: {e}")
+
+    def move_models_to_gpu(self):
+        """将模型移回GPU"""
+        try:
+            logger.info("将所有模型移回GPU...")
+            
+            models_to_move = [
+                ('caption_model', self.caption_model),
+                ('clip_model', self.clip_model),
+                ('sd_pipeline', self.sd_pipeline),
+                ('controlnet_pipeline', self.controlnet_pipeline),
+                ('controlnet', self.controlnet)
+            ]
+            
+            for model_name, model in models_to_move:
+                if model is not None:
+                    try:
+                        if hasattr(model, 'to'):
+                            model.to(self.device)
+                        logger.info(f"{model_name} 已移回GPU")
+                    except Exception as e:
+                        logger.warning(f"移动 {model_name} 到GPU失败: {e}")
+            
+            if torch.cuda.is_available():
+                allocated = torch.cuda.memory_allocated() / 1024**3
+                logger.info(f"移回GPU后显存使用: {allocated:.2f}GB")
+            
+            logger.info("所有模型已移回GPU")
+            
+        except Exception as e:
+            logger.error(f"移动模型到GPU失败: {e}")
+
+    def force_reload_all_models(self):
+        """强制重新加载所有模型"""
+        logger.info("开始强制重新加载所有模型...")
+        try:
+            # 释放现有模型
+            models_to_delete = [
+                'caption_model', 'caption_processor',
+                'clip_model', 'clip_processor', 
+                'sd_pipeline', 'controlnet', 'controlnet_pipeline'
+            ]
+            
+            for model_name in models_to_delete:
+                if hasattr(self, model_name):
+                    model = getattr(self, model_name)
+                    if model is not None:
+                        try:
+                            del model
+                            setattr(self, model_name, None)
+                            logger.info(f"释放 {model_name}")
+                        except Exception as e:
+                            logger.warning(f"释放 {model_name} 失败: {e}")
+            
+            # 强制垃圾回收
+            gc.collect()
+            
+            # 清理GPU缓存
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+                torch.cuda.ipc_collect()
+            
+            logger.info("开始重新加载模型...")
+            
+            # 重新加载所有模型
+            self.load_all_models()
+            
+            logger.info("所有模型重新加载完成")
+            
+        except Exception as e:
+            logger.error(f"强制重新加载模型失败: {e}")
+            raise
+
+    def get_model_status(self):
+        """获取模型加载状态"""
+        status = {
+            "caption_model": self.caption_model is not None,
+            "clip_model": self.clip_model is not None,
+            "sd_pipeline": self.sd_pipeline is not None,
+            "controlnet_pipeline": self.controlnet_pipeline is not None,
+            "device": self.device
+        }
+        
+        if torch.cuda.is_available():
+            status["gpu_memory"] = {
+                "allocated": f"{torch.cuda.memory_allocated() / 1024**3:.2f}GB",
+                "cached": f"{torch.cuda.memory_reserved() / 1024**3:.2f}GB",
+                "max_allocated": f"{torch.cuda.max_memory_allocated() / 1024**3:.2f}GB"
+            }
+        
+        return status
+
+    def optimize_for_inference(self):
+        """优化模型以提高推理速度"""
+        logger.info("优化模型推理性能...")
+        
+        try:
+            # 编译模型（如果PyTorch版本支持）
+            if hasattr(torch, 'compile'):
+                models_to_compile = [
+                    self.caption_model,
+                    self.clip_model
+                ]
+                
+                for model in models_to_compile:
+                    if model is not None:
+                        try:
+                            model = torch.compile(model)
+                            logger.info(f"模型编译成功")
+                        except Exception as e:
+                            logger.info(f"模型编译跳过: {e}")
+            
+            # 设置模型为评估模式
+            models = [self.caption_model, self.clip_model]
+            for model in models:
+                if model is not None:
+                    model.eval()
+            
+            logger.info("模型优化完成")
+            
+        except Exception as e:
+            logger.warning(f"模型优化失败: {e}")
+
+    def benchmark_models(self):
+        """基准测试模型性能"""
+        logger.info("开始模型性能基准测试...")
+        
+        try:
+            # 创建测试图像
+            test_image = Image.new('RGB', (512, 512), color=(128, 128, 128))
+            
+            results = {}
+            
+            # 测试BLIP
+            if self.caption_model is not None:
+                start_time = time.time()
+                _ = self.generate_caption(test_image)
+                results['caption_time'] = time.time() - start_time
+            
+            # 测试CLIP
+            if self.clip_model is not None:
+                start_time = time.time()
+                _ = self.analyze_style(test_image)
+                results['clip_time'] = time.time() - start_time
+            
+            # 测试SD
+            if self.sd_pipeline is not None:
+                start_time = time.time()
+                _ = self.generate_image("test fashion design", num_inference_steps=5)
+                results['sd_time'] = time.time() - start_time
+            
+            logger.info(f"基准测试结果: {results}")
+            return results
+            
+        except Exception as e:
+            logger.error(f"基准测试失败: {e}")
+            return {}