使用Scrapy爬取网站并生成PDF

介绍

我偶然发现了一个技术分享网站，里面的内容我都很喜欢，想把它们都下载下来变成PDF文件学习和收藏。后面有类似的需求也都可以通过这个方法实现，于是就研究起来网页爬虫和网页生成PDF的技术。

网页生成PDF

网页转PDF有如下方案：

我选择使用基于 wkhtmltopdf 的 Python 库：pdfkit. 原因是可以和爬虫技术无缝结合。它的安装方法如下：

  1. 安装 python-pdfkit:
1
pip install pdfkit  (or pip3 for python3)
  1. 安装 wkhtmltopdf:
  • Debian/Ubuntu:
1
sudo apt-get install wkhtmltopdf
  • macOS:
1
brew install homebrew/cask/wkhtmltopdf
  • Windows 需要自行下载二进制安装包

可以写一个小脚本测试一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import pdfkit
import os
import logging
logger = logging.getLogger()

options = {
    'page-size': 'A2',
    'encoding': "UTF-8",
    'cookie': [
    ],
}

def generate_pdf(url, dst, options):
    try:
        if os.path.exists(dst):
            logger.warning(f"dst -> [{dst}] already exists, pass it")
            return
        pdfkit.from_url(url, dst, options=options)
    except Exception as e:
        raise e

Scrapy 使用入门

Scrapy 安装

1
pip3 install Scrapy

快速入门

创建 Scrapy 项目

1
scrapy startproject your_project_name

会创建一个目录your_project_name, 目录下是如下结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
scrapy.cfg            # deploy configuration file

 your_project_name/             # project's Python module, you'll import your code from here
     __init__.py

     items.py          # project items definition file

     middlewares.py    # project middlewares file

     pipelines.py      # project pipelines file

     settings.py       # project settings file

     spiders/          # a directory where you'll later put your spiders
         __init__.py

我们第一个爬虫程序

Scrapy 爬虫程序需要做如下事情：

  • 获取需要访问的 URL 列表，生成访问请求 Request
  • 访问 Request 获取 Response, 解析它目的是：
    • 生成下一层的访问请求 yield Request
    • 在当前页面解析结果，生成最终的数据结果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import scrapy

cookies = {
    'JSESSIONID': 'XXXX'
}

# 继承 Spider 类，写自己的爬虫程序
class IndexSpider(scrapy.Spider):

	# 取一个名字，启动时需要它
    name = "index"

	# 重载的方法，用于启动爬虫
    def start_requests(self):
        urls = [
            'http://example.com/index/index.html',
        ]
        for url in urls:
        # 生成下一层爬取的请求Request, 并在callback中写明访问成功时的回调
            yield scrapy.Request(url=url, cookies=cookies, callback=self.parse_categories)

    def parse_categories(self, response):
    # 访问成功，解析得出下一层爬取的请求 Request
        for li in response.xpath('//ul/li/a/@href').getall():
            yield scrapy.Request(url=response.urljoin(li), cookies=cookies, callback=self.parse_level2_categories,
            cb_kwargs={'from_url': li})


    def parse_level2_categories(self, response, from_url):
        for a in response.xpath('//a[contains(@class,"archive-article-title")]'):
            text = a.xpath('./text()').get()
            link = a.xpath('./@href').get()
            # 解析html后，生成最终返回的结果
            yield {
                'level1': from_url,
                'level2_categories': response.url,
                'detail_link': response.urljoin(link),
                'detail_title': text
            }

之后我们就可以在终端下，运行这个爬虫啦：

1
scrapy crawl index -o data.csv

  • index 是我们爬虫类里面写明的name.
  • -o 可以将生成的结果导出到 csv 或者 json格式

调试爬虫程序

可以使用 Scrapy shell 交互式的访问爬取的网页。

1
2
3
4
5
6
7
$ scrapy shell

>>> from scrapy import Request
>>> req = Request('example.com/index.html', cookies={'a':'b'})
>>> fetch(req) # 发起爬虫访问
>>> response.headers # response 是内置对象，可以直接查看
>>> view(response) # 开启一个浏览器，查看返回的响应

也可以直接在代码中插入 shell:

1
2
3
4
5
6
7
8
from scrapy.shell import inspect_response

def parse_details(self, response, item=None):
    if item:
        # populate more `item` fields
        return item
    else:
        inspect_response(response, self)

抓取需要登录的网页

通过 FormRequest 发起 form 表单提交请求。更复杂的可能需要使用 headless 浏览器发起登录请求，从而获取登录状态。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import scrapy  
from scrapy import Spider  
from scrapy.http import FormRequest  
  
  
class HiddenDataLoginSpider(Spider):  
	name = 'hidden_data_login'  
  
	def start_requests(self):  
		login_url = 'http://quotes.toscrape.com/login'  
		return scrapy.Request(login_url, callback=self.login)  
  
	def login(self, response):  
		token = response.css("form input[name=csrf_token]::attr(value)").extract_first()  
		return FormRequest.from_response(response,  
		formdata={'csrf_token': token,  
		'password': 'foobar',  
		'username': 'foobar'},  
		callback=self.start_scraping)  
  
	def start_scraping(self, response):  
		## Insert code to start scraping pages once logged in  
		pass

总结

通过 Scrapy 获取需要爬取的网页地址，和登录状态后，就可以结合中 generate_pdf 方法就可以将网页生成PDF。

展开全文 >>

Apache Maven 安装和使用

Maven 介绍

