LLM请求响应循环全解析：从Token化到流式输出的技术实践

当你第一次调用 OpenAI API 发送一个简单的 prompt 时，有没有想过这背后到底发生了什么？为什么有时候响应很快，有时候却要等好几秒？为什么相同的 prompt 在不同时间会得到不同的回答？

这些问题背后，隐藏着一个看似简单实则复杂的技术过程：LLM 的请求响应循环。对于开发者来说，理解这个过程不仅仅是技术好奇，更是优化应用性能、控制成本、提升用户体验的关键。很多人在使用 LLM API 时遇到的超时、token 超限、响应不一致等问题，其实都源于对这个循环机制理解不够深入。

本文将从实际开发角度，完整拆解 LLM 请求响应循环的每个环节。你会看到从你按下回车键到收到 AI 回复的完整技术路径，包括 token 化、模型推理、流式传输等关键步骤。更重要的是，我会通过具体代码示例展示如何在实际项目中优化每个环节，避免常见的性能陷阱。

1. 这篇文章真正要解决的问题

很多开发者在使用 LLM API 时存在一个误区：认为这只是一个简单的 HTTP 请求，像调用普通 REST API 一样。但实际上，LLM 的请求响应循环涉及复杂的计算过程和状态管理。不理解这个机制，会导致以下几个实际问题：

性能优化无从下手：为什么同样的 prompt 在不同时段响应速度差异很大？为什么流式响应比一次性响应感觉更快？这些现象背后是模型推理、缓存机制和网络传输的复杂交互。

成本控制缺乏依据：按 token 计费的模式下，如何准确预估和优化成本？为什么有些请求会意外产生高额费用？这需要对 token 计数和模型计算过程有清晰认识。

错误处理不够全面：遇到 "maximum context length exceeded" 或 "request timed out" 错误时，如何快速定位问题根源？单纯的重试策略往往不够，需要理解限制条件的本质。

用户体验难以保障：在构建聊天应用或文档处理工具时，如何平衡响应速度与回答质量？如何实现自然的流式输出效果？这要求对响应生成机制有深入理解。

本文将通过完整的代码示例和架构分析，让你不仅理解 LLM 请求响应循环的理论机制，更能掌握在实际项目中优化性能、控制成本、提升稳定性的实用技巧。

2. 基础概念与核心原理

在深入技术细节之前，需要明确几个关键概念。这些概念是理解整个循环过程的基础，也是后续优化工作的理论依据。

2.1 LLM 请求响应循环的定义

LLM 请求响应循环是指从用户提交 prompt 到接收模型完整响应的完整技术过程。这个过程包括以下几个核心阶段：

1. 请求预处理：将文本 prompt 转换为模型可理解的数字序列
2. 模型推理：基于输入序列生成输出序列的计算过程
3. 响应后处理：将模型输出转换为人类可读的文本格式
4. 结果返回：通过 API 将最终结果返回给客户端

与传统的 REST API 调用不同，LLM 请求响应循环具有几个独特特点：计算密集型、状态依赖性强、响应时间可变性大、资源消耗与输入输出长度直接相关。

2.2 Token：LLM 的基本处理单元

Token 是 LLM 处理文本的基本单位，理解 token 的概念对于优化请求至关重要。

什么是 token：token 不是简单的单词或字符，而是模型词汇表中的基本元素。一个英文单词可能被拆分成多个 token，而一个中文字符通常对应一个或多个 token。

token 化的意义：模型实际处理的是 token 序列而非原始文本。token 数量直接影响 API 调用成本、响应时间和上下文窗口利用率。

# 使用 tiktoken 库查看文本的 token 分解 import tiktoken def analyze_tokens(text, model="gpt-3.5-turbo"): encoding = tiktoken.encoding_for_model(model) tokens = encoding.encode(text) token_details = [] for token in tokens: token_text = encoding.decode([token]) token_details.append({ 'token_id': token, 'text': token_text, 'length': len(token_text) }) return token_details # 示例分析 sample_text = "LLM请求响应循环工作机制详解" details = analyze_tokens(sample_text) print(f"总token数: {len(details)}") for detail in details: print(f"Token ID: {detail['token_id']}, 文本: '{detail['text']}', 长度: {detail['length']}")

