大模型应用：基于本地大模型的中文命名实体识别技术实践与应用

def __init__(self, model_name="uer/roberta-base-finetuned-cluener2020-chinese"):
    print(f"加载可靠NER模型: {model_name}")
    
    try:
        # 尝试直接加载huggingface模型
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForTokenClassification.from_pretrained(model_name)
    except:
        # 如果失败，通过modelscope下载
        model_path = snapshot_download(model_name)
        self.tokenizer = AutoTokenizer.from_pretrained(model_path)
        self.model = AutoModelForTokenClassification.from_pretrained(model_path)

# CLUENER2020的标签映射
self.label_map = {
    0: 'O',
    1: 'B-address', 2: 'I-address',      # 地址
    3: 'B-book', 4: 'I-book',            # 书籍
    # ... 其他标签
}

# 简化标签映射到常用类型
self.simple_label_map = {
    'address': '地理位置',
    'company': '组织机构', 
    'government': '组织机构',
    'name': '人物',
    # ... 其他映射
}

def predict(self, text: str) -> Dict:
    # Tokenize
    inputs = self.tokenizer(
        text,
        return_tensors="pt",
        padding=True,
        truncation=True,
        max_length=512,
        return_offsets_mapping=True
    )
    
    # 移动到设备
    inputs = {k: v.to(self.device) for k, v in inputs.items()}
    offset_mapping = inputs.pop('offset_mapping').cpu().numpy()[0]
    
    # 预测
    with torch.no_grad():
        outputs = self.model(**inputs)
        predictions = torch.argmax(outputs.logits, dim=-1)[0].cpu().numpy()

def _extract_entities(self, text: str, predictions: List[int], offset_mapping: List) -> List[Dict]:
    entities = []
    current_entity = None
    
    for i, (pred, offset) in enumerate(zip(predictions, offset_mapping)):
        # 跳过特殊token和填充token
        if offset[0] == offset[1] == 0:
            if current_entity:
                entities.append(current_entity)
                current_entity = None
            continue
        
        label = self.label_map.get(pred, 'O')
        
        if label.startswith('B-'):
            # 开始新实体
            if current_entity:
                entities.append(current_entity)
            
            entity_type = label[2:]
            simple_type = self.simple_label_map.get(entity_type, entity_type)
            start, end = offset
            
            current_entity = {
                'text': text[start:end],
                'type': simple_type,
                'start': start,
                'end': end,
                'raw_type': entity_type
            }
            
        elif label.startswith('I-') and current_entity:
            # 继续当前实体
            entity_type = label[2:]
            simple_type = self.simple_label_map.get(entity_type, entity_type)
            
            # 检查类型是否匹配
            if simple_type == current_entity['type']:
                _, end = offset
                current_entity['text'] = text[current_entity['start']:end]
                current_entity['end'] = end

class SimpleButEffectiveNER:
    def __init__(self):
        self.patterns = {
            '人物': [
                r'[李王张刘陈杨赵黄周吴徐孙胡朱高林何郭马罗梁宋郑谢韩唐冯于董萧][\u4e00-\u9fa5]{1,3}'
            ],
            '组织机构': [
                r'[\u4e00-\u9fa5a-zA-Z0-9]{2,20}(公司|集团|银行|大学|学院|医院|政府|局|所|中心)'
            ],
            # ... 其他模式
        }

return {
    'text': text,  # 原始文本
    'entities': entities,  # 实体列表
    'entities_by_type': entities_by_type  # 按类型分组的实体
}

# 单个实体结构：
{
    'text': '马效云',           # 实体文本
    'type': '人物',           # 实体类型  
    'start': 0,              # 起始位置
    'end': 2,                # 结束位置
    'raw_type': 'name'       # 原始标签类型
}

# -*- coding: utf-8 -*-
import torch
import re
from typing import List, Dict
from transformers import AutoTokenizer, AutoModelForTokenClassification
from modelscope import snapshot_download

