Spark移动平均：时间序列数据平均值

最新推荐文章于 2024-07-25 08:33:44 发布
最新推荐文章于 2024-07-25 08:33:44 发布
阅读量2k 收藏 1
点赞数
分类专栏： 大数据 文章标签： spark 移动平均 时间序列

一、内存排序

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext


object MovingAverageInMemory {

  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("MovingAverageInMemory").setMaster("local")
    val sc = new SparkContext(sparkConf)

    val window = 3
    val input = "file:///media/chenjie/0009418200012FF3/ubuntu/gupiao1.txt"
    val output = "file:///media/chenjie/0009418200012FF3/ubuntu/gupiao1"

    val brodcastWindow = sc.broadcast(window)

    val rawData = sc.textFile(input)
    /*
    * GOOG,2004-11-04,184.70
      GOOG,2004-11-03,191.67
      GOOG,2004-11-02,194.87
      AAPL,2013-10-09,486.59
      AAPL,2013-10-08,480.94
      AAPL,2013-10-07,487.75
      AAPL,2013-10-04,483.03
      AAPL,2013-10-03,483.41
      IBM,2013-09-30,185.18
      IBM,2013-09-27,186.92
      IBM,2013-09-26,190.22
      IBM,2013-09-25,189.47
      GOOG,2013-07-19,896.60
      GOOG,2013-07-18,910.68
      GOOG,2013-07-17,918.55
    * */
    val keyValue = rawData.map(line => {
      val tokens = line.split(",")
      (tokens(0), (tokens(1), tokens(2).toDouble))
    })
    /*
    * (GOOG,(2004-11-04,184.7))
      (GOOG,(2004-11-03,191.67))
      (GOOG,(2004-11-02,194.87))
      (AAPL,(2013-10-09,486.59))
      (AAPL,(2013-10-08,480.94))
      (AAPL,(2013-10-07,487.75))
      (AAPL,(2013-10-04,483.03))
      (AAPL,(2013-10-03,483.41))
      (IBM,(2013-09-30,185.18))
      (IBM,(2013-09-27,186.92))
      (IBM,(2013-09-26,190.22))
      (IBM,(2013-09-25,189.47))
      (GOOG,(2013-07-19,896.6))
      (GOOG,(2013-07-18,910.68))
      (GOOG,(2013-07-17,918.55))
    * */
    val groupByStockSymbol = keyValue.groupByKey()
    /*
    * (IBM,CompactBuffer((2013-09-30,185.18), (2013-09-27,186.92), (2013-09-26,190.22), (2013-09-25,189.47)))
      (GOOG,CompactBuffer((2004-11-04,184.7), (2004-11-03,191.67), (2004-11-02,194.87), (2013-07-19,896.6), (2013-07-18,910.68), (2013-07-17,918.55)))
      (AAPL,CompactBuffer((2013-10-09,486.59), (2013-10-08,480.94), (2013-10-07,487.75), (2013-10-04,483.03), (2013-10-03,483.41)))
    * */
    val result = groupByStockSymbol.mapValues(values => {
      val dateFormat = new java.text.SimpleDateFormat("yyyy-MM-dd")
      val sortedValues = values.map(s => (dateFormat.parse(s._1).getTime.toLong, s._2)).toSeq.sortBy(_._1)
      /*
      * values:CompactBuffer((2013-09-30,185.18), (2013-09-27,186.92), (2013-09-26,190.22), (2013-09-25,189.47))
        sortedValues:List((1380038400000,189.47), (1380124800000,190.22), (1380211200000,186.92), (1380470400000,185.18))
        values:CompactBuffer((2004-11-04,184.7), (2004-11-03,191.67), (2004-11-02,194.87), (2013-07-19,896.6), (2013-07-18,910.68), (2013-07-17,918.55))
        sortedValues:List((1099324800000,194.87), (1099411200000,191.67), (1099497600000,184.7), (1373990400000,918.55), (1374076800000,910.68), (1374163200000,896.6))
        values:CompactBuffer((2013-10-09,486.59), (2013-10-08,480.94), (2013-10-07,487.75), (2013-10-04,483.03), (2013-10-03,483.41))
        sortedValues:List((1380729600000,483.41), (1380816000000,483.03), (1381075200000,487.75), (1381161600000,480.94), (1381248000000,486.59))
      *
      * */
      val queue = new scala.collection.mutable.Queue[Double]()
      for (tup <- sortedValues) yield {
        queue.enqueue(tup._2)
        if (queue.size > brodcastWindow.value)
          queue.dequeue
        (dateFormat.format(new java.util.Date(tup._1)), (queue.sum / queue.size))
      }
    })
    /*
    * (IBM,List((2013-09-25,189.47), (2013-09-26,189.845), (2013-09-27,188.87), (2013-09-30,187.43999999999997)))
      (GOOG,List((2004-11-02,194.87), (2004-11-03,193.26999999999998), (2004-11-04,190.41333333333333), (2013-07-17,431.64000000000004), (2013-07-18,671.31), (2013-07-19,908.61)))
      (AAPL,List((2013-10-03,483.41), (2013-10-04,483.22), (2013-10-07,484.73), (2013-10-08,483.9066666666667), (2013-10-09,485.0933333333333)))
    * */
    val formattedResult = result.flatMap(kv => {
      kv._2.map(v => (kv._1 + "," + v._1 + "," + v._2.toString()))
    })
    /*
    * IBM,2013-09-25,189.47
      IBM,2013-09-26,189.845
      IBM,2013-09-27,188.87
      IBM,2013-09-30,187.43999999999997
      GOOG,2004-11-02,194.87
      GOOG,2004-11-03,193.26999999999998
      GOOG,2004-11-04,190.41333333333333
      GOOG,2013-07-17,431.64000000000004
      GOOG,2013-07-18,671.31
      GOOG,2013-07-19,908.61
      AAPL,2013-10-03,483.41
      AAPL,2013-10-04,483.22
      AAPL,2013-10-07,484.73
      AAPL,2013-10-08,483.9066666666667
      AAPL,2013-10-09,485.0933333333333
    * */
    formattedResult.saveAsTextFile(output)
    sc.stop()
  }
}


