east – 第51页 – gitweixin

Flink 4月 8,2022

Flink面试题汇总

1、Flink如何保证精确一次性消费

Flink 保证精确一次性消费主要依赖于两种Flink机制

1、Checkpoint机制

2、二阶段提交机制

Checkpoint机制

主要是当Flink开启Checkpoint的时候，会往Source端插入一条barrir，然后这个barrir随着数据流向一直流动，当流入到一个算子的时候，这个算子就开始制作checkpoint，制作的是从barrir来到之前的时候当前算子的状态，将状态写入状态后端当中。然后将barrir往下流动，当流动到keyby 或者shuffle算子的时候，例如当一个算子的数据，依赖于多个流的时候，这个时候会有barrir对齐，也就是当所有的barrir都来到这个算子的时候进行制作checkpoint，依次进行流动，当流动到sink算子的时候，并且sink算子也制作完成checkpoint会向jobmanager 报告 checkpoint n 制作完成。

二阶段提交机制

Flink 提供了CheckpointedFunction与CheckpointListener这样两个接口，CheckpointedFunction中有snapshotState方法，每次checkpoint触发执行方法，通常会将缓存数据放入状态中，可以理解为一个hook，这个方法里面可以实现预提交，CheckpointListyener中有notifyCheckpointComplete方法，checkpoint完成之后的通知方法，这里可以做一些额外的操作。例如FLinkKafkaConumerBase使用这个来完成Kafka offset的提交，在这个方法里面可以实现提交操作。在2PC中提到如果对应流程例如某个checkpoint失败的话，那么checkpoint就会回滚，不会影响数据一致性，那么如果在通知checkpoint成功的之后失败了，那么就会在initalizeSate方法中完成事务的提交，这样可以保证数据的一致性。最主要是根据checkpoint的状态文件来判断的。

2、flink和spark区别

flink是一个类似spark的“开源技术栈”，因为它也提供了批处理，流式计算，图计算，交互式查询，机器学习等。flink也是内存计算，比较类似spark，但是不一样的是，spark的计算模型基于RDD，将流式计算看成是特殊的批处理，他的DStream其实还是RDD。而flink吧批处理当成是特殊的流式计算，但是批处理和流式计算的层的引擎是两个，抽象了DataSet和DataStream。flink在性能上也表现的很好，流式计算延迟比spark少，能做到真正的流式计算，而spark只能是准流式计算。而且在批处理上，当迭代次数变多，flink的速度比spark还要快，所以如果flink早一点出来，或许比现在的Spark更火。

3、Flink的状态可以用来做什么？

Flink状态主要有两种使用方式：

checkpoint的数据恢复
逻辑计算

4、Flink的waterMark机制，Flink watermark传递机制

Flink 中的watermark机制是用来处理乱序的，flink的时间必须是event time ，有一个简单的例子就是，假如窗口是5秒，watermark是2秒，那么总共就是7秒，这个时候什么时候会触发计算呢，假设数据初始时间是1000，那么等到6999的时候会触发5999窗口的计算，那么下一个就是13999的时候触发10999的窗口

其实这个就是watermark的机制，在多并行度中，例如在kafka中会所有的分区都达到才会触发窗口

5、Flink的时间语义

Event Time 事件产生的时间

Ingestion time 事件进入Flink的时间

processing time 事件进入算子的时间

6、Flink window join

1、window join，即按照指定的字段和滚动滑动窗口和会话窗口进行 inner join

2、是coGoup 其实就是left join 和 right join，

3、interval join 也就是在窗口中进行join 有一些问题，因为有些数据是真的会后到的，时间还很长，那么这个时候就有了interval join但是必须要是事件时间，并且还要指定watermark和水位以及获取事件时间戳。并且要设置偏移区间，因为join 也不能一直等的。

7、flink窗口函数有哪些

Tumbing window

Silding window

Session window

Count winodw

8、keyedProcessFunction 是如何工作的。假如是event time的话

keyedProcessFunction 是有一个ontime 操作的，假如是 event时间的时候那么调用的时间就是查看，event的watermark 是否大于 trigger time 的时间，如果大于则进行计算，不大于就等着，如果是kafka的话，那么默认是分区键最小的时间来进行触发。

9、flink是怎么处理离线数据的例如和离线数据的关联？

1、async io

2、broadcast

3、async io + cache

4、open方法中读取，然后定时线程刷新，缓存更新是先删除，之后再来一条之后再负责写入缓存

10、flink支持的数据类型

DataSet Api 和 DataStream Api、Table Api

11、Flink出现数据倾斜怎么办

Flink数据倾斜如何查看：

在flink的web ui中可以看到数据倾斜的情况，就是每个subtask处理的数据量差距很大，例如有的只有一M 有的100M 这就是严重的数据倾斜了。

KafkaSource端发生的数据倾斜

例如上游kafka发送的时候指定的key出现了数据热点问题，那么就在接入之后，做一个负载均衡（前提下游不是keyby）。

聚合类算子数据倾斜

预聚合加全局聚合

12、flink 维表关联怎么做的

1、async io

2、broadcast

3、async io + cache

4、open方法中读取，然后定时线程刷新，缓存更新是先删除，之后再来一条之后再负责写入缓存

13、Flink checkpoint的超时问题如何解决。

1、是否网络问题

2、是否是barrir问题

3、查看webui，是否有数据倾斜

4、有数据倾斜的话，那么解决数据倾斜后，会有改善，

14、flinkTopN与离线的TopN的区别

topn 无论是在离线还是在实时计算中都是比较常见的功能，不同于离线计算中的topn，实时数据是持续不断的，这样就给topn的计算带来很大的困难，因为要持续在内存中维持一个topn的数据结构，当有新数据来的时候，更新这个数据结构

15、sparkstreaming 和flink 里checkpoint的区别

sparkstreaming 的checkpoint会导致数据重复消费

但是flink的 checkpoint可以保证精确一次性，同时可以进行增量，快速的checkpoint的，有三个状态后端，memery、rocksdb、hdfs

16、简单介绍一下cep状态编程

Complex Event Processing（CEP）：

FLink Cep 是在FLink中实现的复杂时间处理库，CEP允许在无休止的时间流中检测事件模式，让我们有机会掌握数据中重要的部分，一个或多个由简单事件构成的时间流通过一定的规则匹配，然后输出用户想得到的数据，也就是满足规则的复杂事件。

17、 Flink cep连续事件的可选项有什么

18、如何通过flink的CEP来实现支付延迟提醒

19、Flink cep 你用过哪些业务场景

20、cep底层如何工作

21、cep怎么老化

22、cep性能调优

23、Flink的背压，介绍一下Flink的反压，你们是如何监控和发现的呢。

Flink 没有使用任何复杂的机制来解决反压问题，Flink 在数据传输过程中使用了分布式阻塞队列。我们知道在一个阻塞队列中，当队列满了以后发送者会被天然阻塞住，这种阻塞功能相当于给这个阻塞队列提供了反压的能力。

当你的任务出现反压时，如果你的上游是类似 Kafka 的消息系统，很明显的表现就是消费速度变慢，Kafka 消息出现堆积。

如果你的业务对数据延迟要求并不高，那么反压其实并没有很大的影响。但是对于规模很大的集群中的大作业，反压会造成严重的“并发症”。首先任务状态会变得很大，因为数据大规模堆积在系统中，这些暂时不被处理的数据同样会被放到“状态”中。另外，Flink 会因为数据堆积和处理速度变慢导致 checkpoint 超时，而 checkpoint 是 Flink 保证数据一致性的关键所在，最终会导致数据的不一致发生。

Flink Web UI

Flink 的后台页面是我们发现反压问题的第一选择。Flink 的后台页面可以直观、清晰地看到当前作业的运行状态。

Web UI，需要注意的是，只有用户在访问点击某一个作业时，才会触发反压状态的计算。在默认的设置下，Flink的TaskManager会每隔50ms触发一次反压状态监测，共监测100次，并将计算结果反馈给JobManager，最后由JobManager进行反压比例的计算，然后进行展示。

在生产环境中Flink任务有反压有三种OK、LOW、HIGH

OK正常

LOW一般

HIGH高负载

24、Flink的CBO，逻辑执行计划和物理执行计划

Flink的优化执行其实是借鉴的数据库的优化器来生成的执行计划。

CBO，成本优化器，代价最小的执行计划就是最好的执行计划。传统的数据库，成本优化器做出最优化的执行计划是依据统计信息来计算的。Flink 的成本优化器也一样。Flink 在提供最终执行前，优化每个查询的执行逻辑和物理执行计划。这些优化工作是交给底层来完成的。根据查询成本执行进一步的优化，从而产生潜在的不同决策：如何排序连接，执行哪种类型的连接，并行度等等。

// TODO

25、Flink中数据聚合，不使用窗口怎么实现聚合

valueState 用于保存单个值
ListState 用于保存list元素
MapState 用于保存一组键值对
ReducingState 提供了和ListState相同的方法，返回一个ReducingFunction聚合后的值。
AggregatingState和 ReducingState类似，返回一个AggregatingState内部聚合后的值

26、Flink中state有哪几种存储方式

Memery、RocksDB、HDFS

27、Flink 异常数据怎么处理

异常数据在我们的场景中，一般分为缺失字段和异常值数据。

异常值： 例如宝宝的年龄的数据，例如对于母婴行业来讲，一个宝宝的年龄是一个至关重要的数据，可以说是最重要的，因为宝宝大于3岁几乎就不会在母婴上面购买物品。像我们的有当日、未知、以及很久的时间。这样都属于异常字段，这些数据我们会展示出来给店长和区域经理看，让他们知道多少个年龄是不准的。如果要处理的话，可以根据他购买的时间来进行实时矫正，例如孕妇服装、奶粉的段位、纸尿裤的大小，以及奶嘴啊一些能够区分年龄段的来进行处理。我们并没有实时处理这些数据，我们会有一个底层的策略任务夜维去跑，一个星期跑一次。

缺失字段： 例如有的字段真的缺失的很厉害，能修补就修补。不能修补就放弃，就像上家公司中的新闻推荐过滤器。

28、Flink 监控你们怎么做的

1、我们监控了Flink的任务是否停止

2、我们监控了Flink的Kafka的LAG

3、我们会进行实时数据对账，例如销售额。

29、Flink 有数据丢失的可能吗

Flink有三种数据消费语义：

At Most Once 最多消费一次发生故障有可能丢失
At Least Once 最少一次发生故障有可能重复
Exactly-Once 精确一次如果产生故障，也能保证数据不丢失不重复。

flink 新版本已经不提供 At-Most-Once 语义。

30、Flink interval join 你能简单的写一写吗

DataStream<T> keyed1 = ds1.keyBy(o -> o.getString("key"))
DataStream<T> keyed2 = ds2.keyBy(o -> o.getString("key"))
//右边时间戳-5s<=左边流时间戳<=右边时间戳-1s
keyed1.intervalJoin(keyed2).between(Time.milliseconds(-5), Time.milliseconds(5))

31、Flink 提交的时候并行度如何制定，以及资源如何配置

并行度根据kafka topic的并行度，一个并行度3个G

32、Flink的boardcast join 的原理是什么

利用 broadcast State 将维度数据流广播到下游所有 task 中。这个 broadcast 的流可以与我们的事件流进行 connect，然后在后续的 process 算子中进行关联操作即可。

33、flink的source端断了，比如kafka出故障，没有数据发过来，怎么处理？

会有报警，监控的kafka偏移量也就是LAG。

34、flink有什么常用的流的API?

window join 啊 cogroup 啊 map flatmap，async io 等

35、flink的水位线，你了解吗，能简单介绍一下吗

Flink 的watermark是一种延迟触发的机制。

一般watermark是和window结合来进行处理乱序数据的，Watermark最根本就是一个时间机制，例如我设置最大乱序时间为2s，窗口时间为5秒，那么就是当事件时间大于7s的时候会触发窗口。当然假如有数据分区的情况下，例如kafka中接入watermake的话，那么watermake是会流动的，取的是所有分区中最小的watermake进行流动，因为只有最小的能够保证，之前的数据都已经来到了，可以触发计算了。

