全国职业技能大赛(大数据技术赛项)，任务B 离线数据处理 任务C 数据挖掘

已于 2024-02-05 16:50:50 修改
阅读量768 收藏 12
点赞数 10
分类专栏： 全国职业技能大赛大数据技术与应用赛项离线数据处理 文章标签： 大数据 数据挖掘 scala 数据库 spark linux
于 2024-01-25 20:50:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xuejiujiu/article/details/135853455
版权

前言：

比赛的方式有很多很多种，努努力把东西写一写吧，这是我自己做的一个模拟的集群
先展示一波集群吧

这是现在已经装的内容

a13b99faffc74453a0706eb20f18ae04.png

MySQL数据库

e444067bc29c488d812c94509001515b.png

这是我自己一点一点更新的，嘿嘿制作不易哦

对如果你想做实时，我们有一个自己写的数据生成器，最重要的还是要学会方法，这样才能在比赛的时候随机应变哦，不管是搭建，离线，挖掘，实时还是可视化，都要多遇见错误，才能在比赛的时候从容应对。

第十套任务书，不废话直接上代码
前期准备

package org.xuejiujiu.spark

import org.apache.spark.SparkConf
import org.apache.spark.sql.SparkSession

import java.util.Properties

object packages {
  def Hive():SparkSession={
    val conf = new SparkConf().setAppName("TASK").setMaster("local").set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    val spark = SparkSession.builder().config(conf).enableHiveSupport().getOrCreate()
    spark.sparkContext.setLogLevel("OFF")
    // 写入1900-01-01 00:00:00的时间要加入此行代码
    spark.conf.set("spark.sql.legacy.avro.datetimeRebaseModeInWrite", "CORRECTED")
    spark
  }

  def MySQL():Properties={
    val properties = new Properties()
    properties.put("user","root")
    properties.put("password","123456")
    properties.put("driver","com.mysql.jdbc.Driver")
    properties
  }

  def getUrl():String={
    val url = "jdbc:mysql://bigdata1:3306/shtd_industry"
    url
  }

  def Clickhouse() : Properties= {
    val properties = new Properties()
    properties.put("driver", "ru.yandex.clickhouse.ClickHouseDriver")
    properties.put("batchsize", "100000")
    properties.put("socket_timeout", "300000")
    properties.put("rewriteBatchedStatements", "true")
    properties
  }
}

数据抽取的代码

package org.xuejiujiu.spark

import org.apache.hudi.DataSourceWriteOptions.{PARTITIONPATH_FIELD, PRECOMBINE_FIELD, RECORDKEY_FIELD}
import org.apache.hudi.QuickstartUtils.getQuickstartWriteConfigs
import org.apache.hudi.config.HoodieWriteConfig.TBL_NAME
import packages._
import org.apache.spark.sql.functions._

object task1 {
  def main(args: Array[String]): Unit = {
    System.setProperty("HADOOP_USER_NAME", "root")

    val spark = Hive()
    val properties = MySQL()

    val table = Array("BaseMachine", "ChangeRecord", "EnvironmentData", "MachineData", "ProduceRecord")

    table.foreach(tableName => {
      spark.read.jdbc(getUrl(),tableName,properties).createTempView(s"a_$tableName")
      spark.table(s"a_$tableName").show()
      //显示当前数据表
      val frame = spark.table(s"a_$tableName")
        .withColumn("etldate", date_format(date_sub(current_timestamp(), 1), "yyyyMMdd").cast("string"))
      frame.createTempView(s"b_$tableName")
      if(tableName.equals("EnvironmentData")){
        spark.table(s"b_$tableName")
          .write.format("hudi")
          .options(getQuickstartWriteConfigs)
          .option(PRECOMBINE_FIELD.key(), "InPutTime")
          .option(RECORDKEY_FIELD.key(), "EnvoId")
          .option(PARTITIONPATH_FIELD.key(), "etldate")
          .option(TBL_NAME.key(), "environmentdata")
          .mode("overwrite")
          .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_ods.db/environmentdata")
        println("----- 写入成功 -----")
      }else if(tableName.equals("ChangeRecord")){
        spark.table(s"b_$tableName")
          .write.format("hudi")
          .options(getQuickstartWriteConfigs)
          .option(PRECOMBINE_FIELD.key(), "ChangeEndTime")
          .option(RECORDKEY_FIELD.key(), "ChangeMachineID,ChangeID")
          .option(PARTITIONPATH_FIELD.key(), "etldate")
          .option(TBL_NAME.key(), "changerecord")
          .mode("overwrite")
          .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_ods.db/changerecord")
        println("----- 写入成功 -----")
      }else if(tableName.equals("BaseMachine")){
        spark.table(s"b_$tableName")
          .write.format("hudi")
          .options(getQuickstartWriteConfigs)
          .option(PRECOMBINE_FIELD.key(), "MachineAddDate")
          .option(RECORDKEY_FIELD.key(), "BaseMachineID")
          .option(PARTITIONPATH_FIELD.key(), "etldate")
          .option(TBL_NAME.key(), "basemachine")
          .mode("overwrite")
          .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_ods.db/basemachine")
        println("----- 写入成功 -----")
      }else if(tableName.equals("ProduceRecord")) {
        spark.table(s"b_$tableName").drop(col("ProducePrgCode"))
          .write.format("hudi")
          .options(getQuickstartWriteConfigs)
          .option(PRECOMBINE_FIELD.key(), "ProduceCodeEndTime")
          // TODO 联合主键
          .option(RECORDKEY_FIELD.key(), "ProduceRecordID,ProduceMachineID")
          .option(PARTITIONPATH_FIELD.key(), "etldate")
          .option(TBL_NAME.key(), "producerecord")
          .mode("overwrite")
          .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_ods.db/producerecord")
        println("----- 写入成功 -----")
      }else if(tableName.equals("MachineData")) {
        spark.table(s"b_$tableName")
          .write.format("hudi")
          .options(getQuickstartWriteConfigs)
          .option(PRECOMBINE_FIELD.key(), "MachineRecordDate")
          .option(RECORDKEY_FIELD.key(), "MachineRecordID")
          .option(PARTITIONPATH_FIELD.key(), "etldate")
          .option(TBL_NAME.key(), "machinedata")
          .mode("overwrite")
          .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_ods.db/machinedata")
        println("----- 写入成功 -----")
      }
    })
  }
}

