- 营销
- 会计学
- 经济学
- 心理学
- 社会学
- ...

- 社会
- 企业
- 用户
- 其他

import cntext as ct

# 大邓Mac 96G内存， 12核使用的代码。
w2v = ct.Word2Vec(corpus_file='留言板.txt',
                  vector_size=200,
                  window_size=15,
                  lang='chinese',
                  chunksize=100000,
                  min_count=5)

Mac(Linux) System, Enable Parallel Processing
Cache output/renmin_board_cache.txt Not Found or Empty, Preprocessing Corpus
Reading Preprocessed Corpus from output/renmin_board_cache.txt
Start Training Word2Vec
Word2Vec Training Cost 2692 s.
Output Saved To: output/留言板-Word2Vec.200.15.bin

ct.evaluate_similarity(w2v)

近义测试: similarity.txt
/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/cntext/model/evaluate_data/similarity.txt

评估结果：
+----------+------------+----------------------------+
| 发现词语 | 未发现词语 | Spearman's Rank Coeficient |
+----------+------------+----------------------------+
|   426    |    111     |            0.45            |
+----------+------------+----------------------------+

ct.evaluate_analogy(wv)

类比测试: analogy.txt
/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/cntext/model/evaluate_data/analogy.txt
Processing Analogy Test: 100%|██████████████| 1198/1198 [00:11<00:00, 99.91it/s]

评估结果：
+--------------------+----------+------------+------------+----------+
|      Category      | 发现词语 | 未发现词语 | 准确率 (%) | 平均排名 |
+--------------------+----------+------------+------------+----------+
| CapitalOfCountries |   238    |    439     |   19.33    |   2.74   |
|   CityInProvince   |   175    |     0      |   100.00   |   1.01   |
| FamilyRelationship |   272    |     0      |   61.40    |   1.96   |
|   SocialScience    |    10    |     60     |   20.00    |   1.50   |
+--------------------+----------+------------+------------+----------+

import cntext ct

w2v = ct.load_w2v('output/留言板-Word2Vec.200.15.bin')
print('维度数:', w2v.vector_size)
print('词汇量: ', len(w2v))
w2v

Loading output/留言板-Word2Vec.200.15.bin...
维度数: 200
词汇量:  1050245
<gensim.models.keyedvectors.KeyedVectors at 0x328d737a0>

# 词表带顺序的
list(w2v.index_to_key)[:20]

['问题',
 '进行',
 '您好',
 '工作',
 '小区',
 '反映',
 '领导',
 '情况',
 '相关',
 '留言',
 '没有',
 '感谢您',
 '网友',
 '业主',
 '办理',
 '公司',
 '建设',
 '回复',
 '支持',
 '部门']

w2v.key_to_index

{'问题': 0,
 '进行': 1,
 '您好': 2,
 '工作': 3,
 '小区': 4,
 '反映': 5,
 '领导': 6,
 ...
  '连续': 995,
 '稳定': 996,
 '市住建局': 997,
 '降低': 998,
 '会同': 999,
 ...}

# w2v['问题']
w2v.get_vector('问题')

array([-6.2813835 ,  1.5916584 , -0.48086444, -2.6446412 , 10.031776  ,
       -0.11915778, -5.039283  , -2.1107564 ,  1.1351422 , -2.881387  ,
        4.2890835 , -1.1337206 ,  3.7850847 , -3.640467  , -0.96282107,
        ...
        ...
        1.1314462 , -2.5386178 , -2.3993561 , -2.0407596 ,  0.95457   ,
        3.03732   , -2.033116  , -0.20390491,  3.5368073 ,  6.5452943 ,
        2.1186016 ,  0.79572505,  2.5855987 ,  0.88565165, -1.812104  ],
      dtype=float32)

word = '这是一个不存在的词'
w2v.get_vector(word)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[130], line 2
      1 word = '这是一个不存在的词'
----> 2 w2v.wv.get_vector(word)

File /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/gensim/models/keyedvectors.py:446, in KeyedVectors.get_vector(self, key, norm)
    422 def get_vector(self, key, norm=False):
    423     """Get the key's vector, as a 1D numpy array.
    424
    425     Parameters
   (...)
    444
    445     """
--> 446     index = self.get_index(key)
    447     if norm:
    448         self.fill_norms()

File /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/gensim/models/keyedvectors.py:420, in KeyedVectors.get_index(self, key, default)
    418     return default
    419 else:
--> 420     raise KeyError(f"Key '{key}' not present")

KeyError: "Key '这是一个不存在的词' not present"

w2v.similar_by_word('问题', topn=10)

[('情况', 0.6178732514381409),
 ('现象', 0.5385990142822266),
 ('此类情况', 0.418301522731781),
 ('留言', 0.4179410934448242),
 ('一事', 0.40703579783439636),
 ('事项', 0.39551448822021484),
 ('事情', 0.3860214948654175),
 ('情形', 0.38478103280067444),
 ('事件', 0.36725184321403503),
 ('现像', 0.3665226995944977)]

question_vector = w2v.get_vector('问题')
w2v.similar_by_word(question_vector, topn=10)

[('问题', 1.0),
 ('情况', 0.6178732514381409),
 ('现象', 0.5385990142822266),
 ('此类情况', 0.4183014929294586),
 ('留言', 0.4179410934448242),
 ('一事', 0.40703579783439636),
 ('事项', 0.39551448822021484),
 ('事情', 0.3860214948654175),
 ('情形', 0.38478103280067444),
 ('事件', 0.36725184321403503)]

eco_vector = ct.semantic_centroid(wv=w2v,
                                  words=['经济', '建设', '发展'])


# 寻找 eco_vector 语义最相似的10个词
w2v.similar_by_vector(eco_vector, topn=10)

[('发展', 0.8317984938621521),
 ('建设', 0.7508440613746643),
 ('经济', 0.6406075954437256),
 ('经济社会发展', 0.6385446786880493),
 ('发展壮大', 0.6317417621612549),
 ('化发展', 0.5961641073226929),
 ('大力发展', 0.585274338722229),
 ('经济腾飞', 0.5823679566383362),
 ('产业', 0.5820372700691223),
 ('高质量发展', 0.5803337097167969)]

import cntext as ct

# 数值越大，表示越接近于c_words2，越寒冷。
ct.sematic_projection(wv=w2v,
                     words=['杭州', '哈尔滨', '广州', '潍坊'],
                     poswords=['寒冷', '冰雪'],
                     negwords=['炎热', '酷暑'],
                     )

[('杭州', -2.52), ('广州', -2.06), ('潍坊', 2.18), ('哈尔滨', 2.78)]

- 尺寸(大, 小)
- 湿度(干燥,潮湿)
- 财富(富裕, 贫穷)
- 性别(男, 女)
- 等

cd desktop
pip install cntext --upgrade

%%time
from openai import OpenAI
api_key= '你自己的api_key'

client = OpenAI(
    # 如何获取API Key：https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key
    api_key=api_key, 
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)


completion = client.chat.completions.create(
    # 模型列表：https://help.aliyun.com/zh/model-studio/getting-started/models
    model="qwen-plus",  
    messages=[
        {'role': 'system', 'content': '你是文本编码的专家, 现在需要你将收到的文本编码情感值，情感值范围为-1.0~1.0，-1.0表示负面情感，1.0表示正面情感，0.0表示中性情感。结果返回JSON格式，格式为{"score": 0.0}'},
        {'role': 'user', 'content': '今天很开心啊， 我很喜欢这个国家'}
    ]
)
print(completion.choices[0].message.content)

{"score": 0.8}
CPU times: user 31.8 ms, sys: 5.82 ms, total: 37.6 ms
Wall time: 554 ms

- api-key https://bailian.console.aliyun.com/?tab=model#/api-key
- 账单详情 https://billing-cost.console.aliyun.com/finance/expense-report/expense-detail-by-instance
- 充值 https://billing-cost.console.aliyun.com/fortune/fund-management/recharge
- 模型列表 https://bailian.console.aliyun.com/?tab=model#/model-market

ct.llm.tasks_list()

['sentiment',
 'emotion',
 'classify',
 'intent',
 'keywords',
 'entities',
 'summarize',
 'rewrite',
 'quality',
 'similarity']

ct.llm.tasks_get('sentiment')

{
  "prompt": "分析评论的情感倾向：返回情感类别 label（pos 表示正面，neg 表示负面，neutral 表示中性）和情感分值 score（取值范围 -1~1，负数为负面）。结果返回JSON格式，格式为{'label': 'pos', 'score': 0.5}",
  "output_format": {"label": "str", "score": "float"}
}

%%time
%%time
import cntext as ct

PROMPT = '''
请从以下三个维度对外卖评论进行分析，每个维度打分范围为 0.0 ~ 1.0：
- 口味（taste）：食物的味道、质量如何。
- 速度（speed）：配送是否及时，出餐快不快。
- 服务（service）：骑手态度、商家沟通、售后等服务体验。

请返回 JSON 格式结果，形如：
{"taste": 0.8, "speed": 0.5, "service": 0.9}
'''

OUTPUT = {'taste': "float", 'speed': "float", 'service': "float"}


score = ct.llm(text="服务很棒",
               prompt=PROMPT ,
               output_format=OUTPUT,
               base_url="https://dashscope.aliyuncs.com/compatible-mode/v1", #阿里云百炼base_url
               api_key="你自己的api_key", #更改自己的阿里云百炼的api_key
               model_name = 'qwen-plus')

score

CPU times: user 41.1 ms, sys: 4.74 ms, total: 45.8 ms
Wall time: 1.26 s

{'taste': 0.0, 'speed': 0.0, 'service': 1.0}

import pandas as pd

#构造实验数据， 或者直接读取data.csv(含text字段)

texts = [
    "这家的红烧肉简直入口即化，米饭香喷喷的，就是外卖盒没盖紧，汤洒了一半，心痛！",
    "从下单到敲门只用了18分钟，骑手小哥飞毛腿啊！不过面有点坨了，汤也不够热。",
    "连续下雨天都点它家，每次送来的饭都是热的，还贴心地放了暖宝宝，服务太暖了，菜也好吃！",
    "等了快一个小时，客服说骑手摔了，挺担心的，但最后饭送来时都凉透了，味道还行，就是体验差。",
    "螺蛳粉味道正宗，酸笋够味，还多给了一份炸蛋！就是包装没封好，电梯里一股味儿，社死现场……",
    "披萨送到时歪了，芝士都滑到一边，颜值崩塌！但味道确实香，骑手态度也好，下次希望改进包装。",
    "深夜加班点的馄饨，没想到25分钟就到了，感动哭了！热汤下肚瞬间回血，五星好评送温暖。",
    "咖喱鸡里的土豆没煮熟，硬的！反馈给商家，人家说‘下次注意’就完了？这服务也太敷衍了吧。",
    "味道普普通通，不难吃也不惊艳，但配送准时，包装严实，骑手还发消息说放门口了，很省心。",
    "生日点的蛋糕，商家写了祝福语还送了小蜡烛，仪式感拉满！就是配送稍慢，路上奶油有点化了。"
]

df = pd.DataFrame({'text': texts})
#df = pd.read_csv('data.csv')
df

%%time
import cntext as ct

# 定义提示词：要求模型从三个维度打分
PROMPT = '''
请从以下三个维度对外卖评论进行分析，每个维度打分范围为 0.0 ~ 1.0：
- 口味（taste）：食物的味道、质量如何。
- 速度（speed）：配送是否及时，出餐快不快。
- 服务（service）：骑手态度、商家沟通、售后等服务体验。

请返回 JSON 格式结果，形如：
{"taste": 0.8, "speed": 0.5, "service": 0.9}
'''