36、Flink怎么维护Checkpoint？在HDFS上存储的话会有小文件吗

默认情况下，如果设置了Checkpoint选项，Flink只保留最近成功生成的1个Checkpoint。当Flink程序失败时，可以从最近的这个Checkpoint来进行恢复。但是，如果我们希望保留多个Checkpoint，并能够根据实际需要选择其中一个进行恢复，这样会更加灵活。Flink支持保留多个Checkpoint，需要在Flink的配置文件conf/flink-conf.yaml中，添加如下配置指定最多需要保存Checkpoint的个数。

关于小文件问题可以参考代达罗斯之殇-大数据领域小文件问题解决攻略。

37、Spark和Flink的序列化，有什么区别吗？

Spark 默认使用的是 Java序列化机制，同时还有优化的机制，也就是kryo

Flink是自己实现的序列化机制，也就是TypeInformation

38、Flink是怎么处理迟到数据的？但是实际开发中不能有数据迟到，怎么做？

Flink 的watermark是一种延迟触发的机制。

39、画出flink执行时的流程图。

40、Flink分区分配策略

41、Flink关闭后状态端数据恢复得慢怎么办？

42、了解flink的savepoint吗？讲一下savepoint和checkpoint的不同和各有什么优势

43、flink的状态后端机制

Flink的状态后端是Flink在做checkpoint的时候将状态快照持久化，有三种状态后端 Memery、HDFS、RocksDB

44、flink中滑动窗口和滚动窗口的区别，实际应用的窗口是哪种？用的是窗口长度和滑动步长是多少？

45、用flink能替代spark的批处理功能吗

Flink 未来的目标是批处理和流处理一体化，因为批处理的数据集你可以理解为是一个有限的数据流。Flink 在批出理方面，尤其是在今年 Flink 1.9 Release 之后，合入大量在 Hive 方面的功能，你可以使用 Flink SQL 来读取 Hive 中的元数据和数据集，并且使用 Flink SQL 对其进行逻辑加工，不过目前 Flink 在批处理方面的性能，还是干不过 Spark的。

目前看来，Flink 在批处理方面还有很多内容要做，当然，如果是实时计算引擎的引入，Flink 当然是首选。

46、flink计算的UV你们是如何设置状态后端保存数据

可以使用布隆过滤器。

47、sparkstreaming和flink在执行任务上有啥区别，不是简单的流处理和微批，sparkstreaming提交任务是分解成stage，flink是转换graph，有啥区别？

48、flink把streamgraph转化成jobGraph是在哪个阶段？

49、Flink中的watermark除了处理乱序数据还有其他作用吗？

还有kafka数据顺序消费的处理。

50、flink你一般设置水位线设置多少

我们之前设置的水位线是6s

52、Flink任务提交流程

Flink任务提交后，Client向HDFS上传Flink的jar包和配置，之后向Yarn ResourceManager提交任务，ResourceManager分配Container资源并通知对应的NodeManager启动
ApplicationMaster，ApplicationMaster启动后加载Flink的jar包和配置构建环境，然后启动JobManager；之后Application Master向ResourceManager申请资源启动TaskManager
，ResourceManager分配Container资源后，由ApplicationMaster通知资源所在的节点的NodeManager启动TaskManager，NodeManager加载Flink的Jar包和配置构建环境并启动TaskManager，TaskManager启动向JobManager发送心跳，并等待JobManager向其分配任务。

53、Flink技术架构图

54、flink如何实现在指定时间进行计算。

55、手写Flink topN

57、Flink的Join算子有哪些

一般join是发生在window上面的:

1、window join，即按照指定的字段和滚动滑动窗口和会话窗口进行 inner join

2、是coGoup 其实就是left join 和 right join，

58、Flink1.10 有什么新特性吗？

内存管理及配置优化

Flink 目前的 TaskExecutor 内存模型存在着一些缺陷，导致优化资源利用率比较困难，例如：

流和批处理内存占用的配置模型不同
流处理中的 RocksDB state backend 需要依赖用户进行复杂的配置

为了让内存配置变的对于用户更加清晰、直观，Flink 1.10 对 TaskExecutor 的内存模型和配置逻辑进行了较大的改动（FLIP-49 [7]）。这些改动使得 Flink 能够更好地适配所有部署环境（例如 Kubernetes, Yarn, Mesos），让用户能够更加严格的控制其内存开销。

Managed 内存扩展

Managed 内存的范围有所扩展，还涵盖了 RocksDB state backend 使用的内存。尽管批处理作业既可以使用堆内内存也可以使用堆外内存，使用 RocksDB state backend 的流处理作业却只能利用堆外内存。因此为了让用户执行流和批处理作业时无需更改集群的配置，我们规定从现在起 managed 内存只能在堆外。

简化 RocksDB 配置

此前，配置像 RocksDB 这样的堆外 state backend 需要进行大量的手动调试，例如减小 JVM 堆空间、设置 Flink 使用堆外内存等。现在，Flink 的开箱配置即可支持这一切，且只需要简单地改变 managed 内存的大小即可调整 RocksDB state backend 的内存预算。

另一个重要的优化是，Flink 现在可以限制 RocksDB 的 native 内存占用，以避免超过总的内存预算—这对于 Kubernetes 等容器化部署环境尤为重要。

统一的作业提交逻辑
在此之前，提交作业是由执行环境负责的，且与不同的部署目标（例如 Yarn, Kubernetes, Mesos）紧密相关。这导致用户需要针对不同环境保留多套配置，增加了管理的成本。

在 Flink 1.10 中，作业提交逻辑被抽象到了通用的 Executor 接口。新增加的 ExecutorCLI （引入了为任意执行目标指定配置参数的统一方法。此外，随着引入 JobClient负责获取 JobExecutionResult，获取作业执行结果的逻辑也得以与作业提交解耦。

原生 Kubernetes 集成（Beta）

对于想要在容器化环境中尝试 Flink 的用户来说，想要在 Kubernetes 上部署和管理一个 Flink standalone 集群，首先需要对容器、算子及像 kubectl 这样的环境工具有所了解。

在 Flink 1.10 中，我们推出了初步的支持 session 模式的主动 Kubernetes 集成（FLINK-9953）。其中，“主动”指 Flink ResourceManager (K8sResMngr) 原生地与 Kubernetes 通信，像 Flink 在 Yarn 和 Mesos 上一样按需申请 pod。用户可以利用 namespace，在多租户环境中以较少的资源开销启动 Flink。这需要用户提前配置好 RBAC 角色和有足够权限的服务账号。

Table API/SQL: 生产可用的 Hive 集成

Flink 1.9 推出了预览版的 Hive 集成。该版本允许用户使用 SQL DDL 将 Flink 特有的元数据持久化到 Hive Metastore、调用 Hive 中定义的 UDF 以及读、写 Hive 中的表。Flink 1.10 进一步开发和完善了这一特性，带来了全面兼容 Hive 主要版本的生产可用的 Hive 集成。

Batch SQL 原生分区支持

此前，Flink 只支持写入未分区的 Hive 表。在 Flink 1.10 中，Flink SQL 扩展支持了 INSERT OVERWRITE 和 PARTITION 的语法（FLIP-63 ），允许用户写入 Hive 中的静态和动态分区。

写入静态分区

INSERT { INTO | OVERWRITE } TABLE tablename1 [PARTITION (partcol1=val1, partcol2=val2 ...)] select_statement1 FROM from_statement;

写入动态分区

INSERT { INTO | OVERWRITE } TABLE tablename1 select_statement1 FROM from_statement;

对分区表的全面支持，使得用户在读取数据时能够受益于分区剪枝，减少了需要扫描的数据量，从而大幅提升了这些操作的性能。

另外，除了分区剪枝，Flink 1.10 的 Hive 集成还引入了许多数据读取方面的优化，例如：

投影下推：Flink 采用了投影下推技术，通过在扫描表时忽略不必要的域，最小化 Flink 和 Hive 表之间的数据传输量。这一优化在表的列数较多时尤为有效。
LIMIT 下推：对于包含 LIMIT 语句的查询，Flink 在所有可能的地方限制返回的数据条数，以降低通过网络传输的数据量。
读取数据时的 ORC 向量化：为了提高读取 ORC 文件的性能，对于 Hive 2.0.0 及以上版本以及非复合数据类型的列，Flink 现在默认使用原生的 ORC 向量化读取器。

59、Flink的重启策略

固定延迟重启策略

固定延迟重启策略是尝试给定次数重新启动作业。如果超过最大尝试次数，则作业失败。在两次连续重启尝试之间，会有一个固定的延迟等待时间。

故障率重启策略

故障率重启策略在故障后重新作业，当设置的故障率（failure rate）超过每个时间间隔的故障时，作业最终失败。在两次连续重启尝试之间，重启策略延迟等待一段时间。

无重启策略

作业直接失败，不尝试重启。

后备重启策略

使用群集定义的重新启动策略。这对于启用检查点的流式传输程序很有帮助。默认情况下，如果没有定义其他重启策略，则选择固定延迟重启策略。

60、Flink什么时候用aggregate()或者process()

aggregate： 增量聚合

process： 全量聚合

当计算累加操作时候可以使用aggregate操作。

当计算窗口内全量数据的时候使用process，例如排序等操作。

61、Flink优化你了解多少

62、Flink内存溢出怎么办

63、说说Flink中的keyState包含哪些数据结构

64、Flink shardGroup的概念

作者 east

mongodb, redis 4月 8,2022

MongoDB vs. Redis——你应该使用哪个数据库？

比较 MongoDB 和 Redis 时的 5 个重要区别：

1、速度：Redis 比 MongoDB 快，因为它是一个内存数据库。
2、 RAM：Redis 使用比 MongoDB 更多的 RAM 来存储重要数据集。
3、可扩展性：MongoDB 的可扩展性优于 Redis。
4、存储：企业（主要）使用 Redis 进行键值存储。 MongoDB 将所有内容存储在文档中。
5、评论：MongoDB 和 Redis 的评论普遍是正面的。（两者在 G2 上都有 4.5/5 星。）

在当今的数字世界中，可靠的数据库具有多种功能。所有类型的企业都需要在数据库中存储、管理和访问信息，以用于销售、库存、客户服务等。一些世界上最大的品牌将 MongoDB 和 Redis 用于各种抽象数据结构。但是哪一个更好呢？有什么区别？

下面我们在几个因素上比较 MongoDB 和 Redis，以便您选择正确的一个。

MongoDB 与 Redis：特性和优势
MongoDB 与 Redis：技术细节
在比较特性之前，我们先来看看 MongoDB 和 Redis 的主要区别：

MongoDB 是一个 NoSQL 数据库。 MongoDB 于 2009 年发布，使用类似 JSON 的文档，允许用户存储无模式数据集。它将自己描述为“现代应用程序最流行的数据库”。有关 Integrate.io 的本机 MongoDB 连接器的更多信息，请访问我们的集成页面。
Redis 是一种内存数据结构存储，可兼作数据库。 Redis 同样于 2009 年发布，支持列表、地图、位图、流、字符串和空间索引等各种数据结构。
虽然 MongoDB 和 Redis 有很多不同，但它们有一些共同点：

两者都有开源许可证。
两者都启用二级索引。
两个数据库最终都成为计算密集型的。
MongoDB vs. Redis：数据库结构
MongoDB 和 Redis 具有不同的数据库结构设置，MongoDB 的性能类似于关系数据库。（它使用表达性查询语言。）不过，关键的区别在于 MongoDB 是无模式的，因此用户不必创建文档结构。这意味着该平台是两者中更容易使用的。

另一方面，Redis 使用键值存储，用最简单的术语来说，将数据分配给键和关联值。这意味着设置与 MongoDB 完全不同，MongoDB 使用传统上与关系数据库相关的行和列。键值存储使一些用户受益，但 Redis 一开始对一些人来说可能看起来很陌生。正如我们之前提到的，Redis 使用其他数据结构——位图、集合、字符串，等等——尽管它优先考虑键值存储。

MongoDB 与 Redis：可扩展性
MongoDB 和 Redis 都在可扩展性方面得分，这使得它们对于任何成长中的业务都值得添加。不过还是有区别的：

