数据分析与挖掘

輕栀

已于 2024-05-05 11:34:20 修改

阅读量1.6k

点赞数 16

文章标签：数据库

于 2024-03-24 16:05:02 首次发布

本文链接：https://blog.csdn.net/mnwl12_0/article/details/136984905

版权

数据起源：

规模庞大，结构复杂，难以通过现有商业工具和技术在可容忍的时间内获取、管理和处理的数据集。具有5V特性：数量（Volume）：数据量大、多样性（Variety）：种类繁多、速度（Volocity）：处理速度快、真实性（Veracity）、数据价值：价值密度低（Value）。

数据处理的三驾马车：

分布式文件系统GFS
大数据分布式计算框架MapReduce
NoSQL数据库系统BigTable

搜索引擎主要就做两件事情：网页抓取和索引构建。三驾马车”就是用来解决这个过程中大量的数据存储和计算。一个文件系统、一个计算框架、一个数据库系统。

Doug Cutting根据三驾马车论文原理初步实现了类似GFS和MapReduce的功能，后来将这些大数据相关的功能从开源搜索引擎Nutch中分离了出来，然后启动了一个独立的项目专门开发维护大数据技术——Hadoop，主要包括Hadoop分布式文件系统HDFS和大数据计算引擎MapReduce。

Yahoo的一些人觉得用MapReduce进行大数据编程太麻烦了，于是便开发了Pig。Pig是一种脚本语言，使用类SQL的语法，开发者可以用Pig脚本描述要对大数据集上进行的操作，Pig经过编译后会生成MapReduce程序，然后在Hadoop上运行。

编写Pig脚本虽然比直接MapReduce编程容易，但是依然需要学习新的脚本语法。于是Facebook又发布了Hive。Hive支持使用SQL语法来进行大数据计算，然后Hive会把SQL语句转化成MapReduce的计算程序（2011年的时候，Facebook大数据平台上运行的作业90%都来源于Hive）。

随后，众多Hadoop周边产品开始出现，大数据生态体系逐渐形成，其中包括：专门将关系数据库中的数据导入导出到Hadoop平台的Sqoop；针对大规模日志进行分布式收集、聚合和传输的Flume；MapReduce工作流调度引擎Oozie等。Yarn把MapReduce执行引擎和资源调度分离开来，Yarn成为大数据平台上最主流的资源调度系统。

由于MapReduce进行机器学习计算的时候性能非常差，因为机器学习算法通常需要进行很多次的迭代计算，而MapReduce每执行一次Map和Reduce计算都需要重新启动一次作业，带来大量的无谓消耗。还有一点就是MapReduce主要使用磁盘作为存储介质。于是出现了Spark，一经推出立即受到业界的追捧，并逐步替代MapReduce在企业应用中的地位。

一般说来，像MapReduce、Spark这类计算框架处理的业务场景都被称作批处理计算，因为它们通常针对以“天”为单位产生的数据进行一次计算，然后得到需要的结果，这中间计算需要花费的时间大概是几十分钟甚至更长的时间。因为计算的数据是非在线得到的实时数据，而是历史数据，所以这类计算也被称为大数据离线计算。

在大数据领域，还有另外一类应用场景，它们需要对实时产生的大量数据进行即时计算，比如对于遍布城市的监控摄像头进行人脸识别和嫌犯追踪。这类计算称为大数据流计算，相应地，有Storm、Flink、Spark Streaming等流计算框架来满足此类大数据应用的场景。流式计算要处理的数据是实时在线产生的数据，所以这类计算也被称为大数据实时计算。

数据业务最通用的做法是，采用批处理的技术处理历史全量数据，采用流式计算处理实时新增数据。而像Flink这样的计算引擎，可以同时支持流式计算和批处理计算。

除了大数据批处理和流处理，NoSQL系统处理的主要也是大规模海量数据的存储与访问，所以也被归为大数据技术。大数据处理的主要应用场景包括数据分析、数据挖掘与机器学习。数据分析主要使用Hive、Spark SQL等SQL引擎完成；数据挖掘与机器学习则有专门的机器学习框架TensorFlow、Mahout以及MLlib等，内置了主要的机器学习和数据挖掘算法。大数据要存入分布式文件系统（HDFS），要有序调度MapReduce和Spark作业执行，并能把执行结果写入到各个应用系统的数据库中，还需要有一个大数据平台整合所有这些大数据组件和企业应用系统。

大数据应用：

搜索引擎时代：Google开发了GFS（Google文件系统），将数千台服务器上的数万块磁盘统一管理起来，然后当作一个文件系统，统一存储所有这些网页文件。Google得到这些网页文件是要构建搜索引擎，需要对所有文件中的单词进行词频统计，然后根据PageRank算法计算网页排名。基于这些需求，Google又开发了MapReduce大数据计算框架。

数据仓库时代：Hive可以在Hadoop上进行SQL操作，实现数据统计与分析。也就是说，我们可以用更低廉的价格获得比以往多得多的数据存储与计算能力。我们可以把运行日志、应用采集数据、数据库数据放到一起进行计算分析，获得以前无法得到的数据结果。

数据挖掘时代：除了数据统计，我们还希望发掘出更多数据的价值，发现数据之间关联性。

机器学习时代：在过去，我们受数据采集、存储、计算能力的限制，只能通过抽样的方式获取小部分数据，无法得到完整的、全局的、细节的规律。而现在有了大数据，可以把全部的历史数据都收集起来，统计其规律，进而预测正在发生的事情。

医疗健康领域：医学影像智能识别、病历大数据智能诊疗

教育领域： AI外语老师、智能解题

金融领域：大数据风控、量化交易

社交媒体领域：舆情监控与分析

新零售领域：全链路管理。从生产、物流、购物体验，使用大数据进行分析和预判，实现精准生产、零库存

交通领域：无人驾驶技术

大数据的存储：

单机时代，主要的解决方案是RAID（独立磁盘冗余阵列）
分布式时代，主要解决方案是分布式文件系统

大规模数据存储都需要解决核心问题：数据存储容量的问题；数据读写速度的问题；数据可靠性的问题。

RAID（独立磁盘冗余阵列）技术是将多块普通磁盘组成一个阵列，共同对外提供服务。主要是为了改善磁盘的存储容量、读写速度，增强磁盘的可用性和容错能力。目前服务器级别的计算机都支持插入多块磁盘（8块或者更多），通过使用RAID技术，实现数据在多块磁盘上的并发读写和数据备份。

数据存储容量的问题。RAID使用了N块磁盘构成一个存储阵列，如果使用RAID 5，数据就可以存储在N-1块磁盘上，这样将存储空间扩大了N-1倍。
数据读写速度的问题。RAID根据可以使用的磁盘数量，将待写入的数据分成多片，并发同时向多块磁盘进行写入，显然写入的速度可以得到明显提高；同理，读取速度也可以得到明显提高。不过，需要注意的是，由于传统机械磁盘的访问延迟主要来自于寻址时间，数据真正进行读写的时间可能只占据整个数据访问时间的一小部分，所以数据分片后对N块磁盘进行并发读写操作并不能将访问速度提高N倍。
数据可靠性的问题。使用RAID 10、RAID 5或者RAID 6方案的时候，由于数据有冗余存储，或者存储校验信息，所以当某块磁盘损坏的时候，可以通过其他磁盘上的数据和校验数据将丢失磁盘上的数据还原。

实现更强的计算能力和更大规模的数据存储有两种思路，一种是升级计算机，一种是用分布式系统。前一种也被称作“垂直伸缩”（scaling up），通过升级CPU、内存、磁盘等将一台计算机变得更强大；后一种是“水平伸缩”（scaling out），添加更多的计算机到系统中，从而实现更强大的计算能力。HDFS则是水平伸缩，通过添加更多的服务器实现数据更大、更快、更安全存储与访问。

RAID技术只是在单台服务器的多块磁盘上组成阵列，大数据需要更大规模的存储空间和更快的访问速度。将RAID思想原理应用到分布式服务器集群上，就形成了Hadoop分布式文件系统HDFS的架构思想。

大数据技术框架：

存储 – HDFS 应用场景

最基本的存储技术是HDFS。比如把通过各种渠道得到的数据，比如关系数据库的数据、日志数据、应用程序埋点采集的数据、爬虫从外部获取的数据，统统存储到HDFS上，供后续的统一使用。

存储 – HBase 应用场景

HBase作为NoSQL类非关系数据库的代表性产品，从分类上可以划分到存储类别，它的底层存储也用到了HDFS。HBase的主要用途是在某些场景下，代替MySQL之类的关系数据库的数据存储访问，利用自己可伸缩的特性，存储比MySQL多得多的数据量。

计算 – 离线大数据处理技术

大数据计算框架最早是MapReduce，目前看来，用的最多的是Spark，通常我们会用Hive或者Spark SQL这样的大数据仓库工具进行大数据分析和计算。MapReduce、Spark、Hive、Spark SQL这些技术主要用来解决离线大数据的计算，也就是针对历史数据进行计算分析，比如针对一天的历史数据计算，一天的数据是一批数据，所以也叫批处理计算。

