freeCodeCamp.org

How to Build an NLP Pipeline in Python to Analyze Therapy Progress Notes

7.1内容质量
How to Build an NLP Pipeline in Python to Analyze Therapy Progress Notes

TL;DR · AI 摘要

How to Build an NLP Pipeline in Python to Analyze Therapy Progress Notes November 17, 2026 / Python Samuel Tosin Therapy...

核心要点

  • 主题聚焦:How to Build an NLP Pipeline in Python to Analyz
  • 来源:freeCodeCamp.org,建议结合原文判断细节。
  • AI 分析暂不可用,本条为保底评分与摘要。
#AI#编程#后端#安全#开源
打开原文

如何使用Python构建NLP管道以分析治疗进展记录

2026年11月17日

/

#Python

Samuel Tosin

治疗进展记录是记录治疗过程中发生情况的书面文件。它们可能包括客户所说的话、治疗师的观察、讨论的主题以及下一次会话的计划。随着时间的推移,这些记录会积累成大量文本。

阅读一条记录可以帮助我们理解一次会话。但如果我们要查看多条记录呢?我们能否通过文本分析来观察语言在不同会话之间的变化?

自然语言处理(NLP)是使用计算机处理人类语言的一种方法。通过Python,你可以将文本拆分为句子,提取语言特征,并使用模型对情感和情绪进行分类。在本教程中,你将使用spaCy的语言处理管道进行文本处理,并使用Hugging Face Transformers运行预训练的分类模型。

你将使用虚构的治疗记录构建一个小型NLP管道。你将使用spaCy处理文本,使用两个现成的Hugging Face模型对情感和情绪进行分类,使用pandas按会话组织结果,并使用Matplotlib创建图表。

你可以在GitHub仓库中找到完整的项目代码。

我们并不是要判断治疗是否有效。目标是学习如何将书面文本转化为我们可以查看、提问并在图表中展示的数据。

最后,你将拥有一个使用spaCy、Hugging Face Transformers、pandas和Matplotlib的实用Python项目,用于探索虚构治疗记录中的情感、情绪和语言模式。

注意:本教程仅用于学习目的,使用虚构文本。这些模型未经临床测试,不能告诉我们治疗是否有效,不能识别治疗师与客户关系中的问题,也不能替代受过专业训练的人员。

目录

  • NLP能告诉我们什么和不能告诉我们什么
  • 我们正在构建什么
  • 工具和模型
  • 设置Python项目
  • 创建合成数据集
  • 使用spaCy预处理记录
  • 使用DistilBERT进行情感分析
  • 使用DistilRoBERTa进行情绪分类
  • 探索语言特征
  • 跨会话比较结果
  • 可视化输出
  • 连接管道
  • 测试项目
  • 局限性和伦理考量
  • 结论和进一步学习
  • 参考文献

NLP能告诉我们什么和不能告诉我们什么

自然语言处理(NLP)是人工智能的一部分,帮助计算机处理人类语言。常见的NLP任务包括将文本拆分为单词和句子、识别语法、查找人名和地点,以及对情感和情绪进行分类。

每个任务都有不同的功能。分词将文本拆分为更小的片段,如单词。词性标注识别单词在句子中的用法,如名词或动词。词形还原将单词映射到其基本形式,而命名实体识别识别如人物、组织和地点等项目。这些都是spaCy处理管道中可用组件的示例。情感分析根据模型学习的示例估计文本听起来是积极还是消极。情绪分类则为模型在训练期间学习的情绪类别提供评分。

这些结果并不能告诉我们一个人真实的情绪。治疗笔记可能包含治疗师的观察记录、来访者的原话,或者治疗师对来访者话语的总结。模型可能无法判断某句话是谁说的,也无法理解完整的上下文。在本教程中,我们将讨论模型预测和语言模式,而不是个人的情绪或治疗进展。

我们要构建的内容

我们的项目将分析一组虚构的会谈笔记,并生成四种类型的结果:

  • 每句话的情感预测
  • 每句话的情绪预测及平均分
  • 简单的语言特征,如特定代词和短语(如“也许”或“我认为”)的统计数量
  • 时间线和仪表盘,用于跨会谈比较结果

工作流程如下:

图1. NLP工作流程的高层视图。该图表还显示了可能的扩展功能(如CSV和HTML报告),但这些功能在本教程的每个步骤中并未全部实现。

我们将代码保存在单独的文件中,使每个部分都有明确的职责。该项目不会计算关系破裂评分或标注临床结果。

工具和模型

Python

Python将连接项目各部分。它还拥有许多处理数据和语言的库。

spaCy是一个Python库,帮助我们处理文本。其处理流程可以将文本拆分为标记、分配词性标签、查找单词的基本形式,并识别可能的人名或地点。我们将使用其小型英语模型en_core_web_sm。该模型适用于通用英语,而非专门针对治疗笔记。

Hugging Face Transformers

我们将使用两个预训练分类模型:

第一个模型distilbert/distilbert-base-uncased-finetuned-sst-2-english将文本分类为积极或消极。根据该模型的卡片信息,这是一个在斯坦福情感树库(SST-2)上微调的DistilBERT检查点,SST-2是一个通用英语句子的数据集。DistilBERT本身在研究论文“DistilBERT,BERT的蒸馏版本:更小、更快、更便宜和更轻量”中有所描述。该检查点和原始DistilBERT论文均未证明该模型适用于治疗笔记。