MongoDB 是用 C++ 编写的，可用于 Windows、OS X、Linux 和 Solaris。
Redis 是用 C 编写的，可用于 Windows、OS X、Linux 和 BSD。
MongoDB 和 Redis 都支持广泛的编程语言，包括 C、C~、C++、Java、Python 和 Scala。

在考虑扩展数据管理时，用户应该考虑到所有这些。

MongoDB 与 Redis：性能
Redis 比 MongoDB 快，因为它是一个内存数据库。这使它成为快速构建复杂数据结构的绝佳选择。然而，MongoDB 适合大多数需要可靠数据库的中型企业。它相对简单易用，而且正如我们前面提到的，它非常可扩展。

速度带来了一些缺点。 Redis，也许并不奇怪，比 MongoDB 使用更多的 RAM，这对于非平凡的数据集是显而易见的。

MongoDB vs. Redis：流行度
这两个开源数据库都有一个忠实的用户社区：

MongoDB 定期在其社区页面上举办网络研讨会和其他活动。
Redis 拥有一个蓬勃发展的社区，用户在这里讨论新功能，甚至亲自见面。
许多著名公司使用这些工具：

Uber、Lyft 和 Stack 使用 MongoDB。
Twitter、GitHub 和微博都使用 Redis。

集成您的数据仓库

MongoDB 与 Redis：定价
MongoDB 和 Redis 都有开源许可证，可以免费使用。但是，因此这两个平台都存在局限性。尽管 MongoDB 和 Redis 允许用户存储和管理各种数据，但用户需要了解编程语言。

在数据管理方面，一些企业将受益于支付不需要任何代码的 ETL 平台。这使得无需学习查询语言即可轻松简化数据处理和优化工作流程。

MongoDB 与 Redis：评论
人们如何看待 MongoDB 和 Redis？

MongoDB 评论
根据 356 条客户评论（截至 2020 年 9 月），MongoDB 在流行的技术评论网站 G2 上的平均评分为 4.5/5 星。

一位评论员是一家大公司的工程师，他说：

“MongoDB 可以非常正确、轻松、实时地读取数据。在那里编写查询也非常容易。通过 API 链接到各种资源也非常容易。该应用程序还提供了出色的结果。”

大多数 MongoDB 评论都是正面的。然而，对数据库的批评包括：

用户需要了解一门编程语言。
很难识别不同的特征。
文档的大小限制。
一位担任数据分析师的审稿人指出：

“我很伤心，因为它需要大量内存，因为它存储每个值对的键名，因此意味着存在高数据冗余。它还限制了嵌套，也不支持连接。”

Redis 评论
根据 82 条用户评论（截至 2020 年 9 月），Redis 在 G2 上的平均评分也为 4.55。

一位评论员是一家大公司的数据架构师，他说：

“Redis 数据库非常易于安装和使用。配置也适合单个文件。性能非常好，此工具可让您轻松扩展应用程序。”

这位审稿人将 Redis 用于各种目的，例如“缓存文件、存储临时数据、排队、发布/子系统”等等。

对 Redis 的批评包括：

缺乏用户支持文档。
脚本语言。
内存限制。

作者 east

Java 4月 7,2022

地图不同坐标系的转换工具类

提供以下的坐标系互相转换：

GCJ-02(火星坐标系)转换为WGS84坐标系

BD-09(百度坐标系)转换为WGS84坐标系

BD-09(百度坐标系)转换为GCJ-02(火星坐标)

sogou转换为WGS84

/**
 * @author jy 地图转换测试/
 */
public final class MapUtil {

    /**
     * 辅助类禁止共有构造函数
     */
    private MapUtil() {

    }

    /**
     * 常量:pi
     */
    public static final double CONSTANT_PI = 3.1415926535897932384626;

    /**
     * 常量:a
     */
    public static final double CONSTANT_A = 6378245.0;

    /**
     * 常量:e
     */
    public static final double CONSTANT_E = 0.00669342162296594323;

    /**
     * 常量:ccc
     */
    private static final double[] CCC = new double[]{12890594.86, 8362377.87, 5591021, 3481989.83, 1678043.12, 0};

    /**
     * 常量:ddd
     */
    private static final double[][] DDD = {
            new double[]{1.410526172116255e-8, 0.00000898305509648872, -1.9939833816331, 200.9824383106796,
                    -187.2403703815547, 91.6087516669843, -23.38765649603339, 2.57121317296198, -0.03801003308653,
                    17337981.2},
            new double[]{-7.435856389565537e-9, 0.000008983055097726239, -0.78625201886289, 96.32687599759846,
                    -1.85204757529826, -59.36935905485877, 47.40033549296737, -16.50741931063887, 2.28786674699375,
                    10260144.86},
            new double[]{-3.030883460898826e-8, 0.00000898305509983578, 0.30071316287616, 59.74293618442277,
                    7.357984074871, -25.38371002664745, 13.45380521110908, -3.29883767235584, 0.32710905363475,
                    6856817.37},
            new double[]{-1.981981304930552e-8, 0.000008983055099779535, 0.03278182852591, 40.31678527705744,
                    0.65659298677277, -4.44255534477492, 0.85341911805263, 0.12923347998204, -0.04625736007561,
                    4482777.06},
            new double[]{3.09191371068437e-9, 0.000008983055096812155, 0.00006995724062, 23.10934304144901,
                    -0.00023663490511, -0.6321817810242, -0.00663494467273, 0.03430082397953, -0.00466043876332,
                    2555164.4},
            new double[]{2.890871144776878e-9, 0.000008983055095805407, -3.068298e-8, 7.47137025468032,
                    -0.00000353937994, -0.02145144861037, -0.00001234426596, 0.00010322952773, -0.00000323890364,
                    826088.5}};

    /**
     * GCJ-02(火星坐标系)转换为WGS84坐标系<br>
     * GCJ-02:谷歌中国地图、搜搜中国地图、高德地图<br>
     *
     * @param lat 纬度
     * @param lon 经度
     * @return
     */
    public static Coord gcj02ToWgs84(double lat, double lon) {

        Coord coord = transform(lat, lon);

        double finalLon = lon * 2 - coord.getLon();
        double finalLat = lat * 2 - coord.getLat();

        return new Coord(finalLat, finalLon);

    }

    /**
     * BD-09(百度坐标系)转换为WGS84坐标系<br>
     *
     * @param lat 纬度
     * @param lon 经度
     * @return
     */
    public static Coord bd09ToWgs84(double lat, double lon) {

        Coord gcj02 = MapUtil.bd09ToGcj02(lat, lon);
        Coord wgs84 = MapUtil.gcj02ToWgs84(gcj02.getLat(), gcj02.getLon());

        return wgs84;
    }

    /**
     * BD-09(百度坐标系)转换为GCJ-02(火星坐标)<br>
     *
     * @param lat 纬度
     * @param lon 经度
     * @return
     */
    public static Coord bd09ToGcj02(double lat, double lon) {

        double x = lon - 0.0065;
        double y = lat - 0.006;
        double z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * CONSTANT_PI);

        double theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * CONSTANT_PI);

        double finalLon = z * Math.cos(theta);
        double finalLat = z * Math.sin(theta);

        return new Coord(finalLat, finalLon);

    }

    /**
     * sogou转换为WGS84
     *
     * @param lat 纬度
     * @param lon 经度
     * @return
     */
    public static Coord sogouToWgs84(double lat, double lon) {

        Coord coord = new Coord(lat, lon);

        Coord tmp = new Coord();
        tmp.setLon(Math.abs(coord.getLon()));
        tmp.setLat(Math.abs(coord.getLat()));

        double[] obj = new double[9];
        for (int i = 0; i < CCC.length; i++) {
            if (tmp.getLat() > CCC[i]) {
                obj = DDD[i];
                break;
            }
        }

        return MapUtil.convert(coord, obj);
    }

    /**
     * sogou内部转换函数
     *
     * @param coord
     * @param varAttr
     * @return
     */
    private static Coord convert(Coord coord, double[] varAttr) {
        Coord tmp = new Coord();
        tmp.setLon(varAttr[0] + varAttr[1] * Math.abs(coord.getLon()));
        double f = Math.abs(coord.getLat()) / varAttr[9];
        double tmpLat = varAttr[2] + varAttr[3] * f + varAttr[4] * f * f + varAttr[5] * f * f * f
                + varAttr[6] * f * f * f * f + varAttr[7] * f * f * f * f * f + varAttr[8] * f * f * f * f * f * f;
        tmp.setLat(tmpLat);
        tmp.setLon(tmp.getLon() * (coord.getLon() < 0 ? -1 : 1));
        tmp.setLat(tmp.getLat() * (coord.getLat() < 0 ? -1 : 1));

        return tmp;
    }

    /**
     * 坐标点转换函数
     *
     * @param lat 纬度
     * @param lon 经度
     * @return
     */
    private static Coord transform(double lat, double lon) {

        if (outOfChina(lat, lon)) {
            return new Coord(lat, lon);
        }

        double dLat = transformLat(lat - 35.0, lon - 105.0);
        double dLon = transformLon(lat - 35.0, lon - 105.0);

        double radLat = lat / 180.0 * CONSTANT_PI;

        double magic = Math.sin(radLat);
        magic = 1 - CONSTANT_E * magic * magic;
        double sqrtMagic = Math.sqrt(magic);
        dLat = (dLat * 180.0) / ((CONSTANT_A * (1 - CONSTANT_E)) / (magic * sqrtMagic) * CONSTANT_PI);
        dLon = (dLon * 180.0) / (CONSTANT_A / sqrtMagic * Math.cos(radLat) * CONSTANT_PI);
        double mgLat = lat + dLat;
        double mgLon = lon + dLon;

        return new Coord(mgLat, mgLon);

    }

    /**
     * 纬度转换函数
     *
     * @param lat 维度
     * @param lon 经度
     * @return
     */
    private static double transformLat(double lat, double lon) {

        double ret = -100.0 + 2.0 * lon + 3.0 * lat + 0.2 * lat * lat + 0.1 * lon * lat
                + 0.2 * Math.sqrt(Math.abs(lon));
        ret += (20.0 * Math.sin(6.0 * lon * CONSTANT_PI) + 20.0 * Math.sin(2.0 * lon * CONSTANT_PI)) * 2.0 / 3.0;
        ret += (20.0 * Math.sin(lat * CONSTANT_PI) + 40.0 * Math.sin(lat / 3.0 * CONSTANT_PI)) * 2.0 / 3.0;
        ret += (160.0 * Math.sin(lat / 12.0 * CONSTANT_PI) + 320 * Math.sin(lat * CONSTANT_PI / 30.0)) * 2.0 / 3.0;

        return ret;
    }

    /**
     * 经度转换函数
     *
     * @param lat 纬度
     * @param lon 经度
     * @return
     */
    private static double transformLon(double lat, double lon) {

        double ret = 300.0 + lon + 2.0 * lat + 0.1 * lon * lon + 0.1 * lon * lat + 0.1 * Math.sqrt(Math.abs(lon));

        ret += (20.0 * Math.sin(6.0 * lon * CONSTANT_PI) + 20.0 * Math.sin(2.0 * lon * CONSTANT_PI)) * 2.0 / 3.0;
        ret += (20.0 * Math.sin(lon * CONSTANT_PI) + 40.0 * Math.sin(lon / 3.0 * CONSTANT_PI)) * 2.0 / 3.0;
        ret += (150.0 * Math.sin(lon / 12.0 * CONSTANT_PI) + 300.0 * Math.sin(lon / 30.0 * CONSTANT_PI)) * 2.0 / 3.0;

        return ret;
    }

    /**
     * 判断坐标点是否在中国范围内
     *
     * @param lat
     * @param lon
     * @return
     */
    private static boolean outOfChina(double lat, double lon) {

        if (lon < 72.004 || lon > 137.8347) {
            return true;
        }

        if (lat < 0.8293 || lat > 55.8271) {
            return true;
        }

        return false;
    }

}

public class Coord implements Serializable {

    /**
     *
     */
    private static final long serialVersionUID = -229841606158709053L;
    /**
     * 纬度
     */
    private double lat;
    /**
     * 经度
     */
    private double lon;

