Chen Qijin’s BLOG

记录安装open-AI的gym库时的步骤，以防再次踩坑

2021-11-22T00:00:00+08:00

本文中的步骤基于Windows11的 Linux 子系统

首先，不推荐在任何Windows系统上安装. 如果是Windows的电脑, 一定安装在 wsl 子系统上. “Windows 是最好的 Linux 发行版”
安装mujoco:
1. 首先参考这个 install mujoco 的步骤, 但是推荐安装
2. 下载 activation key 并放置在 ~/.mujoco 路径下
3. 在个人文件夹下的 .bashrc 文件中添加:
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/换成你自己的用户名/.mujoco/mjpro150/bin
```

按顺序运行以下命令:

sudo apt-get update
    
sudo apt-get install -y libglu1-mesa-dev libgl1-mesa-dev libosmesa6-dev xvfb ffmpeg curl patchelf libglfw3 libglfw3-dev cmake zlib1g zlib1g-dev swig
   
pip install gym[all]

如果在 build wheel for mujoco-py 时出错, 参考以下代码:
```
git clone https://github.com/openai/mujoco-py.git
cd mujoco-py
pip install -e.
```
来源: https://github.com/openai/mujoco-py#install-mujoco

Introduction To Hackman Model

2021-11-11T00:00:00+08:00

中文文本

2021-11-11T00:00:00+08:00

2021-11-11-test

layout: post title: 使用Pandas来进行数据分析 categories:

- data science
- pandas
- 财经文本

In [1]:

import pandas as pd

from pandas.util.testing import makeDataFrame

C:\Users\cqj\AppData\Local\Temp/ipykernel_26400/432841707.py:3: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.
  from pandas.util.testing import makeDataFrame

I am add some text here¶

test test

In [2]:

df = makeDataFrame()
df

Out[2]:

	A	B	C	D
FqLZLUqLCY	3.627949	-1.555797	1.458431	1.622218
M9l0h9d59Y	-0.527205	-2.004501	-0.127559	0.609814
72MAvfmUL5	1.188889	0.089531	1.340012	0.915467
vdIvb3ergR	-0.014269	-0.773431	-0.428795	-0.481142
V8bTtaCmdS	1.042277	0.450739	0.069589	-0.811076
ifFnw4QODM	1.002886	-2.129056	-0.688126	0.693922
bhI9WF4YcA	-1.307111	0.256108	0.210564	-2.424327
CxNBz0WFQp	0.070121	2.445112	-1.493426	0.991601
8Mano0wqir	-0.139102	-1.559955	1.117109	0.115896
VUDmeWDWB0	0.228584	-0.863405	1.478317	-1.338303
0aYFpOc6g6	0.927212	0.925563	-0.297272	-0.360075
nGGKYBlC1c	1.073805	0.680605	0.271386	-2.388816
GWq2cxHYD8	1.660381	0.314358	-0.914082	0.021068
4Iod6Etk6j	1.387721	0.127808	-1.069839	0.616804
1O45uORPXG	-0.523008	0.119916	-0.917618	-1.964883
gcL1RUugHf	-1.098534	1.999342	-1.225634	0.679302
fE07kSx7qg	1.197571	0.481607	0.449731	-2.687757
7X4ggkh7jv	0.508883	1.804173	-0.197898	-0.632097
I9Jf2ONpSr	0.139146	-1.459645	0.803552	-0.135293
ehj6Itzzrl	-0.286057	0.392289	0.156096	0.428110
by2X8fZ2tL	1.044101	-1.202301	-0.012825	0.914465
AwJM2QSjky	0.612415	-0.706799	0.093917	-1.778126
zZo0Yi0bC3	-0.994082	0.347263	-2.136663	1.220651
tjsdfUKGRp	-0.227632	-0.449670	-0.207484	1.904929
d09yVfOpoy	-0.961927	0.046097	0.590607	-1.915548
Uns09NwUku	-0.587393	-0.573810	-1.141514	-0.971181
Ccn2eewzWz	1.252385	0.337571	1.289367	-0.824076
5OW7nh1TGY	-0.033208	-0.635043	0.743121	1.790220
SQQp6o1Vjc	-0.911632	-0.871304	0.519956	-0.207241
RrAID9JnEF	1.196845	0.110563	-1.165277	1.139311

In [3]:

import matplotlib.pylab as plt

df.plot()

Out[3]:

<AxesSubplot:>

测试 jupyter notebook 是否能正常显示

2021-11-10T00:00:00+08:00

import pandas as pd

from pandas.util.testing import makeDataFrame

df = makeDataFrame()
df

	A	B	C	D
btGRTrh9LU	-0.742145	-0.893328	-1.304956	1.034842
BV2CsQIPdw	1.824368	-0.386302	0.678756	0.404220
jEIGok5qYf	-0.267949	0.584441	-0.744999	1.339014
bFacdWMgsD	-1.010524	-1.649774	-0.754501	-0.684241
soAEDHnanD	0.269725	-0.083877	0.602573	-0.896465
U7EVhbcWNZ	0.455026	1.387828	-2.045870	-0.961229
Ug84kJ8EEu	2.225741	0.447942	1.604812	0.049973
uVFU0kqoXp	-1.182075	-0.212537	0.676468	-0.099554
BERsx5D6rd	-0.967468	-1.494943	1.130980	-2.050188
FCfT0fjoSq	-0.403244	-1.646424	2.097804	-1.564483
q0I0xD3vie	-0.049393	0.146242	0.521698	0.846845
ppwOCxqTl0	0.067105	0.432056	-0.730543	0.490270
z0RGWHIYIb	-0.262235	-0.999249	-0.733476	0.567824
YHVIsWEgQb	0.655289	1.298319	-0.939714	-0.623303
Ip4bikgZbZ	-0.262531	-0.033943	1.294955	-0.490842
xJZeCSG96a	-0.119527	0.505828	0.510533	-1.566203
jCJQ3aPSO1	-1.332722	-0.094682	-0.188290	-1.749978
rc7nMgpMjp	-0.088242	1.217513	0.170726	1.032927
PlM4c1j08c	-0.316564	-0.303150	1.853104	0.161671
d5yxJs1zl6	1.135084	-1.554537	0.466070	0.382947
vGUAcPGaK5	-0.073617	0.337186	-0.168406	-1.041977
OnV8UXwVr4	0.159056	0.786618	1.259272	-0.881401
6cyGD5lb18	0.039900	0.041941	0.706655	-0.917063
0lLebAGL3k	0.266503	0.334693	1.129501	0.248132
iD7o5BWJAS	1.971463	1.616939	0.788988	0.516291
M4A3YjbjLI	-0.107087	-1.496449	-0.264386	0.946963
q3s1p2wQ88	-0.459087	1.033434	-0.082343	-0.598603
6deAxa0QVz	0.687213	-0.417025	0.858427	1.399216
arlIugFbzB	-0.836555	-2.293708	-0.958141	-0.852751
I6ZGEiHAtw	-0.599726	0.117627	-1.063599	0.654528

import matplotlib.pylab as plt

df.plot()

<AxesSubplot:>

【论文解读】JPE2016 使用年报的产品描述来进行行业分类

2021-11-09T00:00:00+08:00

本文的作者 Hoberg 在 2016年的 Journal of Political Economy 提出了一种新的对公司进行分类的方法. 作者通过网络爬虫收集了许多年份美国上市公司的 10-K 披露文件中的产品描述(里面包含了产品的细节, 对公司之间计算相似度, 进一步进行行业分类.

根据公司面向市场提供的产品来进行行业分类.

根据产品描述中的文本信息, 每个公司都被投影到一个向量空间. 显然, 在这个向量空间中, 可以计算两家公司的距离. 一家公司附近的竞争对手公司, 则是和其有着相似产品描述的公司.

根据公司被表征出来的向量, 可以计算公司之间的相似度. 两家公司之间的相似度越大, 则说明它们更像是处于同一个行业, 竞争关系越紧密.

而两家公司之间的距离越大, 则意味着两家公司的产品面向不同的细分市场, 或者它们根本就不在一个行业.

此外, 由于公司每年都会更新它们的产品描述, 所以公司向量、公司之间的相似度都是随时间变化的。

那么如何在高维向量空间内分出行业呢? 用的最多的办法就是聚类.

文中提到了两种聚类的思想，区别在于有无竞争关系的传导。

如果使用固定的行业分类定义来聚类, 那么公司的行业属性是可以传导的.

考虑 3 家公司 A, B, C, 如果 B 和 C 都在 A的行业里, 那么 B 和 C 属于同一个行业

此时, 聚类算法的目标则是最大化

而如果

Automate Boring Stuff In Python 1

2021-11-06T00:00:00+08:00

【动态请求】：用代码帮我们来“点击加载更多”

2021-11-04T00:00:00+08:00

这篇博客解答了上一篇博客遗留的问题, 介绍了在浏览器中调试类似的数据加载网页，并讲解了如何用Python的requests库来编写代码，不断地获取网站后端返回给我们的数据。

本教程用到的技术栈：

Python

文本读写

JSON数据的处理

异常处理

模拟浏览器发送请求

网页

F12调试发现网页规律

本博客由果然科技有限公司独家赞助.

简介

一般来说，东方财富对每个股票都设有“问董秘”板块。通过该股票的主页，以贵州茅台为例, 点击”问董秘”即可进入贵州茅台的问董秘网站.

我们可以在浏览器的搜索框里看到该网站的网址.

因为东方财富体量巨大, 需要对众多上市公司的信息进行维护, 我们合理地推测: 网址的链接也是有一定的规律可循的. 例如: http://guba.eastmoney.com/qa/qa_search.aspx?company=600519&keyword=&questioner=&qatype=1中的company=600519, 若是把600519换成别的公司的代码, 或许就是别的公司的问董秘板块.

当然, 这一切都是猜测. 是否是这样, 我们需要后续的调试和进一步的观察.

网页调试

打开F12, 进入调试界面. 如果没有反应, 可能是在笔记本上需要按下Fn+F12.

按下Ctrl+R刷新一下, 按照下图中的顺序, 找到这个界面.

请求类型

我们发现: 浏览器一共进行了两次请求, 两个请求的名称都是GetData.aspx. 我们可以随便点击一个请求, 这样在右边会弹出该请求的具体情况, 如下图所示:

红框框起来的几项里, 包含了我们用浏览器和东方财富网站进行交互的一些参数. 例如:

请求的URL是: http://guba.eastmoney.com/interface/GetData.aspx
请求的方法是: POST

我们向下划, 找到请求标头, 我们可以看到User-Agent这一项. 它记录了你是用什么浏览器来向 http://guba.eastmoney.com/interface/GetData.aspx 这个URL进行的 POST 请求. 而上面的Referer, 在多观察了几个公司的F12页面之后, 我们发现, 针对不同的股票代码, 它的结构是http://guba.eastmoney.com/qa/qa_search.aspx?company=股票代码&keyword=&questioner=&qatype=1. 这也便于我们后续使用Python编写爬虫程序的时候, 构造Referer.

表单数据 (form data)

继续向下划, 我们找到了表单数据, 如下图所示:

这里记录了你传递给http://guba.eastmoney.com/interface/GetData.aspx的参数. 根据我的理解, code=600519&ps=15&p=2&qatype=1中, code=600519代表你请求的股票代码, ps=15代表你请求数据的条数, 这里是15条, 也就是按下点击加载更多按钮之后, 你又向东方财富的后台请求了15条新的股东-董秘问答, 而qatype=1代表着问答的类型, 对于所有的公布出来的股东-董秘问答, 或许它们的qatype在东财后台都被标记为1. 三者用&连接起来, 则构成了完整的表单数据.

现在, 我们已经知道了, 人类用户在使用浏览器时是如何和网站后台交互的了, 现在就是教会机器用户和东财后台交互了.

简单使用requests库

构建表单数据

假设我们想让机器爬取300条问董秘的问答文本, 结合我们刚刚在表单数据-param中发现的规律, 点击一次点击加载更多, 会额外请求15条, 那么机器一共要发送20个GetData.aspx的请求. 并且每个请求的表单数据应该是:

code = 600519
for i in range(1, 21):
    data = dict(param=f'code={code}&ps=15&p={i}&qatype=1', path='question/api/Info/Search', env=2) 

为什么i要从1开始呢，这也是尝试对比了从0开始和从1开始之后发现的规律.

构建头文件

而对于每一次请求, 头文件都是一样的, 可以用一个字典数据表示:

header = {
'Referer': f'http://guba.eastmoney.com/qa/qa_search.aspx?company={code}&keyword=&questioner=&qatype=1', 
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36 Edg/95.0.1020.40)'
}

发送请求

我们调用requests的post函数, 传给它url, headers, data 三个参数, 函数的返回值就是网页给我们的response.

import requests
url = r'http://guba.eastmoney.com/interface/GetData.aspx'
response = requests.post(url=url, headers=header, data=data)

什么是网页的response呢? 在开发者工具页面 , 点击响应, 就能看到网页给我们返回了一个漂亮的json. 关于json这种数据格式, 你可以把它理解成python里的字典数据类型, 都是由一对对的key和value构成.

通过``type函数, 我们可以查看response` 的数据类型, 并且还能看出它包含了哪些性质, 如下图所示:

调用response的.json()方法, 我们就能得到东财返回给我们的json数据

response_json = response.json()

自我探索时间:

我们想要的”问董秘”问答文本在哪呢?

我们发现, response_json['re']返回了一个列表, 列表里的元素是一个字典, 似乎, 这就是一条条的问答帖子.

我们随便找一条继续观察:

发现: post_title, user_nickname, post_content, ask_question, ask_answer里都有一定的文本信息, 并且有些重叠. 简单拼接一下, 我们就能得到一条完整的问答:

for record in response_json['re']:
    record['user_nickname'] + ': ' + record['ask_question'] + '\n' + record['ask_answer']

异常处理

拿茅台来说, 可能问董秘模块里根本没有300条问答, 那我们直接运行爬虫去爬取300条数据, 就会遇到错误, 而错误会导致程序的中断.

一个比较保险的做法是:

try:
    our_crawling_code
except:
    pass

而一个习惯更好的方法是在except后面指定错误类型, 我们推测, 在后台没有数据返回时, response_json['re']可能返回空列表[], 那么显然它会造成IndexError. 把异常处理的异常部分写得更具体:

try:
    our_crawling_code
except IndexError:
    pass

总结

到这里为止, 我们就完成了从调试网页到编写爬虫程序的一条龙. 很自然地我们希望把上述过程打包成为一个函数, 函数接受上市公司的股票代码作为输入, 输出爬下来的”问董秘”问答文本. 具体代码如下