class ReliableChineseNER:
    """中文命名实体识别"""
    
    def __init__(self, model_name="uer/roberta-base-finetuned-cluener2020-chinese"):
        """
        使用在CLUENER2020上微调过的模型，这个数据集专门用于中文NER
        """
        print(f"加载NER模型: {model_name}")
        
        try:
            # 尝试直接加载huggingface模型
            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
            self.model = AutoModelForTokenClassification.from_pretrained(model_name)
        except:
            # 如果失败，通过modelscope下载
            model_path = snapshot_download(model_name)
            self.tokenizer = AutoTokenizer.from_pretrained(model_path)
            self.model = AutoModelForTokenClassification.from_pretrained(model_path)
        
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.model.to(self.device)
        self.model.eval()
        
        # CLUENER2020的标签映射
        self.label_map = {
            0: 'O',
            1: 'B-address', 2: 'I-address',      # 地址
            3: 'B-book', 4: 'I-book',            # 书籍
            5: 'B-company', 6: 'I-company',      # 公司
            7: 'B-game', 8: 'I-game',            # 游戏
            9: 'B-government', 10: 'I-government', # 政府
            11: 'B-movie', 12: 'I-movie',        # 电影
            13: 'B-name', 14: 'I-name',          # 人名
            15: 'B-organization', 16: 'I-organization', # 组织
            17: 'B-position', 18: 'I-position',  # 职位
            19: 'B-scene', 20: 'I-scene'         # 场景
        }
        
        # 简化标签映射到常用类型
        self.simple_label_map = {
            'address': '地理位置',
            'company': '组织机构', 
            'government': '组织机构',
            'name': '人物',
            'organization': '组织机构',
            'position': '职位',
            'scene': '场景'
        }
        
        print("NER模型加载完成!")
    
    def predict(self, text: str) -> Dict:
        """预测命名实体"""
        try:
            # Tokenize
            inputs = self.tokenizer(
                text,
                return_tensors="pt",
                padding=True,
                truncation=True,
                max_length=512,
                return_offsets_mapping=True
            )
            
            # 移动到设备
            inputs = {k: v.to(self.device) for k, v in inputs.items()}
            offset_mapping = inputs.pop('offset_mapping').cpu().numpy()[0]
            
            # 预测
            with torch.no_grad():
                outputs = self.model(**inputs)
                predictions = torch.argmax(outputs.logits, dim=-1)[0].cpu().numpy()
            
            # 处理结果
            entities = self._extract_entities(text, predictions, offset_mapping)
            
            # 按类型分组
            entities_by_type = {}
            for entity in entities:
                entity_type = entity['type']
                if entity_type not in entities_by_type:
                    entities_by_type[entity_type] = []
                entities_by_type[entity_type].append(entity)
            
            return {
                'text': text,
                'entities': entities,
                'entities_by_type': entities_by_type
            }
            
        except Exception as e:
            print(f"NER预测错误: {e}")
            return {'text': text, 'entities': [], 'entities_by_type': {}}
    
    def _extract_entities(self, text: str, predictions: List[int], offset_mapping: List) -> List[Dict]:
        """提取实体 - 改进版本"""
        entities = []
        current_entity = None
        
        for i, (pred, offset) in enumerate(zip(predictions, offset_mapping)):
            # 跳过特殊token和填充token
            if offset[0] == offset[1] == 0:
                if current_entity:
                    entities.append(current_entity)
                    current_entity = None
                continue
            
            label = self.label_map.get(pred, 'O')
            
            if label.startswith('B-'):
                # 开始新实体
                if current_entity:
                    entities.append(current_entity)
                
                entity_type = label[2:]
                # 转换为简化标签
                simple_type = self.simple_label_map.get(entity_type, entity_type)
                start, end = offset
                
                current_entity = {
                    'text': text[start:end],
                    'type': simple_type,
                    'start': start,
                    'end': end,
                    'raw_type': entity_type
                }
                
            elif label.startswith('I-') and current_entity:
                # 继续当前实体
                entity_type = label[2:]
                simple_type = self.simple_label_map.get(entity_type, entity_type)
                
                # 检查类型是否匹配
                if simple_type == current_entity['type']:
                    _, end = offset
                    current_entity['text'] = text[current_entity['start']:end]
                    current_entity['end'] = end
                else:
                    # 类型不匹配，结束当前实体
                    entities.append(current_entity)
                    current_entity = None
            else:
                # O标签或其他，结束当前实体
                if current_entity:
                    entities.append(current_entity)
                    current_entity = None
        
        # 添加最后一个实体
        if current_entity:
            entities.append(current_entity)
        
        return entities