    /**
     * 默认构造参数
     */
    public Coord() {

    }

    /**
     * 重载构造方法
     *
     * @param lat 纬度
     * @param lon 经度
     */
    public Coord(double lat, double lon) {
        this.lat = lat;
        this.lon = lon;
    }

    public double getLat() {
        return lat;
    }

    public void setLat(double lat) {
        this.lat = lat;
    }

    public double getLon() {
        return lon;
    }

    public void setLon(double lon) {
        this.lon = lon;
    }

}

作者 east

数据库 4月 6,2022

MongoDB vs PostgreSQL：数据库结构的详细比较

任何公司功能中最重要的部分之一是安全数据库。随着网络钓鱼攻击、恶意软件和其他威胁的增加，您必须做出正确的选择，以确保您的数据安全并有效处理数据。然而，在当今市场上种类繁多的数据库解决方案中进行选择可能非常困难。两个常用的选项是 Mongodb 和 Postgresql。

关于 MongoDB 与 PostgreSQL，您需要了解什么？本文将带您比较每个的主要特性、功能和性能。

什么是 MongoDB？
MongoDB 是一个无模式文档数据库，提供免费和付费计划。作为文档数据库，MongoDB 的结构和语法与传统的 RDMS（关系数据库管理系统）不同。它是一个 NoSQL（不仅仅是 SQL）数据库。

NoSQL 数据库通常本质上更简单，因此对于具有任何编程经验的人来说，MongoDB 相对容易学习。文档数据库将数据处理为 JSON 类型的文档。这些数据是半结构化的，而不是完全结构化的。这意味着它可以比许多其他解决方案更快地处理大量数据。这也意味着用户可以在处理的所有不同阶段以及各种格式和结构中搜索和处理数据，从而使数据库比传统的关系数据库具有更高的灵活性。用户可以根据需要访问数据并对模式进行更改或更新，这与 SQL 数据库模型不同，在 SQL 数据库模型中，用户只能在数据经过处理和正确格式化后才能访问数据。

MongoDB 使用 BSON（二进制 JSON）。 BSON 允许某些不与常规 JSON 一起使用的数据类型，例如 long、floating-point 和 date。 MongoDB 还提供了一种替代 SQL 的查询语言，称为 MQL。 MQL 带来了许多与 SQL 相同的功能以及对各种编程语言的额外支持。该数据库具有分布式架构，这意味着组件在多个平台上相互协作。这也意味着 MongoDB 具有几乎无限的可扩展性，因为它可以根据需要跨多个平台进行扩展。这是将 MongoDB 与关系数据库区分开来的众多因素之一，因为关系数据库只能垂直扩展并且价格昂贵，因为在某些时候它们需要多个服务器才能扩展数据库的多个副本。 MongoDB 可以水平扩展。

MongoDB 是用 C、C++ 和 JS 编写的。

MongoDB 通过 TLS 和 SSL（传输层安全和安全套接字层）提供客户端、字段级加密。 TLS 和 SSL 都是使 HTTP（超文本传输协议）变成 HTTPS（安全超文本传输协议）的互联网加密协议。事实上，TLS 只是一种升级的 SSL，旨在减少安全漏洞。用户因此可以加密所有 MongoDB 网络流量。此外，MongoDB 有各种保护措施来确保正确验证用户身份。

MongoDB 提供社区支持，并在支持工程师的监督下提供有偿的全面培训和升级。

MongoDB 的任务完成速度非常快，特别是由于数据只是半结构化的。根据各种评论，即使在定期处理大量数据时，它也是市场上速度更快的解决方案之一。这使其非常适合需要实时或接近实时数据的情况，从而使公司能够立即全面了解其业务。

MongoDB 可以托管在 Google Cloud Platform、Amazon Web Services (AWS) 和 Microsoft Azure 等云平台上。

MongoDB 的常见用例包括客户分析、内容管理、业务交易和产品数据。该数据库还非常适合需要扩展到数百万用户的移动解决方案，这要归功于它的扩展能力。另一个主要用例是提供数据即服务的平台。 MongoDB 可以实时更新数据，允许用户在新信息进入时查看它。最后，MongoDB 提供的 IDP（智能数据平台）将数据库与其他互补技术相结合，成为一个完整的 IoT（物联网）支持物联网应用的平台。

什么是 PostgreSQL？
PostgreSQL 是一个 100% 免费和开源的 ORD（对象关系数据库）。数据库不是像文档那样存储数据，而是将其存储为结构化对象。它遵循 SQL 数据库的传统语法和模式。 Schema 实际上是一个模板或结构，您可以使用一组词汇将其应用于数据库。模式包含各种模式对象，包括任何表、列、键等。您必须在将数据加载到此类数据库之前对其进行结构化。虽然这往往需要更多时间，但它也可以将数据转换为更易于管理和可读的格式。

PostgreSQL 具有单体架构，这意味着组件是完全统一的。这也意味着数据库只能与运行它的机器一样扩展。它是用 C 语言编写的。代码是开源的，可供开发人员访问。 PostgreSQL 提供社区支持，并且仅通过某些其他公司提供额外的付费支持选项。

Postgres 包括基本文件保护、通过 IP 地址限制客户端连接的能力，以及与旨在使其更加安全的各种其他外部包的兼容性。

PostgreSQL 的用例包括银行系统、风险评估、多应用程序数据存储库、BI（商业智能）、制造和支持各种业务应用程序。它是事务性工作流程的理想选择。此外，PostgreSQL 具有故障保险和冗余，使其存储特别可靠。这意味着它非常适合医疗保健和制造业等重要行业。

两个数据库都使用不同的语法和术语来执行许多相同的任务。 PostgreSQL 使用表的地方，MongoDB 使用集合。 PostgreSQL 使用行来记录数据，MongoDB 使用文档等。它们还具有许多将它们彼此区分开来的特性。

MongoDB 与 PostgreSQL 的主要特性
MongoDB 具有 ACID 合规性的潜力，而 Postgres 具有内置的 ACID 合规性。 ACID（原子性、一致性、隔离性、持久性）是致力于数据有效性的原则或组件，尤其是在用于事务工作流的数据库中。

MongoDB 使用集合的目的与 Postgres 使用表的目的相同。这些集合包括用于设置验证规则和设置最大大小的选项。 Postgres 用一种非常特定的语言描述表，并以数据库或 ETL 工具可以处理它的方式构造数据。

两者之间术语和语法差异的另一个示例是 MongoDB 使用文档来获取数据，而 Postgres 使用行来实现相同目的。

虽然 MongoDB 不支持 FOREIGN KEY 约束，但 PostgreSQL 支持。外键可以是一个列或一组列，您可以使用它们同时在来自多个表的数据中创建链接。由于这些约束不允许破坏从一个表到另一个表的链接的任何操作，并且可以阻止将无效数据插入外键列，因此这可能是某些用户的必要功能。

MongoDB 聚合管道由多个阶段组成，用于转换数据。 Postgres 使用 GROUP_BY 运行查询，而 MongoDB 使用聚合管道。

MongoDB 使用冗余副本集，Postgres 执行同步或 2-safe 复制来维护数据集。您可以根据需要使用副本集来记录和“重播”过程。同步复制涉及同时更新多个存储库或系统。由于 PostgreSQL 数据库同时更新两条记录，以同样的方式，您可以减少错误，从而使用户拥有完整准确的备份。

像 Postgres 这样的 SQL 数据库使用连接将来自多个表的数据组合到一个表中。您可以使用四种不同类型的连接：全连接、左连接、右连接和内连接。假设您有两个表要连接一些数据，但不是全部，您将使用 left、right 或 inner 将两个表合并到您的第一个表或第二个表中，或者将两个表的一部分合并到第三张桌子。如果要将所有数据同时连接到一个表中，则可以使用完全连接。 MongoDB 使用索引，它只是连接的一个组成部分。该数据库不是为执行常规连接而设计的。索引是一种数据结构，可以以易于阅读的形式存储非常少量的数据。它们通过使数据更简单从而更易于扫描来帮助您更高效地解决查询。

MongoDB	PostgreSQL
Schema-free	SQL-based but supports various NoSQL features
Document database	Relational database
Uses BSON	Uses SQL
Distributed architecture	Monolithic architecture
Potential for ACID compliance	ACID-compliant
Uses collections	Uses tables
Uses documents to obtain data	Uses rows to obtain data
Does not support foreign key constraints	Supports foreign key constraints
Uses the aggregation pipeline for running queries	Uses GROUP_BY
Redundant replica sets	2-safe replication
Uses indexes	Uses joins

综上所述，MongoDB 和 PostgreSQL 的主要区别在于它们的系统、架构和语法：MongoDB 是文档数据库，而 Postgres 是关系数据库管理系统； MongoDB 是分布式架构，而 PostgreSQL 是单体架构； Postgres 使用 SQL，而 MongoDB 使用 BSON。

对于已经初步了解 JavaScript 的人来说，MongoDB 的学习曲线更短，而那些在 SQL 数据库方面有长期经验的人可能会发现更容易适应 Postgres。两者都作为各种行业的综合数据库解决方案越来越受欢迎。然而，公司在处理来自任一数据库的数据时遇到的最大问题之一是所涉及的时间和复杂性。

ETL（提取、传输和加载）数据到 MongoDB 或 PostgreSQL 数据库中通常涉及大量编码和复杂、耗时的过程。此外，由于 MongoDB 具有不寻常的语法和 NoSQL 支持，许多 ETL 提供商可能没有优化他们的解决方案来应对其特定挑战。

作者 east

mysql, 数据库 4月 6,2022

Oracle 与 MySQL：语法和使用详细比较

数据库管理系统允许组织对可用数据进行分类和结构化，以创建一个流畅、更有条理的工作环境。它们是企业的基础，因为它们提供了管理大量和各种数据类型的有效方法。因此，公司可以更快地做出明智的决定。选择正确的数据库管理系统会有所作为。虽然有些系统具有符合您的业务目标的特定功能，但其他系统根本没有。如果您要决定下一个数据库管理系统，是使用 MySQL 还是 Oracle，以下比较将为您提供做出正确决定所需的信息。

Oracle 和 MySQL 之间的主要区别
虽然 MySQL 和 Oracle 都提供了与关系模型相同的体系结构，并提供了许多标准功能，例如专有软件许可证，但这两种工具之间存在一些关键差异。

MySQL 提供 GPL 软件许可，而 Oracle 没有。
Oracle 与 Linux、UNIX、Windows、Mac OS X 和 z/OS 兼容。 MySQL 与所有这些以及 Symbian、BSD 和 AmigaOS 兼容。
MySQL 仅支持全文和哈希索引。 Oracle 使用的索引不止这些，包括位图、基于函数、分区等。
Oracle 支持分布式数据库，而 MySQL 不支持
Oracle 更适合企业部署，而 MySQL 更适合中小型规模。
MySQL 是免费的，而 Oracle 需要许可费。

甲骨文概述
Oracle 是一个关系数据库管理系统，旨在实现自动驱动、自我保护、自我修复，并消除容易出错的手动数据库管理。它可以在各种操作系统上运行，并允许安全存储和快速检索数据。 Oracle 是第一个为商业目的而开发的使用查询语言管理数据的数据库工具，于 1980 年发布，具有基本的 SQL 功能。

Oracle 数据库特性
它是可扩展的、可移植的、分布式的和可编程的。
它允许在不知道数据的物理存储的情况下与数据库进行交互。
Oracle 使跨不同平台的应用程序与 Oracle 数据库之间的通信顺畅。
Oracle数据库可以运行在Windows、Linux、Mac等多种操作系统上。
它使 ACID 属性能够维护数据的完整性和可靠性。
它可以快速管理大量数据。
它有一个恢复管理器工具，可提供冷、热和增量数据库备份和恢复。
Oracle 的其他一些好处包括：

能够运行大型 ILTB 和 VLDB。
功能非常丰富。
可靠的。
提供闪回技术。

MySQL概述
MySQL 是一种流行的数据库管理系统，专为处理关系数据库而设计。它是 Oracle 公司支持的可扩展的开源工具。与 Oracle 数据库相比，MySQL 的处理速度一样快，并且它的界面经常在评论网站上被引用为更直观和更易于使用。