全部代码

下列代码可能不是最新的，但也能正常运行，最新代码请参见Github

import os
import requests

url = r'http://guba.eastmoney.com/interface/GetData.aspx'


def get_question_answer_pairs(code):
    if not os.path.exists('./output'):
        os.makedirs('./output')

    with open(f'./output/{code}.txt', mode='w') as f:
        f.write('')
    for i in range(1, 21):
        data = dict(param=f'code={code}&ps=15&p={i}&qatype=1', path='question/api/Info/Search', env=2)

        header = {'Referer': f'http://guba.eastmoney.com/qa/qa_search.aspx?company={code}&keyword=&questioner=&qatype=1',
                  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36 Edg/95.0.1020.40)'}

        response = requests.post(url=url, headers=header, data=data)

        response_json = response.json()
        with open(f'./output/{code}.txt', mode='a') as f:
            for record in response_json['re']:
                try:
                    f.write('发表时间(publish time): ' + record['post_publish_time'] + '\t' + '展示时间(display time): ' + record['post_display_time'] + '\n')
                    f.write(record['user_nickname'] + ': ' + record['ask_question'] + '\n')
                    f.write(record['ask_answer'] + '\n'*2)
                except IndexError:
                    pass


if __name__ == '__main__':
    code = 600519
    get_question_answer_pairs(code=code)