计算 – 流处理大数据技术

而Storm、Spark Streaming、Flink这类的大数据技术是针对实时的数据进行计算，比如摄像头实时采集的数据、实时的订单数据等，数据实时流动进来，所以也叫流处理大数据技术。

资源管理 – Yarn

不管是批处理计算还是流处理计算，都需要庞大的计算资源，需要将计算任务分布到一个大规模的服务器集群上。那么如何管理这些服务器集群的计算资源，如何对一个计算请求进行资源分配，这就是大数据集群资源管理框架Yarn的主要作用。各种大数据计算引擎，不管是批处理还是流处理，都可以通过Yarn进行资源分配，运行在一个集群中。在由很多台服务器组成的服务器集群中，某台服务器可能运行着HDFS的DataNode进程，负责HDFS的数据存储；同时也运行着Yarn的NodeManager，负责计算资源的调度管理；而MapReduce、Spark、Storm、Flink这些批处理或者流处理大数据计算引擎则通过Yarn的调度，运行在NodeManager的容器（container）里面。

Hive和Hue区别：

Hive 是注册表中的一组键、子键，具有一组包含数据备份的支持文件。基本上，配置单元是存储 Windows 注册表信息的位置。每个配置单元都包含一棵树，该树具有不同的键，键用作树的起点或注册表中层次结构的顶部的根。注册表包含注册表项、注册表子项和注册表值。所有被视为配置单元的键都以“HKEY”开头。Hives 是一组注册表键，当所有其他键都被最小化时，它们在屏幕左侧显示为文件夹。无法创建、删除或重命名 Hive。

Hue 是一个提供多种服务的 Web 用户界面，Hue 是一个 Hadoop 框架。Hue 提供了一个 Web 用户界面以及用于浏览 HDFS 的文件路径。Hue 最重要的功能是作业浏览器、Hadoop shell、用户管理员权限、Impala 编辑器、HDFS 文件浏览器、Pig 编辑器、Hive 编辑器、Ozzie Web 界面和 Hadoop API 访问。此 Web UI 布局可帮助用户浏览文件，类似于普通 Windows 用户在其计算机上查找文件的方式。Hue 为编程语言提供了 Web 用户界面，这是用户在执行查询时避免语法错误的便捷工具。只能使用 Web 浏览器安装或配置 Hue。

大数据基准测试工具HiBench：

是Intel推出的一个大数据基准测试工具。大数据作为一个生态体系，不但有各种直接进行大数据处理的平台和框架，比如HDFS、MapReduce、Spark，还有很多周边的支撑工具，而大数据基准测试工具就是其中一个大类。作用是对各种大数据产品进行测试，检验大数据产品在不同硬件平台、不同数据量、不同计算任务下的性能表现。

HiBench内置了若干主要的大数据计算程序作为基准测试的负载（workload）。

Sort，对数据进行排序大数据程序。
WordCount，前面多次提到过，词频统计大数据计算程序。
TeraSort，对1TB数据进行排序，最早是一项关于软件和硬件的计算力的竞赛，所以很多大数据平台和硬件厂商进行产品宣传的时候会用TeraSort成绩作为卖点。
Bayes分类，机器学习分类算法，用于数据分类和预测。
k-means聚类，对数据集合规律进行挖掘的算法。
逻辑回归，数据进行预测和回归的算法。
SQL，包括全表扫描、聚合操作（group by）、连接操作（join）几种典型查询SQL。
PageRank，Web排序算法。

Hibench的编译需要java环境 (java 环境配置(详细教程)_java环境配置-CSDN博客)和maven(maven的下载与安装教程（超详细）_maven安装-CSDN博客)，Spark2.4.0，Scala2.11.12。

下载：https://github.com/Intel-bigdata/HiBench，下载好后解压缩到目录下，进入该目录编译：

大数据平台：

大数据计算通过将可执行的代码分发到大规模的服务器集群上进行分布式计算，以处理大规模的数据，即所谓的移动计算比移动数据更划算。但是在分布式系统中分发执行代码并启动执行，这样的计算方式必然不会很快，即使在一个规模不太大的数据集上进行一次简单计算，MapReduce也可能需要几分钟，Spark快一点，也至少需要数秒的时间。

而互联网产品处理用户请求，需要毫秒级的响应，也就是说，要在1秒内完成计算，因此大数据计算必然不能实现这样的响应要求。但是互联网应用又需要使用大数据，实现统计分析、数据挖掘、关联推荐、用户画像等一系列功能。因此要构建一个大数据平台，互联网大数据平台的架构：

大数据平台里面向用户的在线业务处理组件用褐色标示出来，这部分是属于互联网在线应用的部分，其他蓝色的部分属于大数据相关组件，使用开源大数据产品或者自己开发相关大数据组件。大数据平台由上到下可分为三个部分：数据采集、数据处理、数据输出与展示。

数据采集

将应用程序产生的数据和日志等同步到大数据系统中，由于数据源不同，这里的数据同步系统实际上是多个相关系统的组合。数据库同步通常用Sqoop，日志同步可以选择Flume，打点采集的数据经过格式化转换后通过Kafka等消息队列进行传递。

数据处理

这部分是大数据存储与计算的核心，数据同步系统导入的数据存储在HDFS。MapReduce、Hive、Spark等计算任务读取HDFS上的数据进行计算，再将计算结果写入HDFS。MapReduce、Hive、Spark等进行的计算处理被称作是离线计算，HDFS存储的数据被称为离线数据。在大数据系统上进行的离线计算通常针对（某一方面的）全体数据，比如针对历史上所有订单进行商品的关联性挖掘，这时候数据规模非常大，需要较长的运行时间，这类计算就是离线计算。

数据输出与展示

大数据计算产生的数据还是写入到HDFS中，但应用程序不可能到HDFS中读取数据，所以必须要将HDFS中的数据导出到数据库中。数据同步导出相对比较容易，计算产生的数据都比较规范，稍作处理就可以用Sqoop之类的系统导出到数据库。

将上面三个部分整合起来的是任务调度管理系统，不同的数据何时开始同步，各种MapReduce、Spark任务如何合理调度才能使资源利用最合理、等待的时间又不至于太久，同时临时的重要任务还能够尽快执行，这些都需要任务调度管理系统来完成。

简单的大数据平台任务调度管理系统其实就是一个类似Crontab的定时任务系统，按预设时间启动不同的大数据作业脚本。复杂的大数据平台任务调度还要考虑不同作业之间的依赖关系，根据依赖关系的DAG图进行作业调度，形成一种类似工作流的调度方式。

构建大数据平台的一种常规架构原型方案为Lambda架构，其原型为：

数据（new data）同时写入到批处理大数据层（batch layer）和流处理大数据层（speed layer）。
批处理大数据层是数据主要存储与计算的地方，所有的数据最终都会存储到批处理大数据层，并在这里被定期计算处理。
批处理大数据层的计算结果输出到服务层（serving layer），供应用使用者查询访问。
由于批处理的计算速度比较慢，数据只能被定期处理计算（比如每天），因此延迟也比较长（只能查询到截止前一天的数据，即数据输出需要T+1）。所以对于实时性要求比较高的查询，会交给流处理大数据层（speed layer），在这里进行即时计算，快速得到结果。
流处理计算速度快，但是得到的只是最近一段时间的数据计算结果（比如当天的）；批处理会有延迟，但是有全部的数据计算结果。所以查询访问会将批处理计算的结果和流处理计算的结果合并起来，作为最终的数据视图呈现。

大数据平台的数据来源：

大数据就是存储、计算、应用大数据的技术，如果没有数据，所谓大数据就是无源之水、无本之木，所有技术和应用也都无从谈起。可以说，数据在大数据的整个生态体系里面拥有核心的、最无可代替的地位

1、从数据库导入

在大数据技术风靡之前，关系数据库（RDMS）是数据分析与处理的主要工具，能不能将关系数据库数据处理的技巧和方法转移到大数据技术上，于是Hive、Spark SQL、Impala这样的大数据SQL产品就出现了。

虽然Hive这样的大数据产品可以提供和关系数据库一样的SQL操作，但是互联网应用产生的数据却还是只能记录在类似MySQL这样的关系数据库上。这是因为互联网应用需要实时响应用户操作，基本上都是在毫级完成用户的数据读写操作，而大数据不是为这种毫秒级的访问设计的。所以要用大数据对关系数据库上的数据进行分析处理，必须要将数据从关系数据库导入到大数据平台上，目前比较常用的数据库导入工具有Sqoop和Canal。Sqoop是一个数据库批量导入导出工具，可以将关系数据库的数据批量导入到Hadoop，也可以将Hadoop的数据导出到关系数据库。

$ sqoop import --connect jdbc:mysql://localhost/db --username foo --password --table TEST
# 指定数据库URL、用户名、密码、表名，就可以将数据表的数据导入到Hadoop