数据清洗的代码
 

package org.xuejiujiu.spark

import org.apache.hudi.DataSourceWriteOptions.{PARTITIONPATH_FIELD, PRECOMBINE_FIELD, RECORDKEY_FIELD}
import org.apache.hudi.QuickstartUtils.getQuickstartWriteConfigs
import org.apache.hudi.config.HoodieWriteConfig.TBL_NAME
import org.apache.spark.sql.functions._
import org.xuejiujiu.spark.packages.{Hive, MySQL}

object task2 {
  def main(args: Array[String]): Unit = {
    System.setProperty("HADOOP_USER_NAME", "root")

    val spark = Hive()
    val properties = MySQL()

    val table = Array("basemachine", "changerecord", "environmentdata", "machinedata", "producerecord")

    table.foreach(tableName => {
      spark.read.format("hudi").load(s"hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_ods.db/$tableName").createOrReplaceTempView(s"a_$tableName")
      spark.table(s"a_$tableName").show()
      spark.table(s"a_$tableName")
        .withColumn("dwd_insert_user",lit("user1"))
        .withColumn("dwd_modify_user",lit("user1"))
        .withColumn("dwd_insert_time",date_format(current_date(),"yyyyMMdd HH:mm:ss"))
        .withColumn("dwd_modify_time",date_format(current_date(),"yyyyMMdd HH:mm:ss"))
        .createOrReplaceTempView(s"b_$tableName")
      if(tableName.equals("environmentdata")) {
        spark.table(s"b_$tableName")
          .write.format("hudi")
          .options(getQuickstartWriteConfigs)
          .option(PRECOMBINE_FIELD.key(), "InPutTime")
          .option(RECORDKEY_FIELD.key(), "EnvoId")
          .option(PARTITIONPATH_FIELD.key(), "etldate")
          .option(TBL_NAME.key(), "fact_environment_data")
          .mode("overwrite")
          .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_dwd.db/fact_environment_data")
        println("----- 写入成功 -----")
      }else if(tableName.equals("changerecord")){
        spark.table(s"b_$tableName")
          .write.format("hudi")
          .options(getQuickstartWriteConfigs)
          .option(PRECOMBINE_FIELD.key(), "ChangeEndTime")
          .option(RECORDKEY_FIELD.key(), "ChangeMachineID,ChangeID")
          .option(PARTITIONPATH_FIELD.key(), "etldate")
          .option(TBL_NAME.key(), "fact_change_record")
          .mode("overwrite")
          .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_dwd.db/fact_change_record")
        println("----- 写入成功 -----")
    }else if(tableName.equals("basemachine")){
      spark.table(s"b_$tableName")
        .write.format("hudi")
        .options(getQuickstartWriteConfigs)
        .option(PRECOMBINE_FIELD.key(), "MachineAddDate")
        .option(RECORDKEY_FIELD.key(), "BaseMachineID")
        .option(PARTITIONPATH_FIELD.key(), "etldate")
        .option(TBL_NAME.key(), "dim_machine")
        .mode("overwrite")
        .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_dwd.db/dim_machine")
      println("----- 写入成功 -----")
    }else if(tableName.equals("producerecord")) {
        spark.table(s"b_$tableName")
          .write.format("hudi")
          .options(getQuickstartWriteConfigs)
          .option(PRECOMBINE_FIELD.key(), "ProduceCodeEndTime")
          // TODO 联合主键
          .option(RECORDKEY_FIELD.key(), "ProduceRecordID,ProduceMachineID")
          .option(PARTITIONPATH_FIELD.key(), "etldate")
          .option(TBL_NAME.key(), "fact_produce_record")
          .mode("overwrite")
          .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_dwd.db/fact_produce_record")
        println("----- 写入成功 -----")
      }else if(tableName.equals("machinedata")) {
        spark.table(s"b_$tableName")
          .write.format("hudi")
          .options(getQuickstartWriteConfigs)
          .option(PRECOMBINE_FIELD.key(), "MachineRecordDate")
          .option(RECORDKEY_FIELD.key(), "MachineRecordID")
          .option(PARTITIONPATH_FIELD.key(), "etldate")
          .option(TBL_NAME.key(), "fact_machine_data")
          .mode("overwrite")
          .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_dwd.db/fact_machine_data")
        println("----- 写入成功 -----")
      }
    })
  }
}