Maven 安装

  • 下载地址：http://maven.apache.org/download.cgi
  • 解压到本地磁盘，如：C:\Users\fan.yang\work\env\apache-maven-3.5.3
  • 设置windows环境变量：MAVEN_HOME=C:\Users\fan.yang\work\env\apache-maven-3.5.3
  • 加入PATH=%MAVEN_HOME%\bin;%PATH%
  • 检查 maven 是否运行正确：mvn -v
1
2
3
4
5
6
7
C:\Users\fan.yang>mvn -v
Apache Maven 3.5.3 (3383c37e1f9e9b3bc3df5050c29c8aff9f295297; 2018-02-25T03:49:05+08:00)
Maven home: C:\Users\fan.yang\work\env\apache-maven-3.5.3\bin\..
Java version: 1.8.0_144, vendor: Oracle Corporation
Java home: C:\JDK\jdk1.8.0_144\jre
Default locale: zh_CN, platform encoding: GBK
OS name: "windows 7", version: "6.1", arch: "amd64", family: "windows"

Maven 使用

创建新的工程

1
2
# 通过 archetype 插件，去`clone`一个现成的模板，不用自己手写pom.xml; 
mvn archetype:generate

运行上面的命令，如果是首次，会下载很多模板到本地；之后需要根据提示，确定模板，以及本工程的信息：groupId\artifactId\version.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
1182: remote ->- org.apache.maven.archetypes:maven-archetype-quickstart (An archetype which contains a sample Maven project.)
Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): 1182:
Choose org.apache.maven.archetypes:maven-archetype-quickstart version:
1: 1.0-alpha-1
2: 1.0-alpha-2
3: 1.0-alpha-3
4: 1.0-alpha-4
5: 1.0
6: 1.1
7: 1.3
Choose a number: 7:
Downloading from central: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/maven-archetype-quickstart/1.3/maven-archetype-quickstart-1.3.pom
Downloaded from central: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/maven-archetype-quickstart/1.3/maven-archetype-quickstart-1.3.pom (1.6 kB at 4.4 kB/s)
Downloading from central: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/maven-archetype-bundles/1.3/maven-archetype-bundles-1.3.pom
Downloaded from central: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/maven-archetype-bundles/1.3/maven-archetype-bundles-1.3.pom (4.5 kB at 12 kB/s)
Downloading from central: https://repo.maven.apache.org/maven2/org/apache/maven/maven-parent/31/maven-parent-31.pom
Downloaded from central: https://repo.maven.apache.org/maven2/org/apache/maven/maven-parent/31/maven-parent-31.pom (43 kB at 84 kB/s)
Downloading from central: https://repo.maven.apache.org/maven2/org/apache/apache/19/apache-19.pom
Downloaded from central: https://repo.maven.apache.org/maven2/org/apache/apache/19/apache-19.pom (15 kB at 37 kB/s)
Downloading from central: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/maven-archetype-quickstart/1.3/maven-archetype-quickstart-1.3.jar
Downloaded from central: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/maven-archetype-quickstart/1.3/maven-archetype-quickstart-1.3.jar (7.0 kB at 7.7 kB/s)
Define value for property 'groupId': cn.fr4nk
Define value for property 'artifactId': test
Define value for property 'version' 1.0-SNAPSHOT: :
Define value for property 'package' cn.fr4nk: :
Confirm properties configuration:
groupId: cn.fr4nk
artifactId: test
version: 1.0-SNAPSHOT
package: cn.fr4nk
 Y: :
  Y: :
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Archetype: maven-archetype-quickstart:1.3
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: cn.fr4nk
[INFO] Parameter: artifactId, Value: test
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: package, Value: cn.fr4nk
[INFO] Parameter: packageInPathFormat, Value: cn/fr4nk
[INFO] Parameter: package, Value: cn.fr4nk
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: groupId, Value: cn.fr4nk
[INFO] Parameter: artifactId, Value: test
[INFO] Project created from Archetype in dir: C:\Users\fan.yang\work\projects\mvn\test
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 05:07 min
[INFO] Finished at: 2018-05-11T10:21:29+08:00
[INFO] ------------------------------------------------------------------------


一路回车，加上选填的信息，就建立了一个空Java工程。

编译和打包

Maven 对项目管理包括如下阶段：

  • Validate: validates that all project information is available and is correct
  • Compile: compiles the source code
  • Test: runs unit tests within a suitable framework
  • Package: packages the compiled code in its distribution format
  • Integration-test: processes the package in the integration-test environment
  • Verify: runs checks to verify that the package is valid
  • Install: installs the package in the local repository
  • Deploy: installs the final package in a remote repository
  • 下载依赖： mvn dependency:resolve
  • 编译：mvn compile
  • 打包: mvn package
  • 清理：mvn clean
  • 生成eclipse 工程: mvn eclipse:eclipse
  • 清理eclipse 工程: mvn eclipse:clean

展开全文 >>

斐讯 K2 路由器刷 breed 与第三方固件教程

介绍

斐讯 K2 路由器用399入手了，号称399其实做工也就一般，凑合用用。因为其可以刷机，而且可以免费兑换（K码结合APP注册返现），故而入手。

斐讯 K2 最简单刷 breed 与第三方固件教程

上面的文章，我没有成功，因为我的固件版本是：22.5.11.14。按照如下论坛的方法成功刷入 breed ：

【刷机必读】斐讯K2刷breed的安全方法及开源一键刷机脚本和终极大法【2017-04-24】

其中,我把最有技术含量的东西修改好放到我的博客，就是如下代码了：