Sqoop适合关系数据库数据的批量导入，如果想实时导入关系数据库的数据，可以选择Canal。Canal是阿里巴巴开源的一个MySQL binlog获取工具，binlog是MySQL的事务日志，可用于MySQL数据库主从复制，Canal将自己伪装成MySQL从库，从MySQL获取binlog。

只要开发一个Canal客户端程序就可以解析出来MySQL的写操作数据，将这些数据交给大数据流计算处理引擎，就可以实现对MySQL数据的实时处理。

2、从日志文件导入

日志也是大数据处理与分析的重要数据来源之一，应用程序日志一方面记录了系统运行期的各种程序执行状况，一方面也记录了用户的业务处理轨迹。依据这些日志数据，可以分析程序执行状况，比如应用程序抛出的异常；也可以统计关键业务指标，比如每天的PV、UV、浏览数Top N的商品等。

Flume是大数据日志收集常用的工具。Flume最早由Cloudera开发，后来捐赠给Apache基金会作为开源项目运营。Flume架构如下：

Flume收集日志的核心组件是Flume Agent，负责将日志从数据源收集起来并保存到大数据存储设备。

Agent Source负责收集日志数据，支持从Kafka、本地日志文件、Socket通信端口、Unix标准输出、Thrift等各种数据源获取日志数据。

Source收集到数据后，将数据封装成event事件，发送给Channel。Channel是一个队列，有内存、磁盘、数据库等几种实现方式，主要用来对event事件消息排队，然后发送给Sink。

Sink收到数据后，将数据输出保存到大数据存储设备，比如HDFS、HBase等。Sink的输出可以作为Source的输入，这样Agent就可以级联起来，依据具体需求，组成各种处理结构，也可以将多个Agent输出汇聚到一个Agent，还可以将一个Agent输出路由分发到多个Agent，根据实际需求灵活组合。

3、爬虫系统

通过网络爬虫获取外部数据也是公司大数据的重要来源之一。有些数据分析需要行业数据支撑，有些管理和决策需要竞争对手的数据做对比，这些数据都可以通过爬虫获取。

对于百度这样的公开搜索引擎，如果遇到网页声明是禁止爬虫爬取的，通常就会放弃。但是对于企业大数据平台的爬虫，常常被禁止爬取的数据才是真正需要的数据，比如竞争对手的数据。被禁止爬取的应用通常也会采用一些反爬虫技术，比如检查请求的HTTP头信息是不是爬虫，以及对参数进行加密等。遇到这种情况，需要多花一点技术手段才能爬到想要的数据。

4、前端埋点采集

前端埋点数据采集也是互联网应用大数据的重要来源之一，用户的某些前端行为并不会产生后端请求，比如用户在一个页面的停留时间、用户拖动页面的速度、用户选中一个复选框然后又取消了。这些信息对于大数据处理，对于分析用户行为，进行智能推荐都很有价值。但是这些数据必须通过前端埋点获得，所谓前端埋点，就是应用前端为了进行数据统计和分析而采集数据。

事实上，互联网应用的数据基本都是由用户通过前端操作产生的，有些互联网公司会将前端埋点数据当作最主要的大数据来源，用户所有前端行为，都会埋点采集，再辅助结合其他的数据源，构建自己的大数据仓库，进而进行数据分析和挖掘。

埋点的方式主要有手工埋点和自动化埋点。

手工埋点就是前端开发者手动编程将需要采集的前端数据发送到后端的数据采集系统。通常公司会开发一些前端数据上报的SDK，前端工程师在需要埋点的地方，调用SDK，按照接口规范传入相关参数，比如ID、名称、页面、控件等通用参数，还有业务逻辑数据等，SDK将这些数据通过HTTP的方式发送到后端服务器。

自动化埋点则是通过一个前端程序SDK，自动收集全部用户操作事件，然后全量上传到后端服器。自动化埋点有时候也被称作无埋点，意思是无需埋点，实际上是全埋点，即全部用户操作都埋点采集。自动化埋点的好处是开发工作量小，数据规范统一。缺点是采集的数据量大，很多数据采集来也不知道有什么用，白白浪费了计算资源，特别是对于流量敏感的移动端用户而言，因为自动化埋点采集上传花费了大量的流量，可能因此成为卸载应用的理由，这样就得不偿失。

数据指标与可视化监控：

数据分析是大数据应用的一个主要场景，通过数据分析指标监控企业运营状态，及时调整运营和产品策略，是大数据技术的关键价值之一。互联网企业大数据平台上运行的绝大多数大数据计算都是关于数据分析的，各种统计、关联分析、汇总报告，都需要大数据平台来完成。

1. 新增用户数

新增用户数是网站增长性的关键指标，指新增加的访问网站的用户数（或者新下载App的用户数），对于一个处于爆发期的网站，新增用户数会在短期内出现倍增的走势，是网站的战略机遇期，很多大型网站都经历过一个甚至多个短期内用户暴增的阶段。新增用户数有日新增用户数、周新增用户数、月新增用户数等几种统计口径。

2. 用户留存率

新增的用户并不一定总是对网站（App）满意，在使用网站（App）后感到不满意，可能会注销账户（卸载App）经过一段时间依然没有流失的用户称作留存用户，留存用户数比当期新增用户数就是用户留存率。

用户留存率 = 留存用户数 / 当期新增用户数

计算留存有时间窗口，即和当期数据比，3天前新增用户留存的，称作3日留存；相应的，还有5日留存、7日留存等。用户留存率是反映用户体验和产品价值的一个重要指标。

用户流失率 = 1 - 用户留存率

3. 活跃用户数

用户下载注册，但是很少打开产品，表示产品缺乏黏性和吸引力。活跃用户数表示打开使用产品的用户数，根据统计口径不同，有日活跃用户数、月活跃用户数等

4. PV

打开产品就算活跃，打开以后是否频繁操作，就用PV这个指标衡量，用户每次点击，每个页面跳转，被称为一个PV（Page View）。PV是网页访问统计的重要指标，在移动App上，需要进行一些变通来进行统计。

5. GMV

GMV即成交总金额（Gross Merchandise Volume），是电商网站统计营业额（流水）、反映网站营收能力的重要指标。和GMV配合使用的还有订单量（用户下单总量）、客单价（单个订单的平均价格）等。

6. 转化率

转化率是指在电商网站产生购买行为的用户与访问用户之比。

转化率 = 有购买行为的用户数 / 总访问用户数

1、折线图

折线图是用的最多的可视化图表之一，通常横轴为时间，用于展示在时间维度上的数据变化规律，正向指标（比如日活跃用户数）斜率向上，负向指标（比如用户流失率）斜率向下。

2. 散点图

数据分析的时候，散点图可以有效发现数据分布上的规律与趋势，可谓肉眼聚类算法。

3. 热力图

热力图用以分析网站页面被用户访问的热点区域，以更好进行页面布局和视觉展示。

4. 漏斗图

漏斗图可谓是网站数据分析中最重要的图表，表示在用户的整个访问路径中每一步的转化率。当重要的营收指标（GMV、利润、订单量）发生异常的时候，就必须要对整个的漏斗图进行分析，判断是网站的入口流量发生了问题，还是中间某一步的转化发生了问题；是内容的问题还是系统的问题，需要逐个进行分析排查。

此外还有柱状图、饼图等，也经常用于数据分析和展示。可视化图形在数据分析时可以更准确、更快速做出趋势预判并发现问题，在汇报工作时使用图表更有说服力，决策时也更有依据和信心。

图表可用ECharts进行绘制。ECharts百度开源的一个前端可视化图表组件，使用这个组件，只需要几行代码，就可以将运营数据可视化。

A/B测试

A/B测试将每一次测试当作一个实验。通过A/B测试系统的配置，将用户随机分成两组（或者多组），每组用户访问不同版本的页面或者执行不同的处理逻辑，即运行实验。通常将原来产品特性当作一组，即原始组；新开发的产品特性当作另一组，即测试组。经过一段时间（几天甚至几周）以后，对A/B测试实验进行分析，观察两组用户的数据指标，使用新特性的测试组是否好于作为对比的原始组，如果效果比较好，那么这个新开发的特性就会在下次产品发布的时候正式发布出去，供所有用户使用；如果效果不好，这个特性就会被放弃，实验结束。如一款软件的发布：

A/B测试的系统架构：A/B测试系统最重要的是能够根据用户ID（或者设备ID）将实验配置参数分发给应用程序，应用程序根据配置参数决定给用户展示的界面和执行的业务逻辑：

在实验管理模块里进行用户分组，比如测试组、原始组，并指定每个分组用户占总用户的百分比；流量分配模块根据某种Hash算法将用户（设备）分配到某个实验组中；一个实验可以有多个参数，每个组有不同的参数值。