def test_reliable_ner():
    """测试的NER模型"""
    print("=" * 60)
    print("NER模型测试")
    print("=" * 60)
    
    try:
        ner = ReliableChineseNER()
        
        test_texts = [
            "马云在杭州创立了阿里巴巴集团，该公司总部位于浙江省杭州市。",
            "苹果公司由史蒂夫·乔布斯于1976年4月1日在美国加利福尼亚州创立。",
            "李彦宏在北京创立了百度公司，百度是全球最大的中文搜索引擎。",
            "清华大学位于北京市海淀区，创建于1911年。",
            "周树人显示了他对中国传统文化的深刻理解，并对中国现代文学产生了深远的影响。"
        ]
        
        for i, text in enumerate(test_texts, 1):
            print(f"\n📝 示例 {i}: {text}")
            result = ner.predict(text)
            
            print("🔍 识别到的实体:")
            if result['entities']:
                for entity_type, entities in result['entities_by_type'].items():
                    entity_texts = [e['text'] for e in entities]
                    print(f" {entity_type}: {', '.join(entity_texts)}")
            else:
                print("  ℹ️  未识别到实体")
                
    except Exception as e:
        print(f"NER模型测试失败: {e}")

def test_multiple_models():
    """测试多个模型"""
    print("\n" + "=" * 60)
    print("多模型对比测试")
    print("=" * 60)
    
    models_to_test = [
        # ("uer/roberta-base-finetuned-cluener2020-chinese", "CLUENER微调模型"),
        ("hfl/chinese-bert-wwm-ext", "中文BERT"),
        # 如果上面的不行，尝试这个
    ]
    
    for model_name, description in models_to_test:
        print(f"\n🧪 测试模型: {description}")
        try:
            # 简单的测试，不进行完整NER
            tokenizer = AutoTokenizer.from_pretrained(model_name)
            print(f"✅ {description} 加载成功")
        except Exception as e:
            print(f"❌ {description} 加载失败: {e}")

class SimpleButEffectiveNER:
    """简单但有效的中文NER"""
    
    def __init__(self):
        self.patterns = {
            '人物': [
                r'[李王张刘陈杨赵黄周吴徐孙胡朱高林何郭马罗梁宋郑谢韩唐冯于董萧][\u4e00-\u9fa5]{1,3}'
            ],
            '组织机构': [
                r'[\u4e00-\u9fa5a-zA-Z0-9]{2,20}(公司|集团|银行|大学|学院|医院|政府|局|所|中心)'
            ],
            '地理位置': [
                r'[\u4e00-\u9fa5]{2,10}[省市县区州国]',
                r'[北京|上海|天津|重庆|广州|深圳|杭州|南京|武汉|成都|西安|郑州|青岛|大连|厦门|苏州|宁波|无锡|佛山|东莞|沈阳|长沙|济南|哈尔滨|长春|石家庄|太原|合肥|南昌|福州|昆明|贵阳|兰州|银川|西宁|乌鲁木齐|呼和浩特|南宁|海口|香港|澳门|台北|台中|台南|高雄]{2,4}'
            ],
            '时间': [
                r'\d{4}年',
                r'\d{1,2}月',
                r'\d{1,2}日',
                r'\d{1,2}世纪'
            ]
        }
    
    def extract_entities(self, text: str) -> Dict:
        """使用正则表达式提取实体"""
        entities = []
        
        for entity_type, pattern_list in self.patterns.items():
            for pattern in pattern_list:
                matches = re.finditer(pattern, text)
                for match in matches:
                    entities.append({
                        'text': match.group(),
                        'type': entity_type,
                        'start': match.start(),
                        'end': match.end()
                    })
        
        # 去重
        unique_entities = []
        seen = set()
        for entity in entities:
            key = (entity['text'], entity['type'], entity['start'])
            if key not in seen:
                seen.add(key)
                unique_entities.append(entity)
        
        # 按类型分组
        entities_by_type = {}
        for entity in unique_entities:
            entity_type = entity['type']
            if entity_type not in entities_by_type:
                entities_by_type[entity_type] = []
            entities_by_type[entity_type].append(entity)
        
        return {
            'text': text,
            'entities': unique_entities,
            'entities_by_type': entities_by_type,
            'method': 'regex'
        }