运行上述代码，你会发现一个简短的中文句子可能被分解成多个 token，这解释了为什么中英文混合内容的 token 计数往往超出预期。

2.3 上下文窗口与注意力机制

上下文窗口决定了模型一次性能处理的最大 token 数量，而注意力机制则是模型理解上下文关系的关键技术。

上下文窗口限制：每个模型都有固定的上下文窗口大小（如 4k、16k、128k tokens）。超过这个限制会导致错误或截断。理解这个限制对于设计提示词和处理长文档至关重要。

注意力机制的作用：在生成每个新 token 时，模型会关注输入序列中的所有相关部分。这种机制使得模型能够保持对话连贯性，但也带来了计算复杂度的平方级增长问题。

3. 环境准备与前置条件

为了后续的实践演示，需要准备合适的开发环境。本节将介绍必要的工具和配置，确保你能完整复现本文中的示例。

3.1 Python 环境配置

推荐使用 Python 3.8 或更高版本，并配置虚拟环境以避免依赖冲突。

# 创建并激活虚拟环境 python -m venv llm_env source llm_env/bin/activate # Linux/Mac # llm_env\Scripts\activate # Windows # 安装核心依赖 pip install openai tiktoken requests python-dotenv

3.2 API 密钥配置

安全地管理 API 密钥是生产环境应用的基本要求。建议使用环境变量或配置文件方式。

# config.py - API配置管理 import os from dotenv import load_dotenv load_dotenv() class OpenAIConfig: def __init__(self): self.api_key = os.getenv('OPENAI_API_KEY') self.base_url = os.getenv('OPENAI_BASE_URL', 'https://api.openai.com/v1') self.default_model = os.getenv('DEFAULT_MODEL', 'gpt-3.5-turbo') def validate(self): if not self.api_key: raise ValueError("OPENAI_API_KEY 环境变量未设置") return True # 使用示例 config = OpenAIConfig() config.validate()

在项目根目录创建.env文件存储敏感信息：

# .env 文件 OPENAI_API_KEY=your_api_key_here DEFAULT_MODEL=gpt-3.5-turbo

3.3 测试连接

在深入复杂功能前，先验证基础连接是否正常。

# test_connection.py - 基础连接测试 from openai import OpenAI from config import OpenAIConfig def test_basic_connection(): config = OpenAIConfig() client = OpenAI(api_key=config.api_key, base_url=config.base_url) try: response = client.chat.completions.create( model=config.default_model, messages=[{"role": "user", "content": "Hello, respond with 'OK' if you can hear me."}], max_tokens=10 ) print("连接测试成功:", response.choices[0].message.content) return True except Exception as e: print(f"连接测试失败: {e}") return False if __name__ == "__main__": test_basic_connection()

4. 完整请求响应循环拆解

现在进入核心内容：逐步拆解 LLM 请求响应循环的每个技术环节。通过具体的代码示例，你会清晰看到每个阶段发生了什么。

4.1 阶段一：请求构造与验证

在发送请求前，需要正确构造请求参数并验证其有效性。这个阶段的问题会导致立即的错误响应。

# request_builder.py - 请求构造与验证 import tiktoken from config import OpenAIConfig class LLMRequestBuilder: def __init__(self, model=None): self.config = OpenAIConfig() self.model = model or self.config.default_model self.encoding = tiktoken.encoding_for_model(self.model) def calculate_tokens(self, messages): """计算消息列表的token数量""" tokens_per_message = 3 # 每条消息的开销 tokens_per_name = 1 # 名字字段的开销 token_count = 0 for message in messages: token_count += tokens_per_message for key, value in message.items(): token_count += len(self.encoding.encode(value)) if key == "name": token_count += tokens_per_name token_count += 3 # 每次回复的开销 return token_count def validate_request(self, messages, max_tokens=None): """验证请求参数是否有效""" errors = [] # 检查消息格式 if not messages or len(messages) == 0: errors.append("消息列表不能为空") # 检查token数量 input_tokens = self.calculate_tokens(messages) if input_tokens > 8192: # 示例限制，实际值因模型而异 errors.append(f"输入token数({input_tokens})超过限制") # 检查max_tokens合理性 if max_tokens and max_tokens > 4096: errors.append(f"max_tokens({max_tokens})设置过大") if max_tokens and max_tokens < 1: errors.append("max_tokens必须大于0") return errors def build_request(self, messages, **kwargs): """构造完整的API请求""" errors = self.validate_request(messages, kwargs.get('max_tokens')) if errors: raise ValueError(f"请求验证失败: {errors}") base_request = { "model": self.model, "messages": messages, "temperature": kwargs.get('temperature', 0.7), "max_tokens": kwargs.get('max_tokens', 1000), } # 添加可选参数 optional_params = ['stream', 'top_p', 'frequency_penalty', 'presence_penalty'] for param in optional_params: if param in kwargs: base_request[param] = kwargs[param] return base_request # 使用示例 builder = LLMRequestBuilder() messages = [ {"role": "system", "content": "你是一个有帮助的AI助手。"}, {"role": "user", "content": "请解释LLM的请求响应循环。"} ] try: request = builder.build_request(messages, max_tokens=500, temperature=0.5) print("请求构造成功:", request) except ValueError as e: print("请求构造失败:", e)