第二个模型j-hartmann/emotion-english-distilroberta-base可预测七种情绪类别:愤怒、厌恶、恐惧、喜悦、中性、悲伤和惊讶。根据Jochen Hartmann的模型卡片信息,该模型是在从六个数据集中提取的平衡数据集上训练的,包括社交媒体帖子、学生自述和对话。该模型尚未经过验证用于分析治疗进展笔记。

这些模型帮助我们了解文本分类的工作原理。但由于它们是在通用文本上训练的,我们不能假设它们在治疗笔记上表现良好。

pandas和Matplotlib

pandas将帮助我们将结果组织到名为DataFrame的表格中。Matplotlib将帮助我们将结果转化为图表。

pytest

pytest是一个用于验证代码是否按预期工作的工具。在某些测试中,我们将使用示例模型结果,这样可以在不下载大型模型文件的情况下测试代码。

创建Python项目

创建项目文件夹并进入该文件夹:

code
mkdir therapy_notes_nlp
cd therapy_notes_nlp
mkdir data src tests images

您的项目文件夹和文件结构应如下所示:

code
therapy_notes_nlp/
├── data/
│   └── synthetic_notes.json
├── images/
├── src/
│   ├── __init__.py
│   ├── preprocessor.py
│   ├── sentiment.py
│   ├── emotions.py
│   ├── tracker.py
│   └── visualizer.py
├── tests/
│   ├── conftest.py
│   ├── test_analyzer.py
│   ├── test_emotions.py
│   ├── test_preprocessor.py
│   ├── test_sentiment.py
│   └── test_tracker.py
├── analyzer.py
├── main.py
├── pytest.ini
└── requirements.txt

创建虚拟环境并激活它。虚拟环境可以将该项目的Python包与其他项目的包隔离开来:

code
python -m venv .venv

# Windows
.venv\Scripts\activate

# macOS 或 Linux
source .venv/bin/activate

将以下包添加到 requirements.txt 文件中:

code
spacy>=3.8,<4.0
transformers>=4.45,<6.0
torch>=2.2
pandas>=2.2,<3.0
matplotlib>=3.8,<4.0
pytest>=8.0,<10.0

安装这些包并下载 spaCy 的英文语言模型:

code
pip install -r requirements.txt
python -m spacy download en_core_web_sm

首次运行项目时,Hugging Face 会下载模型文件。虽然可以在 CPU 上运行这些模型,但速度可能比在 GPU 上运行更慢。

创建合成数据集

治疗笔记可能包含个人信息。为保护隐私,本教程将全程使用虚构示例。这也意味着任何人都无需访问真实患者记录即可跟随本项目。

本教程继续使用虚构数据。除非你已获得适当授权和安全措施,并确认适用的法律法规,否则不要用真实治疗笔记替换这些虚构数据。

spaCy 有时可以识别文本中的姓名和其他信息,但有时也会遗漏。移除某人的姓名并不能使治疗笔记完全匿名。本教程请仅使用虚构示例。任何真实研究项目都需要获得相关批准并采取隐私保护措施。

如果尚未创建,请在 data 文件夹中新建一个名为 synthetic_notes.json 的文件:

/think

code
[
  {
    "session": 1,
    "client_id": "SYNTHETIC_001",
    "note": "这位虚构的客户表示自己因工作需求感到不堪重负。他们说睡眠变得困难,也不确定应该从哪里开始。"
  },
  {
    "session": 2,
    "client_id": "SYNTHETIC_001",
    "note": "这位虚构的客户讨论了尝试新的晚间例行程序。他们描述了一个有帮助的时刻,但也提到持续存在的担忧。"
  },
  {
    "session": 3,
    "client_id": "SYNTHETIC_001",
    "note": "这位虚构的客户报告称经历了压力重重的一周,并表示感到沮丧。他们还指出自己处理了一个不同的情况。"
  },
  {
    "session": 4,
    "client_id": "SYNTHETIC_001",
    "note": "这位虚构的客户描述了对一次工作谈话感到更加乐观。他们仍然担心能否维持这些改变。"
  },
  {
    "session": 5,
    "client_id": "SYNTHETIC_001",
    "note": "这位虚构的客户质疑当前的方法是否有用,并表示自己原本预期会有不同的节奏。他们想讨论这个担忧。"
  },
  {
    "session": 6,
    "client_id": "SYNTHETIC_001",
    "note": "这位虚构的客户和治疗师讨论了之前提出的担忧。客户表示感觉自己被倾听,但指出一些问题仍未解决。"
  },
  {
    "session": 7,
    "client_id": "SYNTHETIC_001",
    "note": "这位虚构的客户反思了在困难对话中使用应对策略的情况。他们描述了既感到宽慰又仍有紧张感。"
  },
  {
    "session": 8,
    "client_id": "SYNTHETIC_001",
    "note": "这位虚构的客户回顾了早期会话中的主题。他们描述了注意到的变化,并指出了仍想解决的挑战。"
  }
]

每个条目包含会话编号、虚构的客户ID和备注。示例中包含了积极和困难的体验。我们没有编写这些内容来迫使模型给出特定答案。我们将运行模型并检查它们生成的结果。