1
05 |wget -T 10 http://www.frank.cn/uploads/breed-mt7620-phicomm-psg1208.bin -O /tmp/breed.bin && [ -f /tmp/breed.bin ] && [ $(md5sum /tmp/breed.bin|cut -d ' ' -f1) = cfbc68e305b6c0da38c0bb89c47814a3  ] && mtd unlock Bootloader&&mtd -r write /tmp/breed.bin Bootloader

等同于：

1
2
3
4
5
6
7
8
9
10
11
12
13
#K2能正常联网，下载breed，设置10秒超时
wget -T 10 http://www.frank.cn/uploads/breed-mt7620-phicomm-psg1208.bin -O /tmp/breed.bin

#判断是否有下载文件
if [ -f "/tmp/breed.bin" ] ;then
vmd5=`md5sum /tmp/breed.bin|cut -d ' ' -f1 `
#判断下载文件的MD5值是否正确
if [ "$vmd5" = "cfbc68e305b6c0da38c0bb89c47814a3" ] ;then
  #如果正确则开始刷写breed
  mtd unlock Bootloader
  mtd -r write /tmp/breed.bin Bootloader
fi
fi

原始文件从官网https://breed.hackpascal.net/下载的。

展开全文 >>

感知机模型

感知机模型是一种线性分类模型，可以用于解决2分类问题，同时它也是支持向量机SVM模型的基础。

一般不直接使用这个简单的模型，可以使用一些技巧，将原来线性不可分的问题转换成线性可分的问题，再使用它或者SVM算法。

问题定义

设$\chi$是定义在$R^{n}$的输入空间，分类结果$Y = \{-1, +1\}$。

对于$\bf x_{i} \in \chi, i=1,…,m$ 线性可分，意味存在一个超平面$w^{T} \bf x+b=0$ （$w$,$b$均是一个$n$维列向量），使得对所有的$y_{i}=1$有 $sign(w^{T}\bf x+b) > 0$；对所有的$y_{i}=-1$有 $sign(w^{T}\bf x+b) > 0$。

现在已知$\chi$线性可分，我们需要根据训练数据，找到对应的超平面$w^{T}\bf x+b=0$ （求出向量$w$,$b$）。对于新的数据 $\bf x_j$，根据$sign(w^{T}\bf x+b)$ 判断$y_j$属于1还是-1.

$$
y_{j} =
\begin{cases}
1& sign(w^{T}\bf x+b) > 0 \\
-1& sign(w^{T}\bf x+b) < 0
\end{cases}
$$

点到超平面的距离

在介绍损失函数之前，需要知道$R^{n}$维空间中，一个点$x$距离超平面$w^{T}\bf x+b=0$的距离怎么求？

超平面$w^{T}\bf x+b=0$的法向量是$w$，在超平面上任意选一点$\bf x’$,点$\bf x$距离超平面$w^{T}\bf x+b=0$的距离$h$等于向量$\vec{\bf x’x}=(\bf x-\bf x’)$在$w$上投影的长度。

$$
h = ||(\bf x-\bf x’)||_{2} \cos \theta \tag{2.1}
$$
其中，$\theta$是$\vec{\bf x’x}$和$w$的夹角。

$$
\cos \theta = \frac{w^{T}(\bf x-\bf x’)} {||w||_{2}||\bf x-\bf x’||_{2}} \tag{2.1}
$$

结合$2.1$,可知，

$$
h = \frac{w^{T}(\bf x-\bf x’)} {||w||_{2}} = \frac{|w^{T}\bf x+b|} {||w||_{2}} \tag{2.3}
$$

其中$||w||_{2}$表示2范数。

向量的范数
对于向量$x=[x_1,x_2,…,x_n]^T$，范数表示一种函数，意义用于表达“长度”。常见的范数有L0-范数，L1-范数，L2-范数，无穷范数，Lp-范数。

  • L0-范数: 表示向量$x$中非0元素的个数，用于表示向量的稀疏性。
  • L1-范数: 表示向量$x$元素的绝对值之和，$\sum_i^n(|x_i|)$
  • L2-范数: 表示向量$x$元素的平方之和的平方根，$\sqrt{\sum_i^n(x_i^{2})}$
  • 无穷范数: 表示向量$x$元素最大的一个，$\max (x_i)$
  • Lp-范数: 是L2范数的扩展，${[\sum_i^n(x_i^{p})]}^{\frac{1}{p}}$

损失函数

现在的策略是最小化使用超平面$w^{T}\bf x+b=0$误分类导致的误差。这个损失函数可以表示为所有误分类的点$x_i$，到超平面的距离之和最小。

因为误分类了$x_i$，对于$y_i=1$,有$sign(w^{T}\bf x_i+b)<0$，$-y_i(w^{T}\bf x_i+b)>0$。
对于$y_i=-1$,有$sign(w^{T}\bf x_i+b)>0$，$-y(w^{T}\bf x_i+b)>0$。

假设误分类点集合是$\it M$，那么目标要求是最小化所有错误分类点到超平面距离最小，即：
$$
\min \sum_{\bf x_i \in \it M} {\frac{-y_i(w^{T}\bf x_{i}+b)} {||w||_2}} \tag {3.1}
$$

因为$||w||_2$不变，所以可以定义如下损失函数:

$$
L(w, b) = \sum_{\bf x_i \in \it M} { -y_i(w^{T}\bf x_{i}+b)} \tag {3.2}
$$

学习的策略就是最小化损失函数，得到参数$w^{*}, b^{*}$:

$$
(w^{*}, b^{*}) = \arg \min L(w, b) \tag {3.3}
$$

最优化问题：使用梯度下降法