指标计算的代码

(我直接写到一个里面了，没有分开写，没有用小海豚调度器，这个自己学学就可以，很简单)
 

package org.xuejiujiu.spark

import org.apache.hudi.DataSourceWriteOptions.{PARTITIONPATH_FIELD, PRECOMBINE_FIELD, RECORDKEY_FIELD}
import org.apache.hudi.QuickstartUtils.getQuickstartWriteConfigs
import org.apache.hudi.config.HoodieWriteConfig.{CLIENT_HEARTBEAT_INTERVAL_IN_MS, TBL_NAME}
import org.apache.spark.sql.expressions.Window
import org.apache.spark.sql.functions
import org.apache.spark.sql.functions._
import org.xuejiujiu.spark.packages.{Clickhouse, Hive, MySQL}

object task3 {
  def main(args: Array[String]): Unit = {
    System.setProperty("HADOOP_USER_NAME", "root")

    val spark = Hive()
    val properties = Clickhouse()

    val table = Array("fact_environment_data", "fact_change_record", "dim_machine", "fact_produce_record", "fact_machine_data")

    table.foreach(tableName => {
      spark.read.format("hudi").load(s"hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_dwd.db/$tableName").createOrReplaceTempView(s"$tableName")
      spark.table(s"$tableName").show()
    })

    val task1 = spark.sql(
      """
        |select
        |b.BaseMachineID  as machine_id,
        |date_format(a.ChangeStartTime, 'yyyy-MM-dd') AS machine_record_date,
        |unix_timestamp(a.ChangeEndTime) - unix_timestamp(a.ChangeStartTime) as total_time
        |from fact_change_record a
        |join dim_machine b on a.ChangeMachineID = b.BaseMachineID
        |where a.ChangeEndTime is not null and a.ChangeRecordState = '运行'
        |""".stripMargin).distinct().withColumn("uuid", functions.expr("uuid()"))

    task1.show()
    task1.write.format("hudi")
      .options(getQuickstartWriteConfigs)
      .option(PRECOMBINE_FIELD.key(), "total_time")
      .option(RECORDKEY_FIELD.key(), "uuid")
      .option(PARTITIONPATH_FIELD.key(), "machine_record_date")
      .option(TBL_NAME.key(), "machine_data_total_time")
      .mode("overwrite")
      .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_dws.db/machine_data_total_time")
    println("----- 写入成功 -----")

    val fact_produce_record = spark.table("fact_produce_record")
    fact_produce_record.show()
    val frame = fact_produce_record
      .dropDuplicates(Seq("ProduceRecordID", "ProduceMachineID"))
      .filter("ProduceCodeEndTime <> '1900-01-01 00:00:00'")
    frame.show()
    frame.createOrReplaceTempView("tmp")

    val task2 = spark.sql(
      """
        |select
        |ProduceRecordID as produce_record_id,
        |ProduceMachineID as produce_machine_id,
        |unix_timestamp(ProduceCodeEndTime) - unix_timestamp(ProduceCodeStartTime) as producetime,
        |CAST(AVG(UNIX_TIMESTAMP(ProduceCodeEndTime) - UNIX_TIMESTAMP(ProduceCodeStartTime)) OVER () AS INT) AS produce_per_avgtime
        |from tmp
        |""".stripMargin).distinct()
    task2.show()
    task2.write
      .mode("overwrite")
      .jdbc("jdbc:clickhouse://bigdata1:8123/shtd_industry", "machine_produce_per_avgtime", properties)

    // 读取数据
    val inputDF = spark.read.format("hudi")
      .load("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_dws.db/machine_data_total_time")

    // 定义窗口规范
    val windowSpec = Window.partitionBy("machine_record_date").orderBy(desc("total_time"))

    // 添加排名列
    val rankedDF = inputDF.withColumn("rank", dense_rank().over(windowSpec))

    // 保留排名前三的设备，包括并列情况
    val resultDF = rankedDF
      .filter("rank <= 3")
      .groupBy("machine_record_date")
      .agg(
        collect_list(struct("machine_id", "total_time", "rank")).as("machines")
      )
      .selectExpr(
        "machine_record_date",
        "machines[0].machine_id as first_id",
        "machines[0].total_time as first_time",
        "machines[1].machine_id as second_id",
        "machines[1].total_time as second_time",
        "machines[2].machine_id as tertiary_id",
        "machines[2].total_time as tertiary_time"
      )

    resultDF.write
      .mode("overwrite")
      .jdbc("jdbc:clickhouse://bigdata1:8123/shtd_industry", "machine_data_total_time_top3", properties)


  }
}

