整合营销服务商
电脑端+手机端+微信端=数据同步管理
免费咨询热线：
电脑端+手机端+微信端=数据同步管理
免费咨询热线：
位小伙伴，今天我们广州蓝景实训部，和大家普及一下前端技术-浏览器渲染流程，希望能帮助大家更深入地了解这方面的知识。
前言
浏览器的内核是指支持浏览器运行的最核心的程序，分为两个部分的，一是渲染引擎，另一个是JS引擎。渲染引擎在不同的浏览器中也不是都相同的。目前市面上常见的浏览器内核可以分为这四种：Trident（IE）、Gecko（火狐）、Blink（Chrome、Opera）、Webkit（Safari）。这里面大家最耳熟能详的可能就是 Webkit 内核了，Webkit 内核是当下浏览器世界真正的霸主。
本文我们就以 Webkit 为例，对现代浏览器的渲染过程进行一个深度的剖析。
页面加载过程
在介绍浏览器渲染过程之前，我们简明扼要介绍下页面的加载过程，有助于更好理解后续渲染过程。
要点如下：
例如在浏览器输入https://www.baidu.com，然后经过 DNS 解析，www.baidu.com对应的 IP 14.215.177.38（不同时间、地点对应的 IP 可能会不同）。然后浏览器向该 IP 发送 HTTP 请求。
服务端接收到 HTTP 请求，然后经过计算（向不同的用户推送不同的内容），返回 HTTP 请求，返回的内容如下：
其实就是一堆 HMTL 格式的字符串，因为只有 HTML 格式浏览器才能正确解析，这是 W3C 标准的要求。接下来就是浏览器的渲染过程。
浏览器渲染过程
从上面这个图上，我们可以看到，浏览器渲染过程如下：
解析HTML，生成DOM树，解析CSS，生成CSSOM树
将DOM树和CSSOM树结合，生成渲染树(Render Tree)
Layout(回流):根据生成的渲染树，进行回流(Layout)，得到节点的几何信息（位置，大小）
Painting(重绘):根据渲染树以及回流得到的几何信息，得到节点的绝对像素
Display: 将像素发送给GPU，最后通过调用操作系统Native GUI的API绘制，展示在页面上。（这一步其实还有很多内容，比如会在GPU将多个合成层合并为同一个层，并展示在页面中。而css3硬件加速的原理则是新建合成层，这里我们不展开，之后有机会再写一篇博客来介绍）
渲染过程看起来也不复杂，让我们来具体了解下每一步具体做了什么。
构建DOM详细流程
浏览器会遵守一套步骤将HTML文件转换为DOM树。宏观上，可以分为几个步骤：
浏览器从磁盘或网络读取HTML的原始字节(字节数据)，并根据文件的指定编码（例如 UTF-8）将它们转换成字符串。
在网络中传输的内容其实都是 0 和 1 这些字节数据。当浏览器接收到这些字节数据以后，它会将这些字节数据转换为字符串，也就是我们写的代码。
将字符串转换成Token，例如：、等。Token中会标识出当前Token是“开始标签”或是“结束标签”或着是“文本”等信息。
这时候你一定会有疑问，节点与节点之间的关系如何维护？
事实上，这就是Token要标识“起始标签”和“结束标签”等标识的作用。
例如“title”Token的起始标签和结束标签之间的节点肯定是属于“head”的子节点。
上图给出了节点之间的关系，例如：“Hello”Token位于“title”开始标签与“title”结束标签之间，表明“Hello”Token是“title”Token的子节点。同理“title”Token是“head”Token的子节点。
生成节点对象并构建DOM
事实上，构建DOM的过程中，不是等所有Token都转换完成后再去生成节点对象，而是一边生成Token一边消耗Token来生成节点对象。换句话说，每个Token被生成后，会立刻消耗这个Token创建出节点对象。注意：带有结束标签标识的Token不会创建节点对象。
接下来我们举个例子，假设有段HTML文本：
<html>
<head>
<title>Web page parsing</title>
</head>
<body>
<div>
<h1>Web page parsing</h1>
<p>This is an example Web page.</p>
</div>
</body>
</html>上面这段HTML会解析成这样：
构建CSSOM详细流程
DOM会捕获页面的内容，但浏览器还需要知道页面如何展示，所以需要构建CSSOM。
构建CSSOM的过程与构建DOM的过程非常相似，当浏览器接收到一段CSS，浏览器首先要做的是识别出Token，然后构建节点并生成CSSOM。
在这一过程中，浏览器会确定下每一个节点的样式到底是什么，并且这一过程其实是很消耗资源的。因为样式你可以自行设置给某个节点，也可以通过继承获得。在这一过程中，浏览器得递归 CSSOM 树，然后确定具体的元素到底是什么样式。
注意：CSS匹配HTML元素是一个相当复杂和有性能问题的事情。所以，DOM树要小，CSS尽量用id和class，千万不要过渡层叠下去。
构建渲染树
当我们生成 DOM 树和 CSSOM 树以后，就需要将这两棵树组合为渲染树。
在这一过程中，不是简单地将两者合并就行了。渲染树只会包括需要显示的节点和这些节点的样式信息，如果某个节点是 display: none 的，那么就不会在渲染树中显示。
注意：渲染树只包含可见的节点
我们或许有个疑惑：浏览器如果渲染过程中遇到JS文件怎么处理？
渲染过程中，如果遇到<script>就停止渲染，执行 JS 代码。因为浏览器有GUI渲染线程与JS引擎线程，为了防止渲染出现不可预期的结果，这两个线程是互斥的关系。JavaScript的加载、解析与执行会阻塞DOM的构建，也就是说，在构建DOM时，HTML解析器若遇到了JavaScript，那么它会暂停构建DOM，将控制权移交给JavaScript引擎，等JavaScript引擎运行完毕，浏览器再从中断的地方恢复DOM构建。
也就是说，如果你想首屏渲染得越快，就越不应该在首屏就加载 JS 文件，这也是建议将 script 标签放在 body 标签底部的原因。当然在当下，并不是说 script 标签必须放在底部，因为你可以给 script 标签添加 defer(延迟) 或者 async(异步) 属性（下文会介绍这两者的区别）。
JS文件不只是阻塞DOM的构建，它会导致CSSOM也阻塞DOM的构建。
原本DOM和CSSOM的构建是互不影响，井水不犯河水，但是一旦引入了JavaScript，CSSOM也开始阻塞DOM的构建，只有CSSOM构建完毕后，DOM再恢复DOM构建。
这是什么情况呢？
这是因为JavaScript不只是可以改DOM，它还可以更改样式，也就是它可以更改CSSOM。因为不完整的CSSOM是无法使用的，如果JavaScript想访问CSSOM并更改它，那么在执行JavaScript时，必须要能拿到完整的CSSOM。
所以就导致了一个现象，如果浏览器尚未完成CSSOM的下载和构建，而我们却想在此时运行脚本，那么浏览器将延迟脚本执行和DOM构建，直至其完成CSSOM的下载和构建。也就是说，在这种情况下，浏览器会先下载和构建CSSOM，然后再执行JavaScript，最后在继续构建DOM。
布局与绘制
当浏览器生成渲染树以后，就会根据渲染树来进行布局（也可以叫做回流）。这一阶段浏览器要做的事情是要弄清楚各个节点在页面中的确切位置和大小。通常这一行为也被称为“自动重排”。
布局流程的输出是一个“盒模型”，它会精确地捕获每个元素在视口内的确切位置和尺寸，所有相对测量值都将转换为屏幕上的绝对像素。
布局完成后，浏览器会立即发出“Paint Setup”和“Paint”事件，将渲染树转换成屏幕上的像素。
回流
前面我们通过构造渲染树，我们将可见DOM节点以及它对应的样式结合起来，可是我们还需要计算它们在设备视口(viewport)内的确切位置和大小，这个计算的阶段就是回流。
为了弄清每个对象在网站上的确切大小和位置，浏览器从渲染树的根节点开始遍历，我们可以以下面这个实例来表示：
<!DOCTYPE html>
<html>
<head>
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>Critial Path: Hello world!</title>
</head>
<body>
<div style="width: 50%">
<div style="width: 50%">Hello world!</div>
</div>
</body>
</html>我们可以看到，第一个div将节点的显示尺寸设置为视口宽度的50%，第二个div将其尺寸设置为父节点的50%。而在回流这个阶段，我们就需要根据视口具体的宽度，将其转为实际的像素值。（如下图）
重绘
最终，我们通过构造渲染树和回流阶段，我们知道了哪些节点是可见的，以及可见节点的样式和具体的几何信息(位置、大小)，那么我们就可以将渲染树的每个节点都转换为屏幕上的实际像素，这个阶段就叫做重绘节点。
既然知道了浏览器的渲染过程后，我们就来探讨下，何时会发生回流重绘。
何时发生回流重绘
我们前面知道了，回流这一阶段主要是计算节点的位置和几何信息，那么当页面布局和几何信息发生变化的时候，就需要回流。
比如以下情况发生回流：
根据改变的范围和程度，渲染树中或大或小的部分需要重新计算，有些改变会触发整个页面的重排，比如，滚动条出现的时候或者修改了根节点。
一些常用且会导致回流的属性和方法：
clientWidth、clientHeight、clientTop、clientLeft
offsetWidth、offsetHeight、offsetTop、offsetLeft
scrollWidth、scrollHeight、scrollTop、scrollLeft
scrollIntoView()、scrollIntoViewIfNeeded()
getComputedStyle()
getBoundingClientRect()
scrollTo()
以下情况发生重绘而不回流
当页面中元素样式的改变并不影响它在文档流中的位置时（例如：color、background-color、visibility等），浏览器会将新样式赋予给元素并重新绘制它，这个过程重绘而不回流。
注意：回流一定会触发重绘，而重绘不一定会回流
性能影响
回流比重绘的代价要更高。
有时即使仅仅回流一个单一的元素，它的父元素以及任何跟随它的元素也会产生回流。
浏览器优化机制
现代浏览器会对频繁的回流或重绘操作进行优化：
浏览器会维护一个队列，把所有引起回流和重绘的操作放入队列中，如果队列中的任务数量或者时间间隔达到一个阈值的，浏览器就会将队列清空，进行一次批处理，这样可以把多次回流和重绘变成一次。
当你访问以下属性或方法时，浏览器会立刻清空队列：
clientWidth、clientHeight、clientTop、clientLeft
offsetWidth、offsetHeight、offsetTop、offsetLeft
scrollWidth、scrollHeight、scrollTop、scrollLeft
width、height
getComputedStyle()
getBoundingClientRect()
因为队列中可能会有影响到这些属性或方法返回值的操作，即使你希望获取的信息与队列中操作引发的改变无关，浏览器也会强行清空队列，确保你拿到的值是最精确的。
以上属性和方法都需要返回最新的布局信息，因此浏览器不得不清空队列，触发回流重绘来返回正确的值。因此，我们在修改样式的时候，最好避免使用上面列出的属性，他们都会刷新渲染队列。如果要使用它们，最好将值缓存起来。
减少回流和重绘
最小化回流和重绘
由于回流和重绘可能代价比较昂贵，因此最好就是可以减少它的发生次数。为了减少发生次数，我们可以合并多次对DOM和样式的修改，然后一次处理掉。考虑这个例子
const el = document.getElementById('test');
el.style.padding = '5px';
el.style.borderLeft = '1px';
el.style.borderRight = '2px';
例子中，有三个样式属性被修改了，每一个都会影响元素的几何结构，引起回流。当然，大部分现代浏览器都对其做了优化，因此，只会触发一次重排。但是如果在旧版的浏览器或者在上面代码执行的时候，有其他代码访问了布局信息(上文中的会触发回流的布局信息)，那么就会导致三次重排。
因此，我们可以合并所有的改变然后依次处理，比如我们可以采取以下的方式：
const el = document.getElementById('test');
el.style.cssText += 'border-left: 1px; border-right: 2px; padding: 5px;';const el = document.getElementById('test');
el.className += ' active';
批量修改DOM
当我们需要对DOM对一系列修改的时候，可以通过以下步骤减少回流重绘次数：
该过程的第一步和第三步可能会引起回流，但是经过第一步之后，对DOM的所有修改都不会引起回流，因为它已经不在渲染树了。
有三种方式可以让DOM脱离文档流：
下面来个例子演示下
我们要执行一段批量插入节点的代码：
function appendDataToElement(appendToElement, data) {
let li;
for (let i = 0; i < data.length; i++) {
li = document.createElement('li');
li.textContent = 'text';
appendToElement.appendChild(li);
}
}
const ul = document.getElementById('list');
appendDataToElement(ul, data);
如果我们直接这样执行的话，由于每次循环都会插入一个新的节点，会导致浏览器回流一次。
我们可以使用这三种方式进行优化:
隐藏元素，应用修改，重新显示
第一种方法：隐藏元素，这个会在展示和隐藏节点的时候，产生两次重绘
function appendDataToElement(appendToElement, data) {
let li;
for (let i = 0; i < data.length; i++) {
li = document.createElement('li');
li.textContent = 'text';
appendToElement.appendChild(li);
}
}
const ul = document.getElementById('list');
ul.style.display = 'none';
appendDataToElement(ul, data);
ul.style.display = 'block';
第二种：使用文档片段(document fragment)在当前DOM之外构建一个子树，再把它拷贝回文档
const ul = document.getElementById('list');
const fragment = document.createDocumentFragment();
appendDataToElement(fragment, data);
ul.appendChild(fragment);
第三种：将原始元素拷贝到一个脱离文档的节点中，修改节点后，再替换原始的元素。
const ul = document.getElementById('list');
const clone = ul.cloneNode(true);
appendDataToElement(clone, data);
ul.parentNode.replaceChild(clone, ul);
避免触发同步布局事件
上文我们说过，当我们访问元素的一些属性的时候，会导致浏览器强制清空队列，进行强制同步布局。举个例子，比如说我们想将一个p标签数组的宽度赋值为一个元素的宽度，我们可能写出这样的代码：
function initP() {
for (let i = 0; i < paragraphs.length; i++) {
paragraphs[i].style.width = box.offsetWidth + 'px';
}
}
这段代码看上去是没有什么问题，可是其实会造成很大的性能问题。在每次循环的时候，都读取了box的一个offsetWidth属性值，然后利用它来更新p标签的width属性。这就导致了每一次循环的时候，浏览器都必须先使上一次循环中的样式更新操作生效，才能响应本次循环的样式读取操作。每一次循环都会强制浏览器刷新队列。我们可以优化为:
const width = box.offsetWidth;
function initP() {
for (let i = 0; i < paragraphs.length; i++) {
paragraphs[i].style.width = width + 'px';
}
}
对于复杂动画效果,使用绝对定位让其脱离文档流
对于复杂动画效果，由于会经常的引起回流重绘，因此，我们可以使用绝对定位，让它脱离文档流。否则会引起父元素以及后续元素频繁的回流。这个我们就直接上个例子。
打开这个例子后，我们可以打开控制台，控制台上会输出当前的帧数(虽然不准)。
从例子中，我们可以看到，帧数一直都没到60。这个时候，只要我们点击一下那个按钮，把这个元素设置为绝对定位，帧数就可以稳定60。
css3硬件加速（GPU加速）
比起考虑如何减少回流重绘，我们更期望的是，根本不要回流重绘。这个时候，css3硬件加速就闪亮登场啦！！
划重点：使用css3硬件加速，可以让transform、opacity、filters这些动画不会引起回流重绘 。但是对于动画的其它属性，比如background-color这些，还是会引起回流重绘的，不过它还是可以提升这些动画的性能。
如何使用css3硬件加速（GPU加速）
常见的触发硬件加速的css3属性：
css3硬件加速的坑
几点补充说明
1.async和defer的作用是什么？有什么区别?
接下来我们对比下 defer 和 async 属性的区别：
其中蓝色线代表JavaScript加载；红色线代表JavaScript执行；绿色线代表 HTML 解析。
1）情况1<script src="script.js"></script>
没有 defer 或 async，浏览器会立即加载并执行指定的脚本，也就是说不等待后续载入的文档元素，读到就加载并执行。
2）情况2 <script defer src="script.js"></script>(延迟执行)
defer 属性表示延迟执行引入的 JavaScript，即这段 JavaScript 加载时 HTML 并未停止解析，这两个过程是并行的。整个 document 解析完毕且 defer-script 也加载完成之后（这两件事情的顺序无关），会执行所有由 defer-script 加载的 JavaScript 代码，然后触发 DOMContentLoaded 事件。
3）情况3<script async src="script.js"></script> (异步下载)
async 属性表示异步执行引入的 JavaScript，与 defer 的区别在于，如果已经加载好，就会开始执行——无论此刻是 HTML 解析阶段还是 DOMContentLoaded 触发之后。需要注意的是，这种方式加载的 JavaScript 依然会阻塞 load 事件。换句话说，async-script 可能在 DOMContentLoaded 触发之前或之后执行，但一定在 load 触发之前执行。
defer 与相比普通 script，有两点区别：载入 JavaScript 文件时不阻塞 HTML 的解析，执行阶段被放到 HTML 标签解析完成之后。 在加载多个JS脚本的时候，async是无顺序的加载，而defer是有顺序的加载。
2.为什么操作DOM慢
把 DOM 和 JavaScript 各自想象成一个岛屿，它们之间用收费桥梁连接。——《高性能 JavaScript》
JS是很快的，在JS中修改DOM对象也是很快的。在JS的世界里，一切是简单的、迅速的。但DOM操作并非JS一个人的独舞，而是两个模块之间的协作。
因为DOM是属于渲染引擎中的东西，而 JS 又是JS引擎中的东西。当我们用JS去操作DOM时，本质上是JS引擎和渲染引擎之间进行了“跨界交流”。这个“跨界交流”的实现并不简单，它依赖了桥接接口作为“桥梁”（如下图）。
过“桥”要收费——这个开销本身就是不可忽略的。我们每操作一次DOM（不管是为了修改还是仅仅为了访问其值），都要过一次“桥”。过“桥”的次数一多，就会产生比较明显的性能问题。因此“减少 DOM 操作”的建议，并非空穴来风。
性能优化策略
基于上面介绍的浏览器渲染原理，DOM 和 CSSOM 结构构建顺序，初始化可以对页面渲染做些优化，提升页面性能。
总结
综上所述，我们得出这样的结论：
做 Web 自动化时，最根本的就是操作页面上的元素，首先要能找到这些元素，然后才能操作这些元素。工具或代码无法像测试人员一样用肉眼来分辨页面上的元素。那么要如何定位到这些元素，本章会介绍各种定位元素的方法。
Selenium 自带 id 定位，可以通过元素的 id 属性进行定位，比如下面的代码：
driver.find_element_by_id('kw')driver.findElement(By.id("kw"));Selenium 自带 name 定位，可以通过元素的 name 属性进行定位，比如下面的代码：
driver.find_element_by_name('wd')driver.findElement(By.name("wd"));注意：通常来说 name 属性与 id 属性在页面中唯一，推荐使用这两个属性进行定位。
XPath 是一个定位语言，英文全称为：XML Path Language，用来对 XML 上的元素进行定位，但也适用于 HTML。下面来看一个例子：
要定位的元素是百度首页的搜索输入框
首先寻找 id 为 form 的 form 元素，然后再寻找它的子元素 span，span 的 class 属性为 bg s_ipt_wr quickdelete-wrap，最后找 span 的子元素 input：
driver.find_element_by_xpath\
("//form[@id='form']/span[@class='bg s_ipt_wr quickdelete-wrap']/input")driver.findElement(By.xpath("//form[@id='form']/span[@class='bg s_ipt_wr quickdelete-wrap']/input"));下面的定位也可以找到这个 input，请注意，这里使用了双斜杠//，它可以找到子孙节点，而但斜杠/只能找到子节点：
driver.find_element_by_xpath("//form[@id='form']//input[@id='kw']")driver.findElement(By.xpath("//form[@id='form']//input[@id='kw']"));XPath 表达式更多内容可参考下面表格：
如何检验 XPath 定位是否正确？可以使用 chrome 的检查模式 → Console，输入$x(‘XPath 表达式’)即可，例如：
XPath 可以定位绝大多数元素，但是XPath采用从上到下的遍历模式，速度并不快，而 css_selector 采用样式定位，速度要优于 XPath，而且语法更简洁：
下面是 Selenium 使用 css_selector 的例子：
css_selector 找到 class 属性为 active 的元素，然后 > 表示找 class 属性为 active 的元素的子节点
driver.find_element_by_css_selector('.logo-big')driver.findElement(By.cssSelector(".logo-big"));下表列出了常用的 css_selector 表达式的用法：
使用 Chrome 的检查模式 → Console 也可以在当前页面检测 css_selector 是否正确，输入$(‘css selector 表达式’)即可：
元素中会出现文字，比如下面的分类，可以利用这段文字进行定位：
driver.find_element_by_link_text('欢迎光临霍格沃兹测试学院')driver.findElement(By.linkText("欢迎光临霍格沃兹测试学院"));也可以采用部分匹配方式，不必写全：“欢迎光临”、“欢迎光临霍格沃兹测试学院”、“霍格沃兹”
driver.find_element_by_partial_link_text('霍格沃兹测试学院')driver.findElement(By.partialLinkText("霍格沃兹测试学院"));注意：partial_link_text 与 link_text 的区别：
partial_link_text 不用写全，只需写部分即可，比如上面使用“霍格沃兹”即可匹配到“欢迎光临霍格沃兹测试学院”。
DOM 结构中，元素都有自己的 tag，比如 input tag, button tag, anchor tag 等等，每一个 tag 拥有多个属性，比如 id, name, value class,等等。下面的高亮部分就是 tag：
可以使用 tag 进行定位:
driver.find_element_by_tag_name('input')driver.findElement(By.tagName("input"));注意：尽量避免使用 tag_name 定位元素，因为有大量重复的元素！
可以通过元素的 class 属性值进行定位：
这里的 active 用的就是上图 class 的值
driver.find_element_by_class_name('active')driver.findElement(By.className("active"));Selenium 常见操作有：
输入、点击、清除在 Selenium 中对应的方法分别是 send_keys、click、clear
from selenium import webdriver
driver = webdriver.Chrome()
driver.get('http"//www.baidu.com')
driver.find_element_by_name('wd').send_keys('霍格沃兹测试学院')
driver.find_element_by_id('su').click()
driver.find_element_by_name('wd').clear()import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class AiceTest {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("http://www.baidu.com");
driver.findElement(By.id("kw")).sendKeys("霍格沃兹测试学院");
driver.findElement(By.id("su")).click();
driver.findElement(By.name("wd")).clear();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
String title = driver.getTitle();
System.out.println(title);
driver.close();
}
}关闭当前句柄窗口（不关闭进程）close()，关闭整个浏览器进程 quit()
#导入对应的依赖
from selenium import webdriver
#初始化webdriver
driver = webdriver.Chrome()
#访问网站
driver.get('http"//www.baidu.com')
#关闭当前窗口
driver.close()
#关闭浏览器
driver.quit()//导入对应的依赖
import org.openqa.selenium.WebDriver;
//初始化webdriver
WebDriver driver = new ChromeDriver();
//访问网站
driver.get("http://www.baidu.com");
//关闭当前窗口
driver.close();
//关闭浏览器
driver.quit();获取元素标签上的属性 get_attribute(‘value’)，元素的坐标 location，元素的大小 size
import logging
from selenium import webdriver
def test_baidu():
driver = webdriver.Chrome()
driver.get('https://www.baidu.com')
search = driver.find_element_by_id('su')
logging.basicConfig(level=logging.INFO)
logging.info(search.get_attribute('value'))
#获取search的value属性值并打印
logging.info(search.get_attribute('value'))
#打印search的位置坐标
logging.info(search.location)
#打印search的元素大小
logging.info(search.size)输出结果为：
INFO:root:百度一下
INFO:root:百度一下
INFO:root:{'x': 844, 'y': 188}
INFO:root:{'height': 44, 'width': 108}@Test
void baiduTest(){
webDriver = new ChromeDriver();
webDriver.get("https://www.baidu.com/");
WebElement search = webDriver.findElement(By.id("su"));
//获取search的value属性值并打印
System.out.println(search.getAttribute("value"));
//打印search的位置坐标
System.out.println(search.getLocation());
//打印search的元素大小
System.out.println(search.getSize());
}输出结果为：
百度一下
(902, 188)
(108, 44)网页源代码 page_source，刷新页面 refresh()
import logging
from selenium import webdriver
driver = webdriver.Chrome()
driver.get('http"//www.baidu.com')
#刷新页面
driver.refresh()
logging.basicConfig(level=logging.INFO)
#打印当前页面的源代码
logging.info(driver.page_source)WebDriver webDriver = new ChromeDriver();
webDriver.get("https://www.baidu.com/");
//刷新页面
webDriver.navigate().refresh();
System.out.println(webDriver.getPageSource());设置窗口大小主要有最小化、最大化和自定义设置窗口具体的大小。
from selenium import webdriver
driver = webdriver.Chrome()
driver.get('http"//www.baidu.com')
#最小化窗口
driver.minimize_window()
#最大化窗口
driver.maximize_window()
#将浏览器设置为1000*1000的大小
driver.set_window_size(1000, 1000)import org.openqa.selenium.Dimension;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import static java.lang.Thread.sleep;
public class AiceTest {
public static void main(String[] args) throws InterruptedException {
WebDriver driver = new ChromeDriver();
driver.get("http://www.baidu.com");
//设置窗口最大化
driver.manage().window().maximize();
//浏览器的设定大小
sleep(2000);
Dimension dimension = new Dimension(800, 600);
driver.manage().window().setSize(dimension);
sleep(2000);
//浏览器全屏
driver.manage().window().fullscreen();
sleep(2000);
driver.close();
}
}大家是不是对web控件的定位有了进一步的了解了呀？来跟着示例一起练习起来吧~
动学习(Active Learning)综述以及在文本分类和序列标注应用项目链接fork一下，含实践程序，因篇幅有限就没放在本博客中，如有需求请自行fork https://aistudio.baidu.com/aistudio/projectdetail/4897371?contributionType=1
在机器学习(Machine learning)领域，监督学习(Supervised learning)、非监督学习(Unsupervised learning)以及半监督学习(Semi-supervised learning)是三类研究比较多，应用比较广的学习技术，wiki上对这三种学习的简单描述如下：
其实很多机器学习都是在解决类别归属的问题，即给定一些数据，判断每条数据属于哪些类，或者和其他哪些数据属于同一类等等。这样，如果我们上来就对这一堆数据进行某种划分(聚类)，通过数据内在的一些属性和联系，将数据自动整理为某几类，这就属于非监督学习。 如果我们一开始就知道了这些数据包含的类别，并且有一部分数据(训练数据)已经标上了类标，我们通过对这些已经标好类标的数据进行归纳总结，得出一个 “数据-->类别” 的映射函数，来对剩余的数据进行分类，这就属于监督学习。 而半监督学习指的是在训练数据十分稀少的情况下，通过利用一些没有类标的数据，提高学习准确率的方法。
我们使用一些传统的监督学习方法做分类的时候，往往是训练样本规模越大，分类的效果就越好。但是在现实生活的很多场景中，标记样本地获取是比较困难的，这需要领域内的专家来进行人工标注，所花费的时间成本和经济成本都是很大的。而且，如果训练样本的规模过于庞大，训练的时间花费也会比较多。那么有没有办法，能够使用较少的训练样本来获得性能较好的分类器呢？主动学习(Active Learning)为我们提供了这种可能。主动学习通过一定的算法查询最有用的未标记样本，并交由专家进行标记，然后用查询到的样本训练分类模型来提高模型的精确度。
主动学习是一种策略/算法，是对现有模型的增强。而不是新模型架构。主动学习背后的关键思想是，如果允许机器学习算法选择它学习的数据，这样就可以用更少的训练标签实现更高的准确性。——Active Learning Literature Survey, Burr Settles。通过为专家的标记工作进行优先级排序可以大大减少训练模型所需的标记数据量。降低成本，同时提高准确性。
主动学习不是一次为所有的数据收集所有的标签，而是对模型理解最困难的数据进行优先级排序，并仅对那些数据要求标注标签。然后模型对少量已标记的数据进行训练，训练完成后再次要求对最不确定数据进行更多的标记。
通过对不确定的样本进行优先排序，模型可以让专家（人工）集中精力提供最有用的信息。这有助于模型更快地学习，并让专家跳过对模型没有太大帮助的数据。这样在某些情况下，可以大大减少需要从专家那里收集的标签数量，并且仍然可以得到一个很好的模型。这样可以为机器学习项目节省时间和金钱!
主动学习的模型如下:
A=(C,Q,S,L,U)，
其中 C 为一组或者一个分类器，L是用于训练已标注的样本。Q 是查询函数，用于从未标注样本池U中查询信息量大的信息，S是督导者，可以为U中样本标注正确的标签。学习者通过少量初始标记样本L开始学习，通过一定的查询函数Q选择出一个或一批最有用的样本，并向督导者询问标签，然后利用获得的新知识来训练分类器和进行下一轮查询。主动学习是一个循环的过程，直至达到某一停止准则为止。 这个准则可以是迭代次数，也可以是准确率等指标达到设定值
在各种主动学习方法中，查询函数的设计最常用的策略是：不确定性准则（uncertainty）和差异性准则（diversity）。 不确定性越大代表信息熵越大，包含的信息越丰富；而差异性越大代表选择的样本能够更全面地代表整个数据集。
对于不确定性，我们可以借助信息熵的概念来进行理解。我们知道信息熵是衡量信息量的概念，也是衡量不确定性的概念。信息熵越大，就代表不确定性越大，包含的信息量也就越丰富。事实上，有些基于不确定性的主动学习查询函数就是使用了信息熵来设计的，比如熵值装袋查询（Entropy query-by-bagging）。所以，不确定性策略就是要想方设法地找出不确定性高的样本，因为这些样本所包含的丰富信息量，对我们训练模型来说就是有用的。
那么差异性怎么来理解呢？之前说到或查询函数每次迭代中查询一个或者一批样本。我们当然希望所查询的样本提供的信息是全面的，各个样本提供的信息不重复不冗余，即样本之间具有一定的差异性。在每轮迭代抽取单个信息量最大的样本加入训练集的情况下，每一轮迭代中模型都被重新训练，以新获得的知识去参与对样本不确定性的评估可以有效地避免数据冗余。但是如果每次迭代查询一批样本，那么就应该想办法来保证样本的差异性，避免数据冗余。
从上图也可以看出来，在相同数目的标注数据中，主动学习算法比监督学习算法的分类误差要低。这里注意横轴是标注数据的数目，对于主动学习而言，相同的标注数据下，主动学习的样本数>监督学习，这个对比主要是为了说明两者对于训练样本的使用效率不同：主动学习训练使用的样本都是经过算法筛选出来对于模型训练有帮助的数据，所以效率高。但是如果是相同样本的数量下去对比两者的误差，那肯定是监督学习占优，这是毋庸置疑的。
很多人认为主动学习也属于半监督学习的范畴了，但实际上是不一样的，半监督学习和直推学习(transductive learning)以及主动学习，都属于利用未标记数据的学习技术，但基本思想还是有区别的。
如上所述，主动学习的“主动”，指的是主动提出标注请求，也就是说，还是需要一个外在的能够对其请求进行标注的实体(通常就是相关领域人员)，即主动学习是交互进行的。
而半监督学习，特指的是学习算法不需要人工的干预，基于自身对未标记数据加以利用。
在未标记的数据集上使用主动学习的步骤是：
基于流(stream-based)的主动学习中，未标记的样例按先后顺序逐个提交给选择引擎，由选择引擎决定是否标注当前提交的样例，如果不标注，则将其丢弃。
在基于流的主动学习中，所有训练样本的集合以流的形式呈现给算法。每个样本都被单独发送给算法。算法必须立即决定是否标记这个示例。从这个池中选择的训练样本由oracle（人工的行业专家）标记，在显示下一个样本之前，该标记立即由算法接收。
于基于流的算法不能对未标注样例逐一比较，需要对样例的相应评价指标设定阈值，当提交给选择引擎的样例评价指标超过阈值，则进行标注，但这种方法需要针对不同的任务进行调整，所以难以作为一种成熟的方法投入使用。
基于池(pool-based)的主动学习中则维护一个未标注样例的集合，由选择引擎在该集合中选择当前要标注的样例。
在基于池的抽样中，训练样本从一个大的未标记数据池中选择。从这个池中选择的训练样本由oracle标记。
这种基于委员会查询的方法使用多个模型而不是一个模型。
委员会查询(Query by Committee)，它维护一个模型集合(集合被称为委员会)，通过查询（投票）选择最“有争议”的数据点作为下一个需要标记的数据点。通过这种委员会可的模式以克服一个单一模型所能表达的限制性假设（并且在任务开始时我们也不知道应该使用什么假设）。
有两个假设前提：
识别接下来需要标记的最有价值的样本的过程被称为“抽样策略”或“查询策略”。在该过程中的评分函数称为“acquisition function”。该分数的含义是：得分越高的数据点被标记后，对模型训练后的产生价值就越高。有很多中不同的采样策略，例如不确定性抽样，多样性采样等，在本节中，我们将仅关注最常用策略的不确定性度量。
不确定性抽样是一组技术，可以用于识别当前机器学习模型中的决策边界附近的未标记样本。这里信息最丰富的例子是分类器最不确定的例子。模型最不确定性的样本可能是在分类边界附近的数据。而我们模型学习的算法将通过观察这些分类最困难的样本来获得有关类边界的更多的信息。
让我们以一个具体的例子，假设正在尝试建立一个多类分类，以区分3类猫，狗，马。该模型可能会给我们以下预测：
{
"Prediction": {
"Label": "Cat",
"Prob": {
"Cat": 0.9352784428596497,
"Horse": 0.05409964170306921,
"Dog": 0.038225741147994995,
}
}
}
这个输出很可能来自softmax，它使用指数将对数转换为0-1范围的分数。
最小置信度=1（100％置信度）和每个项目的最自信的标签之间的差异。
虽然可以单独按置信度的顺序进行排名，但将不确定性得分转换为0-1范围，其中1是最不确定的分数可能很有用。因为在这种情况下，我们必须将分数标准化。我们从1中减去该值，将结果乘以N/（1-N），n为标签数。这时因为最低置信度永远不会小于标签数量（所有标签都具有相同的预测置信度的时候)。
让我们将其应用到上面的示例中，不确定性分数将是：（1-0.9352） *（3/2）= 0.0972。
最小置信度是最简单，最常用的方法，它提供预测顺序的排名，这样可以以最低的置信度对其预测标签进行采样。
不确定性抽样的最直观形式是两个置信度做高的预测之间的差值。也就是说，对于该模型预测的标签对比第二高的标签的差异有多大？这被定义为：
不确定性抽样的最直观形式是两个置信度做高的预测之间的差值。也就是说，对于该模型预测的标签对比第二高的标签的差异有多大？这被定义为：
同样我们可以将其转换为0-1范围，必须再次使用1减去该值，但是最大可能的分数已经为1了，所以不需要再进行其他操作。
让我们将置信度抽样间距应用于上面的示例数据。“猫”和“马”是前两个。使用我们的示例，这种不确定性得分将为1.0 - （0.9352–0.0540）= 0.1188。
置信度比是置信度边缘的变化，是两个分数之间的差异比率而不是间距的差异的绝对值。
应用于概率分布的熵包括将每个概率乘以其自身的对数，然后求和取负数:
让我们在示例数据上计算熵：
得到 0 - sum（–0.0705，–0.0903，–0.2273）= 0.3881
除以标签数的log得到0.3881/ log2（3）= 0.6151
基于不确定性的主动学习方法将最小化条件熵作为寻找判定函数的依据。
Bayesian Active Learning for Classification and Preference Learning（论文 2011年）通过贪婪地找到一个能使当前模型熵最大程度减少的数据点x，但由于模型参数维度很高，直接求解困难，因此在给定数据D和新增数据点x条件下，模型预测和模型参数之间的互信息。
Deep Bayesian Active Learning with Image Data（论文，代码 2017年）中实现了这一思路，过程如下：
（1）从整体的数据中选一个子集作为初始训练集，来训练任务模型（分类，分割等等）
（2）用训好的模型在剩余未标注的图像上以train模式跑多组预测，记录对每个样本的输出。
（3）计算对每个样本的熵作为不确定性分数。
（4）从大到小依次选择下一组数据标注好后加入训练集，更新训练模型（在上一代模型上fine-tuning），直到满足停止条件。
考虑到深度学习中，不能每次选一个数据样本就重新训练一次模型，而是以批数据的形式进行训练，BatchBALD: Efficient and Diverse Batch Acquisition for Deep Bayesian Active Learning（论文 2019年）中，把原来的一个样本变成了一批样本。
基于不确定性的主动学习方法依赖模型预测的分类概率来确定模型对该样本的不确定性，但这个概率并不可靠，因为使用softmax分类器的神经网络并不能识别分布外样本，且很容易对OOD样本做出过度自信的预测。
OOD（Out of Distribution(OOD) detection指的是模型能够检测出 OOD 样本，而 OOD 样本是相对于 In Distribution(ID) 样本来说的。传统的机器学习方法通常的假设是模型训练和测试的数据是独立同分布的(IID, Independent Identical Distribution)，这里训练和测试的数据都可以说是 In Distribution(ID) 。在实际应用当中，模型部署上线后得到的数据往往不能被完全控制的，也就是说模型接收的数据有可能是 OOD样本，也可以叫异常样本(outlier, abnormal)。
基于深度模型的Out of Distribution(OOD)检测相关方法介绍
在主动学习中，初始阶段使用非常少的标注样本训练模型，意味着大量的未标注样本可能都是OOD样本，若模型过早的给这部分样本一个过度自信的预测概率，就可能使我们错失一些有价值的OOD样本。如图所示，初始训练阶段，模型缺乏虚线框以外的区域的训练数据，但softmax分类器仍然会对这些区域给出很自信的预测，导致选择新的待标注样本时，图中的q点会被忽略，而若q点正好不是class B，则会影响主动学习的性能。
针对这个问题NNclassifier中设计了一个基于最近邻和支持向量的分类器来取代softmax, 使模型能对远离已有训练数据的区域产生较高的不确定性。
具体而言，每类训练学习N个支持向量，基于样本特征与各类的支持向量之间的距离，就可以定义分类概率为与这N个支持向量的核函数的最大距离：
$pc\left(fx\right)=\max n \delta\left(-d\left(fx, m_{c, n}\right)\right)$
定义了新的可以意识到OOD样本的分类器之后，作者给出了对应的主动学习策略：
Rejection confidence，用于度量远离所有支持向量的样本，如图(b)所示; confusion confidence，用于度量远离支持向量以及同时靠近多个不同类支持向量的样本，如图©所示。
$\begin{aligned} &M{\text {rejection }}(x)=\sumc\left(1-pc\left(fx\right)\right) \ &M{\text {confusion }}(x)=\sumc\left(1+pc\left(fx\right)-\max c pc\left(f_x\right)\right) \end{aligned}$
Amersfoort用RBF神经网络来促使网络具有良好的OOD样本不确定性，同时给出了基于梯度范数的双边正则来削弱特征崩溃(feature collapse)的问题。与NNClassifier相同，本文的作者也定义了一个与各类特征距离的函数K来帮助检测OOD样本，损失函数同样定义成逐类的二值交叉熵。不同于NNClassifier的是，这里的距离是每个样本与该类样本的指数滑动平均得到的。 $Kc\left(f\theta(x), ec\right)=\exp \left(-\left|Wc f\theta(x)-ec\right|_2^2 /\left(2 n \sigma^2\right)\right)$
另一个不同点在于本文加入了一个双边梯度正则项。 $\max \left(0,\left|\operatorname{grad}z \sumc K{\mathrm{c}}\right|F^2-1\right)$
这个正则项的作用有两个，一个是保证平滑性，也就是相似的输入有相似的输出，这个是由max()中的梯度部分保证的，而梯度-1则起到避免特征崩溃的作用，也就是相比单纯的使用特征范数正则，-1能够避免模型将很多不同的输入映射到完全相同的特征，也就是feature collapse。
接下来主要介绍基于特征空间覆盖的主动学习代表性工作：coreset。coreset的主要贡献：给出了基于特征空间覆盖的主动学习算法的近似损失上界；证明了新添加的样本在能够缩小标注样本对剩余样本的覆盖半径时，才能提高近似效果。
coreset认为主动学习目标就是缩小核心集误差，即主动学习选出的样本损失与全体样本损失之间的差别。
我们在主动学习挑选新样本时，并不知道样本的标签，也就没法直接求核心集损失。作者把核心集损失的上界转换做剩余训练样本与挑选出的标注样本间的最大距离。因此，主动学习问题等价于选择添加一组标注样本，使得其他样本对标注样本集的最大距离$\delta_s$ 最小，也就是k-center集覆盖问题。如图所示，蓝色为挑选出的标注样本，红色为其他样本。
Variational Adversarial Active Learning（地址 2019年）描述了一种基于池的半监督主动学习算法，它以对抗的方式（关于对抗学习的详细介绍参见这里）隐式地学习了这种采样机制。与传统的主动学习算法不同，VAAL与任务无关，也就是说，它不依赖于试图获取标注数据的任务的性能。VAAL使用变分自编码器(VAE)和训练好的对抗网络来学习潜在空间，以区分未标注和标注的数据。
核心思想 本文的出发点可以理解如下：之前很多方法的uncertainty都是基于模型的，也就是说需要有个分割/分类等模型计算预测结果，然后从结果的好坏去分析相应的被预测样本的价值。而本文的uncertainty是基于数据本身的，也就是说并非基于预测结果本身去分析，而是直接基于样本自身的特征去处理。
核心思想：利用VAE对已标注的数据和未标注的数据进行编码。因此，对于一个未标注的数据，如果其编码向量与潜在空间中向量的差异足够大，那么我们就认为该样本是有价值的。
而对于样本的选择，是通过一个对抗网络来实现的，该对抗网络被用来区分一个样本是已标注还是未标注。因此上文的VAE还有一个额外的任务，即他的编码要让判别器难以区分已经标注还是没有标注。
网络结构 VAE和对抗网络之间的最大最小博弈是这样进行的：VAE试图欺骗对抗网络去预测，所有的数据点都来自已标注池；对抗网络则学习如何区分潜在空间中的不相似性。其结构如下：
VAE和对抗网络之间的最大最小博弈是这样进行的：VAE试图欺骗对抗网络去预测，所有的数据点都来自已标注池；对抗网络则学习如何区分潜在空间中的不相似性。其结构如下：
主动学习策略
模型特点 本文的强化学习有点"离线"的味道，即最后选取出的50%数据可以很轻松的迁移至其他模型中，选择的过程只依赖VAE与判别器，而与具体的任务无关。
此外该模型训练十分耗时——从10%逐步提升5%至50%，相当于顺序训练了9个相同的模型，再考虑训练VAE与判别器的耗时，训练该主动学习框架的所需时间可能高达原有基础网络的10倍。
SRAAL（论文 https://openaccess.thecvf.com/contentCVPR2020/html/ZhangState-RelabelingAdversarialActiveLearningCVPR2020_paper.html）是VAAL的一个改进版。在VAAL中，判别器的训练的时候只有两种状态，标注/未标注。SRAAL的作者认为这样忽略了一些信息，有时候任务模型已经能很确信的对某个未标注样本做预测了，就应该降低选择这个样本的优先级。
为了实现这个思路，作者给出了一个任务模型预测不确定度的计算函数，用这个函数的输出结果作为生成对抗网络的判别器训练过程中，无标注样本的标签，而不用简单的个一个二值变量。
VAAL有效的一个关键的因素实际上是同时利用标注/无标注的样本共同训练产生特征映射，而不像之前基于特征的coreset等主动学习方法，仅用标注数据训练产生特征。
ARAL（https://arxiv.org/abs/1912.09720 2019.11）更进一步，也用这些个无标注样本来训练任务模型(如分类器)本身，整体仍然是在VAAL基础上做的，只是增加了cgan的判别器来实现半监督训练任务模型。整体来说，基于池的主动学习用标注样本来训练任务模型，合成的主动学习标注合成的样本来训练任务模型。
相比之下，VAAL用标注数据训练任务模型，用所有数据来训练产生特征；ARAL用所有的训练数据，合成数据来训练任务模型、产生特征映射。相当于使用了半监督的学习方法，与和之前纯基于监督训练的主动学习方法比较自然有所提升。
之前介绍了基于不确定性的方法，以及基于多样性的方法。接下来我们来看看融合两者的方法。就动机而言，如果只用不确定性标准来选样本，在批量选择的场景中，很容易出现选到冗余样本的问题。而在深度学习中，由于训练开销的缘故，通常都采用批主动学习，所以为了提高主动学习的效率，就得考虑批量选择高不确定性样本时的多样性问题。而从多样性样本选择方法的角度来说，单纯的特征空间覆盖算法不能区分模型是否已经能很好预测某部分样本，会限制这类方法所能达到的上限。
融合不确定性和多样性的思路主要有三种：
第一种从理论上来看很优雅，从信息论的角度推出怎么在批量选择的场景里选到对模型参数改善最有效的一组样本。但计算复杂度很高，可能并不是很实用，该论文中的实验部分也都是在很小的数据集上完成的。
这类方法实现起来最简单，非常启发式。整个主动学习分两步来做，第一步先用不确定性(熵，BALD等)选超出主动学习budget size的候选样本集，在用多样性的方法，选择能最好覆盖这个候选集的一组样本。
SA 2017 用Bootstrapping训练若干个模型，用这些模型预测的variance来表示不确定性，之后再用候选集中样本特征相似度来选取与已经选到的样本差异最大的样本，就类似coreset-greedy的做法。
CoreLog 2021 基于Proper Scoring Rules给了表示不确定性的度量，先选出不确定性大的前k%个样本，再用kmeans聚类来选择多样的样本。
这种结合的方式没毛病，但有个小的问题，很难说清咋确定这个候选集大小，到底多大能算作高不确定性，能丢到候选集里。
badge：https://arxiv.org/abs/1906.03671 2020 和第二类方法的思路很像，不确定性的用模型参数就某个样本的梯度大小来表示，多样性用kmeans++来保证。但这个方法很巧妙的地方在于，通过把这个问题丢到梯度嵌入空间来做（而不像第二类方法在样本的特征空间保证多样性），使样本的多样性和不确定性能同时得到保证。
梯度范数大小表示不确定性很好理解，和之前用熵之类的指标来表示不确定性类似，模型预测的概率小，意味着熵大，也意味着如果把这样本标了，模型要有较大的变化才能拟合好这个样本，也就是求出来的梯度大。梯度表示多样性，是这类方法的独特之处，用梯度向量来聚类，选到的差异大的样本就变成：让模型参数的更新方向不同的样本，而不是样本特征本身不同。
在用梯度表示了不确定性和多样性之后，怎么来选一批既有高不确定性，又不同的样本呢？badge的做法是Kmeans++聚类，第一个样本选梯度范数最大的样本，之后依据每个样本梯度与选到的样本梯度的差的范数来采样新的样本。这里注意这个差是两个向量的差，所以自然的避免了重复的选到梯度方向接近且范数都比较大的一组样本。
这一类方法核心的观点是，不管不确定性或多样性，而是希望选出的样本能使模型产生的变化最大。变化最大可以着眼于loss最大，也可以关注梯度的情况，比如梯度范数大小。
learning loss 2019 在任务模型上加一个小的附属子网络用来学习预测样本的损失值。训练任务模型的时候，也同时训练这个预测损失模块，之后就用这个模块来预测对哪个未标注样本的损失大，就选他。整个算法的流程图如下
损失预测模块的结构和损失计算方法如下：
主动学习(Active Learning)综述以及在文本分类和序列标注应用项目链接fork一下，含实践程序，因篇幅有限就没放在本博客中，如有需求请自行fork https://aistudio.baidu.com/aistudio/projectdetail/4897371?contributionType=1
获得有用是标注数据在训练时是非常重要的，但是标注数据可能很非常的费事费力，并且如果标注的质量不佳也会对训练产生很大的影响。主动学习是解决这个问题的一个方向，并且是一个非常好的方向。
*请认真填写需求信息，我们会在24小时内与您取得联系。