假设误分类点集合是$\it M$不变，那么对于$3.3$，在$\it M$中某一点$\bf x_i$梯度有：
$$
\nabla_{\it w} L(w, b) = - y_i\bf x_i \tag {4.1}
$$

$$
\nabla_{\it b} L(w, b) = - y_i\tag {4.2}
$$

算法首先选取一个初始值$(w_0,b_0)$，然后从误分类点集合是$\it M$中选取一个点$\bf x_i$,更新$w,b$，
$$
\begin{align}
w_i &= w_{i-1} + \alpha y_i\bf x_i \\
b_i &= b_{i-1} + \alpha y_i \tag {4.3}
\end{align}
$$

因为是最小化，所以选取负梯度方向作为迭代更新，$0 \< \alpha \le 1$称为学习率。根据新的参数$(w_i,b_i)$，确定错误分类的点集合$\it M$。重复迭代，直到没有误分类的点（$M$为空）。

梯度下降法，多说一些…

梯度的概念和求法见我另一篇文章。

梯度代表函数某一点增长率最大的方向。所以，对于最小化问题，选择负梯度方向作为下降方向迭代。

机器学习问题，就是从训练数据得出预测模型，选取的策略就是预测模型的经验误差$\rm J(\rm \theta)$最小化。

$$
\arg \min_{\bf x_i \in X} \rm J(\rm \theta) \tag {5.1}
$$

迭代方式：

$$
\theta_{n} = \theta_{n-1} + \alpha \nabla _{\theta} \rm J(\rm \theta) \tag {5.2}
$$

这个最优化问题是关于参数$\it\theta$的函数，训练数据$\bf x_i$本身是作为已知参数加入进去的。根据所选的训练数据大小不同，梯度下降法又可以分为：

  • 批量梯度下降法：考虑所有的训练数据，计算$5.2$时$5.1$中的$\bf X$是全体训练数据集合；
  • 随机梯度下降法：每次迭代$5.2$，只从训练数据中随机选取一个数据计算；
  • 小批量梯度下降法：每次迭代$5.2$，每次从训练数据中选取一部分数据作为$\bf X$；

参考

李航 《统计学习》
机器之心：深度解读最流行的优化算法：梯度下降

展开全文 >>

梯度基础概念

在多元函数$f(\bf x), \bf x = (x_1,…,x_n)$中，梯度表示随$\bf x$增大，函数$f(\bf x)$增长最快的方向。负梯度则表示减少最快的方向。因此对于无约束优化问题而言，可以使用迭代的方式，每次迭代选择梯度方向（或者负梯度）来寻找极大（小）的值点。

梯度定义

对于$n×1$的向量$\bf x=(x_1,…,x_n)^{T}$,定义梯度算子$\nabla_{\bf x}$:
$$
\nabla_{\bf x}(\bf x) = (\frac {\partial}{\partial x_1}, …, \frac {\partial}{\partial x_n})^{T} \tag {1.1}
$$

对于包含$n×1$的向量$\bf x=(x_1,…,x_n)^{T}$的函数$f(\bf x)$,定义梯度算子$\nabla_{ \bf x }$:
$$
\nabla_{\bf x}(f(\bf x)) = (\frac {\partial f(\bf x)}{\partial x_1}, …, \frac {\partial f(\bf x)}{\partial x_n})^{T} \tag {1.2}
$$

如果此时$f(\bf x) = [f_1(\bf x), f_2(\bf x),…,f_m(\bf x)]$, 那么此时的梯度是一个$n×m$的矩阵：
$$
\nabla_{\bf x} f(\bf x) =
\left[
\begin{matrix}
\frac {\partial f_1(\bf x)}{\partial x_1} & … & \frac {\partial f_m(\bf x)}{\partial x_1} \\
… & … & … \\
\frac {\partial f_n(\bf 1)}{\partial x_n} & … & \frac {\partial f_m(\bf x)}{\partial x_n}
\end{matrix}
\right]_{n×m} \tag {1.3}
$$

$1.3$又有1种特殊情况：

如果 $f(\bf x) = [x_1, x_2, … , x_n]$, 带入$1.3$，得下：
$$
\nabla_{\bf x} f(\bf x) =
\left[
\begin{matrix}
1 & 0& … & 0 \\
0 & 1 & … & 0 \\
0 & … & … & 0 \\
0 & … & … & 1
\end{matrix}
\right] = I_{n×n} \tag {1.3}
$$

得到：
$$
\nabla f(\bf x^T) = \frac{\partial \bf x^{T}}{\partial \bf x} = I_{n×n} \tag {1.4}
$$

梯度计算方法

首先给出几个特殊例子：

  • 假设$A$与向量$\bf x$无关，$A\bf x$ 是一个标量函数,$A \bf x = (A \bf x)^T = x^TA^T$，那么：
    $$
    \nabla A \bf x = \frac{\partial A \bf x }{\partial \bf x} = \frac{\partial \bf x^{T}A^T}{\partial \bf x} = A ^T
    $$
  • 假设$A\bf y$与向量$\bf x$无关，则
    $$
    \nabla f(\bf x^T A \bf y) = \frac{\partial \bf x^{T}}{\partial \bf x} A \bf y = A \bf y
    $$
  • 假设$A$是与向量$\bf x = [x_1,x_2,…,x_n]^T$无关的方阵$A=[a_1,a_2,…,a_n]$，$\bf xA\bf x$ 是一个标量函数$\bf xA\bf x = \sum_i^n \sum_j^n (x_i a_{ij} x_j)$，那么 $\nabla (\frac{\bf x^T A \bf x} {\bf x})$列向量的第k个分量：
    $$
    \begin{align}
    \left [\nabla \left (\frac{\bf x^T A \bf x} {x_k} \right) \right]_k = & \sum_j^n ( a_{kj} x_j) + \sum_i^n ( a_{ik} x_i) \\
    = & \sum_j^n ( a_{kj}) \bf x + \sum_i^n (a_{ik} ) \bf x
    \end{align}
    $$ 所以，完整得到： $$
    \nabla \left (\frac{\bf x^T A \bf x} {\bf x} \right) = A \bf x+ A^T \bf x = (A+A^T)\bf x
    $$