数据挖掘

第一块

package org.xuejiujiu.spark.dataMining

import org.apache.hudi.DataSourceWriteOptions.{PARTITIONPATH_FIELD, PRECOMBINE_FIELD, RECORDKEY_FIELD}
import org.apache.hudi.QuickstartUtils.getQuickstartWriteConfigs
import org.apache.hudi.config.HoodieWriteConfig.TBL_NAME
import org.apache.spark.sql.functions.{col, current_timestamp, date_format, first, lit, when}
import org.xuejiujiu.spark.packages.{Hive, MySQL, getUrl}

object task1 {
  def main(args: Array[String]): Unit = {
    System.setProperty("HADOOP_USER_NAME", "root")

    val spark = Hive()
    val properties = MySQL()

    val table = Array("BaseMachine", "ChangeRecord", "EnvironmentData", "MachineData", "ProduceRecord")
    // TODO 拿取数据
    table.foreach(tableName => {
      spark.read.jdbc(getUrl(), tableName, properties).createTempView(s"$tableName")
    })

    val df = spark.table("MachineData").selectExpr("MachineRecordData","MachineRecordID")
      .filter(col("MachineRecordData").isNotNull)
      .filter(col("MachineRecordID").isNotNull)
    df.show(false)

    // 使用正则表达式提取ColName和对应的<col></col>信息
    val colPattern = """<col ColName="([^"]*)">([^<]*)</col>""".r

    import spark.implicits._

    // 提取并处理数据
    val extractedDF = df.as[(String, Int)].flatMap { case (machineRecordData, machineRecordID) =>
      colPattern.findAllMatchIn(machineRecordData)
        .map { m =>
          val colName = m.group(1)
          val colValue = if (m.group(2) == "null") "0.0" else m.group(2) // 替换为默认值 "0.0"
          (machineRecordID, colName, colValue)
        }
    }.toDF("MachineRecordID", "ColName", "ColValue")

    // 合并相同的 MachineRecordID
    val mergedDF = extractedDF.groupBy("MachineRecordID")
      .pivot("ColName")
      .agg(first("ColValue"))
      .na.fill("0.0") // 将空值填充为 "0.0"

    // 将 machine_record_state 字段值为 "报警" 的转换为 1，否则为 0
    val transformedDF = mergedDF.withColumn("State",
      when(col("State") === "报警", 1).otherwise(0)
    )

    transformedDF.show(false)
    val frame = transformedDF.withColumnRenamed("State", "machine_record_state")
      .withColumnRenamed("MachineID", "machine_id")
      .withColumnRenamed("MachineRecordID", "machine_record_id")
      .withColumnRenamed("主轴转速", "machine_record_mainshaft_speed")
      .withColumnRenamed("主轴倍率", "machine_record_mainshaft_multiplerate")
      .withColumnRenamed("主轴负载", "machine_record_mainshaft_load")
      .withColumnRenamed("进给倍率", "machine_record_feed_speed")
      .withColumnRenamed("进给速度", "machine_record_feed_multiplerate")
      .withColumnRenamed("PMC程序号", "machine_record_pmc_code")
      .withColumnRenamed("循环时间", "machine_record_circle_time")
      .withColumnRenamed("运行时间", "machine_record_run_time")
      .withColumnRenamed("有效轴数", "machine_record_effective_shaft")
      .withColumnRenamed("总加工个数", "machine_record_amount_process")
      .withColumnRenamed("已使用内存", "machine_record_use_memory")
      .withColumnRenamed("未使用内存", "machine_record_free_memory")
      .withColumnRenamed("可用程序量", "machine_record_amount_use_code")
      .withColumnRenamed("注册程序量", "machine_record_amount_free_code")
      .withColumn("machine_record_date", date_format(current_timestamp(), "yyyy-MM-dd HH:mm:ss"))
      .withColumn("dwd_insert_user",lit("user1"))
      .withColumn("dwd_modify_user",lit("user1"))
      .withColumn("dwd_insert_time",date_format(current_timestamp(), "yyyy-MM-dd HH:mm:ss"))
      .withColumn("dwd_modify_time",date_format(current_timestamp(), "yyyy-MM-dd HH:mm:ss"))

      // 选择数据存入
      .select(
        "machine_record_id",
        "machine_id",
        "machine_record_state",
        "machine_record_mainshaft_speed",
        "machine_record_mainshaft_multiplerate",
        "machine_record_mainshaft_load",
        "machine_record_feed_speed",
        "machine_record_feed_multiplerate",
        "machine_record_pmc_code",
        "machine_record_circle_time",
        "machine_record_run_time",
        "machine_record_effective_shaft",
        "machine_record_amount_process",
        "machine_record_use_memory",
        "machine_record_free_memory",
        "machine_record_amount_use_code",
        "machine_record_amount_free_code",
        "machine_record_date",
        "dwd_insert_user",
        "dwd_modify_user",
        "dwd_insert_time",
        "dwd_modify_time"
      )
    frame.show()

    frame.write.format("hudi")
      .options(getQuickstartWriteConfigs)
      .option(PRECOMBINE_FIELD.key(), "machine_record_date")
      .option(RECORDKEY_FIELD.key(), "machine_record_id")
      .option(PARTITIONPATH_FIELD.key(), "machine_id")
      .option(TBL_NAME.key(), "fact_machine_learning_data")
      .mode("overwrite")
      .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_dwd.db/fact_machine_learning_data")
    val updatedDF = frame.withColumn("machine_record_state", lit(""))
    // TODO 这里写报警预测的测试数据
    updatedDF.write.format("hudi")
      .options(getQuickstartWriteConfigs)
      .option(PRECOMBINE_FIELD.key(), "machine_record_date")
      .option(RECORDKEY_FIELD.key(), "machine_record_id")
      .option(PARTITIONPATH_FIELD.key(), "machine_id")
      .option(TBL_NAME.key(), "fact_machine_learning_data_test")
      .mode("overwrite")
      .save("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_dwd.db/fact_machine_learning_data_test")
    spark.stop()
  }
}