4.2 阶段二：API 调用与网络传输

构造好请求后，通过 HTTP 协议发送到模型服务端。这个阶段需要注意网络稳定性、超时设置和错误处理。

# api_client.py - API调用封装 import time import requests from openai import OpenAI from config import OpenAIConfig class LLMAPIClient: def __init__(self): self.config = OpenAIConfig() self.client = OpenAI(api_key=self.config.api_key, base_url=self.config.base_url) self.timeout = 30 # 默认超时时间 def send_request(self, request_data, retry_count=3): """发送API请求，支持重试机制""" last_exception = None for attempt in range(retry_count): try: start_time = time.time() response = self.client.chat.completions.create( **request_data, timeout=self.timeout ) end_time = time.time() response_time = end_time - start_time print(f"请求成功 (尝试 {attempt + 1}), 耗时: {response_time:.2f}s") return response, response_time except requests.exceptions.Timeout: last_exception = f"请求超时 (尝试 {attempt + 1})" print(last_exception) except requests.exceptions.ConnectionError: last_exception = f"连接错误 (尝试 {attempt + 1})" print(last_exception) time.sleep(2 ** attempt) # 指数退避 except Exception as e: last_exception = f"未知错误: {e} (尝试 {attempt + 1})" print(last_exception) break raise Exception(f"所有重试失败: {last_exception}") def stream_request(self, request_data, callback=None): """处理流式响应""" try: request_data['stream'] = True stream = self.client.chat.completions.create(**request_data) full_response = "" for chunk in stream: if chunk.choices[0].delta.content is not None: content = chunk.choices[0].delta.content full_response += content if callback: callback(content) # 实时处理每个token return full_response except Exception as e: raise Exception(f"流式请求失败: {e}") # 使用示例 def print_stream_content(content): print(content, end='', flush=True) client = LLMAPIClient() request_data = { "model": "gpt-3.5-turbo", "messages": [{"role": "user", "content": "用流式输出介绍AI技术。"}], "max_tokens": 200 } print("开始流式响应:") try: result = client.stream_request(request_data, callback=print_stream_content) print(f"\n完整响应: {result}") except Exception as e: print(f"错误: {e}")

4.3 阶段三：模型推理与 Token 生成

这是最核心的计算阶段，模型基于输入序列逐步生成输出 token。理解这个过程有助于优化提示词和参数设置。