def main():
    """主函数"""
    print("中文命名实体识别解决方案")
    print("=" * 60)
    
    # 测试NER模型
    test_reliable_ner()

if __name__ == "__main__":
    main()

class CMEEMedicalNER:
    def __init__(self, model_name="iic/nlp_raner_named-entity-recognition_chinese-base-cmeee"):
        print(f"加载医疗NER模型: {model_name}")
        
        try:
            # 下载模型
            model_dir = snapshot_download(model_name)
            print(f"模型下载完成: {model_dir}")
            
            # 创建pipeline
            self.ner_pipeline = pipeline(
                Tasks.named_entity_recognition,
                model=model_dir
            )

# 实体类型映射
self.entity_type_mapping = {
    'dis': '疾病',
    'sym': '症状',
    'pro': '医疗程序',
    'equ': '医疗设备', 
    'bod': '身体部位',
    'dur': '药物',
    'ite': '检查检验',
    'mic': '微生物',
    'dep': '科室',
    'phy': '医务人员'
}

def extract_entities(self, text: str) -> Dict:
    if self.ner_pipeline is None:
        return {"text": text, "entities": [], "entities_by_type": {}}
    
    try:
        # 使用pipeline进行实体识别
        result = self.ner_pipeline(text)
        
        # 处理结果
        entities = self._process_ner_result(result, text)
        
        # 按类型分组
        entities_by_type = self._group_entities_by_type(entities)

def _process_ner_result(self, result: Dict, text: str) -> List[Dict]:
    entities = []
    
    if 'output' not in result:
        return entities
    
    # 处理不同的输出格式
    if isinstance(result['output'], list):
        # 格式1: 直接是实体列表
        for entity in result['output']:
            if 'span' in entity and 'type' in entity:
                entity_type = self.entity_type_mapping.get(entity['type'], entity['type'])
                entities.append({
                    'text': entity['span'],
                    'type': entity_type,
                    'start': entity.get('start', text.find(entity['span'])),
                    'end': entity.get('end', text.find(entity['span']) + len(entity['span'])),
                    'score': entity.get('score', 1.0)
                })

# 去重
unique_entities = []
seen = set()
for entity in entities:
    key = (entity['text'], entity['type'], entity['start'])
    if key not in seen:
        seen.add(key)
        unique_entities.append(entity)

class MedicalTextAnalyzer:
    def __init__(self):
        self.ner = CMEEMedicalNER()
    
    def analyze_text(self, text: str) -> Dict:
        result = self.ner.extract_entities(text)
        
        # 统计分析
        stats = self._calculate_statistics(result)
        
        # 临床信息分析
        clinical_info = self._analyze_clinical_info(result)

def benchmark_performance():
    import time
    
    ner = CMEEMedicalNER()
    test_texts = [
        "患者发热咳嗽",
        "糖尿病胰岛素治疗",
        # ... 测试用例
    ]
    
    total_time = 0
    total_entities = 0
    
    for text in test_texts:
        start_time = time.time()
        result = ner.extract_entities(text)
        end_time = time.time()

# -*- coding: utf-8 -*-
import torch
from modelscope.pipelines import pipeline
from modelscope.utils.constant import Tasks
from modelscope import snapshot_download
from typing import List, Dict
import re