由上，可以归纳出如下的求梯度的法则：

  • 假设向量$a$与向量$\bf x$无关的常数向量，那么：
    $$
    \nabla a^T \bf x = \it a, \nabla a \bf x = \it a^T, \nabla a f(\bf x) = \frac{\partial \it f(\bf x)^T}{\partial \bf x} \it a^T,
    $$
  • 假设$\it A$是与$\bf x$无关的方阵，那么 $$
    \nabla \left ( \it f(\bf x)^T A \it f(\bf x) \right) = \frac{\partial \it f(\bf x)^T}{\partial \bf x} (A+A^T) f(\bf x)
    $$
  • 其他还有乘法法则、链式法则等等请见参考资料

参考

http://www.voidcn.com/article/p-ponrkmdt-xd.html

[矩阵分析与应用].张贤达.2004

展开全文 >>

决策树学习

介绍

决策树模型可以解决分类问题，升级版的决策树还可解决回归问题（CART）称为分类回归树。

决策树的节点分为2类：中间节点和叶子节点。其中中间节点对应训练数据的特征，叶子节点对应分类的结果。

下面举个例子，邮件分类的规则：

特征1 特征2 分类结果
email地址包含18+ 内容包含澳门 赌场邮件
email地址不包含18+ 内容包含澳门 正常邮件
email地址包含18+ 内容包含最大 垃圾垃圾
email地址不包含18+ 内容包含最大 正常邮件

根据上述规则得出的决策树：

中间节点都是特征，分类结果是叶子节点。

决策树学习模型

决策树模型可以与if-then的规则方法和条件概率对应起来。因为决策树的内部节点都是特征，从根节点（初始特征）出发遍历到叶子节点（分类）可以看成是经过一系列的if-then规则选择之后的结果。

此外，

决策树还表示在给定特征的条件下类的条件概率分布。

这句话怎么理解？这一条件概率定义为在对特征空间的一个划分的条件下定义一个分类的概率。说白了，就是从根节点（初始特征）出发遍历到叶子节点（分类）可以看成选择一些特征，然后得到叶子节点就得出了一个分类。

条件概率$P(\bf X| \bf Y)$中，$\bf Y$的取值为所有分类的结果，$\bf X$则是特征空间的一个划分（一些特征的组合）。

决策树学习模型本质，是从训练数据出发构建一棵树形结构，树的中间节点为特征，因此学习的过程就是不断迭代的选择特征$X$一直得到叶子节点（即分类$\bf Y$）。

训练的目标是让损失函数最小，即得出的决策树对训练数据的误差最小，但这又可能会陷入过拟合的误区。因为一颗决策树，深度越大，说明对训练数据训练的越细致，会失去部分泛化的能力。解决方式是剪枝。

如何定义损失函数，如何定义剪枝的标准呢？

信息熵

熵的概念对我而言是事物有序无序的一个度量，比如越杂乱无序，熵值是越大，越有序，则熵值越小。

在信息论和概率统计中，熵是对随机变量不确定性的度量。熵越大，随机变量不确定性越大，反之越小。

定义离散随机变量$X$,可能的取值包括${x_1,…,x_n}$,概率分布:
$$
P(X = x_i) = p_i \text{ , i=1…n } \tag {3.1}
$$
随机变量$X$的熵定义为：
$$
H(X) = - \sum_{i=1}^{n} p_i\log(p_i) \tag {3.2}
$$
因为$H(X)$与$X$的取值无关，仅仅与分布有关，随机变量$X$的熵又可写为$H(p)=H(X)$。

设随机变量$X,Y$的联合概率分布为$P(X,Y)$，有：
$$
P(X=x_i,Y=y_j) = p_{ij} \tag {3.3}
$$

条件概率熵$H(Y|X)$表示在随机变量$X$确定的条件下随机变量$Y$的不确定性，定义为在随机变量$X$给定的条件下条件概率分布的熵的期望：
$$
H(X|Y) = \sum_{i=1}^{n} p_{i}H(X=x_i|Y) \tag {3.4}
$$

信息增益和增益率

当随机变量和联合概率分布都是由极大似然估计得来时，所对应的熵和条件概率熵分别成为经验熵和经验条件熵。

信息增益$g(D,X)$定义为经验熵$H(D)$和特征$X$给定条件下条件熵$H(D|X)$之间的差值，表示在给定特征$X$条件下使得类$Y$不确定性减小的程度：

$$
g(D,X) = H(D) - H(D|X) \tag {4.1}
$$

决策树算法ID3就是以信息增益作为目标，选取特征作为中间节点。但是有个缺点，就是会对取值较多的特征有所偏好，故C4.5算法定义了增益率作为目标：

$$
R(D,X) = \frac{g(D,X)} {H(D)} \tag {4.2}
$$