# token_generation.py - 模拟token生成过程 import time import random class TokenGenerationSimulator: """模拟模型生成token的过程，帮助理解推理机制""" def __init__(self, vocabulary_size=50000): self.vocabulary_size = vocabulary_size self.generation_time_per_token = 0.05 # 模拟每个token的生成时间 def simulate_thought_process(self, prompt, max_tokens=50): """模拟模型的"思考"过程""" print(f"输入提示词: '{prompt}'") print("开始推理...") # 模拟编码阶段 time.sleep(0.1) print("编码完成 → 理解输入语义") # 模拟注意力计算 time.sleep(0.2) print("注意力计算 → 确定上下文重点") # 模拟token生成循环 generated_tokens = [] total_time = 0 for i in range(max_tokens): token_gen_start = time.time() # 模拟生成一个token的计算过程 time.sleep(self.generation_time_per_token) # 模拟token选择（简化版） simulated_token = f"token_{i}" generated_tokens.append(simulated_token) token_gen_time = time.time() - token_gen_start total_time += token_gen_time print(f"Token {i+1}: {simulated_token} (耗时: {token_gen_time:.3f}s)") # 模拟遇到停止条件 if random.random() < 0.1: # 10%概率提前结束 print("遇到停止条件 → 生成完成") break print(f"推理完成，共生成 {len(generated_tokens)} 个token，总耗时: {total_time:.2f}s") return generated_tokens, total_time def analyze_generation_pattern(self, prompt_length, response_length): """分析不同长度输入的生成模式""" base_time = 0.1 # 基础处理时间 encoding_time = prompt_length * 0.01 # 编码时间与输入长度相关 generation_time = response_length * self.generation_time_per_token # 生成时间 total_estimated_time = base_time + encoding_time + generation_time return total_estimated_time # 使用示例 simulator = TokenGenerationSimulator() # 模拟短提示词 short_prompt = "你好，请简单介绍自己。" tokens, time_spent = simulator.simulate_thought_process(short_prompt, max_tokens=10) # 分析性能特征 print("\n性能分析:") prompt_length = len(short_prompt) estimated_time = simulator.analyze_generation_pattern(prompt_length, len(tokens)) print(f"预估时间: {estimated_time:.2f}s, 实际时间: {time_spent:.2f}s")

4.4 阶段四：响应处理与结果返回

模型生成完成后，需要对原始输出进行后处理，包括解码、格式化和错误检查。

# response_processor.py - 响应处理与后处理 import json from typing import Dict, Any class LLMResponseProcessor: """处理LLM API响应，提取有用信息并进行后处理""" def __init__(self): self.supported_formats = ['text', 'json', 'markdown'] def process_completion_response(self, response, expected_format='text'): """处理标准完成响应""" if not response or not response.choices: raise ValueError("无效的API响应") choice = response.choices[0] message = choice.message result = { 'content': message.content, 'role': message.role, 'finish_reason': choice.finish_reason, 'usage': { 'prompt_tokens': response.usage.prompt_tokens, 'completion_tokens': response.usage.completion_tokens, 'total_tokens': response.usage.total_tokens } if response.usage else None, 'model': response.model, 'created': response.created } # 格式后处理 if expected_format == 'json': try: result['content'] = json.loads(message.content) except json.JSONDecodeError: print("警告: 响应内容不是有效的JSON格式") return result def validate_response(self, processed_response): """验证响应质量和完整性""" issues = [] content = processed_response['content'] finish_reason = processed_response['finish_reason'] # 检查内容长度 if not content or len(content.strip()) == 0: issues.append("响应内容为空") # 检查停止原因 if finish_reason == 'length': issues.append("响应因达到max_tokens限制而截断") elif finish_reason == 'content_filter': issues.append("响应被内容过滤器拦截") elif finish_reason not in ['stop', 'length']: issues.append(f"非标准停止原因: {finish_reason}") # 检查token使用情况 if processed_response['usage']: prompt_tokens = processed_response['usage']['prompt_tokens'] completion_tokens = processed_response['usage']['completion_tokens'] if completion_tokens == 0 and len(content) > 0: issues.append("Token计数可能不准确") return issues def calculate_cost(self, processed_response, model_pricing=None): """计算请求成本（估算）""" if not processed_response['usage']: return None # 默认定价（美元/千token） default_pricing = { 'gpt-3.5-turbo': {'input': 0.0015, 'output': 0.002}, 'gpt-4': {'input': 0.03, 'output': 0.06} } pricing = model_pricing or default_pricing model = processed_response['model'] if model not in pricing: return None input_cost = (processed_response['usage']['prompt_tokens'] / 1000) * pricing[model]['input'] output_cost = (processed_response['usage']['completion_tokens'] / 1000) * pricing[model]['output'] total_cost = input_cost + output_cost return { 'input_cost': input_cost, 'output_cost': output_cost, 'total_cost': total_cost, 'currency': 'USD' } # 使用示例 processor = LLMResponseProcessor() # 模拟API响应处理 class MockResponse: def __init__(self): self.choices = [MockChoice()] self.usage = MockUsage() self.model = "gpt-3.5-turbo" self.created = 1678901234 class MockChoice: def __init__(self): self.message = MockMessage() self.finish_reason = "stop" class MockMessage: def __init__(self): self.content = "这是一个测试响应。" self.role = "assistant" class MockUsage: def __init__(self): self.prompt_tokens = 20 self.completion_tokens = 10 self.total_tokens = 30 mock_response = MockResponse() processed = processor.process_completion_response(mock_response) print("处理后的响应:") print(json.dumps(processed, indent=2, ensure_ascii=False)) issues = processor.validate_response(processed) if issues: print("发现的问题:", issues) else: print("响应验证通过") cost = processor.calculate_cost(processed) print("估算成本:", cost)