class CMEEMedicalNER:
    """基于CMEEE数据集的医疗命名实体识别"""
    
    def __init__(self, model_name="iic/nlp_raner_named-entity-recognition_chinese-base-cmeee"):
        print(f"加载医疗NER模型: {model_name}")
        
        try:
            # 下载模型
            model_dir = snapshot_download(model_name)
            print(f"模型下载完成: {model_dir}")
            
            # 创建pipeline
            self.ner_pipeline = pipeline(
                Tasks.named_entity_recognition,
                model=model_dir
            )
            
            # 实体类型映射
            self.entity_type_mapping = {
                'dis': '疾病',
                'sym': '症状',
                'pro': '医疗程序',
                'equ': '医疗设备', 
                'bod': '身体部位',
                'dur': '药物',
                'ite': '检查检验',
                'mic': '微生物',
                'dep': '科室',
                'phy': '医务人员'
            }
            
            print("医疗NER模型加载成功!")
            
        except Exception as e:
            print(f"模型加载失败: {e}")
            self.ner_pipeline = None
    
    def extract_entities(self, text: str) -> Dict:
        """提取医疗实体"""
        if self.ner_pipeline is None:
            return {"text": text, "entities": [], "entities_by_type": {}}
        
        try:
            # 使用pipeline进行实体识别
            result = self.ner_pipeline(text)
            
            # 处理结果
            entities = self._process_ner_result(result, text)
            
            # 按类型分组
            entities_by_type = self._group_entities_by_type(entities)
            
            return {
                'text': text,
                'entities': entities,
                'entities_by_type': entities_by_type
            }
            
        except Exception as e:
            print(f"实体识别错误: {e}")
            return {"text": text, "entities": [], "entities_by_type": {}}
    
    def _process_ner_result(self, result: Dict, text: str) -> List[Dict]:
        """处理NER结果"""
        entities = []
        
        if 'output' not in result:
            return entities
        
        # 处理不同的输出格式
        if isinstance(result['output'], list):
            # 格式1: 直接是实体列表
            for entity in result['output']:
                if 'span' in entity and 'type' in entity:
                    entity_type = self.entity_type_mapping.get(entity['type'], entity['type'])
                    entities.append({
                        'text': entity['span'],
                        'type': entity_type,
                        'start': entity.get('start', text.find(entity['span'])),
                        'end': entity.get('end', text.find(entity['span']) + len(entity['span'])),
                        'score': entity.get('score', 1.0)
                    })
        
        elif isinstance(result['output'], dict):
            # 格式2: 包含在字典中
            output_data = result['output']
            if 'entities' in output_data:
                for entity in output_data['entities']:
                    if 'span' in entity and 'type' in entity:
                        entity_type = self.entity_type_mapping.get(entity['type'], entity['type'])
                        entities.append({
                            'text': entity['span'],
                            'type': entity_type,
                            'start': entity.get('start', text.find(entity['span'])),
                            'end': entity.get('end', text.find(entity['span']) + len(entity['span'])),
                            'score': entity.get('score', 1.0)
                        })
        
        # 去重
        unique_entities = []
        seen = set()
        for entity in entities:
            key = (entity['text'], entity['type'], entity['start'])
            if key not in seen:
                seen.add(key)
                unique_entities.append(entity)
        
        return unique_entities
    
    def _group_entities_by_type(self, entities: List[Dict]) -> Dict[str, List[Dict]]:
        """按类型分组实体"""
        grouped = {}
        for entity in entities:
            entity_type = entity['type']
            if entity_type not in grouped:
                grouped[entity_type] = []
            grouped[entity_type].append(entity)
        return grouped

class MedicalTextAnalyzer:
    """医疗文本分析器"""
    
    def __init__(self):
        self.ner = CMEEMedicalNER()
    
    def analyze_text(self, text: str) -> Dict:
        """分析医疗文本"""
        result = self.ner.extract_entities(text)
        
        # 统计分析
        stats = self._calculate_statistics(result)
        
        # 临床信息分析
        clinical_info = self._analyze_clinical_info(result)
        
        return {
            'extraction_result': result,
            'statistics': stats,
            'clinical_info': clinical_info
        }
    
    def _calculate_statistics(self, result: Dict) -> Dict:
        """计算统计信息"""
        entities = result['entities']
        
        stats = {
            'total_entities': len(entities),
            'entities_by_type': {},
            'entity_density': len(entities) / len(result['text']) * 100 if result['text'] else 0
        }
        
        for entity in entities:
            entity_type = entity['type']
            if entity_type in stats['entities_by_type']:
                stats['entities_by_type'][entity_type] += 1
            else:
                stats['entities_by_type'][entity_type] = 1
        
        return stats
    
    def _analyze_clinical_info(self, result: Dict) -> Dict:
        """分析临床信息"""
        entities = result['entities']
        
        # 检查关键临床信息是否存在
        has_disease = any(e['type'] == '疾病' for e in entities)
        has_symptom = any(e['type'] == '症状' for e in entities)
        has_drug = any(e['type'] == '药物' for e in entities)
        has_examination = any(e['type'] == '检查检验' for e in entities)
        
        completeness_score = sum([has_disease, has_symptom, has_drug, has_examination])
        
        return {
            'has_disease': has_disease,
            'has_symptom': has_symptom,
            'has_drug': has_drug,
            'has_examination': has_examination,
            'completeness_score': completeness_score,
            'completeness_percentage': (completeness_score / 4) * 100
        }