瑞典公司 MySQL AB 开发并支持 MySQL。 2008 年 1 月，Sun Microsystems 以 10 亿美元收购了 MySQL AB。 2009 年 4 月，甲骨文公司同意收购 Sun Microsystems，当时是 MySQL 版权和商标的所有者。许多大大小小的公司都使用 MySQL。 MySQL 适用于许多操作系统，如 Windows、Linux、macOS 等，使用 C、C++ 和 Java 语言。

MySQL 数据库功能
它是免费和开源的。
MySQL 是一个易于使用的关系数据库管理系统。
它遵循客户端/服务器架构。
它提供了卓越的性能、高度的灵活性和更高的生产力。
它是可扩展的。
令人难以置信的安全性
它使事务能够回滚、提交和崩溃恢复。

Comparison Basis	MySQL	Oracle
发行年份	1995	1980
价格	It is free and open-source. It is licensed under the GNU.	It is licensed for commercial purposes The express edition is free for students.
操作系统支持	WindowsMac OS XLinuxUNIXz/OSBSDSymbianAmigaOS	WindowsMac OS XLinuxUNIXz/OS
弹性	Better for small and big businesses	Better for large-scale deployments
Data Partitioning	Not Supported	Supported
安全性	Username, password, and host required to access the database	Username, password, and profile validation required to access the database
System Type	Static system.	Static and dynamic systems.
Null Value	Supported	Not Supported
Character Support	CHAR and VARCHAR.	CHAR, VARCHAR2, NCHAR, and NVARCHAR2.
语言支持	SQL	SQL and PL/SQL

如 Oracle 文档中所述，Oracle 与 MySQL 语法的一些显着差异如下：

MySQL Data Type	Oracle Data Type
BIGINT	NUMBER(19, 0)
BIT	RAW
BLOB	BLOB, RAW
CHAR	CHAR
DATE	DATE
DATETIME	DATE
DECIMAL	FLOAT (24)
DOUBLE	FLOAT (24)
DOUBLE PRECISION	FLOAT (24)
ENUM	VARCHAR2
FLOAT	FLOAT
INT	NUMBER(10, 0)
INTEGER	NUMBER(10, 0)
LONGBLOB	BLOB, RAW
LONGTEXT	CLOB, RAW
MEDIUMBLOB	BLOB, RAW
MEDIUMINT	NUMBER(7, 0)
MEDIUMTEXT	CLOB, RAW
NUMERIC	NUMBER
REAL	FLOAT (24)
SET	VARCHAR2
SMALLINT	NUMBER(5, 0)
TEXT	VARCHAR2, CLOB
TIME	DATE
TIMESTAMP	DATE
TINYBLOB	RAW
TINYINT	NUMBER(3, 0)
TINYTEXT	VARCHAR2
VARCHAR	VARCHAR2, CLOB
YEAR	NUMBER

Oracle 与 MySQL：如何选择
在 MySQL 与 Oracle 之间进行选择时，必须了解每种工具的优势和劣势，因为它与您期望的业务成果相关。

Oracle 何时是更好的选择？
Oracle 是财富 100 强公司和大型企业的普遍选择，因为它专为大型业务应用程序和大型数据仓库而设计。

那些寻找最广泛的特性列表的人会选择 Oracle，因为它包含各种特性，并且最大限度地减少了对第三方软件的需求。

什么时候 MySQL 是更好的选择？
MySQL 为较小规模的项目提供了更好的选择。通过将数据库驱动的应用程序迁移到 MySQL，或者将 MySQL 用于新的开发项目，企业正在实现成本节约，这些成本节省了很多倍，达到了数十万美元。对于初创公司和小型公司，MySQL 更适合。

作者 east

Tensorflow, 人工智能 4月 5,2022

解决在kaggle等在线平台运行报错module ‘tensorflow’ has no attribute ‘InteractiveSession’

学习tensorflow，除了本地安装一个外，更喜欢去在线平台玩，特别是kaggle这种带有数据集的。看书仿照下面的例子，没想到运行出错了。

# 进入一个交互式 TensorFlow 会话.
import tensorflow as tf

sess = tf.InteractiveSession()

x = tf.Variable([1.0, 2.0])
a = tf.constant([3.0, 3.0])

# 使用初始化器 initializer op 的 run() 方法初始化 'x' 
x.initializer.run()

# 增加一个减法 sub op, 从 'x' 减去 'a'. 运行减法 op, 输出结果 
sub = tf.subtract(x, a)
print(sub.eval())

运行报下面错误：

--------------------------------------------------------------------------- AttributeError                            Traceback (most recent call last) /tmp/ipykernel_33/152899263.py in <module>      
2 import tensorflow as tf      
3  ----> 
4 sess = tf.InteractiveSession()      
5 #tf.compat.v1.disable_eager_execution()    
6 #sess = tf.compat.v1.InteractiveSession()
 AttributeError: module 'tensorflow' has no attribute 'InteractiveSession'

由于版本问题，要用下面的语句替代

使用 sess = tf.compat.v1.InteractiveSession()

解决了这个问题，又出现新的问题：
AttributeError: ‘NoneType’ object has no attribute ‘run’ ，
这需要在sess之前添加tf.compat.v1.disable_eager_execution()

新的完整代码如下：

# 进入一个交互式 TensorFlow 会话.
import tensorflow as tf

tf.compat.v1.disable_eager_execution()
sess = tf.compat.v1.InteractiveSession()
x = tf.Variable([1.0, 2.0])
a = tf.constant([3.0, 3.0])

# 使用初始化器 initializer op 的 run() 方法初始化 'x' 
x.initializer.run()

# 增加一个减法 sub op, 从 'x' 减去 'a'. 运行减法 op, 输出结果 
sub = tf.subtract(x, a)
print(sub.eval())

作者 east

深度学习 4月 5,2022

Word Embedding的几种模型和示例

介绍

人类有能力理解单词并轻松地从中获取含义。然而，在当今世界，大多数任务都是由计算机执行的。例如，如果您想知道今天是晴天还是下雨天，则必须在 Google 中输入文本查询。现在的问题是，机器将如何频繁地理解和处理文本中呈现的如此大量的信息？答案是词嵌入。

Word Embeddings 基本上是向量（文本转换为数字），用于捕获单词的含义、各种上下文和语义关系。嵌入本质上是使用预定义字典将单词映射到其对应向量。

例如，

句子： It will rain heavily today.

字典：{“it”：[1,0,0,0,0]，“will”：[0,1,0,0,0]，“rain”：[0,0,1,0,0] , “ heavily ”: [0,0,0,1,0], “today”: [0,0,0,0,1]}

在这里，每个单词都被分配了一个唯一的向量（例如），以便区分所有单词。

Let the corpus comprise three sentences.

S1 = In monsoon, it will rain.

S2 = rain rain come again.

S3 = sun is visible in summer. In the monsoon, the sun is hidden by clouds.

Let N be the list of unique words = [‘monsoon’, ‘rain’, ‘come’, ‘again’, ‘sun’, ‘visible’, ‘summer’, ‘hidden’, ‘clouds’]

计数矩阵的维度将是 3X9，因为语料库中有 3 个文档和 9 个唯一词。
计数矩阵如下所示：

优点：由于只考虑单词的频率，因此计算成本较低。

缺点：由于计算只是基于计数并且没有考虑单词的上下文，因此该方法证明不太有用。
代码：

#Importing libraries
from sklearn.feature_extraction.text import CountVectorizer
import nltk 
from nltk.corpus import stopwords 
from nltk.tokenize import word_tokenize 

#Downloading stopwords and punkt packages
nltk.download('stopwords') 
nltk.download('punkt') 

#Initialising stopwords for english
set(stopwords.words('english')) 

#sample sentences
text = ["In monsoon, it will rain", "rain rain come again", "sun is visible in summer. In the monsoon, the sun is hidden by clouds"]

#set of stop words
stop_words = set(stopwords.words('english')) 
all_sentences = []

#Logic for removing stop words and obtaining filtered sentences from the list 

for i in range(len(text)):
  word_tokens[i] = word_tokenize(text[i]) 
  tokenized_sentence = []

  for j in word_tokens[i]: 
      if j not in stop_words: 
          tokenized_sentence.append(j) 
  all_sentences.append(" ".join(tokenized_sentence))

#Initialising the CountVectorizer
countvectorizer = CountVectorizer()

#Applying CountVectorizer to the list of sentences
X = countvectorizer.fit_transform(all_sentences)

#Converting output to array
result = X.toarray()

print("Sentences after removing stop words", all_sentences)
print("Count Vector:", result)

2.TF-IDF：

TF-IDF 代表词频-逆文档频率。该方法是对 Count Vector 方法的即兴创作，因为特定单词的频率被考虑在整个语料库中，而不仅仅是单个文档。主要思想是对某些文档非常具体的词给予更多的权重，而对更普遍且在大多数文档中出现的词给予较少的权重。

例如，诸如“is”、“the”、“and”之类的通用词会经常出现，而诸如“Donald Trump”或“Indira Gandhi”之类的词将特定于特定文档。

数学上，

词频 (TF) = 词条在文档中出现的次数 / 文档中词条的总数

逆文档频率 (IDF) = log(N/n) 其中 N 是文档总数，n 是一个术语出现的文档数。

考虑以下示例。
给出了两个文档——D1 和 D2。

TF(Today, Document 1) = 1/8

TF(Today, Document 2) = 1/8

TF(sunny, Document 1) = 4/8

IDF(Today) = log(2/2) = log(1) = 0

IDF(sunny) = log(2/1) = log(2) = 0.301

Therefore,

TF-IDF(Today, Document 1) = 1/8 * 0 = 0

TF-IDF(Today, Document 2) = 1/8 * 0 = 0

TF-IDF(sunny, Document 1) = 4/8 * 0.301 = 0.1505

从上面的计算可以看出，与文档 1 的上下文中的重要词“sunny”相比，常用词“Today”的权重较低。

优点：

它在计算上很容易。
文档中最重要的单词是通过基本计算提取的，不需要太多努力。

缺点：

它无法捕捉单词的语义，只能像词汇级别的特征一样工作。
代码：

from sklearn.feature_extraction.text import TfidfVectorizer 
import pandas as pd

#Declaring the list of sentences
documents = ['Today is sunny day', 'Today is rainy day']

#Initialising Tfidf Vectorizer
vectorizer = TfidfVectorizer()

#Fitting the Vectorizer to the list
X = vectorizer.fit_transform(documents)
print(X)

#Printing the feature names
print(vectorizer.get_feature_names()) 

matrix = X.todense()
tfidf_list = matrix.tolist()
tfidf_df = pd.DataFrame(tfidf_list, columns = vectorizer.get_feature_names())

print(tfidf_df)

3.Word2Vec：

Word2Vec 是一种基于预测的词嵌入方法。与确定性方法不同，它是一个浅层的两层神经网络，能够预测单词之间的语义和相似性。 Word2Vec 是两种不同模型的组合——（i）CBOW（连续词袋）和（ii）Skip-gram。

模型概述 – CBOW（连续词袋）和 Skip-gram。

3.1 CBOW（连续词袋）：

该模型是一个浅层神经网络，可以在给定上下文的情况下预测单词的概率。这里，上下文是指围绕要预测的单词的单词的输入。
CBOW模型的架构：

作为第一步，输入是通过为给定文本形成一个词袋来创建的。
例如，

Sentence 1 = All work and no play make Jack a dull boy.

Sentence 2 = Jack and Jill went up the hill.

Bag of Words: {“All”:1, “work”:1, “no”:1, “play”:1, “makes”:1, “Jack”:2, “dull”:1, “boy”:1, “Jill”:1, “went”:1, “up”:1, “hill”:1} (after removing the stop words)

这个由单词及其出现频率组成的输入作为向量发送到输入层。对于 X 个单词，输入将是 X[1XV] 个向量，其中 V 是向量的最大长度。

接下来，输入隐藏层矩阵由维数 VXN 组成，其中 N 是表示单词的维数。输出隐藏层矩阵由维数 NXV 组成。在这里，这些值是通过将输入乘以隐藏输入权重来计算的。