【论文解读】GCAN: Graph-aware Co-Attention Networks for Explainable Fake News Detection on Social Media

2021-11-03T00:00:00+08:00

整体概括: 这篇论文研究的基于传播路径的假新闻探测问题, 研究的场景是社交媒体, 以Twitter为例. 本文提出模型, 通过新闻的传播路径(最源头的推文文本信息, 转推者(retweet)的用户信息等)来做二分类问题.

论文提出的模型叫做Graph-aware Co-Attention Networks. 由此可以看出, 模型中用到了图(graph)相关的表征模型和co-attention的机制.

笔者的深度学习知识储备浅薄, 看到文章标题的第一反应是, 模型的可解释性(interpretability) 来自co-attention机制, 而图表征的技术手段则提供了一个新的表征维度, 原文作者一定是因为其给模型带来的增益较大, 才将其作为文题. 传统而言, 假新闻的表征手段关注于表征文本(源文本, 转发文本, 评论等等), 而本文表征的是传播路径.

一起来看看原文作者是怎么做的吧.

问题建模

以下根据原文3 Problem Statement解读

前面这几行没什么好说的, 定义了两个集合, 一个推文集合, 一个用户集合, 然后用单词集合来表示每一篇推文.

紧接着, 作者定义了用户特征和传播路径. 所谓传播路径就是

a sequence of retweet records.

某条推特 $s_i$ 的一条传播路径 $R_i$ 由一个个包含3个元素的tuple组成. 每个tuple里包含了在 $u_j$ 这个用户,以及ta的各种属性 $x_j$ , 以及ta转发这条推特的时间 $t_j$ . 数据集里包含了 $s_i$ 的标签 fake or true, 注意到, 这个标签随着时间从 $t_1$ 变到 $t_K$ (传播路径 $R_i$ 上一共有 $K$ 个用户 ) 是保持不变的.

此外, 根据后文, 用户 $u_j$ 的特征 $x_j$ 主要包括:

number of words in a user’s self-description
number of words in $u_j$ ‘s screen name
number of users who follows $u_j$
number of users that $u_j$ is following
number of created stories for $u_j$
time elapsed after $u_j$’ s first story
whether the $u_j$ account is verified or not
whether $u_j$ allows the geo-spatial positioning
time difference between the source tweet’s post time and $u_j$ ’s retweet time
the length of retweet path between $u_j$ and the source tweet (1 if $u_j$ retweets the source tweet)

作者希望通过传播路径和原始推文来做一个二分类问题, 即原始推文是真还是假. 并且, 作者希望模型能针对假新闻的样例给人们启示:

找出那部分少量的可疑用户
找出假新闻中独特的词语

模型结构

总体来说, 下面的图片概括了原文章提出的深度学习模型.

模型主要包括5个部分:

用户特征提取(user characteristics extraction)
- 对每个用户$u_j$ , 都能提取出特征 $x_j$ , 具体描述见上文
推文的表征(news story encoding) //如何翻译encoding比较好呢
- 设定文本的最大长度$m$, zero padding to maximum length
- 通过全连接层生成 $d$ 维的word embedding $V = [v_1, v_2, …, v_m]$
- 使用GRU来学习$V$里的次序特征, $s_t=GRU(v_t), t=1, …, m$
- 最终的推文表征为 $S = [s^{1}, s^{2}, …, s^{m}]\in \mathbb{R}^{d \times m}$
传播途径的表征
- user propagation representation
  
  针对传播路径 $R_i$ 中用户特征 $[x_1, …, x_j, …, x_K]$ 的处理
  - GRU-based representation
  - CNN-based representation (1-Dimension)
- graph-aware propagation representation
  - 全连接的图; 用户作为节点; 两个用户的相似度作为边, 通过用户的特征向量$x_i$, $x_j$ 的余弦相似度计算得出.
  - 两个GCN层叠加
两个的注意力机制(co-attention mechanisms 用于捕捉推文和传播途径之间的关系)
- 原文里说的是 dual co-attention mechanism. 但是其本质上就是两个 co-attention 机制, 从下面的模型图也能看出. 一个是source-interaction, 一个是source-propagation, 用到的信息就从下面的模型图也能一目了然.
- 具体的公式推导在这里省略, 有兴趣的读者可以参考原始论文
预测(make prediction)
- 对于每一条(原始新闻, 传播路径), 把上述的5个向量拼接起来, 就是最终的特征向量 $f$ . 然后使用全连接层做二分类.