决策树生成算法

  • 输入：训练数据集合$D$，特征集合$A$，分类结果集合$C=\{c_1,…,c_k\}$
  • 输出：决策树$T$
  • 过程：
    • (1) if ( $D$只有一个分类结果$c_k$ ), 返回叶节点$c_k$
    • (2) if ( $A=\varnothing $ ), 返回数据集合$D$中出现最多的分类$c_k$作为叶节点
    • (3) 根据划分标准从特征集合中找出一个特征$a_i$作为根节点$t$，并根据该特征可能的取值，将集合$D$划分成若干子集$D_1,…,D_n$，并更新特征集合$A=A-\{a_i\}$
    • (4) 对生成的子集$D_1,…,D_n$和$A$，按照步骤(1)-(3)递归生成子树
    • (5) 返回决策树
  • 说明：
    • 决策树的中间节点是特征
    • 决策树的叶子节点是分类结果$c_k$
    • 划分标准包括信息增益、增益率等

参考

李航 《统计学习》

展开全文 >>

Python爬虫之Scrapy上手指南

介绍

目前学习了2周机器学习+数据分析方面的知识，但是一直没有实践。网上有一些测试数据可供练习Pandas和可视化，但是还是觉得很假，造出来的数据。于是我想写个爬虫，在网上抓抓数据，实战一下。

现在机器学习和数据方向的工作很热门，但是作为我来说还是不太了解职场的行情，于是我萌生了抓抓招聘网站的数据想法。因为提到招聘网站，我第一个想到就是猎聘网，所以我就选取它作为抓取的对象。

抓取工具方面，之前有使用过原生requests + beautifulSoup + 正则的方式抓取过链家网的房价数据。纯练手还是可以，但是我们的目的是获取数据，因此最快抓取到数据才是我们的目的。
于是乎，选择了Scrapy，作为我的抓取工具，本文也是对我建立工程的介绍以及Scrapy快速上手的指南。

Scrapy 快速上手

我使用了 Anaconda 2的Python环境，安装 Scrapy是一件很轻松的事：

1
pip install scrapy

此外 scrapy-cookbook中文版也是很好的阅读材料，可以帮我们快速上手。

接下来可以使用 Scrapy 了，这部分内容部分来自截取教程：

  • 创建一个新的Scrapy工程
  • 定义你所需要要抽取的Item对象
  • 编写一个spider来爬取某个网站并提取出所有的Item对象
  • 编写一个Item Pipline来存储提取出来的Item对象

在开始之前,我首先访问了猎聘网,并设计了我需要的数据字段:

1
2
工作编号	工作名称	薪资水平	地点	学历要求	工作经验	工作描述	公司编号	公司名称	公司详情
job_id	job_title	salary	address	education	experience	job_description	company_id	company_name	company_detail

可以看出，数据是包括工作信息和公司信息的。

当我在猎聘搜索职位时，URL是这样的：

1
https://www.liepin.com/zhaopin/?pubTime=&ckid=1332aa8f01903528&fromSearchBtn=2&compkind=&isAnalysis=true&init=-1&searchType=1&flushckid=1&dqs=020&industryType=&jobKind=&sortFlag=15&industries=&salary=20$30&compscale=&key=%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90+%E6%8C%96%E6%8E%98&clean_condition=&headckid=1332aa8f01903528&d_pageSize=40&siTag=QO8nKG85cnMdx-KPcDMiNQ~r3i1HcfrfE3VRWBaGW6LoA&d_headId=bbf230b06ecffc26c174201bc44f6c50&d_ckId=bbf230b06ecffc26c174201bc44f6c50&d_sfrom=search_unknown&d_curPage=0

可以看到搜索条件可以包含：薪水范围，工作名关键字，行业，分页信息。

可以说相当完善了，于是我选择如下url作为我起始抓取的URL，并将工作关键词设置为“数据分析 挖掘”

1
https://www.liepin.com/zhaopin/?d_pageSize=40&industries=040&dqs=020&key=%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90++%E6%8C%96%E6%8E%98&d_curPage=1

创建工程和设定item

采集的数据模型建好以后，可以使用scrapy 创建工程采集数据了。

1
2
scrapy startproject data_analyzer_jd
cd data_analyzer_jd

其中data_analyzer_jd可以改成你的工程的名称。

根据我的模型，我在 items.py中如下定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import scrapy


class JobDetailItem(scrapy.Item):
    # define the fields for your item here like:
    # name = scrapy.Field()
    job_id = scrapy.Field()
    job_title = scrapy.Field()
    salary = scrapy.Field()
    salary_min = scrapy.Field()
    salary_max = scrapy.Field()
    job_req = scrapy.Field()
    address = scrapy.Field()
    education = scrapy.Field()
    experience = scrapy.Field()
    job_desp = scrapy.Field()
    comp_id = scrapy.Field()
    comp_name = scrapy.Field()
    comp_detail = scrapy.Field()

分析网页提取信息

接下来，需要定义我们的spider来抓取页面信息了，spider需要定义在 spiders 目录下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class JobDetailSpider(scrapy.Spider):
    name = 'jb'
    allowed_domains = ['liepin.com']

    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36',
    }

    def start_requests(self):
        url = 'https://www.liepin.com/zhaopin/?d_pageSize=40&industries=040&dqs=020&key=%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90++%E6%8C%96%E6%8E%98&d_curPage=1'
        yield Request(url, headers=self.headers)

    def parse(self, response):
        pass

这里我定义了一个名为JobDetailSpider的spider, 一个spider可以看成是一类抓取任务，我们需要不断的生成抓取的URL、实现抓取内容的逻辑。

抓取的内容分为2步：

  • 首先，我在首页获取、解析一个页面中40条工作信息的详情URL，解析下一页的URL并放入放入待抓取的队列中
  • 解析每一个工作的详情页，使用XPath解析得到具体的item

下图是第一步，可以看到链接的具体URL。