2、

自定义分区器CompositeKeyPartitioner


import MovingAverage.CompositeKey
import org.apache.spark.Partitioner

class CompositeKeyPartitioner(partitions: Int) extends Partitioner {
  require(partitions >= 0, s"Number of partitions ($partitions) cannot be negative.")

  def numPartitions: Int = partitions

  def getPartition(key: Any): Int = key match {
    case k: CompositeKey => math.abs(k.stockSymbol.hashCode % numPartitions)
    case null            => 0
    case _               => math.abs(key.hashCode % numPartitions)
  }

  override def equals(other: Any): Boolean = other match {
    case h: CompositeKeyPartitioner => h.numPartitions == numPartitions
    case _                          => false
  }

  override def hashCode: Int = numPartitions
}



import org.apache.spark.SparkConf
import org.apache.spark.SparkContext


object MovingAverageInMemory {

  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("MovingAverageInMemory").setMaster("local")
    val sc = new SparkContext(sparkConf)

    val window = 3
    val input = "file:///media/chenjie/0009418200012FF3/ubuntu/gupiao1.txt"
    val output = "file:///media/chenjie/0009418200012FF3/ubuntu/gupiao1"

    val brodcastWindow = sc.broadcast(window)

    val rawData = sc.textFile(input)
    /*
    * GOOG,2004-11-04,184.70
      GOOG,2004-11-03,191.67
      GOOG,2004-11-02,194.87
      AAPL,2013-10-09,486.59
      AAPL,2013-10-08,480.94
      AAPL,2013-10-07,487.75
      AAPL,2013-10-04,483.03
      AAPL,2013-10-03,483.41
      IBM,2013-09-30,185.18
      IBM,2013-09-27,186.92
      IBM,2013-09-26,190.22
      IBM,2013-09-25,189.47
      GOOG,2013-07-19,896.60
      GOOG,2013-07-18,910.68
      GOOG,2013-07-17,918.55
    * */
    val keyValue = rawData.map(line => {
      val tokens = line.split(",")
      (tokens(0), (tokens(1), tokens(2).toDouble))
    })
    /*
    * (GOOG,(2004-11-04,184.7))
      (GOOG,(2004-11-03,191.67))
      (GOOG,(2004-11-02,194.87))
      (AAPL,(2013-10-09,486.59))
      (AAPL,(2013-10-08,480.94))
      (AAPL,(2013-10-07,487.75))
      (AAPL,(2013-10-04,483.03))
      (AAPL,(2013-10-03,483.41))
      (IBM,(2013-09-30,185.18))
      (IBM,(2013-09-27,186.92))
      (IBM,(2013-09-26,190.22))
      (IBM,(2013-09-25,189.47))
      (GOOG,(2013-07-19,896.6))
      (GOOG,(2013-07-18,910.68))
      (GOOG,(2013-07-17,918.55))
    * */
    val groupByStockSymbol = keyValue.groupByKey()
    /*
    * (IBM,CompactBuffer((2013-09-30,185.18), (2013-09-27,186.92), (2013-09-26,190.22), (2013-09-25,189.47)))
      (GOOG,CompactBuffer((2004-11-04,184.7), (2004-11-03,191.67), (2004-11-02,194.87), (2013-07-19,896.6), (2013-07-18,910.68), (2013-07-17,918.55)))
      (AAPL,CompactBuffer((2013-10-09,486.59), (2013-10-08,480.94), (2013-10-07,487.75), (2013-10-04,483.03), (2013-10-03,483.41)))
    * */
    val result = groupByStockSymbol.mapValues(values => {
      val dateFormat = new java.text.SimpleDateFormat("yyyy-MM-dd")
      val sortedValues = values.map(s => (dateFormat.parse(s._1).getTime.toLong, s._2)).toSeq.sortBy(_._1)
      /*
      * values:CompactBuffer((2013-09-30,185.18), (2013-09-27,186.92), (2013-09-26,190.22), (2013-09-25,189.47))
        sortedValues:List((1380038400000,189.47), (1380124800000,190.22), (1380211200000,186.92), (1380470400000,185.18))
        values:CompactBuffer((2004-11-04,184.7), (2004-11-03,191.67), (2004-11-02,194.87), (2013-07-19,896.6), (2013-07-18,910.68), (2013-07-17,918.55))
        sortedValues:List((1099324800000,194.87), (1099411200000,191.67), (1099497600000,184.7), (1373990400000,918.55), (1374076800000,910.68), (1374163200000,896.6))
        values:CompactBuffer((2013-10-09,486.59), (2013-10-08,480.94), (2013-10-07,487.75), (2013-10-04,483.03), (2013-10-03,483.41))
        sortedValues:List((1380729600000,483.41), (1380816000000,483.03), (1381075200000,487.75), (1381161600000,480.94), (1381248000000,486.59))
      *
      * */
      val queue = new scala.collection.mutable.Queue[Double]()
      for (tup <- sortedValues) yield {
        queue.enqueue(tup._2)
        if (queue.size > brodcastWindow.value)
          queue.dequeue
        (dateFormat.format(new java.util.Date(tup._1)), (queue.sum / queue.size))
      }
    })
    /*
    * (IBM,List((2013-09-25,189.47), (2013-09-26,189.845), (2013-09-27,188.87), (2013-09-30,187.43999999999997)))
      (GOOG,List((2004-11-02,194.87), (2004-11-03,193.26999999999998), (2004-11-04,190.41333333333333), (2013-07-17,431.64000000000004), (2013-07-18,671.31), (2013-07-19,908.61)))
      (AAPL,List((2013-10-03,483.41), (2013-10-04,483.22), (2013-10-07,484.73), (2013-10-08,483.9066666666667), (2013-10-09,485.0933333333333)))
    * */
    val formattedResult = result.flatMap(kv => {
      kv._2.map(v => (kv._1 + "," + v._1 + "," + v._2.toString()))
    })
    /*
    * IBM,2013-09-25,189.47
      IBM,2013-09-26,189.845
      IBM,2013-09-27,188.87
      IBM,2013-09-30,187.43999999999997
      GOOG,2004-11-02,194.87
      GOOG,2004-11-03,193.26999999999998
      GOOG,2004-11-04,190.41333333333333
      GOOG,2013-07-17,431.64000000000004
      GOOG,2013-07-18,671.31
      GOOG,2013-07-19,908.61
      AAPL,2013-10-03,483.41
      AAPL,2013-10-04,483.22
      AAPL,2013-10-07,484.73
      AAPL,2013-10-08,483.9066666666667
      AAPL,2013-10-09,485.0933333333333
    * */
    formattedResult.saveAsTextFile(output)
    sc.stop()
  }
}