实验结果

实验设计

这部分在本文里略过

实验结果

通过和一众模型对比, 可以看出原文里提出的GCAN模型的performance有很大的提升.

上表中的GCAN-G模型是GCAN去掉了GCN那一块之后的模型, 那么显然, 去掉了用户之间的互动信息, 也就去掉了后面的source-interaction co-attention (也有可能没去掉, 可能是用$[x_1, …, x_j, …, x_n]$ 直接feed到source-interaction co-attention里, 但是这样也失去了interaction的含义).

早期探测

下图是在Twitter15和Twitter16两个数据集上的结果, 展示了传播链条的长度对模型预测精度的影响. 可以看出转发人数从50减少到10, 意味着传播链条的长度在缩短, 而GCAN的模型表现并没有太大的变化. 这意味着GCAN可以做到假新闻的早期探测(early detection)

消融实验

结论: 模型的几个模块都是有贡献的

可解释性

关于博客一开始提到的可解释性, 论文作者也从模型的角度给出了一些见解.

值得注意的是, GCAN模型的可解释性主要来自source-propagation co-attention 的权重, 因为经过了GCN 的处理, 用户的interaction 特征不好解读, 所以 source-interaction co-attention 的权重没有被用到.

原推的文本

下图是原论文作者举的例子:

假新闻: “breaking: ks patient at risk for ebola: in strict isolation at ku med center in kansas city #kwch12”

真新闻: “confirmed: this is irrelevant. rt @ks-dknews: confirmed: #mike-brown had no criminal record. #ferguson”

词云展示了假新闻和真新闻在用词上的不同. 字体越大的词, 代表着co-attention weights越大

可以看出, GCAN predicts the former to be fake with stronger attention on words “breaking” and “strict”, and detects the latter as real since it contains “confirmed” and “irrelevant.”

传播链条

下面这张图里, 作者展示了3条假新闻, 3条真新闻的 source-propagation co-attention. 根据这张图, 作者指出检查最开始转发的那几个用户, 是一个判断新闻真假的好办法( 对假新闻而言, 在传播路径的前段, 转发者的权重比较小; 而对真新闻而言, 在传播路径的前段, 转发者的权重比较大)

转发者的特征

这部分的可解释性同样来自 source-propagation co-attention. 参见下面这张图, 根据 source-propagation co-attention 权重的大小, 可以挑选出一些用户特征的维度, 也可以挑选出一些源推特的词语. 论文作者认为, 这些词语(breaking, pipeline)可以反映新闻中隐含的立场(potential stances), 有可能对探测假新闻有用.

笔者认为 stance detection 确实是fake news detection的一个好方向.

总结

到这里为止, 笔者对这篇论文的解读就告一段落了. 接下来的事情是去 Github 上阅读这篇论文的源代码了.

用机器学习来研究假新闻的传播, 检测, 是近几年比较流行的话题. 而模型的可解释性也是我们关注得越来越多的地方.

值得一提的是, 文中提到的GCAN模型不仅可以用在假新闻探测上, 其他的社交媒体上的短文本分类任务(sentiment detection, hate speech detection, tweet popularity prediction)也可以适用.

参考

Lu, Y.-J., & Li, C.-T. (2020). GCAN: Graph-aware Co-Attention Networks for Explainable Fake News Detection on Social Media. Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, 505–514. https://doi.org/10.18653/v1/2020.acl-main.48

正则表达式：从投资者问里提取每经AI新闻

2021-11-03T00:00:00+08:00

本文在已有原始数据的基础上, 使用正则表达式regular expression, 提取投资者和上市公司高管之间的有趣问答.

据观察, 这种基础性的自然语言处理技巧被广泛地运用在部分财经媒体的AI新闻模块

获取数据

东方财富网是一个庞大的财经门户网站, 里面每天都有大量的官方推送和用户生成的内容.

我们的教程也从东方财富网开始.

在东方财富的网站上搜索某家股票, 点进结果, 拉到最下, 就能看到如下的某家股票吧. 下图展示了”宁德时代”的页面. 可以看到, 在最右边一栏有问董秘板块, 点进去之后就是投资者和上市公司之间的各种奇葩对话了.

假设我们还没有掌握爬虫技巧, 那么我们想做的事情就是多次点击页面中的点击加载更多, 让页面展示了足够多的问答数据之后, 再右键-查看网页源代码.

在一个新弹出的页面里面, 我们可以看到一些html代码, 我们按ctrl+A将它们全部选中, 然后复制, 粘贴到一个记事本文件里, 保存成data.txt

有了数据, 接下来就能开始解析了.

值得一提的是, 如果引入爬虫的技术, 其本质上就是把我们人工点击点击加载更多按钮的过程交给一个机器人来做, 显然, 这样更省时省力.

把文本导入进来

一般而言, 导入一个.txt文件, 我们直接使用python的open(文件名).read()方法就可以了, 也就是html = open('./data.txt').read(). 但有的时候, 如果需要读取的文本很大, 一个更安全的做法是使用如下的做法:

with open('./data.txt') as file:
    html = file.read()

到这一步, 一个名为html的字符串类型的数据, 已经存在于我们的console里了

调试正则表达式

上帝: 没有人能一步写100%正确的正则表达式

什么是正则表达式呢?

简单地说, 正则表达式就是想用一种通用的方法来表示一批具有某种相同特征的文本. 以我们刚刚获取的html代码为例:

每一对宁德时代的股民与宁德时代的对话, 它们周围都有一些相似的html标记. 比如, 如果不算换行符和空格之类的干扰, <div class="qa_question_text">之后, 接的一般都是宁德时代的股民的提问; 而<div class="qa_answer_text">之后, 并不直接跟着宁德时代的回答, 而是

<div class="icon icon_answer_small"></div>
                                        <a href="/news,300750,1072951789.html" target="_blank">
                                            <div class="qa_answer_text">

                                                <div class="icon_arrow_left"></div>
                                                <p>

这样一些乱七八糟的html标记.

我们找到了宁德时代的股民与宁德时代的对话的”规律”!

对了, 上面那张截图是在这个网站截取的. 上帝说”没有人能一步写好100%正确的正则表达式”, 但是https://regexr.com/给我们提供了一个便捷地调试正则表达式的platform.

究竟什么是正则表达式

我们今天要写的正则表达式长这样: <div class="qa_question_text">([\s\S]*?)<\/div>[\s\S]*?<div class="qa_answer_text">[\s\S]*?<p>([\s\S]*?)<\/p>

而我们在https://regexr.com/上, 在Expression一栏里填入这个正则表达式, 把最开始复制的网页源代码粘贴进下面的大空白, 然后找到了15个匹配项. 下图里, 蓝色高亮的就是其中一个匹配项.

我们来拆解这个长长的正则表达式.

<div class="qa_question_text">无需多说, 它是我们想要匹配的文本的开头, 我们希望能够精确地找到<div class="qa_question_text">.

同样地, <\/div>, <div class="qa_answer_text">, <p>, <\/p>都是我们想要精确匹配的. 我们可以把它们理解成扫描二维码时用来定位的那几个大黑块, 它们并不携带我们想要的信息, 但是我们想要的信息被包裹在其中.

\是为了表示转义字符/ (\/才能在正则表达式里表示/, 或许你不理解这一点, 但是, 看看regexr.com的侧边栏cheatsheet或许你就明白了)

可以看出, 现在, 我们的正则表达式还剩下([\s\S]*?), [\s\S]*?, [\s\S]*?, ([\s\S]*?), 而这四个有两个还是相同的, 就只剩下了([\s\S]*?), [\s\S]*?. 而它们俩的区别只是少了一对括号().

那么, [\s\S]*?在做什么事呢? 一句话总结, 它能匹配两个精确字符串之间的全部字符. 比如我们截图里这个就在匹配<div class="qa_question_text">和<\/div>之间的全部字符.

至于它具体是怎么实现的嘛, 在https://regexr.com/上, 把鼠标移动到某个正则表达式代码附近, 网站就会提示你, 用小灰框框出可以拆分的最小单元, 然后告诉你这个小单元是在做什么.

然后, 结合着右边的Cheatsheet, 你可以弄懂任何和正则表达式有关的知识!

那么, 你也能发现用()把[\s\S]*?括起来, 是为了把[\s\S]*?匹配到的字符串当作一个group来对待, 方便后续使用.

显然, 这里, 我们把股民的问题和宁德时代的回答分别括起来了.

Python的正则表达式实现

我们首先需要导入一个叫re的包, 毫无疑问, 它是regular expression的缩写.

re为我们提供了一个名为findall的函数, suggested by its name, 它能找到所有的符合条件的子串.

一般来说, re.findall接受两个参数, 就能够实现功能.

string: where to look up, here the long raw html
pattern: the string you try and try and find satisfying in https://regexr.com/

import re
question_answer_pairs = re.findall(string=html,
                                   pattern=r'<div class="qa_question_text">([\s\S]*?)<\/div>[\s\S]*?<div class="qa_answer_text">[\s\S]*?<p>([\s\S]*?)<\/p>')

到这一步, 你已经基本上把我们想要的信息找到了. 但是用在Python Console里输出一下, 你发现, 还有小瑕疵:

\n表示换行符, 也就是我们在word按下enter之后屏幕上出现的符号.

我们想要干净的文本, 所以我们用str自带的strip方法, 就能很方便地去掉开头和结尾的换行符:

那么, 我们用list comprehension对所有的文本都来一遍:

question_answer_pairs = [(q.strip(), a.strip()) for q, a in question_answer_pairs]

到此为止, 我们已经实现了从一段原始的html文件中提取出一对对的股民与上市公司的问答.

完整代码

附上本文用到的全部代码：

import re

with open('./data.txt') as file:
    html = file.read()

# method 1: not safe
questions = re.findall(string=html, pattern=r'<div class="qa_question_text">([\s\S]*?)<\/div>')
questions = [ques.strip() for ques in questions]
answers = re.findall(string=html, pattern=r'<div class="qa_answer_text">[\s\S]*?<p>([\s\S]*?)<\/p>')
answers = [ans.strip() for ans in answers]