5. 完整示例：构建智能问答系统

现在我们将所有组件整合起来，构建一个完整的智能问答系统，演示真实的 LLM 请求响应循环应用。

# smart_qa_system.py - 完整智能问答系统 import time import json from datetime import datetime from request_builder import LLMRequestBuilder from api_client import LLMAPIClient from response_processor import LLMResponseProcessor class SmartQASystem: """智能问答系统 - 完整LLM请求响应循环示例""" def __init__(self, model="gpt-3.5-turbo"): self.builder = LLMRequestBuilder(model) self.client = LLMAPIClient() self.processor = LLMResponseProcessor() self.conversation_history = [] def add_to_history(self, role, content): """添加对话历史""" self.conversation_history.append({ "role": role, "content": content, "timestamp": datetime.now().isoformat() }) # 保持历史记录 manageable（简化示例） if len(self.conversation_history) > 10: self.conversation_history = self.conversation_history[-6:] # 保留最近6条 def build_contextual_messages(self, user_question): """构建包含上下文的对话消息""" messages = [] # 系统提示词 messages.append({ "role": "system", "content": "你是一个专业的技术问答助手。回答要准确、简洁、有帮助。如果不确定，请明确说明。" }) # 对话历史（最近3轮） recent_history = self.conversation_history[-6:] if len(self.conversation_history) > 6 else self.conversation_history for item in recent_history: messages.append({"role": item["role"], "content": item["content"]}) # 当前问题 messages.append({"role": "user", "content": user_question}) return messages def ask_question(self, question, stream=False, max_tokens=500): """提问并获取回答""" print(f"问题: {question}") # 构建消息 messages = self.build_contextual_messages(question) try: # 构建请求 request_data = self.builder.build_request( messages, max_tokens=max_tokens, temperature=0.7 ) # 发送请求 start_time = time.time() if stream: print("回答(流式): ", end="") full_response = self.client.stream_request( request_data, callback=lambda x: print(x, end="", flush=True) ) print() # 换行 response_time = time.time() - start_time # 创建模拟响应对象用于处理 class StreamResponse: def __init__(self, content, model): self.choices = [StreamChoice(content)] self.model = model self.created = int(time.time()) class StreamChoice: def __init__(self, content): self.message = StreamMessage(content) self.finish_reason = "stop" class StreamMessage: def __init__(self, content): self.content = content self.role = "assistant" response = StreamResponse(full_response, request_data["model"]) else: response, response_time = self.client.send_request(request_data) processed = self.processor.process_completion_response(response) print(f"回答: {processed['content']}") full_response = processed['content'] # 记录到历史 self.add_to_history("user", question) self.add_to_history("assistant", full_response) # 性能统计 token_count = self.builder.calculate_tokens(messages) print(f"统计: 响应时间 {response_time:.2f}s, 输入token约 {token_count}") return full_response, response_time except Exception as e: print(f"提问失败: {e}") return None, None def get_conversation_summary(self): """获取对话摘要""" if not self.conversation_history: return "暂无对话历史" summary = f"对话历史摘要 (共{len(self.conversation_history)}条消息):\n" for i, msg in enumerate(self.conversation_history[-4:], 1): # 最近4条 role = "用户" if msg["role"] == "user" else "助手" content_preview = msg["content"][:50] + "..." if len(msg["content"]) > 50 else msg["content"] summary += f"{i}. {role}: {content_preview}\n" return summary # 使用示例 def demo_qa_system(): qa_system = SmartQASystem() questions = [ "什么是机器学习？", "监督学习和无监督学习有什么区别？", "请用简单例子说明线性回归", "深度学习与机器学习有什么关系？" ] print("=== 智能问答系统演示 ===\n") for i, question in enumerate(questions, 1): print(f"\n--- 第{i}个问题 ---") answer, response_time = qa_system.ask_question(question, stream=True) if response_time: print(f"响应时间: {response_time:.2f}秒") time.sleep(1) # 模拟用户阅读时间 print("\n" + "="*50) print(qa_system.get_conversation_summary()) if __name__ == "__main__": demo_qa_system()

