精华内容
下载资源
问答
  • 不等式绘图的一般实现计算几何-regionfill.m 在可视化上matlab已经很强大了(但是令人吐槽的是它的默认色彩方案以及光滑的线条),但是有些功能还是没有现成的官方函数能够简单实现,比如经常会遇到的区域绘图/...
  • 不等式绘图的一般实现计算几何-regionsurf.m 在可视化上matlab已经很强大了(但是令人吐槽的是它的默认色彩方案以及光滑的线条),但是有些功能还是没有现成的官方函数能够简单实现,比如经常会遇到的区域绘图/...
  • 不等式绘图的一般实现计算几何-surfs.rar 在可视化上matlab已经很强大了(但是令人吐槽的是它的默认色彩方案以及光滑的线条),但是有些功能还是没有现成的官方函数能够简单实现,比如经常会遇到的区域绘图/...
  • 背景 ...经过查询,了解到了使用 SystemParametersInfo 函数就可以实现,而且这个函数功能还是很强的,设置桌面墙纸只是其中一个功能,还设置屏保、设置屏保时间等等,基本上计算机里大部分的设置...

    背景

    有一天,Q群里的一个群友向群里提问,怎么用编程实现更改计算机的桌面。好吧,这个功能我之前没有做过,自然也不知道该怎么回答,作为一群之主,也只能勉为其难地上网去搜索下资料,给人一个答复才行啊。

    经过查询,了解到了使用 SystemParametersInfo 函数就可以实现,而且这个函数功能还是很强的,设置桌面墙纸只是其中一个功能,还能设置屏保、设置屏保时间等等,基本上计算机里大部分的设置,都会使用到 SystemParametersInfo 这个函数。

    现在,我就讲解下实现原理和过程,写成文档分享给大家。

     

    点击此处下载文档和源码

     

    展开全文
  • 实时计算 浅谈分布式计算的开发与实现(一) 接上篇,离线计算是对已经入库的数据进行计算,在查询时对... 按照以前离线计算的做法是不能满足的,需要使用到实时计算。 小明作为有理想、有追求的程序员开始设计其解...

    实时计算

    浅谈分布式计算的开发与实现(一)

    接上篇,离线计算是对已经入库的数据进行计算,在查询时对批量数据进行检索、磁盘读取展示。 而实时计算是在数据产生时就对其进行计算,然后实时展示结果,一般是秒级。 举个例子来说,如果有个大型网站,要实时统计用户的搜索内容,这样就能计算出热点新闻及突发事件了。 按照以前离线计算的做法是不能满足的,需要使用到实时计算。

    小明作为有理想、有追求的程序员开始设计其解决方案了,主要分三部分。

    • 每当搜索内容的数据产生时,先把数据收集到消息队列,由于其数据量较大,以使用kafka为例。 这个收集过程是一直持续的,数据不断产生然后不断流入到kafka中。
    • 要有一个能持续计算的框架,一旦收集到数据,计算系统能实时收到数据,根据业务逻辑开始计算,然后不断产生需要的结果,这里以storm为例。
    • 根据结果进行实时展示并入库, 可以一边展示一边入库,对外提供实时查询的服务。这里的入库可以是基于内存的Redis、MongoDB,也可是基于磁盘的HBase、Mysql、SqlServer等。

    其流程图如下:

    storm简介

    通常都介绍Storm是一个分布式的、高容错的实时计算系统。 “分布式”是把数据分布到多台上进行计算,“高容错”下面谈,这里主要细节介绍下“实时计算”的实现。

    storm有个角色叫topology,它类似mapreduce的job,是一个完整的业务计算任务抽象。 上章谈到hadoop的缺点在于数据源单一依赖HDFS,storm中Spout角色的出现解决了这个问题。 在Spout内部我们可以读取任意数据源的数据,比如Redis、消息队列、数据库等等。 而且spout可以是多个,这样更好的分类,比如可以SpoutA读取kafka,SpoutB读取Redis。 示例如下:

    <pre style="margin:0px;
    	padding:0px;
    	white-space:pre-wrap;
    	overflow-wrap:break-word;
    	font-family:&quot;
    	Courier New&quot;
    	!important;
    	font-size:12px !important;
    	">
    public class CalcPriceSpout:BaseRichSpout {
    	private SpoutCollector Collector;
    	public override void NexData() {
    	//读取各种数据源,Redis、消息队列、数据库等
    	Collector.emit("消息")
    }
    }</pre>
    复制代码

    代码中NexData是storm的核心方法,它一直被storm循环调用着, 在方法里我们实时读取kafka的消息,然后把消息通过Collector组件发射到各个计算节点里,它类似小和尚中的Master。 这样应用每产生一条数据,会实时收集到kafka,然后被NextData消费,发射到节点开始计算。 NextData读取的消息时在内存中,然后直接通过网络流动到节点机器上的内存中开始计算,不会持久化到磁盘上。

    因为速度比较快,所以叫实时计算,也有叫持续计算,意思是可以非常快的一直进行计算,至于叫什么都可以。

    流式计算

    主流的流式计算有S4、StreamBase、Borealis,其storm也具有流式计算的特性。 流式计算是指“数据能像液体水一样不断的在各个节点间流动,每个节点都可以对“数据(液体水)”进行计算,然后产生新的数据,继续像水一样流动”。如图:

    图中Spout就是水龙头,它不断的通过NextData产生数据,然后流动各个Bolt中。 Bolt是各个计算节点上的计算逻辑,它拿到数据后开始计算,完成后流向另外一个,直到完成。 其Bolt也可以是任意个,这比Mapreduce只能分成Map、Reduce两部分好多了。 这样可以在BlotA中计算中间值,然后通过这个中间值去任意数据源拉取数据后,在流动到下一步处理逻辑中, 这个中间值直接在内存中,通过网络流动BlotB上。 其大大增加了其适用范围和灵活度,Spout和bolt的数据流动构成了一个有向无环图。 Bolt示例代码如下。

    <pre style="margin:0px;
    	padding:0px;
    	white-space:pre-wrap;
    	overflow-wrap:break-word;
    	font-family:&quot;
    	Courier New&quot;
    	!important;
    	font-size:12px !important;
    	">
    public class CalcProductPriceBolt:BaseRichBolt {
    	private BoltCollector Collector;
    	public override void Execute(Tuple<string,string> input) {
    	//Result=计算计算计算。 //Collector.Emit("Reulst");
    	流动到另外一个节点
    }
    }</pre>
    复制代码

    数据流动图:

    归纳总结

    结合上篇,发现Hadoop离线计算的计算要求是把业务逻辑包上传到平台上,数据导入到HDFS上,这样才能进行计算。 其产生的结果数据是展示之前就计算好的,另外它的计算是按批次来的,比如很多公司的报表,都是每天凌晨开始计算前一天的数据,以便于展示。 其数据是不动的,计算逻辑也是不动的。

    Storm的流式计算同样是把计算逻辑包上传到平台上,由平台调度,计算逻辑是不动的。 但数据可以是任意来源的,不断在计算节点进行流动。 也即是说在数据产生的时刻,就开始进行流动计算,它展示的结果数据是实时变化的。 其数据是流动的,计算逻辑是不动的。storm把产生的每条数据当成一个消息来处理,其内部也是通过消息队列组件zeromq来完成的。

    高容错性

    storm提供了各级别的可靠性保证,一消息从Spout流动到boltA,在流动boltB, 那storm会通过唯一值不断异或的设计去监测这个消息的完成情况,这个监测是一个和业务逻辑类似的bolt,不过它是有storm自身实现的,叫Acker,它的任务就是接收各个消息任务的完成状态,然后告诉Spout这个消息是否已经完全处理。下面是几种异常处理情况:

    • BoltB所在的节点挂了或消息异常,那么这条消息就没有处理完,Spout可在超时后重新发射该数据即可。
    • Acker所在节点挂了后,即当前节点监控的消息完全情况,会全部丢失,Spout会在消息超时做后续处理。
    • 如果Spout所在节点挂了,那Spout发射的数据也会全部丢失, 这时可在消息队列中设置超时时间,如果没有一直没对消息进行Ack的话,那么这条消息会重新让其他的Spout重新接收到。这部分需要单独在消息队列中配置,另外storm消息的Ack确认对性能有一定影响,可根据消息的重要性是否要开启它。
    • 如果storm平台级别的组件挂了,平台会尝试重启失败的组件,storm除nimbus组件外都是多节点点部署,挂了某一节点,不会对任务计算有所影响。

    转载于:https://juejin.im/post/5cbff77ee51d45789024d7ee

    展开全文
  • 但本文从另一角度嵌套SQL查询语句而构建了一个简单的三层全连接网络,虽然由于语句的嵌套过深而不能高效计算,但仍然是一个非常有意思的实验。 在这篇文章中,我们将纯粹用SQL实现含有一个隐藏层(以及带 ReLU 和...

    我们熟知的SQL是一种数据库查询语句,它方便了开发者在大型数据中执行高效的操作。但本文从另一角度嵌套SQL查询语句而构建了一个简单的三层全连接网络,虽然由于语句的嵌套过深而不能高效计算,但仍然是一个非常有意思的实验。

    在这篇文章中,我们将纯粹用SQL实现含有一个隐藏层(以及带 ReLU 和 softmax 激活函数)的神经网络。这些神经网络训练的步骤包含前向传播和反向传播,将在 BigQuery 的单个SQL查询语句中实现。当它在 BigQuery 中运行时,实际上我们正在成百上千台服务器上进行分布式神经网络训练。听上去很赞,对吧?

    也就是说,这个有趣的项目用于测试 SQL 和 BigQuery 的限制,同时从声明性数据的角度看待神经网络训练。这个项目没有考虑任何的实际应用,不过最后我将讨论一些实际的研究意义。

    我们先从一个基于神经网络的简单分类器开始。它的输入尺寸为 2,输出为二分类。我们将有一个维度为 2 的单隐层和 ReLU 激活函数。输出层的二分类将使用 softmax 函数。我们在实现网络时遵循的步骤将是在  Karpathy’s CS231n 指南(https://cs231n.github.io/neural-networks-case-study/)中展示的基于 SQL 版本的 Python 示例。

    模型

    该模型含有以下参数:

    输入到隐藏层

    • W: 2×2 的权重矩阵(元素: w_00, w_01, w_10, w_11)
    • B: 2×1 的偏置向量(元素:b_0, b_1)

    隐藏到输出层

    • W2: 2×2 的权重矩阵(元素: w2_00, w2_01, w2_10, w2_11)
    • B2: 2×1 的偏置向量(元素:b2_0, b2_1)

    训练数据存储在 BigQuery 表格当中,列 x1 和 x2 的输入和输出如下所示(表格名称:example_project.example_dataset.example_table)

    如前所述,我们将整个训练作为单个 SQL 查询语句来实现。在训练完成后,通过 SQL 查询语句将会返回参数的值。正如你可能猜到的,这将是一个层层嵌套的查询,我们将逐步构建以准备这个查询语句。我们将会从最内层的子查询开始,然后逐个增加嵌套的外层。

    前向传播

    首先,我们将权重参数  W 和 W2 设为服从正态分布的随机值,将权重参数 B 和 B2 设置为 0。 W 和 W2 的随机值可以通过 SQL 本身产生。为了简单起见,我们将从外部生成这些值并在 SQL 查询中使用。用于初始化参数的内部子查询如下:

    1. SELECT *,     
    2.                -0.00569693  AS w_00,  
    3.                0.00186517  AS w_01,  
    4.                0.00414431  AS w_10,  
    5.                0.0105101  AS w_11,  
    6.                0.0  AS b_0, 
    7.                0.0  AS b_1, 
    8.                -0.01312284  AS w2_00, 
    9.                - 0.01269512  AS w2_01, 
    10.               0.00379152  AS w2_10,      
    11.               -0.01218354  AS w2_11, 
    12.               0.0  AS b2_0, 
    13.               0.0  AS b2_1 
    14.  FROM  `example_project.example_dataset.example_table` 

    请注意,表格 example_project.example_dataset.example_table 已经包含了列  x1、 x2 和 y。模型参数将会被作为上述查询结果的附加列添加。

    接下来,我们将计算隐藏层的激活值。我们将使用含有元素 d0 和 d1 的向量 D 表示隐藏层。我们需要执行矩阵操作 D = np.maximum(0, np.dot(X, W) + B),其中 X 表示输入向量(元素 x1 和 x2)。这个矩阵运算包括将权重 W 和输入 X 相乘,再加上偏置向量 B。然后,结果将被传递给非线性 ReLU 激活函数,该函数将会把负值设置为 0。SQL 中的等效查询为:

    1. SELECT *,       
    2.            (CASE 
    3.             WHEN ((x1*w_00 + x2*w_10) + b_0) > 0.0 THEN ((x1*w_00 + x2*w_10) + b_0) 
    4.             ELSE 0.0 
    5.         END) AS d0, 
    6.        (CASE 
    7.             WHEN ((x1*w_01 + x2*w_11) + b_0) > 0.0 THEN ((x1*w_01 + x2*w_11) + b_1) 
    8.             ELSE 0.0 
    9.         END) AS d1 
    10. FROM {inner subquery} 

    上面的查询将两个新列 d0 和 d1 添加到之前内部子查询的结果当中。 上述查询的输出如下所示。

    这完成了从输入层到隐藏层的一次转换。现在,我们可以执行从隐藏层到输出层的转换了。

    首先,我们将计算输出层的值。公式是:scores = np.dot(D, W2) + B2。然后,我们将对计算出来的值用 softmax 函数来获得每个类的预测概率。SQL 内部的等价子查询如下:

    1. SELECT *, 
    2.        EXP(scores_0)/(EXP(scores_0) + EXP(scores_1)) AS probs_0, 
    3.        EXP(scores_1)/(EXP(scores_0) + EXP(scores_1)) AS probs_1 
    4. FROM   
    5. SELECT *,    
    6.                 ((d0*w2_00 + d1*w2_10) + b2_0) AS scores_0, 
    7.                 ((d0*w2_01 + d1*w2_11) + b2_1) AS scores_1 
    8.    FROM {INNER sub-query}) 

    首先,我们将使用交叉熵损失函数来计算当前预测的总损失。首先,计算每个样本中正确类预测概率对数的负值。交叉熵损失只是这些 X 和 Y 实例中数值的平均值。自然对数是一个递增函数,因此,将损失函数定义为负的正确类预测概率对数很直观。如果正确类的预测概率很高,损失函数将会很低。相反,如果正确类的预测概率很低,则损失函数值将很高。

    为了减少过拟合的风险,我们也将同样增加 L2 正则化。在整体损失函数中,我们将包含 0.5*reg*np.sum(W*W) + 0.5*reg*np.sum(W2*W2),其中 reg 是超参数。在损失函数中包括这一函数将会惩罚那些权重向量中较大的值。

    在查询当中,我们同样会计算训练样本的数量(num_examples)。这对于后续我们计算平均值来说很有用。SQL 查询中计算整体损失函数的语句如下:

    1. SELECT *,    
    2.     (sum_correct_logprobs/num_examples) + 1e-3*(0.5*(w_00*w_00 + w_01*w_01 + w_10*w_10 + w_11*w_11) + 0.5*(w2_00*w2_00 + w2_01*w2_01 + w2_10*w2_10 + w2_11*w2_11)) AS loss 
    3. FROM   
    4.    (SELECT *,   
    5.                     SUM(correct_logprobs)  OVER ()  sum_correct_logprobs, 
    6.                                      COUNT(1)  OVER ()  num_examples 
    7.    FROM    
    8.       (SELECT *,   
    9.                      (CASE 
    10.                           WHEN y = 0 THEN -1*LOG(probs_0) 
    11.                           ELSE -1*LOG(probs_1) 
    12.                     END) AS correct_logprobs 
    13.       FROM {inner subquery})) 

    反向传播

    接下来,对于反向传播,我们将计算每个参数对于损失函数的偏导数。我们使用链式法则从最后一层开始逐层计算。首先,我们将通过使用交叉熵和 softmax 函数的导数来计算 score 的梯度。与此相对的查询是:

    1. SELECT *,    
    2.               (CASE 
    3.                          WHEN y = 0  THEN (probs_0–1)/num_examples            ELSE probs_0/num_examples 
    4.                END)  AS dscores_0, 
    5.              (CASE 
    6.                         WHEN y = 1 THEN (probs_1–1)/num_examples            ELSE probs_1/num_examples 
    7.               END)  AS dscores_1  
    8. FROM {inner subquery} 

    在上文中,我们用  scores = np.dot(D, W2) + B2 算出了分数。因此,基于分数的偏导数,我们可以计算隐藏层 D 和参数 W2,B2 的梯度。对应的查询语句是:

    1. SELECT *, 
    2.        SUM(d0*dscores_0) OVER () AS dw2_00, 
    3.        SUM(d0*dscores_1) OVER () AS dw2_01,  
    4.        SUM(d1*dscores_0) OVER () AS dw2_10,  
    5.        SUM(d1*dscores_1) OVER () AS dw2_11,  
    6.        SUM(dscores_0) OVER () AS db2_0,  
    7.        SUM(dscores_1) OVER () AS db2_1,  
    8.        CASE  
    9.           WHEN (d0) <= 0.0  THEN 0.0  
    10.           ELSE (dscores_0*w2_00 + dscores_1*w2_01)  
    11.        END AS dhidden_0,  
    12.       CASE  
    13.           WHEN (d1) <= 0.0 THEN 0.0  
    14.           ELSE (dscores_0*w2_10 + dscores_1*w2_11)  
    15.       END AS dhidden_1  
    16. FROM {inner subquery} 

    同理,我们知道  D = np.maximum(0, np.dot(X, W) + B)。因此,通过 D 的偏导,我们可以计算出 W 和 B 的导数。我们无须计算 X 的偏导,因为它不是模型的参数,且也不必通过其它模型参数进行计算。计算 W 和 B 的偏导的查询语句如下:

    1. SELECT *,  
    2.        SUM(x1*dhidden_0) OVER () AS dw_00,  
    3.        SUM(x1*dhidden_1) OVER () AS dw_01,  
    4.        SUM(x2*dhidden_0) OVER () AS dw_10,  
    5.        SUM(x2*dhidden_1) OVER () AS dw_11,  
    6.        SUM(dhidden_0) OVER () AS db_0,  
    7.        SUM(dhidden_1) OVER () AS db_1  
    8. FROM {inner subquery} 

    最后,我们使用 W、B、W2 及 B2 各自的导数进行更新操作。计算公式是 param = learning_rate * d_param ,其中learning_rate 是参数。为了体现 L2 正则化,我们会在计算 dW 和 dW2 时加入一个正则项 reg*weight。我们也去掉如  dw_00, correct_logprobs 等缓存的列,它们曾在子查询时被创建,用于保存训练数据(x1, x2 及 y 列) 和模型参数(权重和偏置项)。对应的查询语句如下:

    1. SELECT x1,  
    2.    x2, 
    3.        y,  
    4.        w_00 — (2.0)*(dw_00+(1e-3)*w_00) AS w_00,  
    5.        w_01 — (2.0)*(dw_01+(1e-3)*w_01) AS w_01,  
    6.        w_10 — (2.0)*(dw_10+(1e-3)*w_10) AS w_10,  
    7.        w_11 — (2.0)*(dw_11+(1e-3)*w_11) AS w_11,  
    8.        b_0 — (2.0)*db_0 AS b_0,  
    9.        b_1 — (2.0)*db_1 AS b_1, 
    10.        w2_00 — (2.0)*(dw2_00+(1e-3)*w2_00) AS w2_00,  
    11.        w2_01 — (2.0)*(dw2_01+(1e-3)*w2_01) AS w2_01, 
    12.        w2_10 — (2.0)*(dw2_10+(1e-3)*w2_10) AS w2_10,  
    13.        w2_11 — (2.0)*(dw2_11+(1e-3)*w2_11) AS w2_11,  
    14.        b2_0 — (2.0)*db2_0 AS b2_0,  
    15.        b2_1 — (2.0)*db2_1 AS b2_1  
    16. FROM {inner subquery} 

    这包含了正向和反向传播的一整个迭代过程。以上查询语句将返回更新后的权重和偏置项。部分结果如下所示:

    为了进行多次训练迭代,我们将反复执行上述过程。用一个简单 Python 函数足以搞定,代码链接如下:https://github.com/harisankarh/nn-sql-bq/blob/master/training.py。

    因为迭代次数太多,查询语句嵌套严重。执行 10 次训练迭代的查询语句地址如下:

    https://github.com/harisankarh/nn-sql-bq/blob/master/out.txt

    因为查询语句的多重嵌套和复杂度,在 BigQuery 中执行查询时多项系统资源告急。BigQuery 的标准 SQL 扩展的缩放性比传统 SQL 语言要好。即使是标准 SQL 查询,对于有 100k 个实例的数据集,也很难执行超过 10 个迭代。因为资源的限制,我们将会使用一个简单的决策边界来评估模型,如此一来,我们就可以在少量迭代后得到较好的准确率。

    我们将使用一个简单的数据集,其输入 X1、X2 服从标准正态分布。二进制输出 y 简单判断   x1 + x2 是否大于 0。为了更快的训练完 10 个迭代,我们使用一个较大的学习率 2.0(注意:这么大的学习率并不推荐实际使用,可能会导致发散)。将上述语句执行 10 个迭代得出的模型参数如下:

    我们将使用 Bigquery 的函数 save to table 把结果保存到一个新表。我们现在可以在训练集上执行一次推理来比较预测值和预期值的差距。查询语句片段在以下链接中:

    https://github.com/harisankarh/nn-sql-bq/blob/master/query_for_prediction.sql。

    仅通过十个迭代,我们的准确率就可达 93%(测试集上也差不多)。

    如果我们把迭代次数加到 100 次,准确率高达 99%。

    优化

    下面是对本项目的总结。我们由此获得了哪些启发?如你所见,资源瓶颈决定了数据集的大小以及迭代执行的次数。除了祈求谷歌开放资源上限,我们还有如下优化手段来解决这个问题。

    创建中间表和多个 SQL 语句有助于增加迭代数。例如,前 10 次迭代的结果可以存储在一个中间表中。同一查询语句在执行下 10 次迭代时可以基于这个中间表。如此,我们就执行了 20 个迭代。这个方法可以反复使用,以应对更大的查询迭代。

    相比于在每一步增加外查询,我们应该尽可能的使用函数的嵌套。例如,在一个子查询中,我们可以同时计算 scores 和 probs,而不应使用 2 层嵌套查询。

    在上例中,所有的中间项都被保留直到最后一个外查询执行。其中有些项如 correct_logprobs 可以早些删除(尽管 SQL 引擎可能会自动的执行这类优化)。

    多尝试应用用户自定义的函数。如果感兴趣,你可以看看这个 BigQuery 的用户自定义函数的服务模型的项目(但是,无法使用 SQL 或者 UDFs 进行训练)。

    意义

    现在,让我们来看看基于深度学习的分布式 SQL 引擎的深层含义。 BigQuery、Presto  这类 SQL 仓库引擎的一个局限性在于,查询操作是在 CPU 而不是 GPU 上执行的。研究 blazingdb 和 mapd 等基于 GPU 加速的数据库查询结果想必十分有趣。一个简单的研究方法就是使用分布式 SQL 引擎执行查询和数据分布,并用 GPU 加速数据库执行本地计算。

    退一步来看,我们已经知道执行分布式深度学习很难。分布式 SQL 引擎在数十年内已经有了大量的研究工作,并产出如今的查询规划、数据分区、操作归置、检查点设置、多查询调度等技术。其中有些可以与分布式深度学习相结合。如果你对这些感兴趣,请看看这篇论文(https://sigmodrecord.org/publications/sigmodRecord/1606/pdfs/04_vision_Wang.pdf),该论文对分布式数据库和分布式深度学习展开了广泛的研究讨论。

    展开全文
  • 阅读目录: 实时计算storm简介流式计算归纳总结高容错性 实时计算 ...接上篇,离线计算是对已经入库的数据进行计算,在查询时对批量数据进行检索、磁盘... 按照以前离线计算的做法是不能满足的,需要使用到实时计

    阅读目录:

    1. 实时计算
    2. storm简介
    3. 流式计算
    4. 归纳总结
    5. 高容错性

    实时计算

    接上篇,离线计算是对已经入库的数据进行计算,在查询时对批量数据进行检索、磁盘读取展示。 而实时计算是在数据产生时就对其进行计算,然后实时展示结果,一般是秒级。 举个例子来说,如果有个大型网站,要实时统计用户的搜索内容,这样就能计算出热点新闻及突发事件了。 按照以前离线计算的做法是不能满足的,需要使用到实时计算。

    小明作为有理想、有追求的程序员开始设计其解决方案了,主要分三部分。

    • 每当搜索内容的数据产生时,先把数据收集到消息队列,由于其数据量较大,以使用kafka为例。 这个收集过程是一直持续的,数据不断产生然后不断流入到kafka中。
    • 要有一个能持续计算的框架,一旦收集到数据,计算系统能实时收到数据,根据业务逻辑开始计算,然后不断产生需要的结果,这里以storm为例。
    • 根据结果进行实时展示并入库, 可以一边展示一边入库,对外提供实时查询的服务。这里的入库可以是基于内存的Redis、MongoDB,也可是基于磁盘的HBase、Mysql、SqlServer等。

    其流程图如下:

    storm简介

    通常都介绍Storm是一个分布式的、高容错的实时计算系统。 “分布式”是把数据分布到多台上进行计算,“高容错”下面谈,这里主要细节介绍下“实时计算”的实现。

    storm有个角色叫topology,它类似mapreduce的job,是一个完整的业务计算任务抽象。 上章谈到hadoop的缺点在于数据源单一依赖HDFS,storm中Spout角色的出现解决了这个问题。 在Spout内部我们可以读取任意数据源的数据,比如Redis、消息队列、数据库等等。 而且spout可以是多个,这样更好的分类,比如可以SpoutA读取kafka,SpoutB读取Redis。 示例如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class CalcPriceSpout : BaseRichSpout
    {
        private SpoutCollector Collector;
        public override void NexData()
        {
            //读取各种数据源,Redis、消息队列、数据库等
            Collector.emit("消息")
        }
    }

    代码中NexData是storm的核心方法,它一直被storm循环调用着, 在方法里我们实时读取kafka的消息,然后把消息通过Collector组件发射到各个计算节点里,它类似小和尚中的Master。 这样应用每产生一条数据,会实时收集到kafka,然后被NextData消费,发射到节点开始计算。 NextData读取的消息时在内存中,然后直接通过网络流动到节点机器上的内存中开始计算,不会持久化到磁盘上。

    因为速度比较快,所以叫实时计算,也有叫持续计算,意思是可以非常快的一直进行计算,至于叫什么都可以。

    流式计算

    主流的流式计算有S4、StreamBase、Borealis,其storm也具有流式计算的特性。 流式计算是指“数据能像液体水一样不断的在各个节点间流动,每个节点都可以对“数据(液体水)”进行计算,然后产生新的数据,继续像水一样流动”。如图:

    图中Spout就是水龙头,它不断的通过NextData产生数据,然后流动各个Bolt中。 Bolt是各个计算节点上的计算逻辑,它拿到数据后开始计算,完成后流向另外一个,直到完成。 其Bolt也可以是任意个,这比Mapreduce只能分成Map、Reduce两部分好多了。 这样可以在BlotA中计算中间值,然后通过这个中间值去任意数据源拉取数据后,在流动到下一步处理逻辑中, 这个中间值直接在内存中,通过网络流动BlotB上。 其大大增加了其适用范围和灵活度,Spout和bolt的数据流动构成了一个有向无环图。 Bolt示例代码如下。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class CalcProductPriceBolt : BaseRichBolt
    {
        private BoltCollector Collector;
        public override void Execute(Tuplestring, string> input)
        {
            //Result=计算计算计算。
            //Collector.Emit("Reulst"); 流动到另外一个节点
        }
    }

    数据流动图:

    归纳总结

    结合上篇,发现Hadoop离线计算的计算要求是把业务逻辑包上传到平台上,数据导入到HDFS上,这样才能进行计算。 其产生的结果数据是展示之前就计算好的,另外它的计算是按批次来的,比如很多公司的报表,都是每天凌晨开始计算前一天的数据,以便于展示。 其数据是不动的,计算逻辑也是不动的。

    Storm的流式计算同样是把计算逻辑包上传到平台上,由平台调度,计算逻辑是不动的。 但数据可以是任意来源的,不断在计算节点进行流动。 也即是说在数据产生的时刻,就开始进行流动计算,它展示的结果数据是实时变化的。 其数据是流动的,计算逻辑是不动的。storm把产生的每条数据当成一个消息来处理,其内部也是通过消息队列组件zeromq来完成的。

    高容错性

    storm提供了各级别的可靠性保证,一消息从Spout流动到boltA,在流动boltB, 那storm会通过唯一值不断异或的设计去监测这个消息的完成情况,这个监测是一个和业务逻辑类似的bolt,不过它是有storm自身实现的,叫Acker,它的任务就是接收各个消息任务的完成状态,然后告诉Spout这个消息是否已经完全处理。下面是几种异常处理情况:

    • BoltB所在的节点挂了或消息异常,那么这条消息就没有处理完,Spout可在超时后重新发射该数据即可。
    • Acker所在节点挂了后,即当前节点监控的消息完全情况,会全部丢失,Spout会在消息超时做后续处理。
    • 如果Spout所在节点挂了,那Spout发射的数据也会全部丢失, 这时可在消息队列中设置超时时间,如果没有一直没对消息进行Ack的话,那么这条消息会重新让其他的Spout重新接收到。这部分需要单独在消息队列中配置,另外storm消息的Ack确认对性能有一定影响,可根据消息的重要性是否要开启它。
    • 如果storm平台级别的组件挂了,平台会尝试重启失败的组件,storm除nimbus组件外都是多节点点部署,挂了某一节点,不会对任务计算有所影响。

    下篇写消息保证机制及改造小和尚的设计。

    展开全文
  • 项目中眼下已有一周表存储了一年中全部的假日,给定查询起始日期和结束日期,推导出查询时间段内工作日是多少。为了简化这个问题,须要以下几个如果。 1. 考虑周六周日,将其视作普通工作日 2. 假日没有交叠情况...
  • 计算min/max直接可以访问相关索引结构,无需全表扫描; 如下所式: desc索引无法支持min/max的查询;而asc类型的索引确实可以.为何这样?是跟索引的物理设计和实现有关吗? SQL> create table t as select *from ...
  • 实验四Floyd 算法 一实验目的 利用MATLAB 实现Floyd 算法可对输入的邻接距离矩阵计算图中任 意两点间的最短距离矩阵和路由矩阵且能查询任意两点间的最短距离 和路由 二实验原理 Floyd 算法适用于求解网络中的任意两...
  • (2) 报名管理功能模块 报各库录入(姓名不能不空,之间不能有空格) 增加、删除、修改、浏览 (3) **准考证管理模块** 准考证生成规则:xxx+yy+zz+kk 其中XXX为考点代码;YY为语言代码,XX为考场号,KK为座位号...
  • 3:最好是花钱,SCCM虽然可以查,但毕竟是商业的,省下钱当然最好啦。以下是四种方法,各有各的好,难度也越来越大和复杂,在这里说下我实践下来的做法。初级篇:最简单的方法,本帖里很多朋友也说了,组策略...
  • 今天小编带着大家完成两个动手实践活动,通过两个简单实用的例子来演示无服务器架构的真正魅力,case1:通过函数计算+Http触发器+云市场三者结合起来,提供一个能查询手机号归属地天气预报,case2:通过输入指定的...
  • 按时间范围查询,想实现查询结果如下: rankAB rankC rankD avg_a avg_b avg_c max_d rate 1 3 4 154.56 5843.25 586.14 251.11 0.25 2 1 2 154.56 5843.25 586.14 251.11 0.14 1 1 3 154.56 5843.25 586.14 251....
  • 今天小编带着大家完成两个动手实践活动,通过两个简单实用的例子来演示无服务器架构的真正魅力,case1:通过函数计算+Http触发器+云市场三者结合起来,提供一个能查询手机号归属地天气预报,case2:通过输入指定的...
  • 造成当前检索的方法查准率和查全率不能兼得的问题,文中提出了基于语义网的电子政务文档检索技 术[1 ] 。该检索结合语义网的资源标注以及传统的概念检索技术,在语义网的框架下进行知识推理和智 能检索,提高检索结果的...
  • 有一个设想当有持续不断的结构化或非结构化大数据集以流(streaming...假设,你已经有一个数据收集的引擎或工具(在本博客讨论范围内,请出门左转Google右转百度),怎么都行, 反正数据以流的方式给出来,塞进Kaf
  • 实验内容 1.设计一个简单的学生信息管理的程序 StudentInfo,教学管理人员能够...2.在添加学生基本信息、课程基本信息相关数据时,学号和课程号不能重复;还有在添加学生选课信息时,要求该学生和课程必须是存在...
  • 隐私计算

    2021-04-30 15:53:39
    比如医学研究上的药效预测分析,需要使用患者用药信息,但是又不能泄露患者隐私。比如借贷机构向黑名单拥有方查询借贷人的信用,只需返回结果,而不应泄露任何个人信息。 关键技术: 内容参考《隐私保护计算...
  • 早知道tkinter有这么多教程而且也简单我就不用pyqt了,纯粹和自己过去。找对工具和开发思路真是事半功倍,以后还要多向大佬取经,集思广益,看看别人,问问大佬们的神器。 有很多地方需要记录一下,写完实验...
  • 第三篇中,我们通过维护节点的深度level,通过迭代所有的节点,只...不能直接查询到节点的深度level。当然,如果需要level字段,在递归过程中,是可以计算得到的。关于在递归过程中,计算level,后面有介绍这种方法。
  • 异步计算FutureTask类

    2020-07-05 19:32:25
    结果只可以在计算完成之后获取,get方法会阻塞当计算没有完成的时候,一旦计算已经完成,那么计算不能再次启动或是取消。 一个FutureTask 可以用来包装一个 Callable 或是一个runnable对象。因为FurtureTask实现了...
  • 嵌套查询与连接查询的性能

    千次阅读 2018-01-19 20:45:14
    (当然和DB优化有关,也可能子查询比连接查询快)其实不能一概而论的~~ 不过,问了下DBA同学,他建议是能用join的,尽量不要用嵌套查询。以下内容,部分是来自网上的一些观点,自己稍加整理的。  子查询实现...
  • 给该对象设置一个当前页数(前端给)、总记录数(拦截器内赋值)2个参数,他就帮你计算出分页sql语句用的2个参数。 /** * 分页对应的实体类 */ public class Page { /** * 总条数 */ private int total...
  • 它使用机器学习算法在图像中查询人的面部。对于人脸这么复杂的东西,并没有一个简单的检测对是否存在人脸下结论,而需要成千上万的特征匹配。算法把人脸识别任务分解成数千个小任务,每个都难处理。这些...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,471
精华内容 588
热门标签
关键字:

查询不能实现计算