使用spaCy预处理备注

在对文本进行分类之前,我们将使用spaCy将每个备注拆分为句子,并收集一些关于词语的基本信息。

在src/preprocessor.py中:

code
from __future__ import annotations
from typing import Any
import spacy

MODEL_NAME = "en_core_web_sm"

def load_nlp(model_name: str = MODEL_NAME):
    return spacy.load(model_name)

_nlp = None

def get_nlp():
    global _nlp
    if _nlp is None:
        _nlp = load_nlp()
    return _nlp

def preprocess_note(text: str, nlp=None) -> dict[str, Any]:
    if not isinstance(text, str):
        raise TypeError("text must be a string")
    if not text.strip():
        return {
            "tokens": [], "lemmas": [], "sentences": [],
            "pos_tags": [], "entities": [],
            "token_count": 0, "sentence_count": 0
        }

    doc = (nlp or get_nlp())(text)
    tokens = [t.text.lower() for t in doc if not t.is_punct and not t.is_space]
    lemmas = [
        t.lemma_.lower() for t in doc
        if not t.is_stop and not t.is_punct and not t.is_space and t.is_alpha
    ]
    sentences = [s.text.strip() for s in doc.sents if s.text.strip()]
    pos_tags = [
        {"text": t.text, "pos": t.pos_, "tag": t.tag_}
        for t in doc if not t.is_punct and not t.is_space
    ]
    entities = [{"text": e.text, "label": e.label_} for e in doc.ents]
code
    return {
        "tokens": tokens,
        "lemmas": lemmas,
        "sentences": sentences,
        "pos_tags": pos_tags,
        "entities": entities,
        "token_count": len(tokens),
        "sentence_count": len(sentences)
    }

_nlp = None / get_nlp() 模式值得特别关注。加载 spaCy 模型需要一两秒钟的时间,你不希望每次函数调用都产生这个开销。通过将 _nlp 作为模块级变量保存,模型只需加载一次,后续所有调用都会复用该模型。(nlp or get_nlp())(text) 这行代码乍看可能有些奇怪,但它的含义是:使用传入的模型,或回退到默认模型。这也让函数后续更容易测试,因为你可以传入一个轻量级的模拟模型,而不是真正的模型。

需要注意的一点是:我们将原始句子传递给分类器,而不是清洗后的 tokens 或 lemmas。这是有意为之。像 "not" 这样的词会改变句子的含义,而分类前将其移除可能会悄无声息地改变模型看到的内容。

entities 字段存储了 spaCy 识别出的可能人名、地点和其他命名实体。它不会移除个人信息或使文本匿名化。

使用 DistilBERT 进行情感分析

情感分析是一种通过模型学习的示例来估计文本是更积极还是更消极的方法。我们选择的 DistilBERT 模型在 SST-2 数据集上进行了进一步训练,这是一个通用的英文句子数据集。它会为每个句子返回一个正面得分和一个负面得分。

在 src/sentiment.py 中:

code
MODEL_ID = "distilbert/distilbert-base-uncased-finetuned-sst-2-english"
_pipeline = None

def get_pipeline():
    global _pipeline
    if _pipeline is None:
        from transformers import pipeline
        _pipeline = pipeline(
            "text-classification", model=MODEL_ID, top_k=None
        )
    return _pipeline

def _normalise_prediction(prediction):
    if isinstance(prediction, dict):
        return [prediction]
    if prediction and isinstance(prediction[0], list):
        return prediction[0]
    return prediction

def analyze_sentiment(sentences: list[str], classifier=None) -> dict:
    clean = [s.strip() for s in sentences if isinstance(s, str) and s.strip()]
    if not clean:
        return {
            "sentence_results": [], "aggregate_score": None,
            "aggregate_label": None, "positive_ratio": 0.0,
            "negative_ratio": 0.0
        }

    model = classifier or get_pipeline()
    predictions = model(clean, truncation=True, batch_size=8)
    results = []

    for sentence, prediction in zip(clean, predictions):
        scores = _normalise_prediction(prediction)
        by_label = {
            item["label"].upper(): float(item["score"])
            for item in scores
        }
        positive = by_label.get("POSITIVE", 0.0)
        negative = by_label.get("NEGATIVE", 0.0)
        signed_score = positive - negative
        label = (
            "POSITIVE" if signed_score > 0
            else "NEGATIVE" if signed_score < 0
            else "BALANCED"
        )
        results.append({
            "sentence": sentence,
            "label": label,
            "positive_score": positive,
            "negative_score": negative,
            "signed_score": round(signed_score, 4)
        })

values = [item["signed_score"] for item in results] aggregate = sum(values) / len(values) return { "sentence_results": results, "aggregate_score": round(aggregate, 4), "aggregate_label": ( "POSITIVE" if aggregate > 0 else "NEGATIVE" if aggregate < 0 else "BALANCED" ), "positive_ratio": round( sum(item["label"] == "POSITIVE" for item in results) / len(results), 3 ), "negative_ratio": round( sum(item["label"] == "NEGATIVE" for item in results) / len(results), 3 ) }

code