下图是第二步，可以看到我们需要采集的具体内容。

这2步的逻辑都写在 parse(self, response)这个方法中。

XPath的介绍

其实逻辑比较简单，就是 XPath语法的使用，这里简单提一下XPath。

如下一个文档结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
<html>
<body>
    <div class="hehe">
        <ul class="lalal">
            content
        </ul>
        <span>
            some words
            <a href="http://xxx/">Link</a>
        </span>
    </div>
</body>
</html>

想要获取到ul的内容，可以这样写：

1
//ul[@class="lalal"]/text()

//表示从文件根开始查找，不管中间节点，一直找到就行。
ul[@class="lalal"]表示找到css属性为lalal的ul标签。
/text()表示取该标签的文本，不包括格式。

我如果想要 <a>的地址如何写呢，如下：

1
//span/a/@href

更多的请自行谷歌了

启动爬虫

运行命令：

1
scrapy crawl jb -o items.csv

这样，抓取的数据就保存到items.csv中了，开心~

其他

我还写了2个Pipeline用于处理抓取到的item，比如去除html标签，和用正则提取薪水的上限和下限。
写了一个run.py，可以按照日期命名保存的数据。

接下来的，我利用采集的数据，简单分析了一下，使用jieba中文分词，统计了工作要求的高频词汇，并制作了图云，先放一波图。

工具的要求

工作内容的要求

小结

以上就是对Scrapy工具快速上手的介绍，所有的代码放在这里https://github.com/lxyangfan/job_analyser
接下来，可以再介绍词云的生成，以及探究一下工作年限、掌握的技能跟薪水之间的关系，目测可以使用贝叶斯回归来做（因为不久前才学，想试试…)
学习使用scikit机器学习包，玩玩这个数据。

展开全文 >>

Python 中的字符编码：str,unicode，utf-8...

介绍

Python 2.7中让人头晕的编码问题几乎是每个初学者的恶梦，今天就来扒一扒。

相关概念：

  • unicode： 是一种编码标准，不涉及具体实现，实现方式有多种如 utf-8,utf-16.
  • utf-8: 是unicode的一种实现，表示8位一组，貌似也是可变长度的编码方式
  • ascii：大学时候就接触过，能表示英文字符128个，最简单，无法表示中文

总结一下来说，unicode是一种编码标准，可以编码包括中英文在内的所有字符集合，但是unicode在实现方式上出于节省空间的角度，有utf-8/utf-16等等实现方式。

Python 中的字符串编码

python 2.7 是支持unicode标准，这是肯定的。具体跟字符串相关的有2个类：str和unicode,它们分别是basestring的子类。

既然是不同的子类，那就当然不一样。

如下：

1
2
3
4
5
6
7
s1 = 'hello'
s2 = '你好'
type(s1)    # str
type(s2)    # 还是 str

s3 = u'你好'
type(s3)    # 变成 unicode了

Python 中正确使用字符串编码的姿势

  • S1： 保持编码方式的统一，IDE\文件\源代码 都是utf-8的编码方式
  • S2：
    • decode early, 对于是str类型的变量，使用decode(‘utf-8’)转化成unicode
    • unicode everywhere, 过程中愉快的统一使用 unicode
    • encode last，最终结果保存到文件还是输出哪里，对unicode字符串使用encode(‘utf-8’)保存

参考

PYTHON-进阶-编码处理小结

展开全文 >>

逻辑回归模型 Logistic Regression

逻辑分布

介绍逻辑回归以前，首先介绍逻辑分布。假设一个随机变量$\bf X$ 满足逻辑分布，则 $\bf X$ 的分布函数 $F(\bf X)$为:

$$
F(\bf X) = \frac{1} {1+ e^{ \frac{-(X-u)}{r}}} \tag{1.1}
$$

逻辑回归模型

逻辑模型属于判断模型，即不去计算具体的$P(Y,X)$联合概率分布，而是通过$P(Y|X)$判断分类的结果。逻辑回归模型有如下假设：

$$
P(Y=1|X) = \frac{e^{W^TX}} {1+ e^{W^TX}}
\tag{2.1}
$$

$$
P(Y=0|X) = \frac{1} {1+ e^{W^TX}}
\tag{2.2}
$$

对于新的数据$X’$, 通过计算$2.1$, $2.2$取概率更大的作为分类的结果。

策略

设采样的数据为$X=\{x_{1}, …, x_{n}\}$， 其中的每一条数据有$m$个维度 $x_i= \{x^{1}_{i},…,x^{m}_{i}\}$。现在根据采样数据 $X$，求逻辑回归参数 $W$。

极大似然估计法是假设$X$服从某个分布$f(X,\theta)$,通过采样数据，估计出分布$f(X,\theta)$。这里假设采样数据是独立同分布采样得出的。有一种最简单有效的参数估计方法，估计的参数在目前抽样的数据上表现最好，即使得$f(X|\theta)$的联合概率最大。设似然函数$L(\theta|x_1,…,x_n)$：

$$
\arg \max_\theta L(\theta|x_1,…,x_n) \tag{3.1}
$$

以上就是求逻辑回归模型参数的策略。

对于分类问题，先定义似然函数$L(W)$如下：
$$
\arg \max_{W}L(W) = \arg P(Y|X;W) = \prod_{i=1}^{n} P(y_i|x_i;W) \tag{3.2}
$$

对于单个样本的后验概率$P(y_i|x_i;W)$，结合$2.1,2.2$,得：
$$
\begin{align}
h(x_i) &= \frac{e^{W^Tx_i}}{1+e^{W^Tx_i}} \tag{3.3} \\
P(y_i|x_i;W) &= h(x_i)^{y_i}(1-h(x_i))^{1-y_i} \tag{3.4}
\end{align}
$$