# method 2: better
question_answer_pairs = re.findall(string=html,
                                   pattern=r'<div class="qa_question_text">([\s\S]*?)<\/div>[\s\S]*?<div class="qa_answer_text">[\s\S]*?<p>([\s\S]*?)<\/p>')
question_answer_pairs = [(q.strip(), a.strip()) for q, a in question_answer_pairs]

未完待续

那么, 如何用爬虫来自动地获取html文件呢, 怎么样才能不用人工点击那个点击加载更多按钮呢? 我们下期见.

一篇教程：使用plotly绘制k线图（进阶）

2021-10-31T00:00:00+08:00

This tutorial is modified based on my repository customize-financial-plotly-plot and focuses on further beautifying and adding more functionalities into the plotly plot created in the last tutorial for my wife.

We know that adjusting and choosing among several parameters’ combinations is a tedious and time-consuming work. So I hope the people who read this tutorial will not struggle to button-or-layout-related problems when plotting k-lines.

In this tutorial, we will continue to dive into the world of plotly, a powerful toolkit that enables us to produce vivid interactive Python plot.

First, let’s recall what we have achieved in the last tutorial.

I have created a repository named sample_plot hosting a basic daily k-line plot, and by clicking the link you may be automatically redirected to the site. You may have noticed the plot is quite rough, since it could only exhibit a basic daily k-lines plot and the x range bar is too tall for a secondary/controlling part of a plot. What if we want to plot the k-lines of 5-days or 1-month and switch among those plots interactively by clicking some buttons as shown in the picture below. And we may also want to make the plot even more elegant to the original one provided by eastmoney, a Chinese giant financial company.

And Below is the final plot we would have by the end of this tutorial, if you are lucky.

The first step we need to conduct is to generate resampled data for the plot purpose. For resampling, we introduce the resample function from pandas package. For the full documentation of this function, please refer to this link.

Add buttons to the plot to produce different k-lines plot

In this part, we will introduce how to add buttons to update the layout of the plot, which is in plain English by clicking one of the buttons you may be able to transform your plot of daily k-lines into a redrawn monthly k-lines.

resample the data

A common practice for k-lines manipulations is to resample the daily data into weekly or monthly data. Using pandas.resample function, we could easily do some resampling. Below we define a function named resample_k_lines.

import pandas as pd
def resample_k_lines(data, resample_config=None):
    """
    resample the k-lines by the given freq
    :param data:
    :param resample_config:
    :return:
    """
    if resample_config is None:
        resample_config = {
            'rule': '1W',
        }
    resampled_data = pd.DataFrame()
    resampled_data['open'] = data['open'].resample(**resample_config).first()
    resampled_data['close'] = data['close'].resample(**resample_config).last()
    resampled_data['low'] = data['low'].resample(**resample_config).min()
    resampled_data['high'] = data['high'].resample(**resample_config).max()
    resampled_data['vol'] = data['vol'].resample(**resample_config).sum()
    resampled_data['color'] = 'red'
    resampled_data.loc[resampled_data['close'] < resampled_data['open'], 'color'] = 'green'
    return resampled_data

And you may have noticed we call the .resample function quite a few times. The basic practice is that we first select a column of the original dataframe, a.k.a. a series and then call the resample function which has already been implemented in the definition of the series class. By the way, you may have been told that everything in Python is an object. I am sure my wife understand the logic of calculating the four metrics of resampled k-line, i.e. the open price of a period is the open price of the first day of the period, and the high price of a period is the highest price in the given period. The other two prices were calculated under similar logic. While the resampled vol is simply the sum of all vol in the given period.

Oops! I forgot to explain one tricky thing we widely used in function definition. The parameter resample_config in the function above receives a dict-like type data, and then directed used by the pandas.resample function by adding ** ahead of its name. This is an unpacking method of dict-like parameter, which is to say, the parameter resample_config could contain all the parameters that could be accepted by pandas.resample method by ranging these parameters into a dict with the parameters’ names as the keys.

Another popular way of constructing the resample_k_lines function is that you don’t define a specific parameter for your function, instead you use **kwargs notation.

def resample_k_lines(data, **kwargs):

    resampled_data = pd.DataFrame()
    resampled_data['open'] = data['open'].resample(**kwargs).first()
    resampled_data['close'] = data['close'].resample(**kwargs).last()
    resampled_data['low'] = data['low'].resample(**kwargs).min()
    resampled_data['high'] = data['high'].resample(**kwargs).max()
    resampled_data['vol'] = data['vol'].resample(**kwargs).sum()
    resampled_data['color'] = 'red'
    resampled_data.loc[resampled_data['close'] < resampled_data['open'], 'color'] = 'green'
    return resampled_data

By either way of implementing the function resample_k_lines, we would like to calculate five resampled data for plotting purpose.

data_list = [df] + [resample_k_lines(df, dict(rule=freq)) for freq in ['1W', '1M', '3M', '6M', '1Y']]
text_list = ['日线', '周线', '月线', '3月线', '半年线', '年线']