# 定义期望的输出格式
OUTPUT = {'taste': "float", 'speed': "float", 'service': "float"}

result_df = ct.llm(text=df['text'].tolist(),   #传入文本列表
                   prompt=PROMPT ,
                   output_format=OUTPUT,
                   base_url="https://dashscope.aliyuncs.com/compatible-mode/v1", #阿里云百炼base_url
                   api_key="你自己的api_key", #更改自己的阿里云百炼的api_key
                   model_name = 'qwen-plus', 
                   #rate_limit参数， 控制访问速度。注意整数和浮点数含义不同。 整数是一分钟访问次数， 浮点数是一秒钟访问次数。
                   #rate_limit=10.0,  #控制速度，一秒10次请求。
                   return_df=True) #结果返回dataframe

#结果中加入原始数据text字段
#注意，一定要有 .tolist()
result_df['text'] = df['text'].tolist()

#保存结果。
result_df.to_csv('result.csv', index=False)
result_df

CPU times: user 95.1 ms, sys: 20.3 ms, total: 115 ms
Wall time: 2.69 s

%%time
result_df = ct.llm(text=df['text'].tolist()*100,   #传入1000条文本(重复100次的列表)
                   prompt=PROMPT ,
                   output_format=OUTPUT,
                   base_url="https://dashscope.aliyuncs.com/compatible-mode/v1", #阿里云百炼base_url
                   api_key="你自己的api_key", #更改自己的阿里云百炼的api_key
                   model_name = 'qwen-plus', 
                   #rate_limit参数， 控制访问速度。注意整数和浮点数含义不同。 整数是一分钟访问次数， 浮点数是一秒钟访问次数。
                   #rate_limit=10.0,  #控制速度，一秒10次请求。
                   return_df=True) #结果返回dataframe

CPU times: user 6.01 s, sys: 1.18 s, total: 7.19 s
Wall time: 20.9 s

%%time
import cntext as ct
import pandas as pd
import time


#读取提示工程

PROMPT = '你设计的PROMPT'
OUTPUT_FORMAT = '你设计的output_format'
BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1" #选择服务器，这里是阿里云百炼的base_url
API_KEY = '你的api_key'  #你的阿里云百炼的api_key
MAX_RETRY = 3 #重复次数(编码失败后的异常处理)
TEMPERATURE = 0 #数字越小，回答越靠谱(随机性小)。
MODEL = 'qwen-plus' #选择兼顾质量、速度的模型
start_time = time.time()
print(f"\n🚀 开始处理模型: {model}")


#每批次100条。使用chunksize后，可以不用设置rate_limit。
chunk_dfs = pd.read_csv('data.csv', chunksize=100)
for idx, chunk_df in enumerate(chunk_dfs):
    batch_texts = chunk_df['text'].tolist()
    batch_df = ct.llm(text = batch_texts, 
                      prompt = PROMPT, 
                      output_format = OUTPUT_FORMAT, 
                      base_url = BASE_URL, 
                      api_key = API_KEY, 
                      model_name = MODEL, 
                      temperature = TEMPERATURE, 
                      max_retries = MAX_RETRY, 
                      return_df = True, 
                      verbose= True)
    #保存原始信息reviewid、rating
    batch_df['reviewid'] = chunk_df['reviewid'].tolist()
    batch_df['rating'] = chunk_df['rating'].tolist()
    batch_df['text'] = chunk_df['text'].tolist()

    #分批次存入新的csv
    if idx==0:
        header=True
        mode='w'
    else:
        header=False
        mode = 'a'
    batch_df.to_csv(f'{MODEL}-result.csv', index=False, mode=mode, header=header)
        
now_time = time.time()
duration = round((now_time-start_time)/60, 2)
print(f"✅ {MODEL} 处理完成，耗时 {duration:.2f} 分钟")

🚀 开始处理模型: qwen-flash
🚀 开始处理模型: qwen-flash
✅ qwen-flash 处理完成，耗时 13.72 分钟

🚀 开始处理模型: qwen-turbo
✅ qwen-turbo 处理完成，耗时 17.23 分钟

🚀 开始处理模型: qwen-plus
✅ qwen-plus 处理完成，耗时 34.29 分钟

🚀 开始处理模型: qwen-max
✅ qwen-plus 处理完成，耗时 48.79 分钟

cd desktop
pip install cntext --upgrade

lms get qwen/qwen3-4b

   🡇 To download: model qwen/qwen3-4b - 170.89 KB
   └─ 🡇 To download: Qwen3 4B 4BIT [MLX] - 2.28 GB

About to download 2.28 GB.
Continue? (Y/N): Y
⠦ [▏                     ] 0.00% |  707 B / 2.28 GB | 837.6777251184834 B/s | ETA 755:46:24        ⠦ [▏                     ] 0.00% |  707 B / 2.28 GB |                 0 B/s | ETA Infinity:NaN:NaN ⠦ [▏                     ] 0.00% |  707 B / 2.28 GB |                 0 B/s | ETA Infinity:NaN:NaN 
⠇ [██████████████████████] 99.87% |   2.28 GB / 2.28 GB |             7.31 MB/s | ETA 00:00        ⠏ [██████████████████████] 99.87% |   2.28 GB / 2.28 GB |             7.31 MB/s | ETA 00:00        Finalizing download...
Download completed.

lms ls

You have 5 models, taking up 26.42 GB of disk space.

LLM               PARAMS    ARCH     SIZE                 
qwen/qwen3-4b               qwen3    2.28 GB              
qwen3-1.7b-mlx              qwen3    984.01 MB            
qwen3-32b-mlx               qwen3    18.45 GB             
qwen3-8b-mlx                qwen3    4.62 GB      ✓ LOADED

EMBEDDING                               PARAMS    ARCH          SIZE        
text-embedding-nomic-embed-text-v1.5              Nomic BERT    84.11 MB  

lms server start

Success! Server is now running on port 1234

%%time
import cntext as ct

texts = ["服务很棒！", "服务一般！", "服务很差！"]
for text in texts:
    score = ct.llm(text, 
                   task="sentiment", 
                   backend="lmstudio",  
                   model_name="qwen/qwen3-4b")

    print(text, score)

[cntext2x] ✅ 连接模型服务: http://localhost:1234/v1

服务很棒！ {'label': 'pos', 'score': 0.9}
服务一般！ {'label': 'neutral', 'score': 0.0}
服务很差！ {'label': 'neg', 'score': -0.95}

CPU times: user 110 ms, sys: 8.3 ms, total: 119 ms
Wall time: 9.14 s

ct.llm.tasks_list()

['sentiment',
 'emotion',
 'classify',
 'intent',
 'keywords',
 'entities',
 'summarize',
 'rewrite',
 'quality',
 'similarity']

ct.llm.tasks_get('emotion')

{'prompt': '识别文本中的主要情绪类型：从 [开心, 愤怒, 悲伤, 惊讶, 厌恶, 恐惧, 中性] 中选择最匹配的一项，返回情绪类型 emotion 和置信度 confidence（0~1）',
 'output_format': {'emotion': 'str', 'confidence': 'float'}}

%%time
import cntext as ct
PROMPT = '从口味taste、速度speed、服务service三个维度， 对外卖评论内容进行文本分析， 分别返回不同维度的分值(分值范围-1.0 ~ 1.0)'
OUTPUT = {'taste': float, 'speed': float, 'service': float}

texts = ["服务很棒！", "服务一般！", "服务很差！"]
for text in texts:
    score = ct.llm(text="服务很棒",
           prompt=PROMPT ,
           output_format=OUTPUT,
           backend="lmstudio",  
           model_name="qwen/qwen3-4b")
    score['text'] = text
    print(score)

{'taste': 0.0, 'speed': 0.0, 'service': 1.0, 'text': '服务很棒！'}
{'taste': 0.0, 'speed': 0.0, 'service': 1.0, 'text': '服务一般！'}
{'taste': 0.0, 'speed': 0.0, 'service': 1.0, 'text': '服务很差！'}
CPU times: user 114 ms, sys: 8.12 ms, total: 122 ms
Wall time: 8.79 s

数据集名称: 港股ESG报告数据集
语言类型: 中文
记录数量: 10350
数据格式: TXT/PDF/CSV
数据体积: 67 G
会计年度: 2012 ~ 2025
发布日期: 2013-03-11 ~ 2025-06-13

声明:   科研用途； 如有问题， 请加微信372335839，备注「姓名-学校-专业」

import pandas as pd

df = pd.read_csv('香港ESG(中文).csv.gz')

df

df['pub_date'] = pd.to_datetime(df['pub_date'])
print('报告发布日期起: ', df['pub_date'].min().strftime('%Y-%m-%d'))
print('报告发布日期止: ', df['pub_date'].max().strftime('%Y-%m-%d'))

报告发布日期起:  2013-03-11
报告发布日期止:  2025-06-13

from plotnine import *
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties

#文泉驿微米黑.ttf位于代码同文件夹
font_prop = FontProperties(fname='文泉驿微米黑.ttf') 

data = df['year'].value_counts().reset_index()
data['year'] = data['year'].astype('category')

(
    ggplot(data,  aes(x='year', y='count'))
    +geom_col()
    +geom_text(aes(label='count'), data=data, va='bottom', color='grey', size=10)
    +theme(figure_size=(10, 6),
           text = element_text(family = font_prop.get_name()), 
           plot_title = element_text(family = font_prop.get_name(), size=14)
          )
    +labs(title='港股中文ESG报告发布数量',
          x = '会计年度', 
          y = '报告数')
)
  

- 管理层讨论与分析txt.zip
- 年报txt.zip
- A01-24.csv.gz
- mda01-24.csv.gz

import pandas as pd

anual_report_df = pd.read_csv('A01-24.csv.gz', compression='gzip')
anual_report_df

len(anual_report_df)

67384

anual_report_df.code.nunique()

5728

mda_df = pd.read_csv('mda01-24.csv.gz', compression='gzip')
mda_df

len(mda_df)

65456

mda_df.code.nunique()

5706

anual_report_df['year'] = anual_report_df['year'].astype(int)
mda_df['year'] = mda_df['year'].astype(int)

print('查看每年mda记录量与年报记录量之比')
for year in range(2001, 2024):
    mda_record_num = len(mda_df[mda_df.year==year])
    anual_report_record_num = len(anual_report_df[anual_report_df.year==year])
    print(f'{year} :', mda_record_num/anual_report_record_num)

查看每年mda记录量与年报记录量之比
2001 : 0.6546700942587832
2002 : 0.8569105691056911
2003 : 0.9287925696594427
2004 : 0.9550398839738942
2005 : 0.9707602339181286
2006 : 0.9745879120879121
2007 : 0.9821882951653944
2008 : 0.9846153846153847
2009 : 0.9859075535512966
2010 : 0.9868544600938968
2011 : 0.9894291754756871
2012 : 0.9891696750902527
2013 : 0.9901458415451321
2014 : 0.9905767056162834
2015 : 0.9922616953921913
2016 : 0.9926681542875359
2017 : 0.9934528892684316
2018 : 0.9892384105960265
2019 : 0.9639227642276422
2020 : 0.9642857142857143
2021 : 0.9310064935064936
2022 : 0.9838492597577388
2023 : 0.9901137847416527
2024 : 1.0