get_pipeline() 与 get_nlp() 采用相同的延迟加载模式:模型仅加载一次,并在后续每次调用时重复使用。设置 top_k=None 会指示 Hugging Face pipeline 返回所有标签的评分,而不仅仅是最高分的标签。如果不设置此参数,我们将只能获取胜出标签,无法比较两个评分。truncation=True 会截断超过 512 个 token 的输入,这是模型能处理的最大长度。batch_size=8 一次性将最多八条句子发送给模型,比逐条发送更快。

_normalise_prediction() 的存在是因为 pipeline 返回的结果形状可能因版本和配置不同而有所差异。它会将所有形状转换为一致的 {"label": ..., "score": ...} 字典列表,使函数其余部分始终能以相同格式处理数据。

对于每条句子,by_label 是一个字典,通过推导式构建,将每个大写标签映射到其对应评分。signed_score 通过从正面评分中减去负面评分,得到一个介于 -1 到 +1 之间的值。最后,函数对所有 signed_score 取平均,生成会话的综合评分。

这个指数仅仅是基于模型评分创建的摘要。它不是经过医学验证的测量指标,也不是康复评分或幸福感指标。接近零的评分也可能意味着正面和负面结果相互抵消。

## 使用 DistilRoBERTa 进行情绪分类

情感分析和情绪分类并不相同。情感分析提供宽泛的正面或负面结果。情绪分类则关注如喜悦、悲伤、愤怒和恐惧等具体类别。

在 src/emotions.py 中:

MODEL_ID = "j-hartmann/emotion-english-distilroberta-base" _pipeline = None

def get_pipeline(): global _pipeline if _pipeline is None: from transformers import pipeline _pipeline = pipeline( "text-classification", model=MODEL_ID, top_k=None ) return _pipeline

def _normalise_prediction(prediction): if isinstance(prediction, dict): return [prediction] if prediction and isinstance(prediction[0], list): return prediction[0] return prediction

def detect_emotions(sentences: list[str], classifier=None) -> dict: clean = [s.strip() for s in sentences if isinstance(s, str) and s.strip()] if not clean: return { "per_sentence": [], "emotion_distribution": {}, "session_dominant_emotion": None }

model = classifier or get_pipeline() predictions = model(clean, truncation=True, batch_size=8) per_sentence = [] totals = {}

for sentence, prediction in zip(clean, predictions): scores = _normalise_prediction(prediction) score_map = { item["label"].lower(): float(item["score"]) for item in scores } for label, score in score_map.items(): totals[label] = totals.get(label, 0.0) + score dominant = max(score_map, key=score_map.get) per_sentence.append({ "sentence": sentence, "dominant_emotion": dominant, "scores": score_map })

distribution = { label: round(score / len(clean), 4) for label, score in totals.items() } dominant_session = max(distribution, key=distribution.get) return { "per_sentence": per_sentence, "emotion_distribution": distribution, "session_dominant_emotion": dominant_session }

code

`totals` 字典会跨句子累积分数。对于每个句子,循环会将每个情绪标签的分数累加到总分中。使用 `totals.get(label, 0.0)` 可以安全地处理首次出现标签的情况,将其初始化为 0 而不是引发键错误。

`max(score_map, key=score_map.get)` 会找到 `score_map` 中当前句子分数最高的标签。`key` 参数告诉 `max()` 函数比较字典中的值而不是键本身。

处理完所有句子后,`distribution` 会将每个累积的总分除以句子数量,得到整个会话中每种情绪的平均分。`max(distribution, key=distribution.get)` 使用相同的模式找到会话级别的主导情绪。

这些结果是模型的预测输出。它们不能确认任何人的真实感受。该模型是在通用英文文本上训练的,而治疗记录是为不同目的撰写的,可能使用不同的语言。我们不应假设模型在处理这些文本时能可靠运行。

## 探索语言特征

我们还可以统计一些简单的语言特征。例如,可以统计第一人称代词的出现频率,并查找“maybe”、“perhaps”和“I guess”等短语。这些是模糊表达的示例,人们在不确定或谨慎发言时有时会使用这些表达。

将以下函数添加到 `src/preprocessor.py`:

def extract_linguistic_features(text: str) -> dict: doc = get_nlp()(text) first_person = { "i", "me", "my", "mine", "myself", "we", "us", "our", "ours", "ourselves" } third_person = { "he", "him", "his", "himself", "she", "her", "hers", "herself", "they", "them", "their", "theirs", "themselves", "it", "its", "itself" } second_person = {"you", "your", "yours", "yourself", "yourselves"}

pronouns = [token.text.lower() for token in doc if token.pos_ == "PRON"] first = sum(word in first_person for word in pronouns) third = sum(word in third_person for word in pronouns) second = sum(word in second_person for word in pronouns) total = first + third + second

hedging_phrases = ( "maybe", "perhaps", "possibly", "i guess", "not sure", "sort of", "kind of", "i think", "might" ) lower = text.lower() hedging_count = sum(lower.count(phrase) for phrase in hedging_phrases)

code

return {
        "first_person_count": first,
        "third_person_count": third,
        "second_person_count": second,
        "pronoun_count": total,
        "first_person_ratio": round(first / total, 3) if total else 0.0,
        "hedging_phrase_count": hedging_count
    }