第二块

package org.xuejiujiu.spark.dataMining

import org.apache.spark.ml.classification.RandomForestClassifier
import org.apache.spark.ml.evaluation.{BinaryClassificationEvaluator, MulticlassClassificationEvaluator}
import org.apache.spark.ml.feature.VectorAssembler
import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.functions.{col, when}
import org.apache.spark.sql.types.DoubleType
import org.xuejiujiu.spark.packages._

object RandomForestModel {
  def main(args: Array[String]): Unit = {
    val spark = Hive()
    val properties = MySQL()

    // 加载训练数据
    val data = spark.read.format("hudi")
      .load("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_dwd.db/fact_machine_learning_data")
    .withColumn("machine_id", col("machine_id").cast(DoubleType))
    .withColumn("machine_record_state", col("machine_record_state").cast(DoubleType))
    .withColumn("machine_record_mainshaft_speed", col("machine_record_mainshaft_speed").cast(DoubleType))
    .withColumn("machine_record_mainshaft_multiplerate", col("machine_record_mainshaft_multiplerate").cast(DoubleType))
    .withColumn("machine_record_mainshaft_load", col("machine_record_mainshaft_load").cast(DoubleType))
    .withColumn("machine_record_feed_speed", col("machine_record_feed_speed").cast(DoubleType))
    .withColumn("machine_record_feed_multiplerate", col("machine_record_feed_multiplerate").cast(DoubleType))
    .withColumn("machine_record_pmc_code", col("machine_record_pmc_code").cast(DoubleType))
    .withColumn("machine_record_circle_time", col("machine_record_circle_time").cast(DoubleType))
    .withColumn("machine_record_run_time", col("machine_record_run_time").cast(DoubleType))
    .withColumn("machine_record_effective_shaft", col("machine_record_effective_shaft").cast(DoubleType))
    .withColumn("machine_record_amount_process", col("machine_record_amount_process").cast(DoubleType))
    .withColumn("machine_record_use_memory", col("machine_record_use_memory").cast(DoubleType))
    .withColumn("machine_record_free_memory", col("machine_record_free_memory").cast(DoubleType))
    .withColumn("machine_record_amount_use_code", col("machine_record_amount_use_code").cast(DoubleType))
    .withColumn("machine_record_amount_free_code", col("machine_record_amount_free_code").cast(DoubleType))
      .select(
        "machine_record_id",
        "machine_id",
        "machine_record_state",
        "machine_record_mainshaft_speed",
        "machine_record_mainshaft_multiplerate",
        "machine_record_mainshaft_load",
        "machine_record_feed_speed",
        "machine_record_feed_multiplerate",
        "machine_record_pmc_code",
        "machine_record_circle_time",
        "machine_record_run_time",
        "machine_record_effective_shaft",
        "machine_record_amount_process",
        "machine_record_use_memory",
        "machine_record_free_memory",
        "machine_record_amount_use_code",
        "machine_record_amount_free_code"
      )
    // 处理缺失值
    val filledData = data.na.fill(0.0)

    // 将特征转换成特征向量
    val featureCols = filledData.columns.filter(_ != "machine_record_state")
    val assembler = new VectorAssembler()
      .setInputCols(featureCols)
      .setOutputCol("features")
    val assembledData = assembler.transform(filledData)

    // 拆分数据集
    val Array(trainingData, testData) = assembledData.randomSplit(Array(0.7, 0.3))

    // 训练随机森林模型
    val rf = new RandomForestClassifier()
      .setLabelCol("machine_record_state")
      .setFeaturesCol("features")
    val model = rf.fit(trainingData)

    // 在测试集上评估模型性能
    val predictions = model.transform(testData)
    val evaluator = new BinaryClassificationEvaluator()
      .setLabelCol("machine_record_state")
      .setRawPredictionCol("prediction")
      .setMetricName("areaUnderROC")
    val auc = evaluator.evaluate(predictions)

    println(s"Area under ROC curve (test set): $auc")


    // 加载测试数据
    val data2 = spark.read.format("hudi")
      .load("hdfs://bigdata1:8020/user/hive/warehouse/hudi_gy_dwd.db/fact_machine_learning_data_test")
      .withColumn("machine_id", col("machine_id").cast(DoubleType))
      .withColumn("machine_record_state", col("machine_record_state").cast(DoubleType))
      .withColumn("machine_record_mainshaft_speed", col("machine_record_mainshaft_speed").cast(DoubleType))
      .withColumn("machine_record_mainshaft_multiplerate", col("machine_record_mainshaft_multiplerate").cast(DoubleType))
      .withColumn("machine_record_mainshaft_load", col("machine_record_mainshaft_load").cast(DoubleType))
      .withColumn("machine_record_feed_speed", col("machine_record_feed_speed").cast(DoubleType))
      .withColumn("machine_record_feed_multiplerate", col("machine_record_feed_multiplerate").cast(DoubleType))
      .withColumn("machine_record_pmc_code", col("machine_record_pmc_code").cast(DoubleType))
      .withColumn("machine_record_circle_time", col("machine_record_circle_time").cast(DoubleType))
      .withColumn("machine_record_run_time", col("machine_record_run_time").cast(DoubleType))
      .withColumn("machine_record_effective_shaft", col("machine_record_effective_shaft").cast(DoubleType))
      .withColumn("machine_record_amount_process", col("machine_record_amount_process").cast(DoubleType))
      .withColumn("machine_record_use_memory", col("machine_record_use_memory").cast(DoubleType))
      .withColumn("machine_record_free_memory", col("machine_record_free_memory").cast(DoubleType))
      .withColumn("machine_record_amount_use_code", col("machine_record_amount_use_code").cast(DoubleType))
      .withColumn("machine_record_amount_free_code", col("machine_record_amount_free_code").cast(DoubleType))
      .select(
        "machine_record_id",
        "machine_id",
        "machine_record_state",
        "machine_record_mainshaft_speed",
        "machine_record_mainshaft_multiplerate",
        "machine_record_mainshaft_load",
        "machine_record_feed_speed",
        "machine_record_feed_multiplerate",
        "machine_record_pmc_code",
        "machine_record_circle_time",
        "machine_record_run_time",
        "machine_record_effective_shaft",
        "machine_record_amount_process",
        "machine_record_use_memory",
        "machine_record_free_memory",
        "machine_record_amount_use_code",
        "machine_record_amount_free_code"
      )

    // 将特征转换成特征向量
    val assembledData2 = assembler.transform(data2)

    // 预测测试数据
    val predictions2 = model.transform(assembledData2)

    // 显示预测结果
    val frame = predictions2.select("machine_id", "prediction").withColumnRenamed("prediction", "machine_record_state")
    frame.show()
    frame.distinct().write.mode("overwrite").jdbc(getUrl(),"ml_result",properties)


  }
}