在输出层，通过将隐藏输入乘以隐藏输出权重来计算输出。在隐藏层和输出层之间计算的权重给出了单词的表示。作为一个连续的中间步骤，通过对输出和目标值之间计算的误差使用反向传播来调整权重。
优点：

与确定性方法相比，概率性方法给出了更好的结果。
由于不需要计算巨大的矩阵，因此内存需求较少。
缺点：

优化非常重要，否则培训将需要很长时间才能完成。

3.2 Skip-gram ：

Skip-gram 模型预测给定单词的上下文，与 CBOW 所做的正好相反。 Skip-gram 模型的架构：

输入层大小：[1XV]，输入隐藏权重矩阵大小：[VXN]，输出隐藏权重矩阵：[NXV]，输出层大小：C[1XV]

模型的输入和直到隐藏层的进一步步骤将类似于 CBOW。输出目标变量的数量取决于上下文窗口的大小。例如，如果上下文窗口的大小为 2，那么将有四个目标变量，两个词在给定词之前，两个词在给定词之后。

将针对四个目标变量计算四个单独的误差，并通过执行元素相加获得最终向量。然后反向传播这个最终向量以更新权重。对于训练，输入和隐藏层之间的权重用于单词表示。

优点：

Skip-gram 模型可以捕获单词的不同上下文信息，因为每个上下文都有不同的向量表示。
对于不常用的术语更准确，并且适用于更大的数据库。
缺点：

它需要更多的内存进行处理。
代码：

要使用 genism 库中预训练的 Word2Vec 模型：

import gensim 
import gensim.downloader as api
from gensim.models.keyedvectors import KeyedVectors

#loading pretrained model
nlp_w2v = api.load("word2vec-google-news-300") 

#save the Word2Vec model
nlp_w2v.wv.save_word2vec_format('model.bin', binary=True)

#load the Word2Vec model 
model = KeyedVectors.load_word2vec_format('model.bin', binary=True)

#Printing the most similar words to New York from vocabulary of pretrained model
model.most_similar('New_York')

从头开始训练 Word2Vec 模型：

import gensim 
'''
Data for training Word2Vec
train: A data frame comprising of text samples
'''

#training data
corpus = train

#creates a list for a list of words for every training sample
w2v_corpus = []
for document in corpus:
   w2v_words = document.split()
   w2v_grams = [" ".join(w2v_words[i:i+1]) 
               for i in range(0, len(w2v_words), 1)]
   w2v_corpus.append(w2v_grams)

#initialising and training the custom Word2Vec model 
'''
size: dimensions of word embeddings 
window: context window for words 
min_count: words which appear less number of times than this count will be ignored 
sg: To choose skip-gram model 
iter: Number of epochs for training
'''

word2vec_model = gensim.models.word2vec.Word2Vec(w2v_corpus, size=300,   
            window=8, min_count=1, sg=1, iter=30)

#vector size of the model
print(word2vec_model.vector_size)

#vocabulary contained by the model
print(len(word2vec_model.wv.vocab))

4.GloVE:

GloVe 代表词表示的全局向量。该算法是对 Word2Vec 方法的改进，因为它考虑全局统计而不是局部统计。在这里，全局统计数据意味着从整个语料库中考虑的单词。 GloVe 基本上试图解释特定单词对在文档中出现的频率。为此，构建了一个共现矩阵，该矩阵将表示特定单词相对于另一个单词的存在。

例如，

Corpus – It is rainy today, tomorrow it will be sunny and the day after will be windy.

上面的矩阵表示一个共现矩阵，其值表示在给定示例语料库中一起出现的每对单词的计数。

在计算给定“today”、p(rainy/today) 和给定“tomorrow”、p(rainy/tomorrow) 的单词“rainy”的出现概率后，结果是与“rainy”最相关的单词与“明天”相比，“今天”是“今天”。

代码：

#Import statements
from numpy import array
from numpy import asarray
from numpy import zeros
from keras.preprocessing.text import Tokenizer 

#Download the pretrained GloVe data files
!wget http://nlp.stanford.edu/data/glove.6B.zip

#Unzipping the zipped folder
!unzip glove*.zip

#Initialising a tokenizer and fitting it on the training dataset
'''
train: a dataframe comprising of rows containing text data
'''
tokenizer = Tokenizer(num_words=5000)
tokenizer.fit_on_texts(train)

#Creating a dictionary to store the embeddings
embeddings_dictionary = dict()

#Opening GloVe file
glove_file = open('glove.6B.50d.txt', encoding="utf8")

#Filling the dictionary of embeddings by reading data from the GloVe file
for line in glove_file:
    records = line.split()
    word = records[0]
    vector_dimensions = asarray(records[1:], dtype='float32')
    embeddings_dictionary[word] = vector_dimensions
glove_file.close()

#Parsing through all the words in the input dataset and fetching their corresponding vectors from the dictionary and storing them in a matrix 
embedding_matrix = zeros((vocab_size, 50))
for word, index in tokenizer.word_index.items():
    embedding_vector = embeddings_dictionary.get(word)
    if embedding_vector is not None:
        embedding_matrix[index] = embedding_vector

#Displaying embedding matrix 
print(embedding_matrix)

结论：

在这篇博客中，我们回顾了一些方法——Count Vector、TF-IDF、Word2Vec 和 GloVe，用于从原始文本数据创建词嵌入。预处理文本然后发送预处理数据以创建词嵌入总是一个好习惯。作为进一步的步骤，这些词嵌入可以发送到机器学习或深度学习模型，用于各种任务，例如文本分类或机器翻译。

作者 east

Hive, 数据库 4月 4,2022

Hive对比SQL：哪个更适合数据分析

Hive 和 SQL 之间的主要区别：

架构：Hive 是一个用于数据分析的数据仓库项目； SQL 是一种编程语言。（但是，Hive 通过称为 HiveQL 的编程语言执行数据分析，类似于 SQL。）

设置：Hive 是一个基于开源软件程序 Hadoop 的数据仓库。
数据分析：Hive 比 SQL 更有效地处理复杂数据，适合不太复杂的数据集。

价格：Hive 价格从每位用户每月 12 美元起。 SQL 是开源和免费的。

评论：Hive 在 G2 网站上的客户评论评分为 4.2/5。因为 SQL 是一种编程语言而不是“产品”，所以它在 G2 上没有评论。

大数据需要强大的工具。成功的组织查询、管理和分析来自数百个数据源的数千个数据集。这就是 Hive 和 SQL 等工具的用武之地。尽管非常不同，但查询和编程大数据都是如此。

但是哪种工具适合您的组织？在这篇评论中，我们在功能、价格、支持、用户评分等方面比较了 Hive 与 SQL。

什么是Hive？
Apache Hive 是一个用于数据查询和分析的数据仓库项目。 Hive 建立在 Apache Hadoop（一个用于处理大数据的开源程序）之上，通过查询语言 HiveQL 执行数据分析，它允许用户构建数据并生成各种有用的分析。

Hive 由 Facebook 开发，使希望从电子表格、网络日志、CRM 系统等中查询和汇总数据的用户受益。它在 Hadoop 分布式文件系统 (HDFS) 中查询数据，并将该系统用于自己的存储。它还运行 MapReduce 作业。

什么是 SQL？
结构化查询语言 (SQL) 是一种特定于领域的编程语言，用于管理数据和/或处理数据流。它主要管理数据并处理关系数据库管理系统中保存的实时数据。在这篇评论的上下文中，SQL 就像 HiveQL。

SQL 由 Oracle 开发，是一种用于分析查询的声明性语言。它比 Hive（和 HiveQL）更新得多。 SQL 可以追溯到 45 年前，并且在许多 IT 系统中已经无处不在。

有关我们的原生 SQL 连接器的更多信息，请访问我们的集成页面。

Hive 和 SQL 的区别
Hive 在 HDFS 中写入和查询数据。 SQL 需要多次读取和写入。
Hive 更适合分析复杂的数据集。 SQL 更适合快速分析不太复杂的数据集。
SQL 支持联机事务处理 (OLTP)。 Hive 不支持 OLTP。
Hive 查询可能具有高延迟，因为 Hive 通过 Hadoop 运行批处理。这意味着某些查询要等待一个小时（或更长时间）。更新 Hive 上的数据也可能需要很长时间。

支持和培训
HIVE
一个在线社区（Apache 软件基金会）
资源
邮件列表
语言手册

SQL
虽然没有提供官方培训，但有各种 SQL 第三方培训模块/支持社区。

价钱
HIVE
计划从每位用户每月 12 美元起。
有 14 天的免费试用期。
SQL
作为一个开源平台，SQL 是 100% 免费的。但是，SQL 定价并未考虑您可能遇到的任何设置或维护成本。

结论
Hive 和 SQL 是处理（和驯服！）大数据的两种工具。尽管这些工具有相似之处，但它们的差异足以保证进行比较。我们认为 Hive 更适合分析复杂的数据集，而 SQL 更适用于不太复杂的数据集，并且在执行这些任务时速度更快。另外，它是开源和免费的。最终，适合您的工具取决于您如何分析组织中的大数据。

作者 east

Hadoop 4月 4,2022

Hadoop对比SQL，哪个更适合数据管理

Hadoop 与 SQL 之间的主要区别：

架构：Hadoop 是一个开源框架（或“生态系统”），它在计算机/服务器集群之间分布数据集并并行处理数据。 SQL 是一种特定领域的编程语言，用于处理关系数据库中的数据。

数据：Hadoop 一次写入数据； SQL 多次写入数据。（Hadoop 和 SQL 多次读取数据。）

技能水平：Hadoop 比 SQL 更难学。（但是，两者都需要代码知识。）

价格：Hadoop 和 SQL 是开源的并且可以免费使用。但是，两者都会产生额外的设置和维护成本。

评论：Hadoop 在软件评论网站 G2.com 上的客户评分为 4.3/5。因为 SQL 是一种编程语言，而不是作为“产品”提供，所以它在 G2 上没有得分。

组织依靠大数据为其业务提供动力，但许多团队都在为数据管理的复杂性而苦苦挣扎。值得庆幸的是，Hadoop 和 SQL 更有效地处理大型数据集。这些工具以独特的方式管理数据，这使得我们很难在同类的基础上比较它们。但是，希望简化其技术堆栈的组织可能有理由选择其中一个。

在本文中，我们根据几个因素比较了 Hadoop 与 SQL，包括功能和客户评论分数。

什么是 Hadoop？
Apache Hadoop 是一个开源工具生态系统，可将数据集存储在分布式系统中并解决各种数据管理问题。

Hadoop 由四个组件组成：MapReduce、Yarn、库，以及最终在现成硬件上运行的 Hadoop 分布式文件系统 (HDFS)。 Hadoop 处理各种数据集，使其成为希望从大量来源生成有价值数据洞察的组织的绝佳选择。它有利于处理大量数据。

Hadoop 对跨计算机和服务器集群的数据集进行分布式处理。它以并行方式处理数据，因此它可以同时在多台机器上工作。 HDFS 存储提交的数据，MapReduce 处理数据，Yarn 划分数据管理任务。

世界上一些最成功的技术组织都使用 Hadoop，包括 IBM、Pivotal Software、Hadapt 和 Amazon Web Services。

什么是 SQL？
结构化查询语言 (SQL) 是一种开源的特定于领域的编程语言，用于在 Oracle、SQL Server 或 MySQL 等关系数据库管理系统 (RDMS) 中进行数据管理和处理数据流。 SQL 由 Oracle 开发，是一种用于分析查询的声明性语言。

有关我们的原生 SQL 连接器的更多信息，请访问我们的集成页面。

Hadoop 与 SQL：有什么区别？
也许 Hadoop 和 SQL 之间最大的区别在于这些工具管理和集成数据的方式。 SQL 只能处理有限的数据集，例如关系数据，并且难以处理更复杂的数据集。 Hadoop 可以处理大型数据集和非结构化数据。

当然，还有很多其他的区别：