土豆拍死马铃薯
关注
专栏目录
spark移动平均
iDuanyingjie的专栏
02-27 1466
需求：计算在一个特定时间窗口内各个日期不同股票代码的不同收盘价的移动平均数“移动”的意思就是随着新的时间序列数据的到来，要不断的重新计算这个平均值，由于会删除最早的值同时增加新的值，这个平均值会相应的“移动” 股票代码 时间 收盘价 移动平均 Apple 2015-12-11 108.0 (108) / 1 = 108.0 Apple 2015-12-13
spark-timeseries：用于在Apache Spark上进行时间序列分析的库
02-20
Spark时间序列（ spark-ts包） 一个Scala / Java / Python库，用于与Apache Spark上的时间序列数据进行交互。 向发布问题和评论，或将其直接通过发送至 。 注意：spark-ts库不再由我（Sandy）积极开发。 不幸的是，我不再有带宽来开发功能，回答邮件列表中的所有问题或解决所有已提交的错误。 就是说，我仍然很乐意审查拉取请求，并尽我所能来帮助其他人推进图书馆。 可在上找到文档。 或者查看 ， 或 。 目的是提供 一组用于处理大型时间序列数据集的抽象，类似于为 ， 和R的和包中的较小数据集提供的抽象。 可以从统计角度处理时间序列的模型，测试和函数，类似于以及各种Matlab和R软件包中提供的内容。 该库位于其他一些出色的Java和Scala库上。 为NumPy的状，BLAS，能够线性代数。 用于日期和时间。 用于常规数学和统计功
spark之时间序列预测(商品销量预测)
最新发布
qq_20182781的博客
07-25 1011
本案例使用前1913天的数据作为训练数据，来预测1914天到1941天的销量。以上数据下载后放入resources/advanced下，并在properties.properties中配置一下文件名和路径，以供程序读取和处理数据。2.模型的训练及预测利用python lightgbm进行操作，见time_series.ipynb，data.7z下是spark处理好的数据。1.数据处理以及特征工程利用java spark进行提取，见TimeSeries.java。二.特征工程代码解读，完整见项目中代码注释。
[Spark中移动平均法的实现]
热门推荐
程序车轮
06-24 1万+
一、 基本概念       移动平均法是一种简单平滑预测技术，它的基本思想是：根据时间序列资料、逐项推移，依次计算包含一定项数的序时平均值，以反映短期趋势的方法。因此，当时间序列的数值由于受周期变动和随机波动的影响，起伏较大，不易显示出事件的发展趋势时，使用移动平均法可以消除这些因素的影响，显示出事件的发展方向与趋势（即趋势线），然后依趋势线分析预测序列的中短期趋势。       移动平均法的应用...
spark之移动平均（内存中排序）
zhangdy12307的博客
01-05 190
spark之移动平均（内存中排序） 关于移动平均的详细解释，可以参考MapReduce之移动平均，这里只是把程序从MapReduce换成了spark-scala，原理上没变化，不过scala写起来确实比MapReduce快 package MoveAverage import org.apache.spark.{SparkConf, SparkContext} object MovingAve...
【笔记】时间序列分析基础：定义、均值、方差、自协方差及相关性
nyist_yangguang的博客
11-26 3444
以下链接中找到有助于理解自协方差和自相关函数的交互式示例。 https://shiny.maths-stats.gla.ac.uk/gnapier/Time_Series_ACF/ 原文链接： Time Series ...
spark-timeSeries.rar_scala 时间序列_spark ARIMA_spark arima_spark 滑
07-15
Spark时间序列分析是一种在大数据处理领域中用于挖掘和预测数据趋势的重要工具，特别是在金融、气象、电商等领域。本文将深入探讨使用Scala语言在Spark平台上实现ARIMA（自回归积分滑动平均模型）和Holt-Winters三次...
Spark SQL中的时间序列数据处理与分析方法
章节一：时间序列数据简介 ## 1.1 什么是时间序列数据 时间序列数据是按照时间顺序排列的一系列数据点的集合。它们通常是以固定时间间隔收集或记录的数据，如每秒钟的股票价格、每小时的气温、每天的销售量等。...
在Spark ML中对时间序列数据进行处理与建模
时间序列数据是按照时间顺序记录的数据点或观测结果的序列，其在许多领域中都有广泛的应用，如金融、天气预测、股票市场分析、销售预测等。时间序列数据可以是离散的，也可以是连续的，常见的例子包括每日的气温、...
HAWQ中的时间序列数据分析：处理时间序列数据的技术
# 第一章：时间序列数据分析介绍 时间序列数据在现实世界中随处可见，它是按时间顺序排列的数据点的集合，通常以固定的时间间隔收集。时间序列数据分析是指对这些数据进行统计、建模和预测的过程，通过对数据的分析...
使用Apache Spark进行时间序列数据分析与预测
# 1. 简介 ## 1.1 什么是时间序列数据 时间序列数据是按照时间先后顺序排列的一系列...Spark支持快速的数据处理、复杂的分析和智能的机器学习，并且能够处理包括时间序列在内的各种数据类型。 ## 1.3 时间序列数据分
Spark 实现简单移动平均值（SMA） - 窗口函数（Window Function
iMonster
05-29 2052
Spark 实现简单移动平均值（SMA） - 窗口函数（Window Function） 原文地址：http://n3xtchen.github.io/n3xtchen/spark/2017/01/24/spark200-window-function 什么是简单移动平均值 简单移动平均（英语：Simple Moving Average，SMA）是某变数之前n个数值的未作加权算术平均。例如，收市...
Spark处理时间序列数据
tom_fans的博客
01-15 5067
整个逻辑为： 设备端毫秒级生成数据以文本方式传输到HDFS，然后通过SPARK解析文件并存储到HBASE中。 问题1：SPARK本身为分布式，如果通过分布式解析文件并存储，如何保证数据系列顺序？ 问题2：使用SPARK进行HBASE插入的时候，使用RddPartitionForeach，然后给每条记录生成时间戳，并插入到HBASE，发现即使是微妙级别，在foreach的时候仍然会出现时间相同的
【时间序列预测算法】——平均算法介绍及代码实现
BlackValley的博客
06-21 1245
背景 适用于统计特性不变的场景 公式 使用从开始到当前t时刻所有y的均值作为下一时刻的预测值。 优化：划分为几个不定长度的时间窗口（按照经验划分，目的是窗口内的均值一致，比如烧烤店的数据在夜晚的部分划为一个窗口，人流量均值明显是高于白天的窗口内计算的均值），各自计算均值，看数据落在哪个窗口内，就用哪个窗口的统计均值来预测t+1时刻的值。或者使用固定长度L的时间窗口，计算t-L到t时刻内的均值，作为t+1时刻的预测值，这样也是变相考虑了相关性的大小，距离当前时刻越近的时刻相关性也就越大。 代码实现 #
【Spark Summit East 2017】使用Spark进行时间序列分析
weixin_33804582的博客
02-18 669
更多精彩内容参见云栖社区大数据频道https://yq.aliyun.com/big-data；此外，通过Maxcompute及其配套产品，低廉的大数据分析仅需几步，详情访问https://www.aliyun.com/product/odps。 本讲义出自Simon Ouellette在Spark Summit East 2017上的演讲，主要介绍了...
Spark 读取、写入时序数据库TDengine以及TDengine概述
Alex的博客
02-01 1949
TDengine 是一款高性能、分布式、支持 SQL 的时序数据库，其核心代码，包括集群功能全部开源（开源协议，AGPL v3.0）。TDengine 能被广泛运用于物联网、工业互联网、车联网、IT 运维、金融等领域。除核心的时序数据库功能外，TDengine 还提供缓存、数据订阅、流式计算等大数据平台所需要的系列功能，最大程度减少研发和运维的复杂度
spark中的时序算法
infent的博客
12-27 1744
spark2.4.0 MLIib官网没提供时序模型API http://spark.apache.org/docs/latest/mllib-guide.html #去GitHub上扒 Spark-TimeSeries使用方法 2017年04月24日 教程参考：https://blog.csdn.net/qq_30232405/article/details/70622400  时间序列包 h...
时间序列分析与Spark：实现预测模型和异常检测
程序员光剑
01-21 1120
1.背景介绍 时间序列分析是一种用于分析和预测基于时间顺序的数据的方法。在现实生活中，时间序列数据非常常见，例如股票价格、气候数据、网络流量等。随着数据规模的增加，传统的时间序列分析方法已经无法满足需求，因此需要采用更高效的分析方法。Apache Spark是一个开源的大规模数据处理框架，可以用于处理和分析时间序列数据。 在本文中，我们将讨论如何使用Spark进行时间序列分析，实现预测模型和异...
时间序列预测spark_Spark中的多时间序列预测
weixin_26642417的博客
09-15 1787
时间序列预测sparkSpark is a great platform for parallelising machine learning algorithms. Algorithms like clustering, random forests already have PySpark libraries available mainly under ml library(previous...
Spark性能调优：数据序列化与内存策略
要启用Kryo序列化，可以通过`spark.serializer`配置项设置，这会覆盖数据混洗和RDD序列化到硬盘的过程。虽然Kryo在Spark 2.0.0及以后版本中自动用于简单类型的数据，但对于复杂场景，用户可能需要根据应用的具体需求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值