数据名称: 2001-2024年A股上市公司年报&管理层讨论与分析
数据来源: 上海证券交易所、深圳证券交易所
数据格式: csv、txt
公司数量: 5706
MD&A数量: 65519
会计年度: 2001-2024

import pandas as pd

# 读取前5行数据
df = pd.read_csv('mda01-24.csv.gz', compression='gzip', nrows=5)
# gz解压后读取csv
# df = pd.read_csv('mda01-24.csv', nrows=5)

print(len(df))
df.head()

65519

%%time

with open('mda01-24.txt', 'w', encoding='utf-8') as f:
    text = '\n'.join(df['text'].fillna(''))
    f.write(text)

pip3 install cntext --upgrade

%%time
%%time
import cntext as ct

w2v_model = ct.Word2Vec(corpus_file='mda01-24.txt', # 语料文件
                        lang='chinese',             # 中文语料
                        vector_size=200,            # 嵌入的维度数
                        window_size=15)             # 词语上下文的窗口大小



glove_model = ct.GloVe(corpus_file='mda01-24.txt',
                       lang='chinese',
                       vector_size=200,
                       window_size=15)

Mac(Linux) System, Enable Parallel Processing
Cache output/mda01-24_cache.txt Not Found or Empty, Preprocessing Corpus
Processing Corpus: 100%|█| 27404772/27404772 [04:38<00:00, 9
Reading Preprocessed Corpus from output/mda01-24_cache.txt
Start Training Word2Vec
Word2Vec Training Cost 1625 s. 
Output Saved To: output/mda01-24-Word2Vec.200.15.bin


Mac(Linux) System, Enable Parallel Processing
Cache output/mda01-24_cache.txt Found, Skip Preprocessing Corpus
Start Training GloVe
BUILDING VOCABULARY
Using vocabulary of size 536863.

COUNTING COOCCURRENCES
Merging cooccurrence files: processed 353975745 lines.

Using random seed 1746091798
SHUFFLING COOCCURRENCES
Merging temp files: processed 353975745 lines.

TRAINING MODEL
Read 353975745 lines.
Using random seed 1746091864
05/01/25 - 05:32.08PM, iter: 001, cost: 0.115862
05/01/25 - 05:33.04PM, iter: 002, cost: 0.082325
05/01/25 - 05:34.00PM, iter: 003, cost: 0.070848
......
......
05/01/25 - 05:43.23PM, iter: 013, cost: 0.050617
05/01/25 - 05:44.19PM, iter: 014, cost: 0.050079
05/01/25 - 05:45.16PM, iter: 015, cost: 0.049582

GloVe Training Cost 1366 s. 
Output Saved To: output/mda01-24-GloVe.200.15.bin
CPU times: user 1h 28min 19s, sys: 2min 6s, total: 1h 30min 26s
Wall time: 49min 55s

import cntext as ct

print(ct.__version__)

w2v_model   = ct.load_w2v('output/mda01-24-Word2Vec.200.15.bin')
glove_model = ct.load_w2v('output/mda01-24-GloVe.200.15.bin')
w2v_model

2.1.6
Loading output/mda01-24-Word2Vec.200.15.bin...
Loading output/mda01-24-GloVe.200.15.bin...
<gensim.models.keyedvectors.KeyedVectors at 0x633060fe0>

ct.evaluate_similarity(w2v_model)

ct.evaluate_analogy(w2v_model)

近义测试: similarity.txt
/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/cntext/model/evaluate_data/similarity.txt

评估结果：
+----------+------------+----------------------------+
| 发现词语 | 未发现词语 | Spearman's Rank Coeficient |
+----------+------------+----------------------------+
|   425    |    112     |            0.42            |
+----------+------------+----------------------------+


类比测试: analogy.txt
/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/cntext/model/evaluate_data/analogy.txt
Processing Analogy Test: 100%|██████████████| 1198/1198 [00:11<00:00, 99.91it/s]

评估结果：
+--------------------+----------+------------+------------+----------+
|      Category      | 发现词语 | 未发现词语 | 准确率 (%) | 平均排名 |
+--------------------+----------+------------+------------+----------+
| CapitalOfCountries |   455    |    222     |   31.21    |   4.30   |
|   CityInProvince   |   175    |     0      |   97.71    |   1.26   |
| FamilyRelationship |    90    |    182     |   10.00    |   5.89   |
|   SocialScience    |    9     |     61     |   44.44    |   4.50   |
+--------------------+----------+------------+------------+----------+

# 词汇量
print('Word2Vec词汇量: ', len(w2v_model))
print('GloVe词汇量: ', len(glove_model))

print('Word2Vec维度数: ', w2v_model.vector_size)
print('GloVe维度数: ', glove_model.vector_size)

Word2Vec词汇量:  902666
GloVe词汇量:     536864
Word2Vec维度数:  200
GloVe维度数:     200

w2v_model.index_to_key

['公司',
 '适用',
 '情况',
 '项目',
 '产品',
 ...
 '比上',
 '境内',
 '最终',
 '启动',
 ...]

w2v_model.key_to_index

{'公司': 0,
 '适用': 1,
 '情况': 2,
 '项目': 3,
 '产品': 4,
 ......
 '比上': 996,
 '境内': 997,
 '最终': 998,
 '启动': 999,
 ...}

# 查询某词的词向量
w2v_model.get_vector('创新')

array([ 2.2048666 ,  1.7392347 ,  3.8569732 ,  2.181498  ,  0.49182096,
       -2.0054908 ,  0.55133677,  0.97385484,  3.6563325 , -2.1495004 ,
       -4.8804154 ,  2.8375697 ,  2.071349  ,  3.0867636 , -1.3978149 ,
       -0.38058507, -2.379905  , -1.8974878 ,  3.596266  ,  0.44742537,
        ......
        0.13521506, -0.78970003, -0.8154422 ,  1.015166  ,  0.30753416,
       -6.1991196 , -2.2295246 ,  0.797445  , -0.21968505,  1.6549479 ,
       -1.1522037 , -1.5377268 , -3.4639692 , -3.3877385 ,  3.5285642 ,
        0.9497059 , -2.6022844 ,  1.6192312 , -0.39254257, -0.5094183 ],
      dtype=float32)

# 查询多个词的词向量
w2v_model.get_mean_vector(['创新', '研发'])

array([ 0.01322632,  0.01596442,  0.08699574,  0.06786569,  0.00441768,
       -0.04059787,  0.01970061,  0.02050735,  0.04548474, -0.01610814,
       -0.10554063,  0.08021796,  0.10255495,  0.06383747, -0.07158516,
        0.00185056, -0.02854855, -0.09506228,  0.1032301 , -0.05448814,
       ......
       -0.01035122, -0.02931183, -0.03785197,  0.04421834,  0.04357708,
       -0.15989086, -0.05572033,  0.02324059, -0.08414906,  0.02760434,
        0.01254621, -0.02324901, -0.05535778, -0.06064604,  0.0409652 ,
       -0.04119795, -0.08222105,  0.03998823, -0.03626942, -0.01975589],
      dtype=float32)

w2v_model.similar_by_word('创新', topn=10)

[('技术创新', 0.6993309855461121),
 ('不断创新', 0.6758015155792236),
 ('创新型', 0.636788547039032),
 ('创新能力', 0.6053606271743774),
 ('引领', 0.604947566986084),
 ('硬核', 0.5690070986747742),
 ('前沿', 0.5627986788749695),
 ('赋能', 0.5582684278488159),
 ('创新性', 0.5509947538375854),
 ('革新', 0.5494255423545837)]

creativeness_vector = w2v_model.get_vector('创新')
w2v_model.similar_by_vector(creativeness_vector, topn=10)

[('创新', 1.0),
 ('技术创新', 0.6993309855461121),
 ('不断创新', 0.6758015155792236),
 ('创新型', 0.636788547039032),
 ('创新能力', 0.6053606271743774),
 ('引领', 0.6049476265907288),
 ('硬核', 0.5690070986747742),
 ('前沿', 0.5627986788749695),
 ('赋能', 0.5582684278488159),
 ('创新性', 0.5509947538375854)]

AI_vector = w2v_model.get_mean_vector(['ai',  '机器学习', '人工智能', '自然语言处理'])
w2v_model.similar_by_vector(AI_vector, topn=20)

[('ai', 0.9074109792709351),
 ('机器学习', 0.8809980750083923),
 ('自然语言处理', 0.8750396966934204),
 ('ai模型', 0.8575210571289062),
 ('人工智能', 0.8506893515586853),
 ('nlp', 0.8240388035774231),
 ('语言模型', 0.8206671476364136),
 ('模态模型', 0.8144882917404175),
 ('深度学习', 0.7912176847457886),
 ('生成式', 0.7850476503372192),
 ('自然语言', 0.7846022248268127),
 ('llm', 0.7809537649154663),
 ('大模', 0.7670232653617859),
 ('gpt', 0.7638874053955078),
 ('自然语言理解', 0.7441188097000122),
 ('知识图谱', 0.7421959638595581),
 ('生成式ai', 0.7387682199478149),
 ('aigc', 0.7381091117858887),
 ('ai算法', 0.7311530709266663),
 ('语音识别', 0.7257674932479858)]

short_term_vector = w2v_model.get_mean_vector(['尽快',  '年内', '马上'])
w2v_model.similar_by_vector(short_term_vector, topn=20)

[('尽快', 0.7294592261314392),
 ('年内', 0.7279667854309082),
 ('尽早', 0.6742831468582153),
 ('马上', 0.6565427184104919),
 ('即将', 0.61030113697052),
 ('早日', 0.6024956107139587),
 ('争取早日', 0.5442042946815491),
 ('争取尽早', 0.5283723473548889),
 ('抓紧', 0.5254929661750793),
 ('争取', 0.5205905437469482),
 ('短时间', 0.5205082297325134),
 ('争取尽快', 0.5160724520683289),
 ('按期', 0.51212477684021),
 ('后续', 0.5105950236320496),
 ('力争早日', 0.5102716684341431),
 ('提前', 0.5060917139053345),
 ('力争', 0.4955942928791046),
 ('力争尽早', 0.4942554235458374),
 ('最后', 0.4882470369338989),
 ('立即', 0.4858567416667938)]

seeddicts = {
    '短视词': ['抓紧', '立刻', '月底', '年底', '年终', '争取', '力争'],
    '创新词': ['创新', '科技',  '研发',  '技术', '标准'],
    '竞争词': ['竞争', '竞争力'],
    }

ct.expand_dictionary(wv = w2v_model,
                     seeddict = seeddicts,
                     topn=30)

Finish! 短视词 candidates saved to output/短视词.txt
Finish! 创新词 candidates saved to output/创新词.txt
Finish! 竞争词 candidates saved to output/竞争词.txt

- 免费     mda01-24-Word2Vec.200.15.bin   链接: https://pan.baidu.com/s/1Gke4UKOnswpctp8vsZ0koQ?pwd=dpry

- 免费     mda01-24-GloVe.200.15.bin 链接: https://pan.baidu.com/s/1TqoA4TqMAhLzpIp0ZvrQEA?pwd=ajjw

- 更多免费词向量      https://cntext.readthedocs.io/zh-cn/latest/embeddings.html

[0]刘景江,郑畅然,洪永淼.机器学习如何赋能管理学研究？——国内外前沿综述和未来展望[J].管理世界,2023,39(09):191-216.
[1]冉雅璇,李志强,刘佳妮,张逸石.大数据时代下社会科学研究方法的拓展——基于词嵌入技术的文本分析的应用[J].南开管理评论:1-27.
[3]胡楠,薛付婧,王昊楠.管理者短视主义影响企业长期投资吗？——基于文本分析和机器学习[J].管理世界,2021,37(05):139-156+11+19-21.
[4]Kai Li, Feng Mai, Rui Shen, Xinyan Yan, Measuring Corporate Culture Using Machine Learning, *The Review of Financial Studies*,2020

Kozlowski, Austin C., Matt Taddy, and James A. Evans. "The geometry of culture: Analyzing the meanings of class through word embeddings." American Sociological Review 84, no. 5 (2019): 905-949.

#pip3 install cntext --upgrade
import cntext as ct

# 模型下载地址
# https://github.com/hiDaDeng/Chinese-Pretrained-Word-Embeddings
wv = ct.load_w2v('大众点评-评论-GloVe.200.15.bin')

print(f'模型词汇量: {len(wv)}')

模型词汇量: 278565

print(wv['富有'].shape)
print(wv['富有'])

(200,)
array([-0.52744 , -0.108866, -0.119827, -0.644396, -0.342953, -0.503506,
       -0.453796, -0.213651,  0.041335,  0.345231,  0.4752  , -0.026904,
       -0.026971, -0.249429, -1.115758,  0.351041, -0.304552,  0.40272 ,
       ......
       ......
       -0.061966,  0.384454,  0.280508, -0.005171, -0.236791,  0.171627,
        0.151691, -0.295215,  0.233423, -0.146419, -0.210322, -0.338783,
        0.214728, -0.101312,  0.489487, -0.257294,  0.732999,  0.057721,
       -0.286473,  0.394552], dtype=float32)

1. 先找出性别(男、女)的正反义词对儿
2. 分别计算正词的多个向量、负词的多个词向量
3. 求得正均值向量、负均值向量
4. 两者相减、归一化处理后得到性别概念向量。  

# 性别概念轴向量
gender_poss = ['男人', '男性', '丈夫', '他', '爷爷', '祖父', '爸爸', '父亲', '儿子', '兄弟']
gender_negs = ['女人', '女性', '妻子', '她', '奶奶', '祖母', '妈妈', '母亲', '女儿', '姐妹']
gender_vector = ct.generate_concept_axis(wv=wv, 
                                         poswords=gender_poss, 
                                         negwords=gender_negs)


# 财富概念轴向量
affluence_poss =['富有', '有钱', '成功', '发达', '富裕', '优势', '高贵', '高端', '昂贵', '华丽', '精致', '奢侈', '奢华', '充裕', '豪华']
affluence_negs = ['贫穷', '没钱', '失败', '落后', '贫困', '劣势', '卑贱', '低端', '廉价', '朴素', '粗糙', '廉价', '节俭', '匮乏', '破旧']
affluence_vector = ct.generate_concept_axis(wv=wv, 
                                            poswords=affluence_poss, 
                                            negwords=affluence_negs)

# 查看性别概念轴向量
print(gender_vector.shape)
print(gender_vector)

(200,)
[-0.11656909 -0.19618881 -0.01077267  0.04915987  0.00569247  0.05462526
 -0.009799    0.00770712  0.05658354  0.04547084  0.03688154 -0.02133968
 -0.0706896   0.08739712  0.11174724 -0.02057768  0.03183764  0.01165388
  ......
  ......
  0.0101583   0.09426635 -0.09078085 -0.13099451 -0.02234778  0.03765206
  0.1083525   0.07751778  0.04983377  0.03304265 -0.05442946  0.11609897
 -0.10463558  0.00224418  0.00210647 -0.04888193  0.01931083  0.07366373
 -0.01534469  0.06682201]

project_word(wv, a, b, cosine=False)

import cntext as ct

# 获取词向量文件
# https://github.com/hiDaDeng/Chinese-Pretrained-Word-Embeddings
dm_w2v = ct.load_w2v('douban-movie-1000w-Word2Vec.200.15.bin')

b='苗条'
for a in ['性感','美丽', '可爱', '丑陋']:
    proj = ct.project_word(dm_w2v, a, b)
    print(f'[{a}]在[{b}]投影值: {proj}')


b='修长'
for a in ['性感','美丽', '可爱', '丑陋']:
    proj = ct.project_word(dm_w2v, a, b)
    print(f'[{a}]在[{b}]投影值: {proj}')

[性感]在[苗条]投影值: 14.172947883605957
[美丽]在[苗条]投影值: 7.0944623947143555
[可爱]在[苗条]投影值: 6.935092926025391
[丑陋]在[苗条]投影值: 1.235807180404663

[性感]在[修长]投影值: 14.599699974060059
[美丽]在[修长]投影值: 9.360642433166504
[可爱]在[修长]投影值: 4.740543842315674
[丑陋]在[修长]投影值: 4.010622501373291

import cntext as ct
import numpy as np
import matplotlib.pyplot as plt
ct.matplotlib_chinese() # 确保中文显示
plt.style.use('ggplot')  # 使用内置的 ggplot 风格作为基础



# ====== 用户已经完成的数据准备部分（假设已运行）======
wv = ct.load_w2v('大众点评-评论-GloVe.200.15.bin')
gender_vector = ct.generate_concept_axis(wv=wv,
                                          poswords=['男人', '男性', '丈夫', '他', '爷爷', '祖父', '爸爸', '父亲', '儿子', '兄弟'],
                                          negwords=['女人', '女性', '妻子', '她', '奶奶', '祖母', '妈妈', '母亲', '女儿', '姐妹'])
affluence_vector = ct.generate_concept_axis(wv=wv,
                                          poswords=['富有', '有钱', '成功', '发达', '富裕', '优势', '高贵', '高端', '昂贵', '华丽', '精致', '奢侈', '奢华', '充裕', '豪华'],
                                          negwords=['贫穷', '没钱', '失败', '落后', '贫困', '劣势', '卑贱', '低端', '廉价', '朴素', '粗糙', '廉价', '节俭', '匮乏', '破旧'])


words =  ["象棋", "麻将", "围棋", "高尔夫", "武术", "潜水", "书法", "瑜伽", "羽毛球", "马术", "网球", "美妆", "旅行"]
# words =  ["烧烤", "寿司", "牛排", "白酒", "啤酒", "麻辣烫", "汉堡", "煎饼", "包子", "小米粥", "沙拉", "披萨"]
# words =  ["阿玛尼", "coach", "lv", "耐克", "阿迪", "爱马仕", "优衣库", "海澜"]

gender_proj = [ct.project_word(wv=wv, a=word, b=gender_vector) for word in words]
affluence_proj = [ct.project_word(wv=wv, a=word, b=affluence_vector) for word in words]
# ========================================================


# ====== 绘图部分 ======
plt.figure(figsize=(10, 8))
ax = plt.gca() # 获取当前 axes 对象，方便后续操作，特别是设置限制

plt.title('爱好的(性别-财富)刻板印象', pad=15, size=plt.rcParams['axes.titlesize']) # 使用样式中定义的标题字号和 padding

# 设置图表显示范围，略大于数据范围，为轴标签和箭头留出空间
# 先根据数据计算一个合理的范围，再根据需求调整
x_data_min, x_data_max = min(affluence_proj), max(affluence_proj)
y_data_min, y_data_max = min(gender_proj), max(gender_proj)
x_range = x_data_max - x_data_min
y_range = y_data_max - y_data_min

# 可以设置固定范围，或者根据数据范围动态计算
x_lims = (x_data_min - x_range * 0.2, x_data_max + x_range * 0.2)
y_lims = (y_data_min - y_range * 0.2, y_data_max + y_range * 0.2)
# 或者设置一个固定的、对称的范围，例如：
max_abs_x = max(abs(x_data_min), abs(x_data_max))
max_abs_y = max(abs(y_data_min), abs(y_data_max))
plot_lim = max(max_abs_x, max_abs_y) * 1.3 # 确保范围包含所有点并有余量
x_lims = (-plot_lim, plot_lim)
y_lims = (-plot_lim, plot_lim)

ax.set_xlim(x_lims)
ax.set_ylim(y_lims)


# 绘制散点
plt.scatter(affluence_proj, gender_proj, s=150, edgecolor='black', facecolor='lightgray', alpha=0.7) # 调整点大小和颜色，使其清晰

# 绘制中心轴线 (0,0)
plt.axhline(0, color='black', linestyle='-', linewidth=1)
plt.axvline(0, color='black', linestyle='-', linewidth=1)

# 生成网格线 (使用更新后的图表限制)
xx, yy = np.meshgrid(np.linspace(-1.2, 1.2, 10), np.linspace(-1.2, 1.2, 10))
plt.contourf(xx, yy, xx**2 + yy**2, levels=10, cmap='gray_r', alpha=0.1)



# 添加轴端点标签和箭头 (更像图 3 的风格)
arrow_length_x = ax.get_xlim()[1] * 0.95 # 箭头长度为范围的 90%
arrow_length_y = ax.get_ylim()[1] * 0.95
head_width_x = (ax.get_xlim()[1] - ax.get_xlim()[0]) * 0.015 # 箭头头部宽度根据轴范围调整
head_width_y = (ax.get_ylim()[1] - ax.get_ylim()[0]) * 0.015

# Affluence 轴 (X) - 贫穷到富有
plt.arrow(0, 0, arrow_length_x, 0, head_width=head_width_y, head_length=head_width_x, fc='black', ec='black', length_includes_head=True, linewidth=0.8)
plt.arrow(0, 0, -arrow_length_x, 0, head_width=head_width_y, head_length=head_width_x, fc='black', ec='black', length_includes_head=True, linewidth=0.8)

# Gender 轴 (Y) - 女性到男性
plt.arrow(0, 0, 0, arrow_length_y, head_width=head_width_x, head_length=head_width_y, fc='black', ec='black', length_includes_head=True, linewidth=0.8)
plt.arrow(0, 0, 0, -arrow_length_y, head_width=head_width_x, head_length=head_width_y, fc='black', ec='black', length_includes_head=True, linewidth=0.8)


# 添加词语标签
# 遍历数据点和词语
for i, (x, y, word) in enumerate(zip(affluence_proj, gender_proj, words)):
     # 可以尝试 xytext 偏移来控制标签位置
    plt.annotate(word, (x, y), textcoords="offset points", xytext=(5, 5), ha='left', va='bottom', fontsize=plt.rcParams['font.size'])


# 设置轴标题
ax.set_xlabel(f'Affluence ({chr(8592)} 贫穷 | 富有 {chr(8594)})', fontsize=plt.rcParams['axes.labelsize']) # 使用箭头符号更直观
ax.set_ylabel(f'Gender ({chr(8595)} 女性化程度 | 男性化程度 {chr(8593)})', fontsize=plt.rcParams['axes.labelsize']) # 使用箭头符号更直观


# 样式中已经设置了网格，如果想自定义，可以取消注释下一行
#plt.grid(True, linestyle='--', alpha=0.5)

# 确保图表元素的布局紧凑
plt.tight_layout()

# 显示图表
plt.show()

distance = distance(女, 成功) - distance(男, 成功)

- 谁说女子不如男
- 不爱红装爱武装
- 女人撑起半边天
...

#pip3 install cntext --upgrade
import cntext as ct
g_wv = ct.GloVe(corpus_file='语料文件.txt', window_size=15, vector_size=200, lang='chinese')

import pandas as pd

df = pd.read_csv('2013/2013-01.csv', nrows=5)
df.dropna(subset=['文书内容'], inplace=True)
df.head(1)

import os
import pandas as pd
from tqdm import tqdm

# 年份、抽样比例
year_fracs = [
    ('2010', 1), ('2011', 1), ('2012', 1),
    ('2013', 0.2), ('2014', 0.04), ('2015', 0.03),
    ('2016', 0.024), ('2017', 0.022), ('2018', 0.04),
    ('2019', 0.02), ('2020', 0.01), ('2021', 0.03)
    ]



with open('裁判文书.txt', 'w', encoding='utf-8') as corpus_file:
    for year, frac in tqdm(year_fracs):
        csvfs = [f'{year}/{csvf}' for csvf in os.listdir(year) if '.csv' in csvf]
        for csvf in csvfs:
            # 为节省内存开销，
            # 只读 csv 中的 “文书内容” 一个字段，
            # 且设置 chunksize 分批次读取
            chunk_dfs = pd.read_csv(csvf, usecols=['文书内容'], chunksize=10000)
            for chunk_df in chunk_dfs:
                chunk_df.dropna(subset=['文书内容'], inplace=True)
                text = '\n'.join(chunk_df['文书内容'].values)
                corpus_file.write(text)

import cntext as ct

g_wv = ct.GloVe(corpus_file='裁判文书.txt', window_size=15, vector_size=200, lang='chinese')

Mac(Linux) System, Enable Parallel Processing
Cache output/裁判文书_cache.txt Not Found, Preprocessing Corpus
Processing Corpus: 100%|██████████████████| 2502938/2502938 [26:37<00:00, 1566.54it/s]
Reading Preprocessed Corpus from output/裁判文书_cache.txt
Start Training GloVe
GloVe Training Cost 1223s.
Output Saved To: output/裁判文书-Word2Vec.200.15.bin

ct.evaluate_similarity(g_wv)

近义测试: similarity.txt
/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/cntext/model/evaluate_data/similarity.txt
Processing Similarity Test: 100%|███████████| 537/537 [00:00<00:00, 131978.28it/s]

评估结果：
+----------+------------+----------------------------+
| 发现词语 | 未发现词语 | Spearman's Rank Coeficient |
+----------+------------+----------------------------+
|   432    |    105     |            0.37            |
+----------+------------+----------------------------+

ct.evaluate_analogy(g_wv)

类比测试: analogy.txt
/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/cntext/model/evaluate_data/analogy.txt
Processing Analogy Test: 100%|████████████████| 1198/1198 [00:48<00:00, 24.75it/s]

评估结果：
+--------------------+----------+------------+------------+----------+
|      Category      | 发现词语 | 未发现词语 | 准确率 (%) | 平均排名 |
+--------------------+----------+------------+------------+----------+
| CapitalOfCountries |   507    |    170     |    7.69    |   4.38   |
|   CityInProvince   |   175    |     0      |   98.86    |   1.39   |
| FamilyRelationship |   272    |     0      |   73.53    |   1.56   |
|   SocialScience    |    8     |     62     |   25.00    |   7.00   |
+--------------------+----------+------------+------------+----------+

g_wv = ct.load_w2v('output/裁判文书-Word2Vec.200.15.bin')
print(type(g_wv))
print(f'模型词汇量: {len(g_wv.wv)}')

<class 'gensim.models.keyedvectors.KeyedVectors'>
模型词汇量: 2099102

g_wv.index_to_key

['被告',
 '原告',
 '本院',
 '公司',
 '规定',
 '执行',
 ...
]

g_wv.key_to_index

{'被告': 0,
 '原告': 1,
 '本院': 2,
 '公司': 3,
 '规定': 4,
 '执行': 5,
 ...
}

# 查询某词的词向量
g_wv.get_vector('经济')

array([ 2.909250e-01,  9.074450e-01,  5.231860e-01,  5.381490e-01,
       -2.813620e-01,  2.661690e-01,  1.045510e-01, -4.516240e-01,
       -2.186710e-01,  1.867590e-01, -4.870700e-01, -1.803480e-01,
       -6.361140e-01, -8.739630e-01,  3.418450e-01,  7.470900e-02,
        ......
        ......
        2.636230e-01, -2.538920e-01, -2.442900e-02,  5.847510e-01,
        5.135750e-01, -4.009650e-01, -3.629850e-01,  2.332400e-01,
       -3.069630e-01, -4.182810e-01,  3.937240e-01, -8.510000e-01,
        7.894350e-01,  3.969710e-01,  7.895660e-01,  4.881190e-01],
      dtype=float32)

# 查询多个词的词向量
g_wv.get_mean_vector(['经济', '犯罪'])

array([ 0.02923387,  0.04620265,  0.03790346,  0.01160904, -0.02162073,
        0.01537724,  0.02025648, -0.03336571, -0.00447518, -0.00529976,
       -0.02856204,  0.01545951,  0.00780857, -0.05398807,  0.02195465,
        0.03140446, -0.02007412,  0.08278576, -0.027172  , -0.00272319,
       ......
        0.0291778 ,  0.03382879, -0.00913138,  0.04487584,  0.06375133,
        0.032144  , -0.02788475,  0.05068161,  0.0122064 ,  0.01759091,
       -0.05560436,  0.00272704, -0.01176615, -0.08875326,  0.00767812,
       -0.00486504,  0.10119167, -0.01212235,  0.06018812,  0.02998512],
      dtype=float32)

g_wv.similar_by_word('动机', topn=10)

[('主观', 0.6688777804374695),
 ('意图', 0.6248725652694702),
 ('恶性', 0.6005507111549377),
 ('蓄意', 0.5913136005401611),
 ('卑劣', 0.5908187627792358),
 ('作案动机', 0.5703221559524536),
 ('心态', 0.5640602707862854),
 ('故意', 0.5533956289291382),
 ('显而易见', 0.5524264574050903),
 ('恶意', 0.5509642958641052)]

g_wv.similar_by_vector(g_wv.get_vector('动机'), topn=10)

[('动机', 0.9999999403953552),
 ('主观', 0.6688777804374695),
 ('意图', 0.6248724460601807),
 ('恶性', 0.600550651550293),
 ('蓄意', 0.5913134813308716),
 ('卑劣', 0.5908187627792358),
 ('作案动机', 0.5703221559524536),
 ('心态', 0.5640602707862854),
 ('故意', 0.5533955693244934),
 ('显而易见', 0.5524263381958008)]

purpose_vector = g_wv.get_mean_vector(['动机',  '意图', '目的'])
g_wv.similar_by_vector(purpose_vector, topn=20)

[('意图', 0.9032057523727417),
 ('目的', 0.8639562726020813),
 ('动机', 0.8277378678321838),
 ('主观', 0.7455390095710754),
 ('恶意', 0.7291366457939148),
 ('故意', 0.7236210107803345),
 ('客观', 0.7146263122558594),
 ('企图', 0.7049675583839417),
 ('行为', 0.6962229609489441),
 ('掩盖', 0.6917882561683655),
 ('所谓', 0.6809536218643188),
 ('并非', 0.667915403842926),
 ('手段', 0.6663289666175842),
 ('利益', 0.6568542718887329),
 ('这种', 0.6558799743652344),
 ('欺骗', 0.6545097231864929),
 ('违背', 0.6538694500923157),
 ('真相', 0.6527130007743835),
 ('显然', 0.6525647640228271),
 ('实质', 0.6521809101104736)]

- 裁判文书-GloVe.200.15.bin   https://pan.baidu.com/s/1a0Fisvnkl8UaQZrHP7olCQ?pwd=8w49

- 更多词向量模型               https://cntext.readthedocs.io/zh-cn/latest/embeddings.html

import pandas as pd

# 以山东省.csv 为例， 只读第一行(前1行)
df = pd.read_csv('山东省.csv', nrows=5)
df

df.columns

Index(['专利名称', '专利类型', '申请人', '申请人类型', '申请人地址', '申请人国家', '申请人省份', '申请人城市',
       '申请人区县', '申请号', '申请日', '申请年份', '公开公告号', '公开公告日', '公开公告年份', '授权公告号',
       '授权公告日', '授权公告年份', 'IPC分类号', 'IPC主分类号', '发明人', '摘要文本', '主权项内容', '当前权利人',
       '当前专利权人地址', '专利权人类型', '统一社会信用代码', '引证次数', '被引证次数', '自引次数', '他引次数',
       '被自引次数', '被他引次数', '家族引证次数', '家族被引证次数'],
      dtype='object')

5000万专利申请全量数据1985-2025年
  |---中国专利数据库.csv.gz
  |---code.ipynb
  |---province_corpus
     |---安徽省.txt
     |---浙江省.txt
     |---...
  |---year_corpus
     |---2025.txt
     |---2024.txt
     |---...
  |---provin_w2vs
        |---安徽省-Word2Vec.200.15.bin
        |---山东省-Word2Vec.200.15.bin
        |---...
  |---year_w2vs
        |---2025-Word2Vec.200.15.bin
        |---2022-Word2Vec.100.6.bin.syn1neg.npy
        |---2022-Word2Vec.100.6.bin.wv.vectors.npy
        |---...

%%time
import pandas as pd
from pathlib import Path
from tqdm import tqdm

# 读取csv文件， 只读取需要的字段
# 按 100000 行分块读取， 避免内存溢出
chunk_dfs = pd.read_csv('中国专利数据库.csv.gz', 
                 compression='gzip', 
                 usecols = ['申请人省份', '申请日', '专利名称', '摘要文本'],
                 chunksize=100000)

for chunk_df in tqdm(chunk_dfs):
    chunk_df['申请日'] = pd.to_datetime(chunk_df['申请日'])

    # 新建 province_corpus 和 year_corpus文件夹
    province_dir = Path('province_corpus')
    province_dir.mkdir(parents=True, exist_ok=True)
    year_dir = Path('year_corpus')
    year_dir.mkdir(parents=True, exist_ok=True)
    
    # 按省份和年份构造语料
    for date, year_df in chunk_df.groupby(pd.Grouper(key='申请日', freq='YE')):
        print(date.year)
        year_file = year_dir / f"{date.year}.txt"
        with open(year_file, 'a+', encoding='utf-8') as yf:
            y_text_series = year_df['专利名称'].fillna('') + year_df['摘要文本'].fillna('')
            y_text = '\n'.join(y_text_series)
            yf.write(y_text)
    
    for prov, prov_df in chunk_df.groupby('申请人省份'):
        print(prov)
        prov_file = province_dir / f"{prov}.txt"
        with open(prov_file, 'a+', encoding='utf-8') as pf:
            prov_text_series = prov_df['专利名称'].fillna('') + prov_df['摘要文本'].fillna('')
            prov_text = '\n'.join(prov_text_series)
            pf.write(prov_text)

2025
2024
...


上海市
云南省
...
安徽省

CPU times: total: 27min 55s
Wall time: 39min 10s

cd desktop
pip install cntext --upgrade

%%time

import glob
from pathlib import Path
import cntext as ct
import os

# 分年份训练
for year_f in glob.glob('year_corpus/*.txt'):
    # 训练word2vec，自动保存到output文件夹内
    ct.Word2Vec(corpus_file = year_f, 
                vector_size=200, 
                window_size=15, 
                only_binary=True)
# 将output文件夹重命名为year_w2vs
os.rename('output', 'year_w2vs')


# 分省份训练
for prov_f in glob.glob('province_corpus/*.txt'):
    # 训练word2vec，自动保存到output文件夹内
    ct.Word2Vec(corpus_file = prov_f, 
                vector_size=200, 
                window_size=15, 
                only_binary=True) 
# 将output文件夹重命名为province_w2vs
os.rename('output', 'province_w2vs')

Windows System, Unable Parallel Processing
Cache output\1985_cache.txt Not Found or Empty, Preprocessing Corpus
Processing Corpus: 100%|████████████████████████████████████████████████████████| 10009/10009 [00:13<00:00, 734.66it/s]
Reading Preprocessed Corpus from output\1985_cache.txt
Start Training Word2Vec
Word2Vec Training Cost 17 s. 
Output Saved To: output\1985-Word2Vec.200.15.bin

......
......

Windows System, Unable Parallel Processing
Cache output\2025_cache.txt Not Found or Empty, Preprocessing Corpus
Processing Corpus: 100%|████████████████████████████████████████████████████████| 10009/10009 [00:13<00:00, 734.66it/s]
Reading Preprocessed Corpus from output\2025_cache.txt
Start Training Word2Vec
Word2Vec Training Cost 17 s. 
Output Saved To: output\2025-Word2Vec.200.15.bin


Windows System, Unable Parallel Processing
Cache output\上海市_cache.txt Not Found or Empty, Preprocessing Corpus
Processing Corpus: 100%|██████████████████████████████████████████████████| 2456943/2456943 [03:42<00:00, 11048.35it/s]
Reading Preprocessed Corpus from output\上海市_cache.txt
Start Training Word2Vec
Word2Vec Training Cost 1400 s. 
Output Saved To: output\上海市-Word2Vec.200.15.bin
......
......

Windows System, Unable Parallel Processing
Cache output\黑龙江省_cache.txt Not Found or Empty, Preprocessing Corpus
Processing Corpus: 100%|█████████████████████████████████████████████████████| 544329/544329 [01:07<00:00, 8114.12it/s]
Reading Preprocessed Corpus from output\黑龙江省_cache.txt
Start Training Word2Vec
Word2Vec Training Cost 320 s. 
Output Saved To: output\黑龙江省-Word2Vec.200.15.bin


CPU times: total: 21354 s
Wall time: 21758 s

import cntext as ct
import glob
from tqdm import tqdm

# 导入各省份词向量
provin_w2vs_ = []
provin_w2v_fs = glob.glob('province_w2vs/*.bin')
for provin_w2v_f in tqdm(provin_w2v_fs):
    provin_w2v = ct.load_w2v(provin_w2v_f)
    provin_w2vs_.append(provin_w2v)


# 导入各年份词向量
year_w2vs_ = []
year_w2v_fs = glob.glob('year_w2vs/*.bin')
for year_w2v_f in tqdm(year_w2v_fs):
    year_w2v = ct.load_w2v(year_w2v_f)
    year_w2vs_.append(year_w2v)

  3%|██▍                                                                                | 1/34 [00:03<01:57,  3.57s/it]
Loading province_w2vs\上海市-Word2Vec.200.15.bin...
  6%|████▉                                                                              | 2/34 [00:04<01:11,  2.23s/it]
Loading province_w2vs\云南省-Word2Vec.200.15.bin...
......
97%|███████████████████████████████████████████████████████████████████████████████▌  | 33/34 [01:07<00:01,  1.10s/it]
Loading province_w2vs\香港特别行政区-Word2Vec.200.15.bin...
100%|██████████████████████████████████████████████████████████████████████████████████| 34/34 [01:09<00:00,  2.04s/it]
Loading province_w2vs\黑龙江省-Word2Vec.200.15.bin...


  2%|██                                                                                 | 1/41 [00:00<00:05,  7.10it/s]
Loading year_w2vs\1985-Word2Vec.200.15.bin...
Loading year_w2vs\1986-Word2Vec.200.15.bin...
 10%|████████                                                                           | 4/41 [00:00<00:05,  6.80it/s]
 ......
 100%|██████████████████████████████████████████████████████████████████████████████████| 41/41 [01:11<00:00,  1.75s/it]
Loading year_w2vs\2025-Word2Vec.200.15.bin...

from pathlib import Path

print('省份Word2vec词汇量')
for provin_w2v_f, provin_w2v in zip(provin_w2v_fs, provin_w2vs_):
    province = Path(provin_w2v_f).stem.split('-')[0]
    print(f'{province} 词汇量: {len(provin_w2v)}')

省份Word2vec词汇量
上海市 词汇量: 640941
云南省 词汇量: 205193
内蒙古自治区 词汇量: 138507
北京市 词汇量: 783162
台湾省 词汇量: 242630
吉林省 词汇量: 185587
四川省 词汇量: 494241
天津市 词汇量: 373286
宁夏回族自治区 词汇量: 91592
安徽省 词汇量: 540111
山东省 词汇量: 722886
山西省 词汇量: 188013
广东省 词汇量: 1010230
广西壮族自治区 词汇量: 190128
新疆维吾尔自治区 词汇量: 110063
江苏省 词汇量: 983871
江西省 词汇量: 256695
河北省 词汇量: 326042
河南省 词汇量: 415905
浙江省 词汇量: 795041
海南省 词汇量: 74657
湖北省 词汇量: 412827
湖南省 词汇量: 400262
澳门特别行政区 词汇量: 7806
甘肃省 词汇量: 148753
福建省 词汇量: 480456
西藏自治区 词汇量: 23115
贵州省 词汇量: 186345
辽宁省 词汇量: 347563
重庆市 词汇量: 358991
陕西省 词汇量: 381781
青海省 词汇量: 53325
香港特别行政区 词汇量: 71947
黑龙江省 词汇量: 253129

print('年份word2vec词汇量')
for year_w2v_f, year_w2v in zip(year_w2v_fs, year_w2vs_):
    year = Path(year_w2v_f).stem.split('-')[0]
    print(f'{year}: {len(year_w2v.index_to_key)}')

年份word2vec词汇量
1985: 15494
1986: 17945
1987: 23625
1988: 27740
1989: 27394
1990: 32920
1991: 37584
1992: 45393
1993: 48326
1994: 46725
1995: 46138
1996: 50117
1997: 53625
1998: 57187
1999: 65154
2000: 78368
2001: 95927
2002: 123513
2003: 145087
2004: 158694
2005: 185840
2006: 215856
2007: 240167
2008: 279364
2009: 334179
2010: 382888
2011: 449648
2012: 508506
2013: 621644
2014: 625248
2015: 685487
2016: 732443
2017: 760332
2018: 776968
2019: 789104
2020: 817553
2021: 799388
2022: 734045
2023: 596784
2024: 516263
2025: 21230

for provin_w2v_f, provin_w2v in zip(provin_w2v_fs, provin_w2vs_):
    try:
        province = Path(provin_w2v_f).stem.split('-')[0]
        wordweigths = provin_w2v.most_similar(['创新', '新颖'], topn=5)
        words = [w for w,p in wordweigths]
        print(f'{province}: {" ".join(words)}')
    except:
        print(f'{province}: NA')

上海市: 独特 巧妙 创新性 理念 新颖结构合理
云南省: 独特 巧妙 精巧 科学合理 新颖合理
内蒙古自治区: 理念 独特 巧妙 合理使用方便 全新
北京市: 巧妙 独特 全新 借鉴 新颖使用方便
台湾省: 全新 独特 精巧 简洁 巧妙
吉林省: 理念 思路 现代 全新 巧妙
四川省: 巧妙 独特 全新 理念 合理使用方便
天津市: 独特 巧妙 合理使用方便 巧妙使用方便 全新
宁夏回族自治区: 更具 多样 丰富 性价比 市场前景
安徽省: 巧妙 独特 巧妙使用方便 合理 合理结构紧凑
山东省: 巧妙 精巧 新颖结构合理 巧妙结构合理 全新
山西省: 独特 全新 科学 现代 已有
广东省: 巧妙 独特 创新性 合理 精巧
广西壮族自治区: 独特 巧妙 合理使用方便 精巧 合理实用性
新疆维吾尔自治区: 合理使用方便 巧妙 简单合理 科学合理 合理
江苏省: 巧妙 独特 合理 全新 科学
江西省: 独特 科学合理 巧妙 简洁 精巧
河北省: 巧妙 新颖使用方便 精巧 独特 理念
河南省: 巧妙 科学合理 独特 新颖使用方便 巧妙使用方便
浙江省: 独特 巧妙 科学 精巧 合理
海南省: 思路 科学合理 人性化 科学 独特
湖北省: 巧妙 巧妙合理 科学合理 独特 新颖结构合理
湖南省: 巧妙 精巧 独特 新颖独特 巧妙结构合理
澳门特别行政区: 撞击 边坡 溜槽 耐高温 材料制成
甘肃省: 独特 全新 理念 现代 普及
福建省: 巧妙 新颖使用方便 独特 巧妙结构合理 全新
西藏自治区: 既能 十分 疲劳 范围广 更加人性化
贵州省: 巧妙 独特 科学合理 合理使用方便 精巧
辽宁省: 巧妙 巧妙结构合理 新颖结构合理 新颖独特 独创
重庆市: 合理使用方便 科学合理 精巧 全新 新颖使用方便
陕西省: 巧妙 独特 新颖结构合理 合理 合理使用方便
青海省: 突破 织机 现行 经济环保 杆织机
香港特别行政区: 全新 更具 美感 市场 丰富
黑龙江省: 独特 精巧 科学合理 巧妙 构思

for year_w2v_f, year_w2v in zip(year_w2v_fs, year_w2vs_):
    try:
        year = Path(year_w2v_f).stem.split('-')[0]
        wordweigths = year_w2v.most_similar(['创新', '新颖'], topn=5)
        words = [w for w,p in wordweigths]
        print(f'{year}: {" ".join(words)}')
    except:
        print(f'{year}: NA')

1985: 公知 专门 特别适用 提出一种 机器人
1986: 植入 理发 135 婴儿车 街道
1987: 落后 儿童智力开发 低档 胶鞋 指甲
1988: 目前市场 低档 捕鱼 证件 普遍使用
1989: 价廉物美 课堂教学 普及型 大众 得心应手
1990: 单纯 精简 多方面 机等 应用领域
1991: 普及型 前途 大众 现代 现代化
1992: 构思 保留传统 不失为 全新 机之
1993: 完美 现代科技 崭新 式样 边墙
1994: 样式 别致 造型新颖 显得 华贵
1995: 多样 结实耐用 独特 别致 高档
1996: 花样 耐冲击浮标 极其 式样新颖 应用范围
1997: 实用美观 室内外装饰 标准化 多变 形象逼真
1998: 现代 改革 开发 高雅 创造
1999: 现代 市场 越来越 款式 大方
2000: 全新 娱乐性趣味性 多样化 多方面 各种各样
2001: 完美 现代 新颖别致 多样化 体现
2002: 全新 现代 实为 科学 大众
2003: 全新 突破传统 多样化 体现 科学
2004: 全新 科技 现代 市场 科学合理
2005: 创意 理念 全新 科学 现代
2006: 全新 构思 理念 新颖性 独特
2007: 全新 突破传统 巧妙 独特 现代
2008: 独特 巧妙 全新 新颖独特 设计理念
2009: 独特 巧妙 全新 科学 新颖独特
2010: 独特 新颖独特 精巧 巧妙 科学合理
2011: 独特 精巧 新颖独特 科学合理 巧妙
2012: 独特 巧妙 新颖独特 精巧 科学合理
2013: 独特 新颖独特 精巧 科学合理 巧妙
2014: 巧妙 独特 科学合理 巧妙合理 精巧
2015: 巧妙 独特 巧妙合理 新颖结构合理 科学合理
2016: 巧妙 结合现在 巧妙合理 独特 全新
2017: 巧妙 科学合理 独特 科学 合理
2018: 巧妙 独特 合理 科学 全新
2019: 巧妙 独特 合理 全新 精巧
2020: 巧妙 独特 合理 精巧 设计
2021: 巧妙 精巧 合理 新颖结构合理 全新
2022: 巧妙 全新 独特 创新性 精巧
2023: 巧妙 独特 全新 创新性 精巧
2024: 巧妙 创新性 独特 精巧 全新
2025: 相结合 双重 独特 多重 优势

- 免费  专利摘要-Word2Vec.200.15.bin  https://pan.baidu.com/s/1CgBjy96hDKM2GKQY4G6kYA?pwd=ba92

- 免费  province_w2vs                https://pan.baidu.com/s/1eBFTIZcv2DWssLiaRnCqZQ?pwd=ikpu

- 免费  year_w2vs                    https://pan.baidu.com/s/1lrVkML92cVJdHQa1HQyAwA?pwd=4gqa

%%time
from pathlib import Path

df['date'] = pd.to_datetime(df['date'])

# 每5年构造一个语料txt文件
for date, freq_df in df.groupby(pd.Grouper(key='date', freq='5YE')):
    print(date)
    corpus_dir = Path('corpus')
    corpus_dir.mkdir(parents=True, exist_ok=True)
    corpus_file = corpus_dir / f"{date.year}.txt"
    with open(corpus_file, 'w', encoding='utf-8') as f:
        text_series = freq_df['content'].fillna('')
        raw_text = '\n'.join(text_series)
        f.write(raw_text)

1946-12-31 00:00:00
1951-12-31 00:00:00
1956-12-31 00:00:00
1961-12-31 00:00:00
1966-12-31 00:00:00
1971-12-31 00:00:00
1976-12-31 00:00:00
1981-12-31 00:00:00
1986-12-31 00:00:00
1991-12-31 00:00:00
1996-12-31 00:00:00
2001-12-31 00:00:00
2006-12-31 00:00:00
2011-12-31 00:00:00
2016-12-31 00:00:00
2021-12-31 00:00:00
2026-12-31 00:00:00
CPU times: user 2.64 s, sys: 1.54 s, total: 4.18 s
Wall time: 5.29 s

cd desktop
pip3 install cntext --upgrade
``

<br>

### 3.2 开始训练

训练代码比较简单，已经封装到 **cntext*， 只需几行代码即可。且 cntext 对代码进行了优化， 训练速度更快， 内存占用更小。

训练环境 Mac 内存 96G， 大家回去可以试试 16G、32G，应该也能跑通。

```python
%%time
import cntext as ct
import glob


# 获取corpus文件夹内的所有语料txt文件的文件路径
corpus_files = sorted(glob.glob('corpus/*.txt'))
for corpus_file in corpus_files:
    print(corpus_file)
    # 结果自动保存到output文件夹内
    w2v = ct.Word2Vec(corpus_file=corpus_file,
                 vector_size=200,
                 window_size=15,
                 min_count=5)  

Mac(Linux) System, Enable Parallel Processing
Cache output/1946_cache.txt Not Found or Empty, Preprocessing Corpus
Processing Corpus: 100%|███████████████████| 5954/5954 [00:07<00:00, 757.68it/s]
Reading Preprocessed Corpus from output/1946_cache.txt
Start Training Word2Vec
Word2Vec Training Cost 16 s. 
Output Saved To: output/1946-Word2Vec.200.15.bin
......
......
......
corpus/2026.txt
Mac(Linux) System, Enable Parallel Processing
Cache output/2026_cache.txt Not Found or Empty, Preprocessing Corpus
Processing Corpus: 100%|██████████████| 105037/105037 [00:34<00:00, 3075.29it/s]
Reading Preprocessed Corpus from output/2026_cache.txt
Start Training Word2Vec
Word2Vec Training Cost 194. 
Output Saved To: output/2026-Word2Vec.200.15.bin
CPU times: user 2h 38min 4s, sys: 4min 41s, total: 2h 42min 45s
Wall time: 1h 5min 39s

import cntext as ct

mfiles = ['output/1946-Word2Vec.200.15.bin',
          'output/1981-Word2Vec.200.15.bin',
          'output/2001-Word2Vec.200.15.bin',
          'output/2026-Word2Vec.200.15.bin']

for mfile in mfiles:
    w2v_model  = ct.load_w2v(mfile)
    print(mfile)
    word_scores = w2v_model.most_similar(['工业'], topn=20)
    for word, score in word_scores:
        print(word, score)
    print()

output/1946-Word2Vec.200.15.bin
市场 0.9601176381111145
重工业 0.9589242935180664
工业部门 0.9484396576881409
物价 0.9464751482009888
商业 0.9423016309738159
工业原料 0.9378510117530823
焦煤 0.9368941783905029
物价暴涨 0.9348677396774292
第一年 0.9331346154212952
农产品 0.9329909682273865
输入 0.9329512119293213
农业 0.9327669143676758
水平 0.9323830008506775
通货 0.9320995807647705
国民经济 0.9268764853477478
投资 0.9261932373046875
输出 0.9258642792701721
钢铁工厂 0.925421953201294
工业生产 0.9251945614814758
十三亿 0.9251589775085449

Loading output/1981-Word2Vec.200.15.bin...
output/1981-Word2Vec.200.15.bin
工业部门 0.6696006655693054
重工业 0.6490920782089233
建筑业 0.6461381316184998
轻工业 0.6443966627120972
工业生产 0.6364479064941406
机器制造业 0.6220380067825317
化学工业 0.6116607785224915
钢铁工业 0.5941601991653442
加工工业 0.5932750701904297
电子工业 0.5880091190338135
轻纺工业 0.5786471366882324
食品工业 0.5777474045753479
重工业轻工业 0.5734774470329285
民用工业 0.5729294419288635
消费品生产 0.5721379518508911
纺织业 0.56629878282547
农业轻工业 0.5642068982124329
机器制造 0.5622154474258423
制造业 0.5620284676551819
化工 0.5588406324386597

Loading output/2001-Word2Vec.200.15.bin...
output/2001-Word2Vec.200.15.bin
重工业 0.6766582727432251
工业生产 0.6742461323738098
制造业 0.641242504119873
轻工业 0.615958571434021
传统产业 0.6039909720420837
加工工业 0.5936708450317383
机械电子 0.5892737507820129
工业部门 0.5891364216804504
轻工 0.5785651803016663
化学工业 0.5783289670944214
纺织 0.5708677172660828
支柱行业 0.5655868053436279
钢铁工业 0.5648497939109802
化工 0.5617026686668396
机械工业 0.5609593987464905
振兴国防科技 0.5588745474815369
纺织业 0.5520373582839966
工业体系 0.5505329370498657
工业总产值 0.5477191805839539
冶金纺织 0.5463222861289978

Loading output/2026-Word2Vec.200.15.bin...
output/2026-Word2Vec.200.15.bin
制造业 0.6705414056777954
工业生产 0.6067013144493103
智能制造 0.5936543941497803
轻工业 0.5885797142982483
钢铁行业 0.5884692072868347
化工 0.5675483345985413
钢铁企业 0.5637045502662659
工业互联网 0.559167742729187
装备制造业 0.5545477271080017
制造 0.5482359528541565
建筑业 0.5467448234558105
冶金 0.5400071740150452
规模工业 0.5395020246505737
重工业 0.537196695804596
钢铁 0.5245063304901123
工业遗产 0.5208563804626465
钢铁工业 0.5142995715141296
改数 0.512413740158081
纺织业 0.5109716653823853
规上工业 0.5082385540008545

%%time
import cntext as ct
from pathlib import Path
import glob

# 基准模型
base_wv = ct.load_w2v('output/2026-Word2Vec.200.15.bin')

#将其他模型与基准模型对齐
for file in glob.glob('output/*.bin'):
    print(file)
    other_wv = ct.load_w2v(file)
    procrusted_w2v = ct.procrustes_align(base_wv=base_wv,
                                         other_wv=other_wv)
    # win
    #year = file.split('\\')[-1][:4]
    
    # mac
    year = file.split('/')[-1][:4]
    
    output_dir = Path('Aligned_Word2Vec')
    output_dir.mkdir(parents=True, exist_ok=True)
    procrusted_w2v.save_word2vec_format(f'Aligned_Word2Vec/{year}.200.15.bin', binary=True)

Loading output/2026-Word2Vec.200.15.bin...
output/1956-Word2Vec.200.15.bin
Loading output/1956-Word2Vec.200.15.bin...

output/2026-Word2Vec.200.15.bin
Loading output/2026-Word2Vec.200.15.bin...

output/2021-Word2Vec.200.15.bin
Loading output/2021-Word2Vec.200.15.bin...

output/1951-Word2Vec.200.15.bin
Loading output/1951-Word2Vec.200.15.bin...

output/1946-Word2Vec.200.15.bin
Loading output/1946-Word2Vec.200.15.bin...

output/2001-Word2Vec.200.15.bin
Loading output/2001-Word2Vec.200.15.bin...

output/1981-Word2Vec.200.15.bin
Loading output/1981-Word2Vec.200.15.bin...

output/1971-Word2Vec.200.15.bin
Loading output/1971-Word2Vec.200.15.bin...

output/1976-Word2Vec.200.15.bin
Loading output/1976-Word2Vec.200.15.bin...

output/2006-Word2Vec.200.15.bin
Loading output/2006-Word2Vec.200.15.bin...

output/1986-Word2Vec.200.15.bin
Loading output/1986-Word2Vec.200.15.bin...

output/1961-Word2Vec.200.15.bin
Loading output/1961-Word2Vec.200.15.bin...

output/2011-Word2Vec.200.15.bin
Loading output/2011-Word2Vec.200.15.bin...

output/1991-Word2Vec.200.15.bin
Loading output/1991-Word2Vec.200.15.bin...

output/2016-Word2Vec.200.15.bin
Loading output/2016-Word2Vec.200.15.bin...

output/1996-Word2Vec.200.15.bin
Loading output/1996-Word2Vec.200.15.bin...

output/1966-Word2Vec.200.15.bin
Loading output/1966-Word2Vec.200.15.bin...

CPU times: user 1min 8s, sys: 49.7 s, total: 1min 58s
Wall time: 46.3 s

distance = distance(女, 成功) - distance(男, 成功)

import pandas as pd
import glob

gender_suceess_data = []

words = ['成功', '成就', '胜利']
c_words1 = ['女', '女人', '她', '母亲', '女儿', '奶奶']
c_words2 = ['男', '男人', '他', '父亲', '儿子', '爷爷']

# 当前代码所处文件 与 Aligned_Word2Vec 处于同一文件夹内
mfiles = sorted(glob.glob('Aligned_Word2Vec/*.bin'))
for file in mfiles:
    distance = ct.sematic_distance(wv=ct.load_w2v(file),
                                   words=words, 
                                   c_words1=c_words1, 
                                   c_words2=c_words2)
    data = dict()
    data['year'] = file.split('/')[-1][:4]
    data['distance'] = distance
    gender_suceess_data.append(data)
    

gender_success_df = pd.DataFrame(gender_suceess_data)
gender_success_df

import matplotlib.pyplot as plt
import matplotlib_inline
matplotlib_inline.backend_inline.set_matplotlib_formats('png', 'svg')
import warnings
import cntext as ct
import scienceplots
import pandas as pd
import glob
plt.style.use(['science', 'no-latex', 'cjk-sc-font'])
ct.matplotlib_chinese() #为正常显示中文

gender_suceess_data = []
words = ['成功', '成就', '胜利']
c_words1 = ['女', '女人', '她', '母亲', '女儿', '奶奶']
c_words2 = ['男', '男人', '他', '父亲', '儿子', '爷爷']

mfiles = sorted(glob.glob('Aligned_Word2Vec/*.bin'))
for file in mfiles:
    distance = ct.sematic_distance(wv=ct.load_w2v(file),
                                   words=words, 
                                   c_words1=c_words1, 
                                   c_words2=c_words2)
    data = dict()
    data['year'] = file.split('/')[-1][:4]
    data['distance'] = distance
    gender_suceess_data.append(data)
    
gender_success_df = pd.DataFrame(gender_suceess_data)
gender_success_df.set_index('year').plot(figsize=(10, 5), kind='bar')
plt.suptitle('人民日报在「成就」概念的文化变迁', size=15)
plt.xticks(rotation=0)
plt.title('大于0表示社会更容易将成功与男性联系起来')

- 谁说女子不如男
- 不爱红装爱武装
- 女人撑起半边天
...

import matplotlib.pyplot as plt
import matplotlib_inline
matplotlib_inline.backend_inline.set_matplotlib_formats('png', 'svg')
import warnings
import cntext as ct
import scienceplots
import pandas as pd
import glob
plt.style.use(['science', 'no-latex', 'cjk-sc-font'])
ct.matplotlib_chinese() #为正常显示中文

gender_responsibility_data = []
words =   ['责任', '重担', '担当']
c_words1 = ['女', '女人', '她', '母亲', '女儿', '奶奶']
c_words2 = ['男', '男人', '他', '父亲', '儿子', '爷爷']

mfiles = sorted(glob.glob('Aligned_Word2Vec/*.bin'))
for file in mfiles:
    distance = ct.sematic_distance(wv=ct.load_w2v(file),
                                   words=words, 
                                   c_words1=c_words1, 
                                   c_words2=c_words2)
    data = dict()
    data['year'] = file.split('/')[-1][:4]
    data['distance'] = distance
    gender_responsibility_data.append(data)
    
gender_responsibility_df = pd.DataFrame(gender_responsibility_data)
gender_responsibility_df.set_index('year').plot(figsize=(10, 5), kind='bar')
plt.xticks(rotation=0)
plt.suptitle('人民日报在「责任」语义的文化变迁', size=15)
plt.title('大于0表示社会更容易将「责任」与男性联系起来')

- 免费   Word2Vec          https://pan.baidu.com/s/1Ru_wxu9egsmhM7lATjSlgQ?pwd=bcea

- 免费   Aligned_Word2Vec  https://pan.baidu.com/s/1IVgP0MyQpez0hpoJyEyFdA?pwd=7qsu

[1]冉雅璇,李志强,刘佳妮,张逸石.大数据时代下社会科学研究方法的拓展——基于词嵌入技术的文本分析的应用[J].南开管理评论:1-27.
[2]Hamilton, William L., Jure Leskovec, and Dan Jurafsky. "Diachronic word embeddings reveal statistical laws of semantic change." arXiv preprint arXiv:1605.09096 (2016).
[3]Garg, Nikhil, Londa Schiebinger, Dan Jurafsky, and James Zou. "Word embeddings quantify 100 years of gender and ethnic stereotypes." Proceedings of the National Academy of Sciences 115, no. 16 (2018): E3635-E3644.
[3]Aceves, Pedro, and James A. Evans. “Mobilizing conceptual spaces: How word embedding models can inform measurement and theory within organization science.” Organization Science (2023).
[4]Kozlowski, A.C., Taddy, M. and Evans, J.A., 2019. The geometry of culture: Analyzing the meanings of class through word embeddings. American Sociological Review, 84(5), pp.905-949.

import pandas as pd
import re

df1 = pd.read_csv('2011-2019.csv.gzip', usecols=['留言内容', '回复内容'], compression='gzip')
df2 = pd.read_csv('2020-2023.csv.gzip', usecols=['留言内容', '回复内容'], compression='gzip')
df1['text'] = df1['留言标题'].fillna('') + df1['留言内容'].fillna('') + df1['回复内容'].fillna('')
df2['text'] = df2['留言标题'].fillna('') + df2['留言内容'].fillna('') + df2['回复内容'].fillna('')
df.head()


with open('留言板.txt', 'w', encoding='utf-8') as f:
    text = '\n'.join(df['text'])
    f.write(text)

cd desktop
pip3 install cntext-2.1.6-py3-none-any.whl

import cntext as ct

# 大邓Mac 96G内存， 12核使用的代码。
w2v = ct.Word2Vec(corpus_file='留言板.txt',
                  vector_size=200,
                  window_size=15,
                  lang='chinese',
                  chunksize=100000,
                  min_count=5)

# 考虑到大家电脑普遍8G、16G内存，保守的训练代码
# w2v = ct.Word2Vec(corpus_file='留言板.txt',
#                  vector_size=200,
#                  window_size=15,
#                  lang='chinese',
#                  chunksize=10000,
#                  min_count=5)

wv

Mac(Linux) System, Enable Parallel Processing
Cache output/renmin_board_cache.txt Not Found or Empty, Preprocessing Corpus
Reading Preprocessed Corpus from output/renmin_board_cache.txt
Start Training Word2Vec
Word2Vec Training Cost 2692 s.
Output Saved To: output/留言板-Word2Vec.200.15.bin

ct.evaluate_similarity(wv)

ct.evaluate_analogy(wv)

近义测试: similarity.txt
/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/cntext/model/evaluate_data/similarity.txt

评估结果：
+----------+------------+----------------------------+
| 发现词语 | 未发现词语 | Spearman's Rank Coeficient |
+----------+------------+----------------------------+
|   426    |    111     |            0.45            |
+----------+------------+----------------------------+


类比测试: analogy.txt
/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/cntext/model/evaluate_data/analogy.txt
Processing Analogy Test: 100%|██████████████| 1198/1198 [00:11<00:00, 99.91it/s]

评估结果：
+--------------------+----------+------------+------------+----------+
|      Category      | 发现词语 | 未发现词语 | 准确率 (%) | 平均排名 |
+--------------------+----------+------------+------------+----------+
| CapitalOfCountries |   238    |    439     |   19.33    |   2.74   |
|   CityInProvince   |   175    |     0      |   100.00   |   1.01   |
| FamilyRelationship |   272    |     0      |   61.40    |   1.96   |
|   SocialScience    |    10    |     60     |   20.00    |   1.50   |
+--------------------+----------+------------+------------+----------+

import cntext ct

w2v = ct.load_w2v('output/留言板-Word2Vec.200.15.bin')
print('维度数:', w2v.vector_size)
print('词汇量: ', len(w2v))
w2v

Loading output/留言板-Word2Vec.200.15.bin...
维度数: 200
词汇量:  1050245
<gensim.models.keyedvectors.KeyedVectors at 0x328d737a0>

# 词表带顺序的
list(w2v.index_to_key)[:20]

['问题',
 '进行',
 '您好',
 '工作',
 '小区',
 '反映',
 '领导',
 '情况',
 '相关',
 '留言',
 '没有',
 '感谢您',
 '网友',
 '业主',
 '办理',
 '公司',
 '建设',
 '回复',
 '支持',
 '部门']

w2v.key_to_index

{'问题': 0,
 '进行': 1,
 '您好': 2,
 '工作': 3,
 '小区': 4,
 '反映': 5,
 '领导': 6,
 ...
  '连续': 995,
 '稳定': 996,
 '市住建局': 997,
 '降低': 998,
 '会同': 999,
 ...}

# w2v['问题']
w2v.get_vector('问题')

array([-6.2813835 ,  1.5916584 , -0.48086444, -2.6446412 , 10.031776  ,
       -0.11915778, -5.039283  , -2.1107564 ,  1.1351422 , -2.881387  ,
        4.2890835 , -1.1337206 ,  3.7850847 , -3.640467  , -0.96282107,
        ...
        ...
        1.1314462 , -2.5386178 , -2.3993561 , -2.0407596 ,  0.95457   ,
        3.03732   , -2.033116  , -0.20390491,  3.5368073 ,  6.5452943 ,
        2.1186016 ,  0.79572505,  2.5855987 ,  0.88565165, -1.812104  ],
      dtype=float32)

word = '这是一个不存在的词'
w2v.get_vector(word)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[130], line 2
      1 word = '这是一个不存在的词'
----> 2 w2v.wv.get_vector(word)

File /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/gensim/models/keyedvectors.py:446, in KeyedVectors.get_vector(self, key, norm)
    422 def get_vector(self, key, norm=False):
    423     """Get the key's vector, as a 1D numpy array.
    424
    425     Parameters
   (...)
    444
    445     """
--> 446     index = self.get_index(key)
    447     if norm:
    448         self.fill_norms()

File /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/gensim/models/keyedvectors.py:420, in KeyedVectors.get_index(self, key, default)
    418     return default
    419 else:
--> 420     raise KeyError(f"Key '{key}' not present")

KeyError: "Key '这是一个不存在的词' not present"

w2v.similar_by_word('问题', topn=10)

[('情况', 0.6178732514381409),
 ('现象', 0.5385990142822266),
 ('此类情况', 0.418301522731781),
 ('留言', 0.4179410934448242),
 ('一事', 0.40703579783439636),
 ('事项', 0.39551448822021484),
 ('事情', 0.3860214948654175),
 ('情形', 0.38478103280067444),
 ('事件', 0.36725184321403503),
 ('现像', 0.3665226995944977)]

question_vector = w2v.get_vector('问题')
w2v.similar_by_word(question_vector, topn=10)

[('问题', 1.0),
 ('情况', 0.6178732514381409),
 ('现象', 0.5385990142822266),
 ('此类情况', 0.4183014929294586),
 ('留言', 0.4179410934448242),
 ('一事', 0.40703579783439636),
 ('事项', 0.39551448822021484),
 ('事情', 0.3860214948654175),
 ('情形', 0.38478103280067444),
 ('事件', 0.36725184321403503)]

eco_vector = ct.semantic_centroid(wv=w2v,
                                  words=['经济', '建设', '发展'])


# 寻找 eco_vector 语义最相似的10个词
w2v.similar_by_vector(eco_vector, topn=10)

[('发展', 0.8317984938621521),
 ('建设', 0.7508440613746643),
 ('经济', 0.6406075954437256),
 ('经济社会发展', 0.6385446786880493),
 ('发展壮大', 0.6317417621612549),
 ('化发展', 0.5961641073226929),
 ('大力发展', 0.585274338722229),
 ('经济腾飞', 0.5823679566383362),
 ('产业', 0.5820372700691223),
 ('高质量发展', 0.5803337097167969)]

- 尺寸(大, 小)
- 湿度(干燥,潮湿)
- 性别(男, 女)
- 财富(富裕, 贫穷)
- 等

import cntext as ct


# 数值越大，表示越接近于c_words2，越寒冷。
ct.sematic_projection(wv=w2v,
                     words=['杭州', '哈尔滨', '广州', '潍坊'],
                     poswords=['寒冷', '冰雪'],
                     negwords=['炎热', '酷暑'],
                     )