def test_cmee_medical_ner():
    """测试CMEEE医疗NER"""
    print("=" * 80)
    print("CMEEE医疗命名实体识别测试")
    print("=" * 80)
    
    analyzer = MedicalTextAnalyzer()
    
    test_cases = [
        "老年男性患者，因突发左侧肢体无力伴言语不清2小时入院。头颅CT提示右侧基底节区脑梗死。",
        "女性患者，45岁，因反复右上腹痛伴发热黄疸一周就诊。超声检查提示胆囊结石伴急性胆囊炎。",
        "患儿，3岁，因发热、咳嗽、气促3天就诊儿科。听诊双肺湿啰音，胸部X线显示支气管肺炎。",
        "患者主诉头痛、发热伴咳嗽三天，体温38.5℃，诊断为上呼吸道感染。",
        "糖尿病患者需要定期监测血糖，使用胰岛素控制血糖水平。",
        "患者因持续性胸痛和呼吸困难就诊急诊科，心电图显示心肌梗死，立即给予阿司匹林治疗。",
        "患者因咳嗽、咳痰伴胸痛就诊，胸部CT显示右肺上叶结节，建议进一步行支气管镜检查。",
        "高血压患者长期服用硝苯地平控制血压，近期出现头晕乏力症状。"
    ]
    
    for i, text in enumerate(test_cases, 1):
        print(f"\n📄 测试案例 {i}:")
        print(f"   {text}")
        
        analysis = analyzer.analyze_text(text)
        result = analysis['extraction_result']
        stats = analysis['statistics']
        clinical = analysis['clinical_info']
        
        print("🔬 识别结果:")
        if result['entities']:
            for entity_type, entities in result['entities_by_type'].items():
                entity_list = [e['text'] for e in entities]
                print(f"   ✅ {entity_type}: {', '.join(entity_list)}")
        else:
            print("   ❌ 未识别到实体")
        
        print(f"统计: {stats['total_entities']}个实体, 密度: {stats['entity_density']:.1f}%")
        print(f"临床完整性: {clinical['completeness_percentage']:.1f}%")

def compare_with_previous():
    """与之前问题案例对比"""
    print("\n" + "=" * 80)
    print("改进效果对比")
    print("=" * 80)
    
    ner = CMEEMedicalNER()
    
    # 之前有问题的案例
    problem_cases = [
        ("糖尿病患者需要定期监测血糖，使用胰岛素控制血糖水平。", 
         "之前问题: 只识别出'胰岛素'，漏掉'糖尿病'"),
        
        ("患者主诉头痛、发热伴咳嗽三天，体温38.5℃，诊断为上呼吸道感染。", 
         "之前问题: 将'患者'、'三天'误识别为症状"),
        
        ("头颅CT提示右侧基底节区脑梗死。", 
         "之前问题: 将'右侧'误识别为疾病")
    ]
    
    for text, problem_desc in problem_cases:
        print(f"\n🔍 {problem_desc}")
        print(f"   文本: {text}")
        
        result = ner.extract_entities(text)
        
        print("✅ 改进后结果:")
        if result['entities']:
            for entity_type, entities in result['entities_by_type'].items():
                entity_list = [e['text'] for e in entities]
                print(f"   {entity_type}: {', '.join(entity_list)}")
        else:
            print("   未识别到实体")