add buttons

First, we would rewrite the candlestick plot we have implemented last time by a function provided by plotly called add_candlestick and create a for loop adding a candlestick for all six datasets.

for text, data in zip(text_list, data_list):
    fig.add_candlestick(
        x=data.index,
        open=data.open,
        high=data.high,
        low=data.low,
        close=data.close,
        increasing=dict(line_color='red'),
        decreasing=dict(line_color='green'),
        visible=False,
        name='k-lines_' + text,)

You may notice a parameter named visible was set to False. Yes, if you type fig.show() for now, nothing would show up since all six traces/candlestick plots are invisible. The buttons are then introduced for controlling purpose by changing these visible parameters. For example, if these visibles set to [True, False, False, False, False, False] , then the first candlestick would become visible while the other five remains invisible.

So, we need six + one (one button for erase all candlesticks) buttons to change the behavior of the plot. And we would also want to arrange these seven buttons in an organized manner, such as align horizontally to the top-right of the plot. fig.layout is called for this need.

fig.update_layout(
    updatemenus=[
        dict(
            type="buttons",
            direction="left",
            x=1.0,
            y=1.1,
            buttons=[
                        dict(label='None',
                             method='update',
                             args=[{"visible": [False for _ in range(len(data_list))]}]
                             )
                    ] +
                    [
                        dict(label=text,
                             method="update",
                             args=[{"visible": [True if _ == idx else False for _ in range(len(data_list))]}])
                        for idx, text in enumerate(text_list)
                    ],
        )
    ]
)

I won’t go in too deep explaining why the function accept parameters this way.

But I want you to have an overall grasp on the configurations. I don’t have much to say about type="buttons" and direction="left", x=1.0, y=1.1, are for buttons’ position and alignment in the plot. And buttons receives a list of dict containing 1 dict in which all the visible value set to False and 6 other dicts of which the visible parameter was set to one True and others False while the position where True occurs differs. Please come to me for more interpretation my dear wife if you are reading this and confused.

Make subplots and do some typography work

So far we have investigated how to add buttons to the plot so that the plot becomes interchangeable. Now we will add subplots so that the plot be able to display the volume data in a subplot that shares x-axis with the k-line plot.

First, we need to define how the subplots are structured. Two rows and one columns and two subplots altogether is defined by the make_subplots function.

from plotly.subplots import make_subplots
n_cols = 2
fig = make_subplots(rows=2, cols=1,
                    shared_xaxes=True,
                    row_heights=[n_cols, 1],
                    vertical_spacing=0.05,
                    subplot_titles=['K线图', '成交量']
                    )

And we need to add row=1, col=1 to the k-line subplot definition.

for text, data in zip(text_list, data_list):
    fig.add_candlestick(
        x=data.index,
        open=data.open,
        high=data.high,
        low=data.low,
        close=data.close,
        increasing=dict(line_color='red'),
        decreasing=dict(line_color='green'),
        visible=False,
        name='k-lines_' + text,
        row=1, col=1)

Then we define the volume subplot.

for text, data in zip(text_list, data_list):
    fig.add_trace(
        go.Bar(x=data.index, y=data.vol, visible=False, marker_color=data['color'], name='Volume_' + text),
        row=2, col=1
    )

After this, we would do some typography work. Below is the code.

fig.update_layout(autosize=True,
                  title=dict(text='贵州茅台K线图', x=0.5),
                  )
# modify the subplot title by fig.layout['annotations']
k = 1
while k < n_cols:
    fig.update_xaxes(rangeslider={'visible': False}, row=k, col=1)
    k += 1
fig.update_xaxes(rangeslider={'visible': True, 'thickness': 0.05}, row=n_cols, col=1)

Well, by now, we have created a plot with better control and more details. You can wrap it into a function and reuse it plotting some other stock.

What about adding MA lines (moving average) to both plots (to be continued)

Chen Qijin’s BLOG

记录安装open-AI的gym库时的步骤，以防再次踩坑

Introduction To Hackman Model

中文文本

I am add some text here¶

测试 jupyter notebook 是否能正常显示

【论文解读】JPE2016 使用年报的产品描述来进行行业分类

Automate Boring Stuff In Python 1

【动态请求】：用代码帮我们来“点击加载更多”

简介

网页调试

请求类型

请求头 (header)

表单数据 (form data)

简单使用requests库

构建表单数据

构建头文件

发送请求

自我探索时间:

异常处理

总结

全部代码

【论文解读】GCAN: Graph-aware Co-Attention Networks for Explainable Fake News Detection on Social Media

问题建模

模型结构

实验结果

实验设计

实验结果

早期探测

消融实验

可解释性

原推的文本

传播链条

转发者的特征

总结

参考

正则表达式：从投资者问里提取每经AI新闻

获取数据

把文本导入进来

调试正则表达式

究竟什么是正则表达式

Python的正则表达式实现

完整代码

未完待续

一篇教程：使用plotly绘制k线图（进阶）

Add buttons to the plot to produce different k-lines plot

resample the data

add buttons

Make subplots and do some typography work

What about adding MA lines (moving average) to both plots (to be continued)