移动App在启动后，定时和A/B测试系统通信，根据自身用户ID或者设备ID获取自己参与的A/B测试实验的配置项，根据配置项执行不同的代码，体验不同的应用特性。应用服务器和A/B测试系统在同一个数据中心，获取实验配置的方式可以更灵活。

移动App和应用服务器上报实验数据其实就是传统的数据采集，但是在有A/B测试的情况下，数据采集上报的时候需要将A/B测试实验ID和分组ID也上报，然后在数据分析的时候，才能够将同一个实验的不同分组数据分别统计，得到A/B测试的实验数据报告。

灰度发布

经过A/B测试验证过的功能特性，就可以发布到正式的产品版本中，向所有用户开放。但是有时候在A/B测试中表现不错的特性，正式版本发布后效果却不好。此外，A/B测试的时候，每个功能都应该是独立（正交）的，正式发布的时候，所有的特性都会在同一个版本中一起发布，这些特性之间可能会有某种冲突，导致发布后的数据不理想。解决这些问题的手段是灰度发布，即不是一次将新版本发布给全部用户，而是一批一批逐渐发布给用户。在这个过程中，监控产品的各项数据指标，看是否符合预期，如果数据表现不理想，就停止灰度发布，甚至进行灰度回滚，让所有用户都恢复到以前的版本，进一步观察分析数据指标。灰度发布系统可以用A/B测试系统来承担，创建一个名叫灰度发布的实验即可，这个实验包含这次要发布的所有特性的参数，然后逐步增加测试组的用户数量，直到占比达到总用户量的100%，即为灰度发布完成。灰度发布的过程也叫作灰度放量，灰度放量是一种谨慎的产品运营手段。

大数据分类算法简介

对历史数据规律的统计，将大量数据进行分类然后发现数据之间的关系，这样当有新的数据进来时，计算机就可以利用这个关系自动进行分类。其实现在火热的机器学习本质上说就是统计学习。

eg：

KNN：K近邻（K Nearest Neighbour）算法主要原理是：对于一个需要分类的数据，将其和一组已经分类标注好的样本集合进行比较，得到距离最近的K个样本，K个样本最多归属的类别，就是这个需要分类数据的类别，如上图所示。

图中，红蓝绿三种颜色的点为样本数据，分属三种类别w1、w2、w3。对于待分类点Xu，计算和它距离最近的5个点（即K为5），这5个点最多归属的类别为w1（4个点归属w1，1个点归属w3），那么Xu的类别被分类为w1。

KNN的算法流程也非常简单：

KNN算法是一种非常简单实用的分类算法，可用于各种分类的场景，比如新闻分类、商品分类等，甚至可用于简单的文字识别。对于新闻分类，可以提前对若干新闻进行人工标注，标好新闻类别，计算好特征向量。对于一篇未分类的新闻，计算其特征向量后，跟所有已标注新闻进行距离计算，然后进一步利用KNN算法进行自动分类。

数据的距离：提取数据的特征值，根据特征值组成一个n维实数向量空间（这个空间也被称作特征空间），然后计算向量之间的空间距离。空间之间的距离计算方法有很多种，常用的有欧氏距离、余弦距离等。

对于数据 $x_{i}$ 和 $x_{j}$ ,若其特征空间为n维实数空间向量 $R^{n}$ ，即 $x_{i}=(x_{i1},x_{i2},...,x_{in})$ , $x_{j}=(x_{j1},x_{j2},...,x_{jn})$ ,则其欧氏距离为：

$d(x_{i},x_{j})=\sqrt{\sum_{k=1}^{n}((x_{ik}-x_{jk}))^{2}}$

两个数据之间的空间距离的计算公式还是这个欧氏计算公式。大多数机器学习算法都需要计算数据之间的距离，因此掌握数据的距离计算公式是掌握机器学习算法的基础。

欧氏距离是最常用的数据计算公式，但是在文本数据以及用户评价数据的机器学习中，更常用的距离计算方法是余弦相似度：

$cos(\theta )=\frac{\sum_{k=1}^{n}(x_{ik}x_{jk})}{\sqrt{\sum_{k=1}^{n}(x_{ik})^{2}}\sqrt{\sum_{k=1}^{n}(x_{jk})^{2}}}$

余弦相似度的值越接近1表示其越相似，越接近0表示其差异越大，使用余弦相似度可以消除数据的某些冗余信息，某些情况下更贴近数据的本质。

余弦相似度其实是计算向量的夹角，而欧氏距离公式是计算空间距离。余弦相似度更关注数据的相似性，比如两个用户给两件商品的打分分别是（3, 3）和（4, 4），那么两个用户对两件商品的喜好是相似的，这种情况下，余弦相似度比欧氏距离更合理。

文本特征值：

文本数据的特征值就是提取文本关键词，TF-IDF算法是比较常用且直观的一种文本关键词提取算法。这种算法是由TF和IDF两部分构成。TF是词频（Term Frequency），表示某个单词在文档中出现的频率，一个单词在一个文档中出现的越频繁，TF值越高。

$TF=\frac{The number of times a word appears in a document}{Total number of words in the document}$

IDF是逆文档频率（Inverse Document Frequency），表示这个单词在所有文档中的稀缺程度，越少文档出现这个词，IDF值越高。

$TF=log(\frac{The total number of all documents}{The number of documents where this word appears})$

TF与IDF的乘积就是TF-IDF：

TF-IDF = TF * IDF

所以如果一个词在某一个文档中频繁出现，但在所有文档中却很少出现，那么这个词很可能就是这个文档的关键词。比如一篇关于原子能的技术文章，“核裂变”“放射性”“半衰期”等词汇会在这篇文档中频繁出现，即TF很高；但是在所有文档中出现的频率却比较低，即IDF也比较高。因此这几个词的TF-IDF值就会很高，就可能是这篇文档的关键词。如果这是一篇关于中国原子能的文章，也许“中国”这个词也会频繁出现，即TF也很高，但是“中国”也在很多文档中出现，那么IDF就会比较低，最后“中国”这个词的TF-IDF就很低，不会成为这个文档的关键词。

提取出关键词以后，就可以利用关键词的词频构造特征向量，比如上面例子关于原子能的文章，“核裂变”“放射性”“半衰期”这三个词是特征值，分别出现次数为12、9、4。那么这篇文章的特征向量就是（12, 9, 4），再利用前面提到的空间距离计算公式计算与其他文档的距离，结合KNN算法就可以实现文档的自动分类。

贝叶斯分类：

基于条件概率的分类算法，如果我们已经知道A和B的发生概率，并且知道了B发生情况下A发生的概率，可以用贝叶斯公式计算A发生的情况下B发生的概率。事实上，我们可以根据A的情况，即输入数据，判断B的概率，即B的可能性，进而进行分类。

举个例子：假设走在商业街上男生占60%，女生占40%。男生总是会一见钟情，女生则一半会一见钟情一半不会一见钟情。假设你走在商业街上，迎面走来一个会一见钟情的学生，你能够推断出这个会一见钟情学生是男生的概率是多少吗？

答案是75%，具体算法就利用了贝叶斯公式，贝叶斯公式的写法是：

$P(B|A)=\frac{P(A|B)*P(B)}{P(A)}=\frac{P(A|B)*P(B)}{P(A|B)*P(B)+P(A|(1-B))*(1-P(B))}$

贝叶斯分类的一个典型的应用场合是垃圾邮件分类，通过对样本邮件的统计，我们知道每个词在邮件中出现的概率 $P(A_{i})$ ，我们也知道正常邮件概率 $P(B_{0})$ 和垃圾邮件的概率 $P(B_{1})$ ，还可以统计出垃圾邮件中各个词的出现概率 $P(A_{i}|B_{1})$ ，那么现在一封新邮件到来，我们就可以根据邮件中出现的词，计算 $P(B_{1}|A_{i})$ ，即得到这些词出现情况下，邮件为垃圾邮件的概率，进而判断邮件是否为垃圾邮件。

现实中，贝叶斯公式等号右边的概率，我们可以通过对大数据的统计获得，当有新的数据到来的时候，我们就可以带入上面的贝叶斯公式计算其概率。而如果我们设定概率超过某个值就认为其会发生，那么我们就对这个数据进行了分类和预测，具体过程如下：

训练样本就是我们的原始数据，有时候原始数据并不包含我们想要计算的维度数据，比如我们想用贝叶斯公式自动分类垃圾邮件，那么首先要对原始邮件进行标注，需要标注哪些邮件是正常邮件、哪些邮件是垃圾邮件。这一类需要对数据进行标注才能进行的机器学习训练也叫作有监督的机器学习。

数据挖掘应用场景

1、搜索排序

PageRank的算法根据网页的链接关系给网页打分。如果一个网页A，包含另一个网页B的超链接，那么就认为A网页给B网页投了一票，以下面四个网页A、B、C、D举例，带箭头的线条表示链接：