token.pos_ == "PRON" 通过词性标签过滤标记。spaCy 将此标签分配给其识别为代词的单词。三个集合 first_person、third_person 和 second_person 定义了哪些小写单词属于每个组。sum() 函数内的生成器表达式会检查每个代词标记的文本是否属于该集合,并统计匹配的数量。

first_person_ratio 将第一人称数量除以总代词数量。当文本中没有代词时,if total else 0.0 的保护语句可防止除以零的错误。

对于模糊用语,text.lower() 在搜索前将整个笔记转换为小写,因此 "Maybe" 和 "maybe" 会被视为相同。lower.count(phrase) 返回该短语作为子字符串出现的次数。每个短语的结果都会被累加到 hedging_count 中。

这些数字仅仅是统计数量。它们无法解释某人为什么使用特定的词语或短语。它们的含义取决于上下文和写笔记的人。要理解这些特征是否有效,我们需要将其与精心标注的示例进行比较。但这超出了本教程的范围。

跨会话比较结果

每个会话都会生成一组结果。我们将使用 pandas 将结果放入表格中,每行对应一个会话。这使得随时间比较结果更加容易。

在 src/tracker.py 中:

code
import pandas as pd

def build_session_timeline(session_results: list[dict]) -> pd.DataFrame:
    rows = []
    for result in session_results:
        sentiment = result["sentiment"]
        emotions = result["emotions"]
        linguistic = result["linguistic_features"]
        rows.append({
            "session": result["session"],
            "sentiment_index": sentiment["aggregate_score"],
            "sentiment_label": sentiment["aggregate_label"],
            "dominant_emotion": emotions["session_dominant_emotion"],
            "first_person_ratio": linguistic["first_person_ratio"],
            "hedging_phrase_count": linguistic["hedging_phrase_count"],
            "sentence_count": result["sentence_count"]
        })

    columns = [
        "session", "sentiment_index", "sentiment_label",
        "dominant_emotion", "first_person_ratio",
        "hedging_phrase_count", "sentence_count"
    ]
    if not rows:
        return pd.DataFrame(columns=columns)
    return pd.DataFrame(rows).sort_values("session").reset_index(drop=True)