Hadoop 线性扩展； SQL 是非线性的。
Hadoop的完整性低； SQL 是高完整性的。
Hadoop只能写一次； SQL 多次写入。
Hadoop具有动态模式结构； SQL 具有静态模式结构。
Hadoop 支持批处理（通过 HDFS）； SQL 没有。
Hadoop 比 SQL 更难学习，但更容易扩展。您可以轻松地将数据节点添加到 Hadoop 集群。
您选择的工具取决于您要管理的数据集。如果您需要处理大量数据，请选择 Hadoop。如果您不想要高级数据管理的复杂性，请选择 SQL。

作者 east

Spark 4月 3,2022

生产环境选型考虑：Spark和Tez有什么不同

让我们开始这场精彩的讨论。首先，退一步；我们已经指出 Apache Spark 和 Hadoop MapReduce 是两种不同的大数据利器。前者是高性能的内存数据处理框架，后者是成熟的PB级批处理平台。我们也知道 Apache Hive 和 HBase 是两个功能相似的非常不同的工具。 Hive 是运行 MapReduce 作业的类似 SQL 的引擎，而 HBase 是 Hadoop 上的 NoSQL 键/值数据库。

在纸面上，它们有很多共同点。两者都具有内存功能，都可以在 Hadoop YARN 之上运行，并且都支持来自任何数据源的所有数据类型。那么两者有什么区别呢？

Tez 非常适合 YARN 架构。 Spark 可能会遇到资源管理问题。

Spark 更适合主流开发人员，而 Tez 是专用工具的框架。

Spark 不能与 YARN 应用程序同时运行（目前）。 Tez 是专门为在 YARN 之上执行而构建的。

Tez 的容器可以在完成后关闭以节省资源。即使不处理数据，Spark 的容器也会占用资源。

这些只是高层次上的一些差异。在这里，我们将探索这些项目中的每一个。

什么是 Apache Spark？

Apache Spark 是一个用于处理大数据的开源分析引擎和集群计算框架。它是非营利性 Apache 软件基金会的创意，该基金会是一个致力于各种开源软件项目的去中心化组织。

它于 2014 年首次发布，基于 Hadoop MapReduce 分布式计算框架构建。它保留了 MapReduce 的许多优点——例如可扩展性和容错性——同时还提高了速度和易用性。

除了核心数据处理引擎，它还包括 SQL、机器学习和流处理库。该框架与 Java、Scala、Python 和 R 编程语言兼容，赢得了开发人员的广泛关注。它还支持第三方技术，如 Amazon S3、Hadoop 的 HDFS、MapR XD 和 NoSQL 数据库，如 Cassandra 和 MongoDB。

它的吸引力在于它能够将不同的流程、技术和技术整合到一个单一的大数据管道中，从而提高生产力和效率。由于其灵活性，它已成为大数据处理领域非常流行和有效的“瑞士军刀”。

什么是 Apache Tez？

Apache Tez 是一个基于 MapReduce 技术的大数据处理开源框架。两者都提供了一个执行引擎，可以使用有向无环图 (DAG) 来处理大量数据。

它通过将计算视为 DAG 来概括 MapReduce 范式。 MapReduce 任务组合成一个作业，该作业被视为 DAG 中的一个节点，执行并发和序列化。

同时，DAG 的边缘表示作业之间的数据移动。 Tez 与数据类型无关，因此它只关心数据的移动（而不是它采用的格式）。

通过改进 MapReduce 的一些限制，Tez 试图提高数据处理作业的性能。这种增加的效率使程序员能够做出他们认为最适合他们的项目的设计和开发选择。

Apache Spark 将自己标榜为“用于大规模数据处理的统一分析引擎”。同时，Apache Tez 称自己为“一个应用程序框架，它允许使用复杂的有向无环图来处理数据的任务”。

因为 Spark 也使用有向无环图，这两个工具听起来是不是很相似？可能是。但也有一些重要的区别需要考虑。以下是两者之间的根本区别：

差异#1：Hive和Pig

差异 #2：Hadoop YARN

差异#3：性能测试

我们将在下面的部分中详细介绍这些差异中的每一个。

他们支持Pig和Hive吗？

Hive 和 Pig 是两个用于大数据的开源 Apache 软件应用程序。 Hive 是一个数据仓库，而 Pig 是一个用于创建在 Hadoop 上运行的数据处理作业的平台。虽然两者都声称支持 Pig 和 Hive，但现实并不那么清楚。我们尝试使用 Spork 项目在 Spark 上运行 Pig，但遇到了一些问题；至少，在 Spark 上使用 Pig 充其量仍是不确定的。

使用YARN

YARN 是 Hadoop 的资源管理器和作业调度器。理论上，Spark 既可以作为独立应用程序执行，也可以在 YARN 之上执行。然而，Tez 是专门为在 YARN 之上执行而构建的。不过，Spark 不能与其他 YARN 应用程序同时运行（至少现在还不能）。

Tez 项目的开发人员之一 Gopal V 写了一篇关于他为什么喜欢 Tez 的详细文章。他的结论是：

“在我使用过的框架之间，这是 Tez 真正的区别特性——Tez 不需要容器保持运行来做任何事情，只需应用程序管理器在不同查询之间的空闲期间运行。您可以保留容器，但这是一种优化，而不是会话空闲期间的要求。”

他所说的“框架”也指 Spark——它的容器需要保持运行并占用资源，即使它们不处理任何数据。但是，Tez 容器可以在完成后立即关闭并释放资源。

大多数情况下，您无论如何都会使用基于 Hadoop 的应用程序，例如 Hive、HBase 甚至经典的 MapReduce。因此，您可以在任何 Hadoop 集群上安装 Spark，但您可能会遇到资源管理问题。另一方面，Tez 可以非常适合您的 YARN 架构，包括资源管理。

Apache Spark 的亮点：图形处理

GraphX 是扩展 Spark RDD 的图计算引擎。术语“图”是指图论中的图，而不是用于商业计算的图。图论中使用的图捕获数据之间的交互和依赖关系。

GraphX 最初是加州大学伯克利分校的一个研究项目。该项目后来被捐赠给了 Apache 软件基金会和 Spark 项目。

GraphX 不同于其他图计算引擎，因为它将图分析和 ETL 统一在一个平台上。 GraphX 还可以分析非图形形式的数据。其内存计算能力使 GraphX 比其他图形处理引擎更快。

图处理的常用场景

社交网络分析 – 用于识别影响者以进行目标营销

欺诈检测 – 银行、信用卡公司和在线商店使用图形分析来识别异常趋势。

供应链优化 – 公司可以使用图表分析来确定其供应链的最佳路线

贷款决策 – 抵押贷款公司和银行使用图表分析来评估申请人的数据以做出贷款决策。

Google 如何使用图形处理

Google 使用一种称为 PageRank 算法的图形分析算法。 PageRank 算法根据重要性对图中的顶点进行排名，其中重要性是指向该顶点的边数。该算法是由 Google 的创始人开发的，因此流行的搜索引擎是 PageRank 的一个典型例子。谷歌根据页面的重要性对页面进行排名，重要性是指向页面的超链接数量。

那么哪个更快？

也许最大的问题是——哪个更快？根据各种基准，这两个选项都显着提高了 MapReduce 性能；但是，获胜者可能取决于谁在进行测量。就独立第三方评估而言，陪审团仍未出局。

Spark 声称运行速度比 MapReduce 快 100 倍。在加州大学伯克利分校的 Amplab 进行的基准测试表明，它的运行速度比它的同类产品快得多（测试将 Spark 称为 Shark，它是 Spark SQL 的前身）。

然而，由于伯克利发明了 Spark，这些测试可能并非完全没有偏见。此外，这些基准测试是几年前使用运行在 MapReduce 上的 Hive 0.12 进行的。从版本 0.13 开始，Hive 使用 Tez 作为其执行引擎，从而显着提高了性能。

与此同时，Hortonworks 对两者之间的问题表现进行了基准测试。他们发现在 Tez 上运行的 Hive 0.13 的运行速度比 Hive 0.12 快 100 倍（尽管相当多的测试查询神秘地消失了）。快了 100 倍……嗯，听起来很熟悉？

因此，它们的性能都比 Hadoop MapReduce 高 100 倍。但哪个最快？

没有人可以说——或者更确切地说，他们不会承认。如果你问为 IBM 工作的人，他们会告诉你答案都不是，而且 IBM Big SQL 比两者都快。我们需要第三方来运行独立的性能测试并一劳永逸地确定分数。

小结：

这个问题最终可能归结为政治和受欢迎程度。这是大数据巨头的冲突，Cloudera 支持 Spark，Hortonworks 支持 Tez。 Spark 更为广泛，因为它可以在各种发行版中使用，而 Tez 仅在 Hortonworks 的发行版中可用。

最终，用户群可能决定框架的命运。目前，至少根据谷歌趋势，Spark 正在赢得这场比赛。

也许在炒作消退之后，在人们获得了更多与两者合作的经验之后，我们最终将能够判断谁将成为 MapReduce 王冠的继承人。

作者 east

大数据开发 4月 3,2022

大数据5种不同数据处理方式

随着商业环境的不断发展，公司越来越依赖于他们的数据。但是，在您可以利用任何数据为公司谋取利益之前，您必须首先处理您收集的结构化和非结构化数据。

虽然最简单和最著名的数据处理形式是数据可视化，但有几种不同的数据处理方法通常用于与数据交互。

继续阅读以了解有关五种数据处理类型的更多信息，以及它们在可用性、原子性、并发性和其他因素方面的不同之处。

为什么数据处理方法很重要？

您采用的数据处理方法将决定查询的响应时间以及输出的可靠性。因此，需要谨慎选择方法。例如，在可用性至关重要的情况下，例如证券交易所门户，交易处理应该是首选方法。

重要的是要注意数据处理和数据处理系统之间的区别。数据处理是将数据转换为有用信息的规则。数据处理系统是针对特定类型的数据处理进行优化的应用程序。例如，分时系统旨在优化运行分时处理。它也可以用于运行批处理。但是，它不会很好地适应这项工作。

从这个意义上说，当我们谈论为您的需求选择正确的数据处理类型时，我们指的是选择正确的系统。以下是最常见的数据处理类型及其应用。

1. 事务处理

事务处理部署在关键任务情况下。这些情况一旦中断，将对业务运营产生不利影响。例如，如前所述，处理证券交易所交易。在事务处理中，可用性是最重要的因素。可用性可能受以下因素的影响：

硬件：事务处理系统应该有冗余硬件。硬件冗余允许部分故障，因为冗余组件可以自动接管并保持系统运行。

软件：事务处理系统的软件应设计为从故障中快速恢复。通常，事务处理系统使用事务抽象来实现这一点。简而言之，如果发生故障，未提交的事务将被中止。这允许系统快速重启。

2.分布式处理

很多时候，数据集太大而无法放在一台机器上。分布式数据处理分解这些大型数据集并将它们存储在多台机器或服务器上。它依赖于 Hadoop 分布式文件系统 (HDFS)。分布式数据处理系统具有高容错性。如果网络中的一台服务器出现故障，则可以将数据处理任务重新分配给其他可用的服务器。

分布式处理也可以极大地节省成本。企业不再需要建造昂贵的大型计算机并投资于维护和维护。

流处理和批处理是分布式处理的常见示例，下面将讨论这两者。

3.实时处理

实时处理类似于事务处理，因为它用于需要实时输出的情况。但是，两者在处理数据丢失的方式上有所不同。实时处理尽可能快地计算传入数据。如果它在输入数据中遇到错误，它会忽略错误并移动到下一个输入数据块。GPS 跟踪应用程序是实时数据处理的最常见示例。

将此与事务处理进行对比。如果出现错误，例如系统故障，事务处理将中止正在进行的处理并重新初始化。在近似答案就足够的情况下，实时处理优于事务处理。

在数据分析领域，流处理是实时数据处理的常见应用。流处理首先由 Apache Storm 推广，它在数据传入时对其进行分析。想想来自物联网传感器的数据，或实时跟踪消费者活动。 Google BigQuery 和 Snowflake 是采用实时处理的云数据平台的示例。

4.批处理

顾名思义，批处理就是将一段时间内存储的数据块一起或分批分析。当需要分析大量数据以获得详细见解时，需要进行批处理。例如，一个公司在一段时间内的销售数据通常会经过批处理。由于涉及大量数据，系统将需要时间来处理它。通过批量处理数据，可以节省计算资源。