B网页包含了A、D两个页面的超链接，相当于B网页给A、D每个页面投了一票，初始的时候，所有页面都是1分，那么经过这次投票后，B给了A和D每个页面1/2分（B包含了A、D两个超链接，所以每个投票值1/2分），自己从C页面得到1/3分（C包含了A、B、D三个页面的超链接，每个投票值1/3分）。而A页面则从B、C、D分别得到1/2、1/3、1分。用公式表示就是

等号左边是经过一次投票后，A页面的PageRank分值；等号右边每一项的分子是包含A页面超链接的页面的PageRank分值，分母是该页面包含的超链接数目。

这样经过一次计算后，每个页面的PageRank分值就会重新分配，重复同样的算法过程，经过几次计算后，根据每个页面PageRank分值进行排序，就得到一个页面重要程度的排名表。根据这个排名表，将用户搜索出来的网页结果排序，排在前面的通常也正是用户想要的结果。

但是这个算法还有个问题，如果某个页面只包含指向自己的超链接，这样的话其他页面不断给它送分，而自己一分不出，随着计算执行次数越多，它的分值也就越高，这显然是不合理的。于是可以设计一个概率 $\alpha$ ，浏览一个页面的时候，有一定概率不是点击超链接，而是在地址栏输入一个URL访问其他页面，表示在公式上，就是

(1- $\alpha$ )就是跳转到其他任何页面的概率，通常取经验值0.15，即 $\alpha$ =0.85，因为有一定概率输入的URL是自己的，所以加上上面公式最后一项，其中分母4表示所有网页的总数。

那么对于N个网页，任何一个页面 $P_{i}$ 的PageRank计算公式为：

$PageRank(P_{i})=\alpha \sum_{P_{j}\in M(P_{i})}^{}(\frac{PageRank(P_{j})}{L(P_{j})})+\frac{(1-\alpha)}{N}$

公式中 $P_{j}\in M(P_{i})$ 表示所有包含有 $P_{i}$ 超链接的 $P_{j}$ ，L( $P_{j}$ )表示 $P_{j}$ 页面包含的超链接数，N表示所有的网页总和。这里的N可能是一个万亿级的数字，一开始将所有页面的PageRank值设为1，带入上面公式计算，每个页面都得到一个新的PageRank值。再把这些新的PageRank值带入上面的公式，继续得到更新的PageRank值，如此迭代计算，直到所有页面的PageRank值几乎不再有大的变化才停止。

2、关联分析

在深入关联分析前，你需要先了解两个基本概念，一个是支持度，一个是置信度。

支持度是指一组频繁模式的出现概率，比如（啤酒，尿不湿）是一组频繁模式，它的支持度是4%，也就是说，在所有订单中，同时出现啤酒和尿不湿这两件商品的概率是4%。

置信度用于衡量频繁模式内部的关联关系，如果出现尿不湿的订单全部都包含啤酒，那么就可以说购买尿不湿后购买啤酒的置信度是100%；如果出现啤酒的订单中有20%包含尿不湿，那么就可以说购买啤酒后购买尿不湿的置信度是20%。

大型超市的商品种类数量数以万计，所有商品的组合更是一个天文数字；而电子商务网站的商品种类更多，历史订单数据同样也非常庞大，如何使用最少的计算资源寻找到最小支持度的频繁模式，

寻找满足最小支持度的频繁模式经典算法是Apriori算法，其步骤是：

第1步：设置最小支持度阈值。

第2步：寻找满足最小支持度的单件商品，也就是单件商品出现在所有订单中的概率不低于最小支持度。

第3步：从第2步找到的所有满足最小支持度的单件商品中，进行两两组合，寻找满足最小支持度的两件商品组合，也就是两件商品出现在同一个订单中概率不低于最小支持度。

第4步：从第3步找到的所有满足最小支持度的两件商品，以及第2步找到的满足最小支持度的单件商品进行组合，寻找满足最小支持度的三件商品组合。

第5步：以此类推，找到所有满足最小支持度的商品组合。
Apriori算法极大地降低了需要计算的商品组合数目，这个算法的原理是，如果一个商品组合不满足最小支持度，那么所有包含这个商品组合的其他商品组合也不满足最小支持度。所以从最小商品组合，也就是一件商品开始计算最小支持度，逐渐迭代，进而筛选出所有满足最小支持度的频繁模式。

通过关联分析，可以发现看似不相关商品的关联关系，并利用这些关系进行商品营销，比如上面提到的啤酒和尿不湿的例子，一方面可以为用户提供购买便利；另一方面也能提高企业营收。

3、聚类

如何将一个数据分到几个确定类别中的一类里去。分类算法通常需要样本数据训练模型，再利用模型进行数据分类，那么一堆样本数据又如何知道各自的类别呢？样本数据归类一方面可以通过人工手动打标签，另一方面也可以利用算法进行自动归类，即所谓的“聚类”。聚类就是对一批数据进行自动归类。

K-means是一种在给定分组个数后，能够对数据进行自动归类，

第1步：随机在图中取K个种子点，图中K=2，即图中的实心小圆点。

第2步：求图中所有点到这K个种子点的距离，假如一个点离种子点X最近，那么这个点属于X点群。在图中，可以看到A、B属于上方的种子点，C、D、E属于中部的种子点。

第3步：对已经分好组的两组数据，分别求其中心点。对于图中二维平面上的数据，求中心点最简单暴力的算法就是对当前同一个分组中所有点的X坐标和Y坐标分别求平均值，得到的<x,y>就是中心点。

第4步：重复第2步和第3步，直到每个分组的中心点不再移动。这时候，距每个中心点最近的点数据聚类为同一组数据。

大数据和数据挖掘的区别

大数据： 是大型组织和企业获取的巨大、庞大或海量的数据、信息或相关统计数据。由于难以手动计算大数据，因此创建和准备了许多软件和数据存储。它用于发现模式和趋势，并做出与人类行为和交互技术相关的决策。

数据挖掘： 数据挖掘是一种从庞大的数据集/库中提取重要信息和知识的技术。它通过仔细提取、审查和处理大量数据以找出对业务很重要的模式和相互关系来获得洞察力。

大数据和云计算的区别

大数据

指规模巨大且随时间迅速增长的数据。大数据包括结构化数据、非结构化数据以及半结构化数据。大数据不能用传统的数据管理工具来存储和处理，它需要专门的大数据管理工具。它指的是复杂而庞大的数据集，具有5个V的数量、速度、真实性、价值和各种信息资产。它包括数据存储、数据分析、数据挖掘和数据可视化。

产生大数据的来源的例子包括社交媒体数据、电子商务数据、气象站数据、物联网传感器数据等。

大数据的特点:

大数据的种类 – 结构化、非结构化和半结构化数据
大数据的速度—数据生成的速度
大数据的数量—正在产生的大量的数据
大数据的价值—提取有用的信息并使其具有价值
大数据的可变性—数据有时会显示出不一致的情况。

大数据的优势 :

节省成本
更好的决策
更好的销售洞察力
提高生产力
改善客户服务。

大数据的劣势 :

不兼容的工具
安全和隐私方面的担忧
需要文化变革
技术的快速变化
特定的硬件需求。

云计算

云计算是指通过互联网按需提供计算资源。这些资源包括服务器、存储、数据库、软件、分析、网络和互联网上的智能，所有这些资源都可以根据客户的要求使用。在云计算中，客户必须按使用情况付费。它非常灵活，可以根据需求轻松地扩展资源。不需要实际购买任何IT资源，所有的资源都可以根据要求从云计算供应商那里获得。云计算有三种服务模式，即基础设施即服务(IaaS)，平台即服务(PaaS)和软件即服务(SaaS)。

提供云计算服务的云计算供应商的例子有亚马逊网络服务(AWS)、微软Azure、谷歌云平台、IBM云服务等。

云计算的特点 :

按需提供
可通过网络访问
弹性可扩展性
随用随付的模式
多租户和资源池。

云计算的优势:

备份和恢复数据
改进协作
卓越的可访问性
低维护成本
按需自助服务。

云计算的劣势:

锁定供应商
控制力有限
安全问题
由于各种原因造成的停工
需要良好的互联网连接。

文本挖掘和自然语言处理的区别

自然语言处理(NLP)

自然语言处理的重要性在于使计算机系统能够识别自然语言。虽然这不再是一个方便的挑战。计算机可以识别信息的结构化，如电子表格和数据库中的表格，但是人类的语言、文本和声音形成了非结构化的数据类别，对计算机来说，识别它是一个挑战，这就是为什么需要NLP的出现。

文本挖掘

其目标是从文本中提取重要的数字指数。因此，使文本内容中包含的事实可以被一系列的算法所利用。信息可以被提取出来，以得出文件中包含的摘要。它本质上是一种人工智能技术，包括处理各种文本内容文件中的信息。许多深度学习算法被用于对文本的有效评估。在这一点上，信息是以非结构化格式保存的。

MapR平台和Cloudera平台的区别

Cloudera