Xuejiujiu
关注
专栏目录
2022年全国职业院校技能大赛高职组“大数据应用开发”模块二三四源码答案及报告①
旺仔Sec&blog
04-28 245
5、将ods库中orders表数据抽取到dwd库中fact_orders的分区表，分区字段为etldate且值与ods库的相对应表该值相等，并添加dwd_insert_user、dwd_insert_time、dwd_modify_user、dwd_modify_time四列，其中dwd_insert_user、dwd_modify_user均填写“user1”，dwd_insert_time、dwd_modify_time均填写操作时间，并进行数据类型转换。
2022年全国职业院校技能大赛高职组大数据技术与应用赛项赛卷⑨—解析答案
旺仔Sec&blog
04-17 129
工业互联网是工业全要素、全产业链、全价值链的全面连接，是人、机、物、工厂互联互通的新型工业生产制造服务体系，是互联网从消费领域向生产领域、从虚拟经济向实体经济拓展的核心载体，是建设现代化经济体系、实现高质量发展和塑造全球产业竞争力的关键支撑
GZ033 大数据应用开发赛题第01套--任务B：离线数据处理（25分）
weixin_44117248的博客
05-08 513
抽取shtd_store库中user_info的增量数据进入Hive的ods库中表user_info。根据ods.user_info表中operate_time或create_time作为增量字段(即MySQL中每条数据取这两个时间中较大的那个时间作为增量字段去和ods里的这两个字段中较大的时间进行比较)，只将新增的数据抽入，字段名称、类型不变，同时添加静态分区，分区字段为etl_date，类型为String，且值为当前比赛日的前一天日期（分区字段格式为yyyyMMdd）。
2024大数据职业技能竞赛（国赛）模块B数据处理题解
weixin_62687791的博客
01-06 1158
第一套各节点可通过Asbru工具或SSH客户端进行SSH访问；主节点MySQL数据库用户名/密码：root/123456（已配置远程连接）；Hive的配置文件位于/opt/apache-hive-2.3.4-bin/conf/Spark任务在Yarn上用Client运行，方便观察日志。
全国职业技能大赛(大数据技术赛项)，任务B离线数据处理
Xuejiujiu的博客
09-11 569
2023年全国职业技能大赛大数据技术与应用赛项第九套任务书 任务B 子任务一 第二小题
【干货】数据挖掘比赛大数据处理和建模经验
腾讯广告算法大赛
01-14 797
有同学反馈，我们决赛的数据比较大，由于机器资源的限制，在处理数据和构建模型的时候，会遇到一些瓶颈。以下来抛一下我们了解的一些处理思路： 1 采样 可以对数据进行下采样，然后使用不同的子集进行特征抽取和建模，最后再进行集成。 2 特征处理 在处理大规模原始数据时，需要充分借助外存（硬盘）空间，只把真正需要处理的数据放进内存。一般而言，采用流式、分块的方式处理数据可以解决大部分问题。以下是一些...
2022年全国职业院校技能大赛(高职组)
weixin_54412689的博客
08-25 6882
2022年全国职业院校技能大赛(高职组)
2022年全国职业院校技能大赛高职组"大数据技术与应用"模块B离线数据处理、模块C数据挖掘、模块D数据采集与实时计算代码答案
03-17
因数据驱动的零售新时代已经到来，没有大数据，我们无法为消费者提供这些体验，为完成电商的大数据分析工作，你所在的小组将应用大数据技术，以Scala作为整个项目的基础开发语言，基于大数据平台综合利用Spark、...
2023年江苏省职业院校技能大赛高职组“大数据技术与应用”赛项赛卷（样卷）
m0_75165895的博客
10-26 781
通过数据追踪，知道顾客从哪儿来，是看了某网站投放的广告还是通过朋友推荐链接，是新访客还是老用户，喜欢浏览什么产品，购物车有无商品，是否清空，还有每一笔交易记录，精准锁定一定年龄、收入、对产品有兴趣的顾客，对顾客进行分组、标签化，通过不同标签组合运用，获得不同目标群体，以此开展精准推送。编写Vue工程代码，根据接口，用折线图展示某年上半年商城总消费额的变化情况，同时将用于图表展示的数据结构在浏览器的console中进行打印输出，将图表可视化结果和浏览器console打印结果分别截图并粘贴至对应报告中。
2022年全国职业院校技能大赛高职组“大数据应用开发”模块二三四源码答案及报告②
旺仔Sec&blog
04-28 166
3、将ods库中nation表数据抽取到dwd库中dim_nation的分区表，分区字段为etldate且值与ods库的相对应表该值相等，并添加dwd_insert_user、dwd_insert_time、dwd_modify_user、dwd_modify_time四列，其中dwd_insert_user、dwd_modify_user均填写“user1”，dwd_insert_time、dwd_modify_time均填写操作时间，并进行数据类型转换。
Flume：大规模日志收集与数据传输的利器
最新发布
Casual_Lei的博客
09-14 859
是一个分布式、可靠、可扩展的日志收集和聚合系统，设计的初衷是用于高效收集和传输大量日志数据。它通常用于将数据从各种数据源，如日志文件、应用服务器、甚至是消息队列，实时传输到大数据处理系统（如 Hadoop 的 HDFS、HBase 或 Kafka）。Flume 的一个重要特点是其“可插拔性”，可以灵活地配置不同的数据源（Source）和目标存储（Sink），通过中间通道（Channel）来实现可靠的数据传输。Apache Flume 是一个非常强大的工具，适用于大规模日志数据的实时收集和传输。
Elasticsearch7.x 集群迁移文档
happy_king_zi的博客
09-11 998
同时检查当前运行集群状态是否为green。如果出现异常，可以配置discovery.zen.ping.unicast.hosts: [“10.200.112.149”, “10.200.112.151”,“10.200.112.153”,“172.31.2.84”, “172.31.0.147”,“172.31.0.94”]，恢复当前关闭节点。操作顺序操作动作1。
flink增量检查点启动恢复的时间是很久的，业务上不能接受，怎么处理
goTsHgo的博客
09-11 881
针对增量检查点恢复时间长的问题，可以从多个方面进行优化，包括合并检查点、提升存储性能、优化 RocksDB 配置、并行化恢复过程等。同时，也可以考虑替代方案，如多活架构、预热恢复、降低状态依赖和改进状态管理策略。此外，在业务层面上，适当调整业务容忍度和提高用户透明度也是有效的应对措施。通过综合应用这些策略，可以有效地降低恢复时间并提高业务的连续性和可靠性。
【RabbitMQ】工作模式
weixin_73060900的博客
09-11 973
对RabbitMQ工作模式的简单概述以及代码案例
滚雪球学SpringCloud[2.2]：Consul与Zookeeper服务注册
**My Coding Family**
09-14 803
在上一节【2.1 服务注册中心Eureka】中，我们探讨了 Netflix 开源的服务注册中心 Eureka 的核心概念及其在微服务架构中的应用。Eureka 通过提供服务注册与发现功能，帮助微服务之间高效通信，并且具备高可用性和扩展性。虽然 Eureka 在微服务架构中应用广泛，但并不是唯一的解决方案。除了 Eureka，还有其他非常优秀的服务注册中心，如Consul和Zookeeper，它们在不同的场景下各有优势。本节将详细介绍Consul和Zookeeper。
从AI到大数据，数字技术服务平台全栈赋能企业升级
smjt2024的博客
09-11 565
海量的数据中蕴含着丰富的信息和价值，数字技术服务平台能够收集、整理和分析这些数据，为企业提供精准的市场洞察和决策支持。企业可以通过参加树莓集团举办的培训课程和研讨会，了解最新的数字技术趋势和应用案例，提升自身的数字技术水平。从技术咨询、解决方案设计到系统实施和运维，数字技术服务平台为企业提供一站式的服务，让企业无需担心技术难题，专注于自身的核心业务。树莓集团的数字技术服务平台，以其先进的技术、专业的服务和丰富的经验，为企业提供了全栈赋能。在数字时代，让我们共同利用数字技术服务平台，开启企业升级的新篇章。
大数据-127 - Flink State 04篇 状态原理和原理剖析：状态存储 Part2
永远好奇，无限进步！
09-10 2341
在Flink的实际实现中，对于同一种StateBackend，不同的State在运行时会有细分的StateBackend托管，例如：MemoryStateBackend，就有DefaultOperatorStateBackend管理OperatorState，HeapKeyedStateBackend管理KeyedState。JOB_ID是应用的唯一ID，CHECK_POINT_ID 是每次 CheckPoint时自增的数字ID，我们可以从备份的CheckPoint数据恢复当时的作业状态。
Kafka下载与安装教程（国产化生产环境无联网服务器部署实操）
latesummer_的博客
09-14 533
请放心观看，已在正式环境部署验证，流程无问题！所用系统为国产化麒麟银河 aarch64系统，部署时间2024年9月份！
全国职业技能大赛：工业数据处理实战训练与大数据技术应用
《工业数据处理训练任务》是一项针对全国职业技能大赛大数据技术比赛的重要环节，它着重考察参赛者在实际工业数据环境下，如何应用大数据技术进行高效、精确的数据处理和分析。该任务的核心目标是提升参赛者的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值