算法

对$3.2$的求解，可以使用梯度下降法、随机梯度下降、共轭梯度法、牛顿法等等。这里可以参考下面引用的文章，具体暂不介绍了。To Be Continued…

参考资料

Logistic Regression 模型简介-美团技术

逻辑回归模型(Logistic Regression, LR)基础

【机器学习算法系列之二】浅析Logistic Regression

展开全文 >>

朴素贝叶斯分类

条件概率和贝叶斯定理

条件概率：定义在事件A发生的条件下发生事件B的概率，记为$P(A|B)$，$P(A|B)$称为事件A的后验概率。

贝叶斯定理：

$$P(A|B) = \frac{P(AB)}{P(B)} \tag{1.1} $$

其中，$P(AB)$表示事件A和事件B同时发生的概率，$P(B)$表示事件B发生的概率，也被称为先验概率。

贝叶斯定理稍作变换，可以得到一个很有用的推论：

$$P(Y_i|X) = \frac{P(XY_i)}{P(X)} = \frac{P(Y_i)P(X|Y_i)}{P(X)} \tag{1.2}$$

后验概率$P(Y=c_i|\bf X) $最大意味着预期损失 $R_{exp}$ 最小

推论${1.2}$是使用朴素贝叶斯分类的理论依据：

这里，设 $\bf X=\{\rm X_{1},…, \rm X_{n}\}$ 为 $n$ 个训练数据，每条训练数据 $\rm X_{i}$ 包括 $m$ 个特征， $\rm X_{i} = \{x_{i}^{1},…,x_{i}^{m}\}$。$Y=c_i$为预测结果（如分类的结果）。$P(Y=c_i|\bf X)$表示在训练数据为 $\bf X$ 的条件下，分类结果为 $c_i$ 的概率。

为此，我们只需得到这样的 $c_i$ 作为分类的结果，使得：
$$\arg \max_{c_i} P(Y=c_i|X) \tag{1.3}$$

我们的策略是最小化预期损失$R_{exp}(f(\bf X))$，定义$0-1$损失函数：
$$L(y, f(\bf X)) =
\left \{
\begin{align}
1 & , y = f(\bf X)\\
0 & , y \ne f(\bf X)
\end{align}
\right.
\tag{1.4}
$$

数学期望$R_{exp}(f(\bf X))$是对联合概率分布 $P(\bf X, Y)$取的，
$$
\begin{align}
& \arg \min_{c_i} R_{exp}(f(\bf X)) \\
& = \arg \min_{c_i} \sum_{i=1}^{n} \sum_{j=1}^{k} P(c_j, \rm X_i)L(c_j, f(\rm X_i)) \\
& = \arg \min_{c_i} \sum_{i=1}^{n} \sum_{j=1}^{k} P(y \ne c_j, \rm X_i), \it y = f(\rm X_i) \ne c_j \\
& = \arg \min_{c_i} \sum_{i=1}^{n} \sum_{j=1}^{k} (1 - P(y = c_j, \rm X_i) ) \\
& = \arg \max_{c_i} \sum_{i=1}^{n} \sum_{j=1}^{k} P(y = c_j, \rm X_i) \\
& = \arg \max_{c_i} \sum_{i=1}^{n} \sum_{j=1}^{k} P(c_j | \rm X_i) P(\rm X_i) \\
& = \arg \max_{c_i} P(c_j | \bf X) \\
\end{align}$$

因此最大化后验概率就是最小化预期损失。

朴素贝叶斯分类

设特征$X = (x_1, x_2, …, x_n)$，则$P(X|Y_i) = P(x_1,x_2,…,x_n|Y_i)$。这里假设$x_1,x_2$都是互相独立的，这是一个很强的假设，因此称为朴素贝叶斯 (native bayes) :
$$
\begin{align}
P(X|Y_i) = & P(x_1,x_2,…,x_n|Y_i) \\
= & P(x_1|Y_i)P(x_2|Y_i)…P(x_n|Y_i) \\
= & \prod_{k=1}^{n} P(x_k|Y_i) \tag{2.1}
\end{align}$$

$$P(Y_i|X) = \frac{P(Y_i)P(X|Y_i)}{P(X)} \tag{2.2}$$

将${2.1}$代入${2.2}$，得：

$$
P(Y = c_i|X) = \frac{P(Y_i)\prod_{k=1}^{n} P(x_k|Y_i) }{P(X)} \tag{2.3}
$$

注意到${2.3}$中的$P(X)$对所有的分类$c_i$都是一样的，结合$1.3$得朴素贝叶斯分类器：

$$
y = f(x) = \arg \max_{Y_i} P(Y_i)\prod_{k=1}^{n} P(x_k|Y_i) \tag{2.4}
$$

对于${2.4}$, 哪些式子是从训练数据得到的，又该怎么使用这个模型？

  • 训练数据得到的: $P(x_k|Y=c_i)$ 当分类结果为$c_i$时出现特征$x_k$的概率；$P(Y_i)=P(Y=c_i)$为所有训练数据中分类为$c_i$的先验概率；
  • 如何使用模型？对于一个新数据$\mathbf X^{j}$, 首先统计出其中包括哪些特征$\rm K = \{x_1,x_3…,x_m\}$,计算${2.4}$时，哪些特征$x_k$出现，则参与$\prod_{k\in \rm K} P(x_k|Y_i)$

算法

有了${2.4}$定义的最优化问题，下面需要给出求解的算法。

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家