Cloudera基于开源的Apache Hadoop，但增加了自己的专利软件。它提供了免费和付费的发行版本，具有额外的功能和支持。Cloudera的长期成就是成为一个企业数据中心，从而减少/消除对数据仓库的需求。它支持MapReduce以及YARN。自Hadoop创建以来，它在这里存在的时间最长。Cloudera Distribution Hadoop(CDH)有能力向正在运行的Hadoop集群添加新的服务，并支持多集群管理。

MapR

MapR是由John Schroeder, M.C. Srivas于2009年创立。它是一个数据平台，一些数据源可以从一个计算机集群中访问，包括大数据工作负载，如Apache Hadoop和Apache Spark，Hive和Drill等等，并同时进行。它以速度、规模和可靠性执行分析和应用。像思科、谷歌云平台和亚马逊EMR这样的大公司都使用MapR Hadoop Distribution提供Hadoop服务。MapR Hadoop发行版(MapRHD)采用分布式架构在处理节点上存储元数据，因为它依赖于不同的文件系统，即MapR文件系统或简称为MapRFS，没有名称节点架构。

用Dask进行并行计算

Dask是一个灵活的开源Python库，用于并行计算。

并行计算：计算方式同时进行几个计算或进程。大型问题通常被划分为可管理的部分，可以分别解决。并行计算的四个类别是：比特级；指令级；数据层面；工作平行化。

Dask是一个平行计算的框架，与Jupyter笔记本无缝集成。最初，它是为了扩展NumPy、Pandas和Scit-kit的计算能力，以超越单机的存储限制而创建的。DASK的类似物可以用来学习，但很快它就被用作一个通用的分布式系统。其优势在于：

可扩展性

Dask与Python版本的Pandas、NumPy和Scikit-Learn进行了原生扩展，并在具有许多内核的集群上弹性地运行。它也可以缩小规模，在单个系统上运行。

Planning

与Airflow、Luigi类似，Dask任务调度器是为计算而优化的。它提供快速反馈，用任务图管理任务，并支持本地和分布式诊断，使其具有动态和响应性。此外，Dask提供了一个实时、动态的仪表盘，每100毫秒更新一次，显示各种信息，如进度、内存利用率等。

根据需要安装Dask:

# conda安装整个dask，推荐
conda instll dask
# 在某个环境安装dask
conda activate envs
pip install dask
# 只安装核心，数据库-核心 是一个受限制的Dask版本，只安装基本的组件。
conda install dask-core
"""如果用dask数据框和dask数组来扩展pandas、numpy是最重要的，也可以只安装dask数据框或dask数组。"""
# 安装数据框架
pip install "dask[dataframe]"
# 安装阵列
pip install "dask[list]"

用dask.delayed来实现并行性。以下两个代码片断应在Jupyter的两个不同单元中运行：

import time
import random
def calcprofit(a, b):
   time.sleep(random.random())
   return a + b
def calcloss(a, b):
   time.sleep(random.random())
   return a - b
def calctotal(a, b):
   time.sleep(random.random())
   return a + b

运行下面代码：

%%time
profit = calcprofit(10, 22)
loss = calcloss(18, 3)
total = calctotal(profit, loss)
print(total)

结果;

尽管它们是相互独立的，但这些功能将按顺序一个接一个地执行。因此，我们可以同时执行它们以节省时间。

import dask
calcprofit = dask.delayed(calcprofit)
calcloss = dask.delayed(calcloss)
calctotal = dask.delayed(calctotal)

现在运行下面的代码:

%%time
profit = calcprofit(10, 22)
loss = calcloss(18, 3)
total = calctotal(profit, loss)
print(total)

结果：

任务图：（需要安装Graphviz，直通车：Download | Graphviz）

total.visualize(rankdir='LR')

Spark与Dask

Spark是一个强大的集群计算框架工具，它将数据和处理分成可管理的部分，将它们分布在任何规模的集群上，并并发地执行它们。

尽管Spark是大数据分析的事实上的标准技术，但Dask似乎是相当有前途的。Dask是轻量级的，是作为Python组件开发的，而Spark有额外的能力，主要是用Scala开发的，也支持Python/R。如果想要一个现实的解决方案，甚至有JVM基础设施，Spark可以成为你的第一选择。然而，如果你想要快速、轻量级的并行处理，Dask是一个可行的选择。在快速的pip安装之后，就可以使用。

Dask, Ray, and Modin

Ray，和Dask有不同的调度策略。一个集群的所有工作都由Dask使用的中央调度器管理。由于Ray是分散的，每台计算机都有自己的调度器，允许在特定的机器上而不是在整个集群上解决计划任务的问题。Ray缺乏Dask提供的丰富的高级集合API（如数据帧、分布式阵列等）。

相反，Modin则在Dask或Ray之上驰骋。只要简单地增加一行代码，将modin.pandas导入为pd，我们就可以用Modin快速扩展我们的Pandas进程。尽管Modin努力将Pandas API的大部分内容并行化，但Dask DataFrame有时并不能扩展完整的Pandas API。

Dask提供的几个数据集。

Dask.array–使用Numpy接口，dask.array将巨大的数组分割成更小的数组，使我们能够对大于系统内存的数组进行计算。
Dask.bag–它提供了对标准Python对象集合的操作，如过滤、映射、分组和折叠。
Dask.dataframe – 分布类似于Pandas的数据框架它是一个由几个微小的数据框架构建的巨大的并行数据框架。

数据科学：将数学和统计学、专业编程、高级分析、机器学习和人工智能（AI）与特定主题的专业知识相结合，以揭示隐藏在组织数据中的可操作的洞察力。数据科学是所有行业中显示出最快增长率的领域之一。这是由于数据源和由其产生的数据量不断增加的结果。

编写生产代码，要熟悉软件工程的基本知识，因为：

完整性 – 代码的完整性是指它是如何有效地编写的，对错误有弹性，能捕捉到异常，经过测试，并受到外界的监督。
可解释性 – 代码被理解的能力及其充分的文件。
速度 – 代码的速度，它可以在现实世界中执行。
模块化 – 脚本和对象应该是模块化的，以允许重复使用，减少重复，并提高不同类的代码效率。

重构的意义：重构提供了整洁和模块化的能力。有机会提高代码的有效性。

运行时间更短
更少的内存空间
编写一个脚本来并行处理数据，同时利用机器的部分或全部处理器，这被称为并行化。

封装指的是将数据和功能整合到一个对象或模块中的能力。

测试：一个单元测试；测试驱动的开发

数据仓库

一个专门用于快速查询和分析数据的数据库。它被用来支持一个组织的决策过程，提供一个集中的数据存储库，可以很容易地访问和分析。

数据仓库中的属性类型：用各种属性来组织和描述数据，这些属性是数据的特征或属性。

名义属性是那些简单标注或分类的数据，没有任何内在的顺序或排名。例如，性别（男性或女性）、眼睛颜色（棕色、蓝色等）和产品类型（电视、冰箱等）。
顺序属性与名义属性类似，但它们确实有一个固有的顺序或等级。例如，”满意程度 “可以是一个序数属性，可能的值是 “非常满意”、”满意”、”中性”、”不满意 “和 “非常不满意”。
区间属性是数字属性，它有一个固有的顺序和一个相等的测量单位，但没有真正的零点。区间属性的一个例子是用摄氏度测量的温度。0度并不代表没有温度，所以它不是一个真正的零点。
比率属性是具有固有的顺序、真正的零点和平等的测量单位的数字属性。比例属性的例子包括重量、长度和货币价值。

数据仓库的结构和组成

数据源 – 这些是各种数据库、文件和其他进入数据仓库的数据源
提取、转换和加载（ETL）过程 – 这是从数据源中提取数据，将其转换为适合分析的格式，并将其加载到数据仓库的过程。
数据仓库数据库 – 这是一个实际的数据库，用于存储数据仓库中的数据。它通常被设计成支持快速查询，并为数据检索而不是数据插入或更新而优化。
在线分析处理（OLAP）引擎 – 这是使用户能够对数据仓库中的数据进行复杂查询和分析的组件。
前端工具 – 这些是用户与之互动以访问数据仓库中的数据的工具。例子包括SQL客户端和商业智能软件。
元数据 – 这是关于数据仓库中的数据的数据，如数据元素的定义和它们之间的关系。
数据集市 – 这些是更小，更集中的数据仓库，旨在支持特定部门或业务功能的需求。它们可能来自主数据仓库，也可能直接从数据源中获取。

属性是数据仓库的一个重要组成部分，因为它们有助于描述和分类数据。通过了解不同类型的属性和它们的组织方式，分析师可以更好地理解他们正在处理的数据，并得出更准确的结论。

考虑一个包含某公司销售数据的数据仓库。通过分析维度属性（如产品类别、地点）、度量属性（如销售数量、收入）和层次属性（如地点），该公司可能能够识别趋势，如哪些产品类别在不同地点最受欢迎，或哪些地点的销售额最高。

属性也可以用来创建预测的模型。例如，一家公司可能使用过去的销售数据和地点等属性来创建一个预测未来销售的模型。

