在这个信息过载的世界,只有那些可以利用解析数据的优势来得出见解的人会获益。Python对于大数据的解释和分析具有很重要的作用。分析公司开发的很多工具都是基于Python来约束大数据块。分析师们会发现Python并不难学,它是一个强有力的数据管理和业务支持的媒介。
使用单一的语言来处理数据有它的好处。如果你以前曾经使用过C++或者Java,那么对你来说,Python应该很简单。数据分析可以使用Python实现,有足够的Python库来支持数据分析。 Pandas是一个很好的数据分析工具,因为它的工具和结构很容易被用户掌握。对于大数据来说它无疑是一个最合适的选择。即使是在数据科学领域,Python也因为它的“开发人员友好性”而使其他语言相形见绌。一个数据科学家熟悉Python的可能性要比熟悉其他语言的可能性高得多。
除了Python在数据分析中那些很明显的优点(易学,大量的在线社区等等)之外,在数据科学中的广泛使用,以及我们今天看到的大多数基于网络的分析,是Python在数据分析领域得以广泛传播的主要原因。
不论是金融衍生品还时大数据分析,Python都发挥了重要的作用。就前者而言,Python能够很好地和其它系统,软件工具以及数据流结合在一起,当然也包括R。用Python来对大数据做图表效果更好,它在速度和帮助方面也一样可靠。有些公司使用Python进行预测分析和统计分析。
开始使用
TensorFlow并不是一个纯粹的神经网络框架, 而是使用数据流图进行数值分析的框架.
TensorFlow使用有向图(graph)表示一个计算任务.图的节点称为ops(operations)表示对数据的处理,图的边flow 描述数据的流向.
该框架计算过程就是处理tensor组成的流. 这也是TensorFlow名称的来源.
TensorFlow使用tensor表示数据. tensor意为张量即高维数组,在python中使用numpy.ndarray表示.
TensorFlow使用Session执行图, 使用Variable维护状态.tf.constant是只能输出的ops, 常用作数据源.
下面我们构建一个只有两个constant做输入, 然后进行矩阵乘的简单图:
from tensorflow import Session, device, constant, matmul'''构建一个只有两个constant做输入, 然后进行矩阵乘的简单图:'''#如果不使用with session()语句, 需要手动执行session.close().
#with device设备指定了执行计算的设备:
# "/cpu:0": 机器的 CPU.
# "/gpu:0": 机器的第一个 GPU, 如果有的话.
# "/gpu:1": 机器的第二个 GPU, 以此类推.
with Session() as session: # 创建执行图的上下文
with device('/cpu:0'): # 指定运算设备
mat1 = constant([[3, 3]]) # 创建源节点
mat2 = constant([[2], [2]])
product = matmul(mat1, mat2) # 指定节点的前置节点, 创建图
result = session.run(product) # 执行计算 print(result)123456789101112131415161718
下面使用Variable做一个计数器:
from tensorflow import Session, constant, Variable, add, assign, initialize_all_variables
state = Variable(0, name='counter') # 创建计数器one = constant(1) # 创建数据源: 1val = add(state, one) # 创建新值节点update = assign(state, val) # 更新计数器setup = initialize_all_variables() # 初始化Variablewith Session() as session:
session.run(setup) # 执行初始化
print(session.run(state)) # 输出初值
for i in range(3):
session.run(update) # 执行更新
print(session.run(state)) # 输出计数器值12345678910111213
在使用变量前必须运行initialize_all_variables()返回的图, 运行Variable节点将返回变量的值.
本示例中将构建图的过程写在了上下文之外, 而且没有指定运行设备.
上面示例中session.run只接受一个op作为参数, 实际上run可以接受op列表作为输入:
session.run([op1, op2])1
上述示例一直使用constant作为数据源, feed可以在运行时动态地输入数据:
from tensorflow import Session, placeholder, mul, float32
input1 = placeholder(float32)
input2 = placeholder(float32)
output = mul(input1, input2)with Session() as session: print session.run(output, feed_dict={input1: [3], input2: [2]})1234567
实现一个简单神经网络
神经网络是应用广泛的机器学习模型, 关于神经网络的原理可以参见这篇随笔, 或者在tensorflow playground上体验一下在线demo.
首先定义一个BPNeuralNetwork类:
class BPNeuralNetwork:
def __init__(self):
self.session = tf.Session()
self.input_layer = None
self.label_layer = None
self.loss = None
self.trainer = None
self.layers = [] def __del__(self):
self.session.close()1234567891011
编写一个生成单层神经网络函数,每层神经元用一个数据流图表示.使用一个Variable矩阵表示与前置神经元的连接权重, 另一个Variable向量表示偏置值, 并为该层设置一个激励函数.
def make_layer(inputs, in_size, out_size, activate=None):
weights = tf.Variable(tf.random_normal([in_size, out_size]))
basis = tf.Variable(tf.zeros([1, out_size]) + 0.1)
result = tf.matmul(inputs, weights) + basis if activate is None: return result else: return activate(result)12345678
使用placeholder作为输入层.
self.input_layer = tf.placeholder(tf.float32, [None, 2])1
placeholder的第二个参数为张量的形状, [None, 1]表示行数不限, 列数为1的二维数组, 含义与numpy.array.shape相同.这里, self.input_layer被定义为接受二维输入的输入层.
同样使用placeholder表示训练数据的标签:
self.label_layer = tf.placeholder(tf.float32, [None, 1])1
使用make_layer为神经网络定义两个隐含层, 并用最后一层作为输出层:
self.loss = tf.reduce_mean(tf.reduce_sum(tf.square((self.label_layer - self.layers[1])), reduction_indices=[1]))1
tf.train提供了一些优化器, 可以用来训练神经网络.以损失函数最小化为目标:
self.trainer = tf.train.GradientDescentOptimizer(learn_rate).minimize(self.loss)1
使用Session运行神经网络模型:
initer = tf.initialize_all_variables()# do trainingself.session.run(initer)
for i in range(limit):
self.session.run(self.trainer, feed_dict={self.input_layer: cases, self.label_layer: labels})12345
使用训练好的模型进行预测:
self.session.run(self.layers[-1], feed_dict={self.input_layer: case})1
完整代码:
import tensorflow as tfimport numpy as npdef make_layer(inputs, in_size, out_size, activate=None):
weights = tf.Variable(tf.random_normal([in_size, out_size]))
basis = tf.Variable(tf.zeros([1, out_size]) + 0.1)
result = tf.matmul(inputs, weights) + basis if activate is None: return result else: return activate(result)class BPNeuralNetwork:
def __init__(self):
self.session = tf.Session()
self.input_layer = None
self.label_layer = None
self.loss = None
self.optimizer = None
self.layers = [] def __del__(self):
self.session.close() def train(self, cases, labels, limit=100, learn_rate=0.05):
# 构建网络
self.input_layer = tf.placeholder(tf.float32, [None, 2])
self.label_layer = tf.placeholder(tf.float32, [None, 1])
self.layers.append(make_layer(self.input_layer, 2, 10, activate=tf.nn.relu))
self.layers.append(make_layer(self.layers[0], 10, 2, activate=None))
self.loss = tf.reduce_mean(tf.reduce_sum(tf.square((self.label_layer - self.layers[1])), reduction_indices=[1]))
self.optimizer = tf.train.GradientDescentOptimizer(learn_rate).minimize(self.loss)
initer = tf.initialize_all_variables() # 做训练
self.session.run(initer) for i in range(limit):
self.session.run(self.optimizer, feed_dict={self.input_layer: cases, self.label_layer: labels}) def predict(self, case):
return self.session.run(self.layers[-1], feed_dict={self.input_layer: case}) def test(self):
x_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_data = np.array([[0, 1, 1, 0]]).transpose()
test_data = np.array([[0, 1]])
self.train(x_data, y_data)
print(self.predict(test_data))
nn = BPNeuralNetwork()
nn.test()12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152
上述模型虽然简单但是使用不灵活, 作者采用同样的思想实现了一个可以自定义输入输出维数以及多层隐含神经元的网络, 可以参见dynamic_bpnn.py
import tensorflow as tfimport numpy as npdef make_layer(inputs, in_size, out_size, activate=None):
weights = tf.Variable(tf.random_normal([in_size, out_size]))
basis = tf.Variable(tf.zeros([1, out_size]) + 0.1)
result = tf.matmul(inputs, weights) + basis if activate is None: return result else: return activate(result)class BPNeuralNetwork:
def __init__(self):
self.session = tf.Session()
self.loss = None
self.optimizer = None
self.input_n = 0
self.hidden_n = 0
self.hidden_size = []
self.output_n = 0
self.input_layer = None
self.hidden_layers = []
self.output_layer = None
self.label_layer = None
def __del__(self):
self.session.close() def setup(self, ni, nh, no):
# 设置参数个数
self.input_n = ni
self.hidden_n = len(nh) #隐藏层的数量
self.hidden_size = nh #每个隐藏层中的单元格数
self.output_n = no #构建输入层
self.input_layer = tf.placeholder(tf.float32, [None, self.input_n]) #构建标签层
self.label_layer = tf.placeholder(tf.float32, [None, self.output_n]) #构建隐藏层
in_size = self.input_n
out_size = self.hidden_size[0]
inputs = self.input_layer
self.hidden_layers.append(make_layer(inputs, in_size, out_size, activate=tf.nn.relu)) for i in range(self.hidden_n-1):
in_size = out_size
out_size = self.hidden_size[i+1]
inputs = self.hidden_layers[-1]
self.hidden_layers.append(make_layer(inputs, in_size, out_size, activate=tf.nn.relu)) #构建输出层
self.output_layer = make_layer(self.hidden_layers[-1], self.hidden_size[-1], self.output_n) def train(self, cases, labels, limit=100, learn_rate=0.05):
self.loss = tf.reduce_mean(tf.reduce_sum(tf.square((self.label_layer - self.output_layer)), reduction_indices=[1]))
self.optimizer = tf.train.GradientDescentOptimizer(learn_rate).minimize(self.loss)
initer = tf.initialize_all_variables() #做训练
self.session.run(initer) for i in range(limit):
self.session.run(self.optimizer, feed_dict={self.input_layer: cases, self.label_layer: labels}) def predict(self, case):
return self.session.run(self.output_layer, feed_dict={self.input_layer: case}) def test(self):
x_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_data = np.array([[0, 1, 1, 0]]).transpose()
test_data = np.array([[0, 1]])
self.setup(2, [10, 5], 1)
self.train(x_data, y_data)
print(self.predict(test_data))
nn = BPNeuralNetwork()
nn.test()12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
经过前面四章的学习,我们已经可以使用Requests库、Beautiful Soup库和Re库,编写基本的Python爬虫程序了。那么这一章就来学习一个专业的网络爬虫框架--Scrapy。没错,是框架,而不是像前面介绍的函数功能库。
Scrapy是一个快速、功能强大的网络爬虫框架。
可能大家还不太了解什么是框架,爬虫框架其实是实现爬虫功能的一个软件结构和功能组件的集合。
简而言之, Scrapy就是一个爬虫程序的半成品,可以帮助用户实现专业的网络爬虫。
使用Scrapy框架,不需要你编写大量的代码,Scrapy已经把大部分工作都做好了,允许你调用几句代码便自动生成爬虫程序,可以节省大量的时间。
当然,框架所生成的代码基本是一致的,如果遇到一些特定的爬虫任务时,就不如自己使用Requests库搭建来的方便了。
PyCharm安装
测试安装:
出现框架版本说明安装成功。
掌握Scrapy爬虫框架的结构是使用好Scrapy的重中之重!
先上图:
整个结构可以简单地概括为: “5+2”结构和3条数据流
5个主要模块(及功能):
(1)控制所有模块之间的数据流。
(2)可以根据条件触发事件。
(1)根据请求下载网页。
(1)对所有爬取请求进行调度管理。
(1)解析DOWNLOADER返回的响应--response。
(2)产生爬取项--scraped item。
(3)产生额外的爬取请求--request。
(1)以流水线方式处理SPIDER产生的爬取项。
(2)由一组操作顺序组成,类似流水线,每个操作是一个ITEM PIPELINES类型。
(3)清理、检查和查重爬取项中的HTML数据并将数据存储到数据库中。
2个中间键:
(1)对Engine、Scheduler、Downloader之间进行用户可配置的控制。
(2)修改、丢弃、新增请求或响应。
(1)对请求和爬取项进行再处理。
(2)修改、丢弃、新增请求或爬取项。
3条数据流:
(1):图中数字 1-2
1:Engine从Spider处获得爬取请求--request。
2:Engine将爬取请求转发给Scheduler,用于调度。
(2):图中数字 3-4-5-6
3:Engine从Scheduler处获得下一个要爬取的请求。
4:Engine将爬取请求通过中间件发送给Downloader。
5:爬取网页后,Downloader形成响应--response,通过中间件发送给Engine。
6:Engine将收到的响应通过中间件发送给Spider处理。
(3):图中数字 7-8-9
7:Spider处理响应后产生爬取项--scraped item。
8:Engine将爬取项发送给Item Pipelines。
9:Engine将爬取请求发送给Scheduler。
任务处理流程:从Spider的初始爬取请求开始爬取,Engine控制各模块数据流,不间断从Scheduler处获得爬取请求,直至请求为空,最后到Item Pipelines存储数据结束。
作为用户,只需配置好Scrapy框架的Spider和Item Pipelines,也就是数据流的入口与出口,便可完成一个爬虫程序的搭建。Scrapy提供了简单的爬虫命令语句,帮助用户一键配置剩余文件,那我们便来看看有哪些好用的命令吧。
Scrapy采用命令行创建和运行爬虫
PyCharm打开Terminal,启动Scrapy:
Scrapy基本命令行格式:
具体常用命令如下:
下面用一个例子来学习一下命令的使用:
1.建立一个Scrapy爬虫工程,在已启动的Scrapy中继续输入:
执行该命令,系统会在PyCharm的工程文件中自动创建一个工程,命名为pythonDemo。
2.产生一个Scrapy爬虫,以教育部网站为例http://www.moe.gov.cn:
命令生成了一个名为demo的spider,并在Spiders目录下生成文件demo.py。
命令仅用于生成demo.py文件,该文件也可以手动生成。
观察一下demo.py文件:
3.配置产生的spider爬虫,也就是demo.py文件:
4.运行爬虫,爬取网页:
如果爬取成功,会发现在pythonDemo下多了一个t20210816_551472.html的文件,我们所爬取的网页内容都已经写入该文件了。
以上就是Scrapy框架的简单使用了。
Request对象表示一个HTTP请求,由Spider生成,由Downloader执行。
Response对象表示一个HTTP响应,由Downloader生成,有Spider处理。
Item对象表示一个从HTML页面中提取的信息内容,由Spider生成,由Item Pipelines处理。Item类似于字典类型,可以按照字典类型来操作。