def test_complex_medical_cases():
    """测试复杂医疗案例"""
    print("\n" + "=" * 80)
    print("复杂医疗案例测试")
    print("=" * 80)
    
    analyzer = MedicalTextAnalyzer()
    
    complex_cases = [
        "老年男性，因突发右侧肢体活动障碍伴言语不清4小时入院。头颅MRI显示左侧基底节区急性脑梗死，NIHSS评分15分。给予阿司匹林、氯吡格雷双抗治疗，并予阿托伐他汀强化降脂。",
        "女性患者，68岁，因反复胸痛、胸闷1周，加重2小时急诊入院。心电图示II、III、aVF导联ST段抬高，心肌酶谱异常，诊断为急性下壁心肌梗死。行急诊PCI术，于右冠脉植入支架1枚。",
        "患儿，5岁，因发热、皮疹3天就诊。体检：体温39.2℃，咽部充血，扁桃体II度肿大，见脓性分泌物，全身可见弥漫性红色斑丘疹。血常规示白细胞18.5×10^9/L，中性粒细胞85%。诊断为猩红热，给予青霉素抗感染治疗。",
        "患者因右上腹持续性胀痛伴皮肤黄染、尿色加深1月余就诊。腹部CT提示肝内胆管扩张，肝门部占位，考虑肝门部胆管癌。行ERCP检查，留置胆道支架引流。"
    ]
    
    for i, text in enumerate(complex_cases, 1):
        print(f"\n 复杂案例 {i}:")
        print(f"   {text}")
        
        analysis = analyzer.analyze_text(text)
        result = analysis['extraction_result']
        
        print("🔬 识别结果:")
        if result['entities']:
            # 只显示主要的医疗实体类型
            medical_types = ['疾病', '症状', '药物', '检查检验', '身体部位', '科室', '医疗程序']
            for entity_type in medical_types:
                if entity_type in result['entities_by_type']:
                    entities = result['entities_by_type'][entity_type]
                    entity_list = [e['text'] for e in entities]
                    print(f"  {entity_type}: {', '.join(entity_list)}")
        
        clinical = analysis['clinical_info']
        print(f" 临床完整性: {clinical['completeness_percentage']:.0f}%")

def benchmark_performance():
    """性能基准测试"""
    print("\n" + "=" * 80)
    print("性能基准测试")
    print("=" * 80)
    
    import time
    
    ner = CMEEMedicalNER()
    test_texts = [
        "患者发热咳嗽",
        "糖尿病胰岛素治疗",
        "头痛伴呕吐腹泻",
        "胸部CT显示肺炎",
        "高血压服用硝苯地平"
    ]
    
    total_time = 0
    total_entities = 0
    
    for text in test_texts:
        start_time = time.time()
        result = ner.extract_entities(text)
        end_time = time.time()
        
        processing_time = (end_time - start_time) * 1000  # 转换为毫秒
        total_time += processing_time
        total_entities += len(result['entities'])
        
        print(f"📝 '{text}' -> {len(result['entities'])}个实体, 耗时: {processing_time:.1f}ms")
    
    avg_time = total_time / len(test_texts)
    avg_entities = total_entities / len(test_texts)
    
    print(f"\n📊 平均性能: {avg_time:.1f}ms/文本, {avg_entities:.1f}个实体/文本")

def main():
    """主函数"""
    print("基于CMEEE的医疗命名实体识别系统")
    print("=" * 80)
    
    print("\n模型信息:")
    print("  模型: iic/nlp_raner_named-entity-recognition_chinese-base-cmeee")
    print("  数据集: CMEEE (Chinese Medical Entity Extraction)")
    print("  实体类型: 疾病(diss), 症状(sym), 药物(dur), 检查检验(ite), 身体部位(bod)等")
    
    # 运行测试
    test_cmee_medical_ner()
    compare_with_previous()
    test_complex_medical_cases()
    benchmark_performance()
    
    print("\n" + "=" * 80)
    print("测试完成!")
    print("=" * 80)


if __name__ == "__main__":
    main()