除了在描述和分类数据方面的作用外，属性对于数据的可视化也很重要。通过根据特定的属性来组织数据，分析师可以创建图表，以帮助说明数据的趋势和模式。

MapReduce和Hive的区别

MapReduce是一种在Hadoop上工作的模型，可以有效地访问存储在HDFS(Hadoop分布式文件系统)中的大数据。它是Hadoop的核心组件，它将大数据分成小块，并对其进行并行处理。

MapReduce的特点：

MapReduce可以在不同的服务器上存储和分配巨大的数据。
MapReduce允许用户以地图和还原的形式存储数据，以获得处理。
MapReduce能保护系统不被任何未经授权的访问。
MapReduce支持并行处理模式。

Hive是一个由Facebook发起的倡议，为MapReduce编程提供了一个传统的数据仓库接口。对于以SQL方式为MapReduce编写查询，Hive编译器在后台将其转换为在Hadoop集群中执行。它帮助程序员使用他们的SQL知识，而不是专注于开发一种新的语言。

Hive的特点：

Hive提供SQL类型的语言，即HQL。
Hive帮助查询存储在HDFS(Hadoop分布式文件系统)的大型数据集。
Hive是一个开源的工具。
Hive支持灵活的项目视图，使数据可视化变得容易。

S.No	MapReduce	Hive
1	MapReduce是一种数据处理语言。	Hive是一种类似SQL的查询语言。
2	MapReduce将工作转换为map-reduce函数。	Hive将SQL查询转换为HQL(Hive-QL)。
3	MapReduce提供了低水平的抽象。	Hive提供了高层次的抽象。
4	用户很难进行连接操作。	Hive使用户很容易在HDFS上执行类似SQL的操作。
5	用户需要写10倍于Pig的代码来执行类似的任务。	与MapReduce相比，用户只需写几行代码。
6	MapReduce有多个作业，因此执行时间较长。	代码执行时间更多，但开发工作更少。
7	MapReduce被Hadoop的各个版本所支持。	Hive也支持最近版本的Hadoop。

PySpark

为了支持Python与Spark，Apache Spark社区发布了一个工具，PySpark，用PySpark，你也可以用Python编程语言来处理RDDs(Py4j 库可以实现这个目标)。PySpark提供了 PySpark Shell ，它将Python API链接到Spark核心，并初始化Spark上下文。

介绍一下Apache Spark：一个快如闪电的实时处理框架。它在内存中进行计算，实时分析数据。它的出现是因为 Apache Hadoop MapReduce 只进行批处理，缺乏实时处理功能。因此，Apache Spark被引入，因为它可以实时执行流处理，也可以处理批处理。除了实时和批处理之外，Apache Spark还支持交互式查询和迭代算法。Apache Spark有自己的集群管理器，它可以在那里托管其应用程序。它利用Apache Hadoop进行存储和处理。它使用 HDFS （Hadoop分布式文件系统）进行存储，它也可以在 YARN 上运行Spark应用程序。

