根据 Hive 中的前几行计算风险评分

Posted 2023-03-23

【中文标题】根据 Hive 中的前几行计算风险评分

【英文标题】：Calculation of risk score based on previous rows in Hive

【发布时间】：2016-12-10 08:58:29

【问题描述】：

我有一个问题是要根据 customer_id 在 Hive 中的前几行计算风险评分。 我对 scala 和 hive 很陌生。

例如，这是我的表 Temp1：

customer_id recency_score period_start period_end
a           4             201501       201512
a           4             201502       201601
a           3             201503       201602
a           3             201504       201603
a           2             201505       201604
a           2             201506       201605
a           2             201507       201606
a           2             201508       201607
a           2             201509       201608
a           2             201510       201609
a           2             201511       201610
a           2             201512       201611
b           4             201501       201512
b           4             201502       201601
b           3             201503       201602
b           3             201504       201603
b           3             201505       201604
b           3             201506       201605
b           4             201507       201606
b           3             201508       201607
b           2             201509       201608
b           3             201510       201609
b           2             201511       201610
b           2             201512       201611

风险评分应为：

如果recency_score 在两个时段之间没有下降，则为0 如果recency_score 在两个时段之间下降，则为1 2 如果recency_score 在两个时段之间下降，则保持在同一水平 3 如果recency_score 在两个时段之间下降，然后再次下降

这部分很简单，我已经找到了方法，但我还想在下一行考虑这个先前的结果，我的意思是如果 risk_score 之前已经是 2 并且 recency_score 下降了新的 risk_score 将为 3，如果 recency_score 保持稳定，则它将保持在 2。

实际上，我不知道如何“记忆”之前的 risk_score。

还有一点，每个 customer_id 的行数各不相同（一个 customer_id 可以是 12，另一个可以是 8，另一个可以是 3...）

所以我想要这样的东西：

customer_id recency_score period_start period_end risk_score
a           4             201501       201512     0
a           4             201502       201601     0
a           3             201503       201602     1
a           3             201504       201603     2
a           2             201505       201604     3
a           2             201506       201605     3
a           2             201507       201606     3
a           2             201508       201607     3
a           2             201509       201608     3
a           2             201510       201609     3
a           2             201511       201610     3
a           2             201512       201611     3
b           4             201501       201512     0
b           4             201502       201601     0
b           3             201503       201602     1
b           3             201504       201603     2
b           3             201505       201604     2
b           3             201506       201605     2
b           4             201507       201606     0
b           3             201508       201607     1
b           2             201509       201608     3
b           3             201510       201609     0
b           2             201511       201610     1
b           2             201512       201611     2

如果您对我有一些想法，我将不胜感激

BR，苏菲

【参考方案1】：

这不是一个完整的解决方案，但是使用评论太长了，它可能会有所帮助。您可以使用window function lag 来“保留”任何东西的先前状态。此函数将行移动特定数量的位置（默认情况下，一个）。例如，这句话将使用之前的recency_score 创建一个额外的列（您可以应用相同的逻辑来存储任何您想要的“之前”状态）。

val table_modified = spark.sql("SELECT customer_id, recency_score, period_start, period_end, 
LAG(recency_score) OVER (PARTITION BY customer_id ORDER BY period_start) AS previous
FROM Temp1")

请注意，您需要提供一个订单（在本例中为 period_start 列）和一个组，在本例中为客户。添加列后，您可以例如使用以前的状态修改表（尽管这不是绝对必要的）。这将生成下表：

scala> table_modified.createOrReplaceTempView("Temp1")
scala> table_modified.show(100)
+-----------+-------------+------------+----------+--------+
|customer_id|regency_score|period_start|period_end|previous|
+-----------+-------------+------------+----------+--------+
|          b|            4|      201501|    201512|    null|
|          b|            4|      201502|    201601|       4|
|          b|            3|      201503|    201602|       4|
|          b|            3|      201504|    201603|       3|
|          b|            3|      201505|    201604|       3|
|          b|            3|      201506|    201605|       3|
|          b|            4|      201507|    201606|       3|
|          b|            3|      201508|    201607|       4|
|          b|            2|      201509|    201608|       3|
|          b|            3|      201510|    201609|       2|
|          b|            2|      201511|    201610|       3|
|          b|            2|      201512|    201611|       2|
|          a|            4|      201501|    201512|    null|
|          a|            4|      201502|    201601|       4|
|          a|            3|      201503|    201602|       4|
|          a|            3|      201504|    201603|       3|
|          a|            2|      201505|    201604|       3|
|          a|            2|      201506|    201605|       2|
|          a|            2|      201507|    201606|       2|
|          a|            2|      201508|    201607|       2|
|          a|            2|      201509|    201608|       2|
|          a|            2|      201510|    201609|       2|
|          a|            2|      201511|    201610|       2|
|          a|            2|      201512|    201611|       2|
+-----------+-------------+------------+----------+--------+

创建后，您可以将所需的逻辑应用于您的行，因为每行在行中都有其“先前”分数。

我希望这会有所帮助。