def describe_sentiment_shift(df: pd.DataFrame) -> dict:
    if df.empty:
        return {
            "session_count": 0,
            "first_half_mean": None,
            "second_half_mean": None,
            "difference": None,
            "description": "No sessions to compare"
        }

    midpoint = max(1, len(df) // 2)
    first = df.iloc[:midpoint]["sentiment_index"].dropna()
    second = df.iloc[midpoint:]["sentiment_index"].dropna()
    first_mean = float(first.mean()) if not first.empty else None
    second_mean = float(second.mean()) if not second.empty else None
    difference = (
        second_mean - first_mean
        if first_mean is not None and second_mean is not None
        else None
    )

if difference is None:
        description = "缺少足够的有效评分来比较两部分"
    elif difference > 0.05:
        description = "第二部分的模型情感指数平均值更高"
    elif difference < -0.05:
        description = "第二部分的模型情感指数平均值更低"
    else:
        description = "两个时间段的平均值差异很小"

    return {
        "session_count": len(df),
        "first_half_mean": first_mean,
        "second_half_mean": second_mean,
        "difference": round(difference, 4) if difference is not None else None,
        "description": description
    }

build_session_timeline() 函数会遍历每个会话结果,从嵌套字典中提取所需字段,并将扁平化字典作为一行数据追加。pd.DataFrame(rows) 将行列表转换为表格。.sort_values("session") 按会话编号排序,.reset_index(drop=True) 则用从零开始的整洁序列替换索引。

在 describe_sentiment_shift() 中,df.iloc[:midpoint] 按位置选择前半段数据。.dropna() 在计算平均值前移除 sentiment_index 缺失的行,这样单个缺失值不会导致整体平均值变为 NaN。0.05 的阈值避免将非常小的数值差异描述为有意义的变化。

描述内容仅涉及模型的情感指数。我们避免使用"显著改善"或"临床恶化"等标签,因为模型评分的变化并不能证明用户心理健康或治疗进展发生了变化。

可视化输出结果

与单纯表格相比,图表能更直观地呈现结果。我们将创建四张图表:情感指数、每节会话预测的最可能情绪、第一人称代词占比,以及模糊用语的数量。

在 src/visualizer.py 中:

code
import matplotlib.pyplot as plt
import pandas as pd

def plot_dashboard(
    df: pd.DataFrame,
    output_path: str = "images/session_dashboard.png"
):
    if df.empty:
        raise ValueError("无法绘制空的会话时间线")

    fig, axes = plt.subplots(2, 2, figsize=(12, 8))
    sessions = df["session"]

    axes[0, 0].plot(sessions, df["sentiment_index"], marker="o")
    axes[0, 0].axhline(0, linestyle="--", linewidth=1)
    axes[0, 0].set(
        title="模型情感指数随会话变化",
        xlabel="会话",
        ylabel="正向得分减去负向得分"
    )

    emotion_codes = {
        name: i for i, name in enumerate(
            sorted(df["dominant_emotion"].dropna().unique())
        )
    }
    emotion_values = [
        emotion_codes.get(value, -1)
        for value in df["dominant_emotion"]
    ]
    axes[0, 1].scatter(sessions, emotion_values)
    axes[0, 1].set(
        title="主导预测情绪",
        xlabel="会话",
        ylabel="情绪类别"
    )
    axes[0, 1].set_yticks(
        list(emotion_codes.values()), list(emotion_codes.keys())
    )

    axes[1, 0].plot(sessions, df["first_person_ratio"], marker="o")
    axes[1, 0].set(
        title="第一人称代词占比",
        xlabel="会话",
        ylabel="统计代词占比",
        ylim=(0, 1)
    )

    axes[1, 1].bar(sessions, df["hedging_phrase_count"])
    axes[1, 1].set(
        title="选定的模糊用语",
        xlabel="会话",
        ylabel="用语数量"
    )

fig.suptitle("Exploratory text-analysis outputs (synthetic data)") fig.tight_layout() fig.savefig(output_path, dpi=160, bbox_inches="tight") plt.close(fig) return output_path

code

plt.subplots(2, 2, figsize=(12, 8)) 创建一个包含 2 行 2 列子图的画布。该函数返回画布对象 fig 和一个二维数组 axes,其中 axes[row, col] 表示每个图表。

情感图表使用 axes[0, 0].axhline(0) 在零点绘制水平参考线。这使得用户可以快速判断哪些会话产生了正向或负向的净指数。

情绪图表需要额外处理步骤,因为 Matplotlib 散点图需要数值而非字符串。emotion_codes 是一个通过 enumerate 将每个唯一情绪标签映射到整数的字典。emotion_values 将主导情绪列转换为这些整数以便绘图。set_yticks() 随后在 y 轴恢复原始标签名称,使图表显示文字而非数字。

fig.tight_layout() 会自动调整子图间距,防止标题和标签重叠。fig.savefig() 将完成的图表写入文件,plt.close(fig) 释放图表占用的内存。

[Figure 2: figure-2.png]

图 2. 来自虚构会话的仪表盘示例。分数和语言统计是模型输出和文本特征,而非治疗进展的衡量指标。

每个图表展示不同结果。情感图表显示我们从模型分数计算出的指数。情绪图表显示每次会话中得分最高的类别。另外两个图表直接从文本中提取计数或比例。

此仪表盘并非治疗进展报告。它仅显示我们代码和所选模型生成的结果。

## 连接流水线

接下来,我们将使用 Python 类将项目不同部分连接起来。这为我们提供了一个统一入口,用于分析单个笔记或多个笔记。

在 analyzer.py 中:

from src.preprocessor import preprocess_note, extract_linguistic_features from src.sentiment import analyze_sentiment from src.emotions import detect_emotions from src.tracker import build_session_timeline, describe_sentiment_shift

class TherapyNoteAnalyzer: def analyze_session(self, note_data: dict) -> dict: required = {"session", "client_id", "note"} missing = required - note_data.keys() if missing: raise ValueError(f"Missing required fields: {sorted(missing)}")

processed = preprocess_note(note_data["note"]) sentiment = analyze_sentiment(processed["sentences"]) emotions = detect_emotions(processed["sentences"]) linguistic = extract_linguistic_features(note_data["note"])

return { "session": note_data["session"], "client_id": note_data["client_id"], "sentence_count": processed["sentence_count"], "sentiment": sentiment, "emotions": emotions, "linguistic_features": linguistic, "entity_candidates": processed["entities"] }

def analyze_all(self, notes: list[dict]) -> dict: if not notes: timeline = build_session_timeline([]) return { "client_id": None, "session_results": [], "timeline": timeline, "sentiment_comparison": describe_sentiment_shift(timeline) }

code

client_ids = {item.get("client_id") for item in notes}
        if len(client_ids) != 1:
            raise ValueError(
                "This example expects notes for one synthetic client at a time"
            )

        results = [self.analyze_session(item) for item in notes]
        timeline = build_session_timeline(results)
        return {
            "client_id": next(iter(client_ids)),
            "session_results": results,
            "timeline": timeline,
            "sentiment_comparison": describe_sentiment_shift(timeline)
        }

最后,在 main.py 中:

code
import json
from pathlib import Path
from analyzer import TherapyNoteAnalyzer
from src.visualizer import plot_dashboard

def main():
    with Path("data/synthetic_notes.json").open(encoding="utf-8") as file:
        notes = json.load(file)

    results = TherapyNoteAnalyzer().analyze_all(notes)
    print(results["timeline"].to_string(index=False))
    print("\nDescriptive comparison:", results["sentiment_comparison"])

    output = plot_dashboard(results["timeline"])
    print(f"\nSaved dashboard to {output}")
    print("Reminder: these model outputs are exploratory, not clinical assessments.")

if __name__ == "__main__":
    main()

从项目根目录运行:

code
python main.py

首次运行脚本时,它会下载两个 Hugging Face 模型。然后会打印会话结果的表格,并在 images 文件夹中保存仪表板图像。

结果可能因模型版本和运行方式而异。始终检查自己运行的结果。描述模型预测的内容,而不是说会话“显示”或“揭示”了什么。模型预测不能证明实际发生了什么。

测试项目

测试有助于验证我们的函数是否能处理正常输入和异常情况,例如空文本。通过这些测试并不能证明模型在临床环境中的准确性或实用性。

对于情感和情绪测试,我们将使用返回预设结果的虚拟分类器。这使测试保持快速,并且无需下载模型文件。

一个简化的情感测试如下所示:

code
from src.sentiment import analyze_sentiment

class FakeSentiment:
    def __call__(self, texts, **kwargs):
        return [
            [
                {"label": "POSITIVE", "score": 0.8},
                {"label": "NEGATIVE", "score": 0.2}
            ],
            [
                {"label": "POSITIVE", "score": 0.1},
                {"label": "NEGATIVE", "score": 0.9}
            ]
        ][:len(texts)]

def test_sentiment_score_is_positive_minus_negative():
    result = analyze_sentiment(
        ["Good sentence.", "Bad sentence."],
        classifier=FakeSentiment()
    )
    assert result["sentence_results"][0]["signed_score"] == 0.6
    assert result["sentence_results"][1]["signed_score"] == -0.8

FakeSentiment 可以作为真实模型的直接替代品,因为它定义了 __call__ 方法。当 Python 看到 model(clean, ...) 时,它会调用 model.__call__(clean, ...),因此任何包含该方法的对象都表现得像可调用对象。FakeSentiment.__call__ 无论输入文本如何,都会返回固定分数列表,这意味着测试可以检查计算逻辑而无需下载模型。

[:len(texts)] 将返回值截断为与输入句子数量匹配的长度。这可以防止虚假分类器返回比输入更多的结果,从而避免 analyze_sentiment 中的 zip() 函数出现异常行为。

将 classifier=FakeSentiment() 传递给 analyze_sentiment 会覆盖该调用中的 get_pipeline()。这种模式称为依赖注入:函数从外部接收其依赖项,而不是在内部创建,这使得函数更易于测试和复用。

完整项目包含对空输入、句子分割、词处理、情感评分计算、情绪评分汇总、会话排序、空时间线以及检查必填输入字段是否存在的测试。

从项目根目录运行测试套件:

code
python -m pytest -q

项目存档包含 15 个测试,项目检查时所有 15 个测试均通过。部分测试使用虚构的模型结果,其他测试使用小型 spaCy 配置来验证特定文本处理步骤。这些测试不会评估模型准确性、确认情绪标签是否正确,或展示模型在真实治疗笔记上的表现。

限制与伦理考量

由于本项目使用与治疗相关的文本,我们需要仔细考虑隐私问题、模型的局限性以及语言模式与专业临床评估之间的差异。

通用领域模型不是临床模型

DistilBERT 模型是在 SST-2 上训练的,而不是在治疗笔记上训练的。DistilRoBERTa 模型是在多种通用英语文本上训练的。除非使用合适的数据和明确的标签进行单独测试,否则我们不知道这两个模型在临床笔记上的表现如何。这些模型可能在处理正式写作、以英语为第二语言者的写作以及不同文化表达痛苦的方式时表现不佳。它们的训练数据并未设计用于涵盖所有这些情况。

情感不等于治疗进展

积极的句子并不能证明客户正在好转。消极的句子也不能证明治疗失败。笔记中可能包含治疗师的观点、客户的原话、困难事件或这些内容的混合。模型可能无法区分这些情况。

语言特征不等于心理诊断

代词数量和模糊表达是文本中简单的特征。这些数量的变化并不能证明客户正在退缩、回避话题、失去信任或与治疗师存在矛盾。我们从该项目的早期版本中移除了破裂评分,因为其评分规则和警报级别尚未经过临床使用的测试或批准。

隐私要求取决于司法管辖区

在美国,HIPAA 适用于某些医疗保健组织及其商业合作伙伴。其他国家有自己的数据保护和医疗隐私法律。在使用真实记录之前,组织必须检查适用的法律、自身的政策、使用数据的法律理由、任何必要的同意、涉及的服务和供应商、安全措施以及数据将保存多长时间。本教程不能替代这些审查。即使 HIPAA 不适用于您所在的地区,这并不意味着处理真实治疗笔记是安全或道德的。

人工监督与透明度

该项目并非用于临床决策,也不应作为临床决策的基础。任何用于实际医疗工作的自然语言处理(NLP)工具都需要针对特定场景进行测试,同时需要经过隐私和偏见审查、清晰的文档说明,并由合格的专业人士进行监督。使用个人信息的相关方应按照相关法规的要求被告知相关信息。

结论与进一步学习

在本项目中,我们使用spaCy、Hugging Face Transformers、pandas和Matplotlib构建了一个自然语言处理工作流程。通过虚构的治疗笔记,我们展示了如何将文本拆分为句子、进行情感和情绪分类、统计语言特征、比较会话内容、创建图表以及测试代码。

自然语言处理可以帮助我们将大量书面文本转化为可组织和探索的数据。但结果存在局限性,尤其是当我们使用通用模型处理未经过训练或测试的敏感类型文本时。

如果你想在此项目基础上进行扩展,这里有几个建议:

  • 尝试不同的情感分析模型并比较它们的预测结果,注意它们的共识和分歧点。
  • 在声称模型性能之前,创建包含人工验证标签的数据集,并获得使用该数据集的适当伦理批准。
  • 如果有正确的标签可供比较,使用精确率、召回率、F1分数和混淆矩阵等指标评估模型结果。
  • 探索临床自然语言处理工具如scispaCy。请记住,即使针对医疗文本设计的工具仍需针对你希望使用的任务进行测试。
  • 构建一个Streamlit应用,仅允许用户使用虚构示例尝试本项目。

如需进一步学习,可以阅读spaCy文档、DistilBERT情感分析模型卡片和DistilRoBERTa情绪模型卡片。你也可以阅读Edward S. Bordin于1979年发表的论文《Psychoanalytic Concept of the Working Alliance的普适性》,了解治疗师与来访者之间工作关系的背景知识。

自然语言处理可以帮助我们研究大量文本。但负责任地使用它意味着理解数据、知道模型被训练用于什么任务,并明确其结果无法告诉我们什么。

如果你想进一步探索该项目,可以查看GitHub仓库。我在其中包含了代码和项目结构,你可以看到所有内容是如何运作的。如果你对Python和自然语言处理在医疗、健康科技、临床自然语言处理和人工智能等领域的应用感兴趣,这也是一个不错的起点。这个领域仍有大量值得探索的内容,希望该项目能为你提供一些可以借鉴的思路。

参考文献

  • Bordin, E. S. (1979). The generalizability of the psychoanalytic concept of the working alliance. *Psychotherapy: Theory, Research & Practice*, 16(3), 252–260. https://doi.org/10.1037/h0085885
  • Hartmann, J. (2022). Emotion English DistilRoBERTa-base. Hugging Face Model Hub.
  • Hugging Face. (n.d.). DistilBERT base uncased fine-tuned on SST-2. Hugging Face Model Hub.
  • Hugging Face. (n.d.). Transformers documentation. https://huggingface.co/docs/transformers .
  • Matplotlib Development Team. (n.d.). Matplotlib documentation. https://matplotlib.org/stable/ .
  • pandas. (n.d.). pandas documentation. https://pandas.pydata.org/docs/ .
  • pytest Development Team. (n.d.). pytest documentation. https://docs.pytest.org/ .
  • Sanh, V., Debut, L., Chaumond, J., & Wolf, T. (2019). DistilBERT, a distilled version of BERT: Smaller, faster, cheaper and lighter . arXiv:1910.01108 .
  • spaCy. (n.d.). Usage documentation: Language processing pipelines . https://spacy.io/usage/processing-pipelines .

合作伙伴推荐课程(侧边栏,第1部分共7部分)

(在新标签页中打开)

广告

  • Udemy NLP - 使用Python进行自然语言处理 Jose Portilla 4.5(满分5星)(19,783人评分)来自19,783人评分 11小时25分钟 中级 证书 查看课程(在新标签页中打开)
  • Coursera 自然语言处理与分类及向量空间 Younes Bensouda Mourri, Łukasz Kaiser, 和 Eddy Shyu 4.6(满分5星)(4,647人评分)来自4,647人评分 4周,每周8小时 中级 证书 查看课程(在新标签页中打开)
  • Udemy Python自然语言处理(NLP)大师课 KGP Talkie 4.4(满分5星)(1,159人评分)来自1,159人评分 1天14小时24分钟 初级 证书 查看课程(在新标签页中打开)
  • Udemy Python自然语言处理 Maven Analytics(200万学员)和 Alice Zhao 4.6(满分5星)(1,178人评分)来自1,178人评分 12小时38分钟 初级 证书 查看课程(在新标签页中打开)

Class Central上更多自然语言处理(NLP)课程

→

合作伙伴推荐课程(侧边栏,第2部分共7部分)

  • Udemy Python自然语言处理(NLP)入门 Lazy Programmer Inc. 4.7(满分5星)(12,915人评分)来自12,915人评分 11小时56分钟 初级 证书 查看课程(在新标签页中打开)
  • Coursera 使用PyTorch进行NLP的生成式AI Fateme Akbari, Harish Pant, IBM Skills Network Team, Joseph Santarcangelo, 和 Kang Wang 4.4(满分5星)(2,129人评分)来自2,129人评分 4周,每周10小时 高级 证书 查看课程(在新标签页中打开)
  • Coursera 自然语言处理 Eddy Shyu, Younes Bensouda Mourri, 和 Łukasz Kaiser 4.6(满分5星)(6,212人评分)来自6,212人评分 12周,每周10小时 中级 证书 查看课程(在新标签页中打开)
  • DataCamp Python自然语言处理入门 Katharine Jarmul 4小时 初级 证书 查看课程(在新标签页中打开)

合作伙伴推荐课程(侧边栏,第3部分共7部分)

  • DataCamp Python自然语言处理(NLP) Fouad Trad 4.9(满分5星)(915人评分)来自915人评分 4小时 初级 证书 查看课程(在新标签页中打开)
  • DataCamp Python自然语言处理的特征工程 Rounak Banik 4.9(满分5星)(156人评分)来自156人评分 4小时 中级 证书 查看课程(在新标签页中打开)

合作伙伴推荐课程(侧边栏,第4部分共7部分)

合作伙伴推荐课程(侧边栏,第5部分共7部分)

合作伙伴推荐课程(侧边栏,第6部分共7部分)

合作伙伴推荐课程(侧边栏,第7部分共7部分)

阅读更多文章。

如果这篇文章对你有帮助,请分享它。

免费学习编程。freeCodeCamp的开源课程已帮助超过40,000人成为开发者。立即开始

合作伙伴推荐课程