这是需要考虑到电脑上已经安装了：((以powershell输入spark-shell查看）凡是出现找不到 “**\bin” 的都是安装路径有空格现象，调整路径重新安装)

note:以下建议先在anaconda创建一个python3.6环境(支持pyspark直接进入)，python3.9环境支持spark-shell进入。

Java(http://www.oracle.com/technetwork/java/javase/downloads/index.html)

scala(Scala 2.10.7 | The Scala Programming Language (scala-lang.org))Windows (msi installer)为hadoop做准备。

winutils(https://github.com/cdarlint/winutils)

hadoop（https://archive.apache.org/dist/hadoop/common Index of /dist/hadoop/common (apache.org)https://archive.apache.org/dist/hadoop/common）

进入Apache Spark的官方下载（Index of /dist/spark/spark-2.3.3 (apache.org)。

1、进入java官网下载8u391版本

下载好后安装默认路径即可，配置环境变量：

JAVA_HOME = C:\Program Files\Java\jdk-1.8
path append ：%JAVA_HOME%\bin

cmd输入java -version:

这里建议不要安装在默认位置，后续引用的时候有空格极不方便，我是安装在：C:\java，注意安装java JDK时有两次安装，你可以创建两个文件夹，java和java1，分别安装在上述两个文件夹，然后配置环境变量，这里最好在 user var 和sys var同时设置env var：

不确定是配置java1还是java在测试scala时你就会知道了。

2、进入scala官网下载对用安装包版本：

下载好后安装默认路径即可，配置环境变量：

SCALA_HOME = C:\Program Files (x86)\scala
path append ：%SCALA_HOME%\bin;%SCALA_HOME%\jre\bin;

cmd输入scala:

如果上述java配置环境变量不正确，这里会报错的，重新配置即可。

3、打包下载winutils集群zip，解压在如：C:\winutils-master\ 路径下。

4、下载hadoop2.7版本，解压到 C:\hadoop-2.7.1\bin 路径下，将C:\winutils-master\hadoop-2.7.1\bin路径下全部文件复制到C:\hadoop-2.7.1\bin做替换(hadoop是基于linux工作的，需要里面的winutils.exe)：

配置环境变量：

HADOOP_HOME = C:\hadoop-2.7.1  # 路径中不要有空格
path append ：%HADOOP_HOME%\bin

修改hadoop.env.cmd

在C:\hadoop-2.7.1\etc\hadoop路径下修改hadoop.env脚本内容：安装的java路径存在空格，在这里修改为默认的：C:\PROGRA~1\Java\jdk-1.8

若安装的路径是C:\java选择等于这个C:\java即可。

5、下载Spark：带bin-hadoop2.7版本的，下载好后解压到： C:\spark-2.4.3-bin-hadoop2.7\ 路径下，配置环境变量：

SPARK_HOME = C:\spark-2.4.3-bin-hadoop2.7
path append ：%SPARK_HOME%\bin

进入pyspark安装目录：C:\spark-2.4.3-bin-hadoop2.7\python\，将pyspark该文件夹复制到C:\Users\59980\anaconda3\envs\py39\Lib\site-packages 和C:\Users\59980\anaconda3\envs\py36\Lib\site-packages目录下。

进入命令行分别激活py39和py36环境安装：

pip install py4j
# pip install pyspark # 不要安装，安装的支持高版本python,不兼容，用复制的pyspark文件夹即可
pip install jieba

测试一下：

PySpark SparkContext：

SparkContext是任何Spark功能的入口点。当运行任何Spark应用程序时，一个驱动程序会启动，它有主要的功能，SparkContext在这里被启动。然后驱动程序在工作节点的执行器内运行操作。

SparkContext使用Py4J来启动一个 JVM 并创建一个 JavaSparkContext。 默认情况下，PySpark有SparkContext可用的 ‘sc ‘，所以创建一个新的SparkContext将不会工作。

PySpark类的细节和参数，SparkContext可以接受这些参数：

class pyspark.SparkContext (
   master = None,
   appName = None, 
   sparkHome = None, 
   pyFiles = None, 
   environment = None, 
   batchSize = 0, 
   serializer = PickleSerializer(), 
   conf = None, 
   gateway = None, 
   jsc = None, 
   profiler_cls = <class 'pyspark.profiler.BasicProfiler'>
)

SparkContext的参数：

Master – 它是它所连接的集群的URL。
appName – 工作的名称。
sparkHome – Spark 的安装目录。
pyFiles – 发送给集群的.zip或.py文件，并添加到PYTHONPATH中。
Environment – 工作节点的环境变量。
batchSize – 以单个Java对象表示的Python对象的数量。设置1可以禁用批处理，设置0可以根据对象的大小自动选择批处理大小，设置-1可以使用无限制的批处理大小。
Serializer – RDD序列化器。
Conf – L{SparkConf}的一个对象，用于设置所有Spark属性。
Gateway – 使用现有网关和JVM，否则初始化一个新的JVM。
JSC – JavaSparkContext实例。
profiler_cls – 用于做剖析的自定义剖析器类（默认是 pyspark.profiler.BasicProfiler）。

其中master 和 appname 是最常用的。

测试pyspark:首先在任意项目创建一个文件如：cache.py

from pyspark import SparkContext

words = ["apple", "banana", "cherry"]
print(f"Test----------------Words before caching: {words}")

# 模拟缓存操作
cached_words = words

# 创建实例
sc = SparkContext("local", "Cache app","")

# scenario one
words = sc.parallelize(
   ["scala",
   "java",
   "hadoop",
   "spark",
   "akka",
   "spark vs hadoop",
   "pyspark",
   "pyspark and spark"])

words.cache()
caching = words.persist().is_cached

print(f"Test----------------Words after caching: {cached_words}")

print(f"Words got chached: {caching}")


# scenario two
logFile = r"C:\Users\59980\qlib\test.txt"

logData = sc.textFile(logFile).cache()
numAs = logData.filter(lambda s: 'a' in s).count()
numBs = logData.filter(lambda s: 'b' in s).count()

print('-----------------------------------------')
print(f"Lines with a: {numAs} lines with b: {numBs}")
print('-----------------------------------------')

其中的test文件是自己随便写的，具体内容为：test.txt

运行该文件发现报错：pyspark SparkContext [WinError 2]系统找不到指定文件(我调试好了，图来源于网络)：

debug发现是实例化时出现问题：

sc = SparkContext("local", "Cache app","")

也就是说conf配置有问题，看源码SparkContext有多个参数都是optional的，常用的是appname和集群master，源码中谈到如果不赋值就会用默认的值去解决JVM路径、jsc、env等参数：

如果try运行不成功，就会捕获异常停止运行，并抛出结果。

那么这里我就把SPARK_HOME的路径参数传给他，重新传给它：

sc = SparkContext("local", "Cache app","C:/spark-2.4.3-bin-hadoop2.7")

运行后同样还是找不到指定文件，经过前期验证所有的环境变量都没有问题，于是回到源码，看conf配置文件，该配置文件告诉可以设置所有变量，并没什么用，于是把SPARK_HOME环境变量以run-edit形式赋给它：

运行后确实不会报错了，但是没结果(一串乱码字符)：

但是程序没有停止也没有报错，等了许久没结果就停止，停止后看源码：

找到获取java路径的位置，这里以None传进来，看源头：

前面2个if都False,看到这里应该明白了，实际上在windows平台上py文件都是用pyspark里面的spark-submit运行的(spark-shell是交互的)于是很简单，别用pycharm运行了，直接用命令行：

激活py36环境，cd到cache.py文件目录下，我将它移到了和bin一致的目录，然后运行：

不出意外，结果出来了：

只要前期路径环境变量没有配置错误一般都会出结果的，如果出现问题，首先检查python、hadoop、scala，spark、java的版本问题，看是否适配，其次再检查环境变量和路径是否出错，都没错误就不会有错误了。检查步骤：java——scala——hadoop——python——spark-shell.

上面打印的INFO信息太多了，把本身代码运行的结果都覆盖掉了，可以把INFO的级别设置成WARN，这样一般的info不会显示了(用pycharm运行不出结果暂不知道怎么解决，用cmd)：

# 设置显示日志的级别
sc.setLogLevel("ERROR")

显示的结果为：

整体代码为（不用引入SparkSession类，否则会出现报错存在多个实例，只能创建一个session，而且看SparkSession类里面设置日志的做法也是用类builder，没必要）：

# cache.py
from pyspark import SparkContext
# 创建实例
sc = SparkContext("local", "Cache","")

# 设置显示日志的级别
sc.setLogLevel("ERROR")

words = ["apple", "banana", "cherry"]
print(f"Test----------------Words before caching: {words}")

# 模拟缓存操作
cached_words = words

# scenario one
words = sc.parallelize(
   ["scala",
   "java",
   "hadoop",
   "spark",
   "akka",
   "spark vs hadoop",
   "pyspark",
   "pyspark and spark"])

words.cache()
caching = words.persist().is_cached

print(f"Test----------------Words after caching: {cached_words}")

print(f"Words got chached: {caching}")


# scenario two
logFile = r"C:\Users\59980\qlib\test.txt"

logData = sc.textFile(logFile).cache()
numAs = logData.filter(lambda s: 'a' in s).count()
numBs = logData.filter(lambda s: 'b' in s).count()

print('-----------------------------------------')
print(f"Lines with a: {numAs} lines with b: {numBs}")
print('-----------------------------------------')

日志级别包括：DEBUG、INFO、WARN、ERROR和FATAL。

PySpark RDD

RDD是 Resilient Distributed Dataset 的缩写，这些元素在多个节点上运行和操作，在集群上做并行处理。RDD是不可改变的元素，这意味着一旦创建了一个RDD，就不能改变它。RDDs也是容错的，因此在发生任何故障时，它们会自动恢复。可以在这些RDDs上应用多种操作，以实现某个任务。

要在这些RDD上应用操作，有两种方法

Transformation
Action

Transformation --这些是应用于RDD的操作，以创建一个新的RDD。过滤器、groupBy和地图是转换的例子。

Action - 这些是应用在RDD上的操作，它指示Spark执行计算并将结果送回给驱动。

为了在PySpark中应用任何操作，首先需要创建一个 PySpark RDD 。下面的代码块有PySpark RDD类的细节：

class pyspark.RDD (
   jrdd, 
   ctx, 
   jrdd_deserializer = AutoBatchedSerializer(PickleSerializer())
)

用PySpark运行一些基本操作。在Python文件中创建RDD词，它存储了一组提到的词。

words = sc.parallelize (
   ["scala", 
   "java", 
   "hadoop", 
   "spark", 
   "akka",
   "spark vs hadoop", 
   "pyspark",
   "pyspark and spark"]
)

对单词进行一些操作：

1、count()

——返回RDD中元素的数量。

#----------------------------------------count.py---------------------------------------
from pyspark import SparkContext
sc = SparkContext("local", "count")
words = sc.parallelize (
   ["scala", 
   "java", 
   "hadoop", 
   "spark", 
   "akka",
   "spark vs hadoop", 
   "pyspark",
   "pyspark and spark"]
)
counts = words.count()
print(f"Number of elements in RDD: {counts}")
#----------------------------------------count.py---------------------------------------

cmd中：

spark-submit count.py

结果为：

Number of elements in RDD: 8

类似的还有：

2、collect()

——返回RDD中的所有元素。

words.collect()

3、foreach(f)

——只返回那些符合foreach里面的函数条件的元素。

def f(x):
    print(x)
fore = words.foreach(f)

4、filter(f)

——一个新的RDD被返回，其中包含满足过滤器内部函数的元素。

words_filter = words.filter(lambda x: 'spark' in x) # 过滤出含有 “spark “的字符串
filtered = words_filter.collect()

5、map(f, preservesPartitioning = False)

——对RDD中的每个元素应用一个函数，返回一个新的RDD

words_map = words.map(lambda x: (x, 1)) # 形成一个键值对，并将每个字符串映射为1的值
mapping = words_map.collect()

结果输出为：

6、reduce(f)

——在执行指定的换元和关联二元操作后，RDD中的元素被返回。

from pyspark import SparkContext
from operator import add
sc = SparkContext("local", "Reduce app")
nums = sc.parallelize([1, 2, 3, 4, 5])
adding = nums.reduce(add) # 从运算器中导入add包，并在’num’上应用它来执行一个简单的加法运算。

7、join(other, numPartitions = None)

——返回具有一对元素的RDD，这些元素具有匹配的键和该特定键的所有值。

from pyspark import SparkContext
sc = SparkContext("local", "Join app")
x = sc.parallelize([("spark", 1), ("hadoop", 4)])
y = sc.parallelize([("spark", 2), ("hadoop", 5)])
joined = x.join(y) # 两个不同的RDD中有两对元素。连接这两个RDD后得到一个RDD，其中的元素具有匹配的键和它们的值
final = joined.collect()

输出结果为：

8、cache()

——以默认的存储级别（MEMORY_ONLY）持久化这个RDD。你也可以检查该RDD是否被缓存了，此时可以通过redis缓存到缓存数据库，用于提取到本地操作或者用于平台策略交互。

from pyspark import SparkContext 
sc = SparkContext("local", "Cache app") 
words = sc.parallelize (
   ["scala", 
   "java", 
   "hadoop", 
   "spark", 
   "akka",
   "spark vs hadoop", 
   "pyspark",
   "pyspark and spark"]
) 
words.cache() 
caching = words.persist().is_cached
# 输出结果为True

PySpark Broadcast和Accumulator

对于并行处理，Apache Spark使用共享变量。当驱动程序向集群上的执行器发送任务时，共享变量的副本会出现在集群的每个节点上，这样它就可以用来执行任务。

有两种类型的共享变量被Apache Spark支持 —

Broadcast
Accumulator

Broadcast：广播变量是用来保存所有节点上的数据副本。这个变量被缓存在所有的机器上，而不是在有任务的机器上发送。下面的代码块是PySpark的Broadcast类的细节：

class pyspark.Broadcast (
   sc = None, 
   value = None, 
   pickle_registry = None, 
   path = None
)

輕栀

关注

16
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
数据分析与挖掘

在大数据系统上进行的离线计算通常针对（某一方面的）全体数据，比如针对历史上所有订单进行商品的关联性挖掘，这时候数据规模非常大，需要较长的运行时间，这类计算就是离线计算。MapReduce、Spark、Hive、Spark SQL这些技术主要用来解决离线大数据的计算，也就是针对历史数据进行计算分析，比如针对一天的历史数据计算，一天的数据是一批数据，所以也叫批处理计算。HBase的主要用途是在某些场景下，代替MySQL之类的关系数据库的数据存储访问，利用自己可伸缩的特性，存储比MySQL多得多的数据量。
复制链接

扫一扫