Method select_the_best_fromAbatch

LoadBalancing.py:527–653

从一批模型中选择帕累托最优的模型 Args: model_list (list): 模型名称列表 mode (str): 选择模式，"fast_first"或"cheap_first" input_proportion (int): 输入比例 output_proportion (int): 输出比例 Returns: tuple: (最优模型名, 源名称, 源模型名, API密钥)

(self, model_list, mode="fast_first", input_proportion=60, output_proportion=40)

        return main_source_name, main_source_model_name, main_api_key, backup_source_name, backup_source_model_name, backup_api_key

    def select_the_best_fromAbatch(self, model_list, mode="fast_first", input_proportion=60, output_proportion=40):
        """从一批模型中选择帕累托最优的模型
        
        Args:
            model_list (list): 模型名称列表
            mode (str): 选择模式，"fast_first"或"cheap_first"
            input_proportion (int): 输入比例
            output_proportion (int): 输出比例
            
        Returns:
            tuple: (最优模型名, 源名称, 源模型名, API密钥)
            
        Raises:
            ValueError: 如果没有可用的模型
        """
        self.logger.info(f"从模型列表中选择最优模型: {model_list}")
        
        # 刷新健康数据
        if (self.healthy and "timestamp" in self.healthy and 
            (datetime.now() - datetime.fromisoformat(self.healthy["timestamp"])).total_seconds() > self.healthy.get("check_timer_span", 15)*60):
            self.logger.info("健康检查数据已过期，正在刷新")
            self.healthy = Harness_localAPI.check_healthy()
        
        # 收集每个模型的性能数据
        model_stats = {}
        
        for model_name in model_list:
            # 收集该模型在所有源上的数据
            for key, value in self.healthy["data"].items():
                if len(key) >= 2 and key[1] == model_name and value:
                    source_name = key[0]
                    
                    # 检查模型在该源上是否有效
                    if not self._check_valid_model(source_name, model_name):
                        continue
                    
                    # 计算平均响应时间和成功率
                    valid_times = [t for t in value if t is not None and not np.isnan(t)]
                    if valid_times:
                        avg_time = np.mean(valid_times)
                        success_rate = len(valid_times) / len(value)
                        
                        # 获取价格信息
                        source_model_name = self._get_actual_model_name(source_name, model_name)
                        price = 1e8  # 默认高价格
                        
                        if source_name in self.source_price and source_model_name in self.source_price[source_name]:
                            price_info = self.source_price[source_name][source_model_name]
                            if price_info is not None:
                                if isinstance(price_info, tuple) and None not in price_info:
                                    price = (price_info[0]*input_proportion + price_info[1]*output_proportion)/(input_proportion+output_proportion)
                                elif isinstance(price_info, float):
                                    price = price_info
                        
                        # 存储统计信息
                        key_str = f"{model_name}|{source_name}"
                        model_stats[key_str] = {
                            'model_name': model_name,