当准确性比速度更重要时，批处理优于实时处理。此外，批处理的效率也以吞吐量来衡量。吞吐量是单位时间内处理的数据量。

5. 多并发处理

多并发处理是一种数据处理方法，其中两个或两个以上的处理器在同一数据集上工作。这听起来可能与分布式处理完全一样，但还是有区别的。在多处理中，不同的处理器驻留在同一系统中。因此，它们存在于相同的地理位置。如果出现组件故障，则会降低系统的速度。

另一方面，分布式处理使用彼此独立并且可以存在于不同地理位置的服务器。由于当今几乎所有系统都具有并行处理数据的能力，因此几乎每个数据处理系统都使用多处理。

但是，在本文的上下文中，可以将多处理视为具有本地数据处理系统。通常，处理非常敏感信息的公司可能会选择本地数据处理而不是分布式处理。例如，从事石油和天然气开采行业的制药公司或企业。

这种数据处理最明显的缺点是成本。构建和维护内部服务器非常昂贵。

作者 east

深度学习 4月 2,2022

Tensorflow：使用 GPU 进行 BERT 微调

训练数据的短缺是自然语言处理面临的最大挑战之一。因为 NLP 是一个多元化的领域，在多语言数据中具有多种任务。最特定于任务的数据集仅包含几千个训练数据，这不足以实现更好的准确性。

为了提高现代基于深度学习的 NLP 模型的性能，需要数百万或数十亿的训练数据。研究人员已经开发出各种方法来使用网络上的大量未注释文本来训练通用语言表示模型。这称为预训练。

这些预训练模型可用于为广泛的 NLP 任务（例如问答和测试分类）创建最先进的模型。它被称为微调。当我们没有足够数量的训练样本时，微调是有效的。

BERT

BERT 代表来自 Transformers 的双向编码器表示。 BERT 是由 Google AI 的研究人员推出的 NLP 框架。它是一种新的预训练语言表示模型，可在各种自然语言处理 (NLP) 任务上获得最先进的结果。只需添加单个输出层即可对预训练的 BERT 模型进行微调。你可以在这里找到 BERT 的学术论文：https://arxiv.org/abs/1810.04805。

在本教程中，您将通过一个示例学习对 BERT 模型进行微调。可以参考之前的 BERT 教程，里面已经解释了 BERT 模型的架构。

我们将使用 Kaggle 的 Quora Insincere Questions Classification 任务数据进行演示。

In [1]:
# Let's load the required packages
import pandas as pd
import numpy as np
import datetime
import zipfile
import sys
import os

下载预训练的 BERT 模型以及模型权重和配置文件

In [2]: !wget storage.googleapis.com/bert_models/2018_10_18/uncased_L-12_H-768_A-12.zip

提取下载的模型 zip 文件。

In [3]:
repo = 'model_repo'
if not os.path.exists(repo):
    print("Dir created!")
    os.mkdir(repo)
with zipfile.ZipFile("uncased_L-12_H-768_A-12.zip","r") as zip_ref:
    zip_ref.extractall(repo)

In [4]:
BERT_MODEL = 'uncased_L-12_H-768_A-12'
BERT_PRETRAINED_DIR = f'{repo}/uncased_L-12_H-768_A-12'

OUTPUT_DIR = f'{repo}/outputs'
if not os.path.exists(OUTPUT_DIR):
    os.makedirs(OUTPUT_DIR)

print(f'***** Model output directory: {OUTPUT_DIR} *****')
print(f'***** BERT pretrained directory: {BERT_PRETRAINED_DIR} *****') 

Out[4]:

***** Model output directory: model_repo/outputs *****
***** BERT pretrained directory: model_repo/uncased_L-12_H-768_A-12 *****

准备和导入 BERT 模块

以下 BERT 模块是从 GitHub 克隆源代码并导入模块。

In [5]:
# Download the BERT modules
!wget raw.githubusercontent.com/google-research/bert/master/modeling.py 
!wget raw.githubusercontent.com/google-research/bert/master/optimization.py 
!wget raw.githubusercontent.com/google-research/bert/master/run_classifier.py 
!wget raw.githubusercontent.com/google-research/bert/master/tokenization.py
!wget raw.githubusercontent.com/google-research/bert/master/run_classifier_with_tfhub.py

In [6]: # Import BERT modules 
import modeling 
import optimization 
import run_classifier 
import tokenization 
import tensorflow as tf 
import run_classifier_with_tfhub

准备训练数据

在这里，我们将在一小部分训练数据上训练 BERT 模型。

In [7]:
from sklearn.model_selection import train_test_split

train_df =  pd.read_csv('input/train.csv')
train_df = train_df.sample(2000)                 # Train on 2000 data

train, val = train_test_split(train_df, test_size = 0.1, random_state=42)

train_lines, train_labels = train.question_text.values, train.target.values
val_lines, val_labels = val.question_text.values, val.target.values

label_list = ['0', '1']

In [8]:
def create_examples(lines, set_type, labels=None):
    guid = f'{set_type}'
    examples = []
    if guid == 'train':
        for line, label in zip(lines, labels):
            text_a = line
            label = str(label)
            examples.append(
              run_classifier.InputExample(guid=guid, text_a=text_a, text_b=None, label=label))
    else:
        for line in lines:
            text_a = line
            label = '0'
            examples.append(
              run_classifier.InputExample(guid=guid, text_a=text_a, text_b=None, label=label))
    return examples

指定 BERT 预训练模型。

这里使用的是 uncased_L-12_H-768_A-12 型号。该模型由12层、768个隐藏、12个头、110M个参数组成。它是一个 Uncased 模型，这意味着文本在标记化之前已被小写。

In [9]:
BERT_MODEL = 'uncased_L-12_H-768_A-12' 
BERT_MODEL_HUB = 'https://tfhub.dev/google/bert_' + BERT_MODEL + '/1'

初始化模型超参数。

In [10]:
TRAIN_BATCH_SIZE = 32
EVAL_BATCH_SIZE = 8
LEARNING_RATE = 2e-5
NUM_TRAIN_EPOCHS = 3.0
WARMUP_PROPORTION = 0.1
MAX_SEQ_LENGTH = 128

# Model Configuration
SAVE_CHECKPOINTS_STEPS = 1000 
ITERATIONS_PER_LOOP = 1000
NUM_TPU_CORES = 8

VOCAB_FILE = os.path.join(BERT_PRETRAINED_DIR, 'vocab.txt')
CONFIG_FILE = os.path.join(BERT_PRETRAINED_DIR, 'bert_config.json')
INIT_CHECKPOINT = os.path.join(BERT_PRETRAINED_DIR, 'bert_model.ckpt')
DO_LOWER_CASE = BERT_MODEL.startswith('uncased')

tpu_cluster_resolver = None   # Model trained on GPU, we won't need a cluster resolver

def get_run_config(output_dir):
    return tf.contrib.tpu.RunConfig(
    cluster=tpu_cluster_resolver,
    model_dir=output_dir,
    save_checkpoints_steps=SAVE_CHECKPOINTS_STEPS,
    tpu_config=tf.contrib.tpu.TPUConfig(
        iterations_per_loop=ITERATIONS_PER_LOOP,
        num_shards=NUM_TPU_CORES,
        per_host_input_for_training=tf.contrib.tpu.InputPipelineConfig.PER_HOST_V2))

加载分词器模块

注意：当您使用 Cased 模型时，传递 do_lower_case = False。

In [11]:
tokenizer = tokenization.FullTokenizer(vocab_file=VOCAB_FILE, do_lower_case=DO_LOWER_CASE)
train_examples = create_examples(train_lines, 'train', labels=train_labels)

# compute number of train and warmup steps from batch size
num_train_steps = int( len(train_examples) / TRAIN_BATCH_SIZE * NUM_TRAIN_EPOCHS)
num_warmup_steps = int(num_train_steps * WARMUP_PROPORTION)

微调来自 TF Hub 的预训练 BERT 模型

本节说明了来自 TensorFlow 集线器模块的微调预训练 BERT 模型。

In [12]:

model_fn = run_classifier_with_tfhub.model_fn_builder(
  num_labels=len(label_list),
  learning_rate=LEARNING_RATE,
  num_train_steps=num_train_steps,
  num_warmup_steps=num_warmup_steps,
  use_tpu=False,
  bert_hub_module_handle=BERT_MODEL_HUB
)

estimator_from_tfhub = tf.contrib.tpu.TPUEstimator(
  use_tpu=False,    #If False training will fall on CPU or GPU
  model_fn=model_fn,
  config=get_run_config(OUTPUT_DIR),
  train_batch_size=TRAIN_BATCH_SIZE,
  eval_batch_size=EVAL_BATCH_SIZE,
)

In [13]:
# Train the model
def model_train(estimator):
    print('Please wait...')
    train_features = run_classifier.convert_examples_to_features(
      train_examples, label_list, MAX_SEQ_LENGTH, tokenizer)
    print('***** Started training at {} *****'.format(datetime.datetime.now()))
    print('  Num examples = {}'.format(len(train_examples)))
    print('  Batch size = {}'.format(TRAIN_BATCH_SIZE))
    tf.logging.info("  Num steps = %d", num_train_steps)
    train_input_fn = run_classifier.input_fn_builder(
      features=train_features,
      seq_length=MAX_SEQ_LENGTH,
      is_training=True,
      drop_remainder=True)
    estimator.train(input_fn=train_input_fn, max_steps=num_train_steps)
    print('***** Finished training at {} *****'.format(datetime.datetime.now()))

In [14]: model_train(estimator_from_tfhub)

In [15]:
# Evaluate the model
def model_eval(estimator):
    
    eval_examples = create_examples(val_lines, 'test')
    
    eval_features = run_classifier.convert_examples_to_features(
        eval_examples, label_list, MAX_SEQ_LENGTH, tokenizer)
        
    print('***** Started evaluation at {} *****'.format(datetime.datetime.now()))
    print('  Num examples = {}'.format(len(eval_examples)))
    print('  Batch size = {}'.format(EVAL_BATCH_SIZE))
    
    eval_steps = int(len(eval_examples) / EVAL_BATCH_SIZE)
    
    eval_input_fn = run_classifier.input_fn_builder(
      features=eval_features,
      seq_length=MAX_SEQ_LENGTH,
      is_training=False,
      drop_remainder=True)
    
    result = estimator.evaluate(input_fn=eval_input_fn, steps=eval_steps)
    
    print('***** Finished evaluation at {} *****'.format(datetime.datetime.now()))
    
    print("***** Eval results *****")
    for key in sorted(result.keys()):
        print('  {} = {}'.format(key, str(result[key])))

In [16]: model_eval(estimator_from_tfhub)

从检查点微调预训练的 BERT 模型

您还可以从保存的检查点加载预训练的 BERT 模型。

In [17]:
CONFIG_FILE = os.path.join(BERT_PRETRAINED_DIR, 'bert_config.json')
INIT_CHECKPOINT = os.path.join(BERT_PRETRAINED_DIR, 'bert_model.ckpt')

OUTPUT_DIR = f'{repo}/outputs_checkpoints'
if not os.path.exists(OUTPUT_DIR):
    os.makedirs(OUTPUT_DIR)

model_fn = run_classifier.model_fn_builder(
    bert_config=modeling.BertConfig.from_json_file(CONFIG_FILE),
    num_labels=len(label_list),
    init_checkpoint=INIT_CHECKPOINT,
    learning_rate=LEARNING_RATE,
    num_train_steps=num_train_steps,
    num_warmup_steps=num_warmup_steps,
    use_tpu=False, #If False training will fall on CPU or GPU, 
    use_one_hot_embeddings=True)

estimator_from_checkpoints = tf.contrib.tpu.TPUEstimator(
    use_tpu=False,
    model_fn=model_fn,
    config=get_run_config(OUTPUT_DIR),
    train_batch_size=TRAIN_BATCH_SIZE,
    eval_batch_size=EVAL_BATCH_SIZE)

In [18]: 
# Train the Model
model_train(estimator_from_checkpoints)

# Evaluate the Model
In [19]: model_eval(estimator_from_checkpoints)

作者 east