6. 运行结果与效果验证

运行上述智能问答系统，你会看到完整的 LLM 请求响应循环在实际应用中的表现。以下是一个典型的运行结果示例：

=== 智能问答系统演示 === --- 第1个问题 --- 问题: 什么是机器学习？ 回答(流式): 机器学习是人工智能的一个分支，让计算机通过数据自动学习和改进，而无需显式编程。它主要关注算法和统计模型的发展... 统计: 响应时间 2.34s, 输入token约 45 --- 第2个问题 --- 问题: 监督学习和无监督学习有什么区别？ 回答(流式): 监督学习使用标注数据训练模型，每个样本都有对应的标签；无监督学习使用未标注数据，让模型自行发现数据中的模式... 统计: 响应时间 1.89s, 输入token约 128 --- 第3个问题 --- 问题: 请用简单例子说明线性回归 回答(流式): 线性回归就像用直线拟合数据点。比如根据房屋面积预测价格：面积越大，价格越高。模型会找到最佳拟合直线... 统计: 响应时间 2.15s, 输入token约 95 --- 第4个问题 --- 问题: 深度学习与机器学习有什么关系？ 回答(流式): 深度学习是机器学习的一个子领域，使用多层神经网络学习数据表征。传统机器学习需要人工特征工程，而深度学习... 统计: 响应时间 2.41s, 输入token约 78 ================================================== 对话历史摘要 (共8条消息): 1. 用户: 什么是机器学习？ 2. 助手: 机器学习是人工智能的一个分支，让计算机通过数据自动学习和改进... 3. 用户: 监督学习和无监督学习有什么区别？ 4. 助手: 监督学习使用标注数据训练模型，每个样本都有对应的标签...

通过这个演示，你可以观察到：

1. 流式输出的优势：用户能立即看到部分结果，减少等待焦虑
2. 上下文保持：系统能记住之前的对话，提供连贯的问答体验
3. 性能可度量：每个请求的响应时间和 token 使用情况都被记录
4. 错误处理：系统能优雅处理网络问题或 API 限制

7. 常见问题与排查思路

在实际使用 LLM API 时，会遇到各种问题。下表总结了常见问题及其解决方案：

7.1 具体排查代码示例

# troubleshooting.py - 常见问题排查工具 import requests from request_builder import LLMRequestBuilder class LLMTroubleshooter: """LLM API问题排查工具""" def diagnose_connection_issues(self): """诊断连接问题""" tests = { "网络连通性": self.test_network_connectivity, "DNS解析": self.test_dns_resolution, "API端点可达性": self.test_api_endpoint, "认证有效性": self.test_authentication } results = {} for test_name, test_func in tests.items(): try: results[test_name] = test_func() except Exception as e: results[test_name] = f"失败: {e}" return results def test_network_connectivity(self): """测试基础网络连接""" try: response = requests.get("https://www.baidu.com", timeout=5) return f"成功 (状态码: {response.status_code})" except Exception as e: return f"失败: {e}" def test_api_endpoint(self): """测试API端点可达性""" try: response = requests.get("https://api.openai.com/v1/models", timeout=10) return f"端点可达 (状态码: {response.status_code})" except Exception as e: return f"不可达: {e}" def analyze_token_usage(self, messages, model="gpt-3.5-turbo"): """分析token使用情况""" builder = LLMRequestBuilder(model) token_count = builder.calculate_tokens(messages) # 不同模型的上下文窗口限制 context_limits = { "gpt-3.5-turbo": 4096, "gpt-3.5-turbo-16k": 16384, "gpt-4": 8192, "gpt-4-32k": 32768 } limit = context_limits.get(model, 4096) usage_percentage = (token_count / limit) * 100 analysis = { "当前token数": token_count, "模型限制": limit, "使用比例": f"{usage_percentage:.1f}%", "剩余空间": limit - token_count, "建议": "正常" if usage_percentage < 80 else "接近限制，建议优化" } return analysis # 使用示例 troubleshooter = LLMTroubleshooter() print("=== 连接诊断 ===") diagnosis = troub