企业级用户画像: 用户活跃度模型-RFE

最新推荐文章于 2024-06-28 07:30:00 发布
最新推荐文章于 2024-06-28 07:30:00 发布
阅读量4.1k 收藏 23
点赞数 7
分类专栏： # 企业级360°全方位用户画像 文章标签： RFE 用户画像 kmeans算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43563705/article/details/109032678
版权

絮叨两句:
博主是一名数据分析实习生,利用博客记录自己所学的知识,也希望能帮助到正在学习的同学们
人的一生中会遇到各种各样的困难和折磨，逃避是解决不了问题的，唯有以乐观的精神去迎接生活的挑战
少年易老学难成，一寸光阴不可轻。
最喜欢的一句话:今日事,今日毕

                                                                  前期准备工作
企业级360°全方位用户画像:标签开发（前期准备工作）

RFE模型引入

RFE模型可以说是RFM模型的变体。 RFE模型基于用户的普通行为（非转化或交易行为）产生，它跟RFM类似都是使用三个维度做价值评估。

RFE详解

RFE 模型是根据会员

  • R（ Recency）:最近一次访问时间、
  • F（Frequency）:访问频率
  • E（Engagements）: 页面互动度
    计算得出的RFE得分。 其中：
  • 最近一次访问时间 R（ Recency）： 会员最近一次访问或到达网站的时间。
  • 访问频率 F（ Frequency）：用户在特定时间周期内访问或到达的频率。
  • 页面互动度 E（ Engagements）：互动度的定义可以根据不同企业或行业的交互情况而定，例如可以定义为页面 浏览时间、浏览商品数量、视频播放数量、点赞数量、转发数量等。

在RFE模型中，由于不要求用户发生交易，因此可以做未发生登录、 注册等匿名用户的行为价值分析， 也可以做实名用户分析。该模型常用来做用户活跃分群或价值区分， 也可用于内容型（例如论坛、新闻、资讯等）企业的会员分析。

RFM和 RFE模型的实现思路相同， 仅仅是计算指标发生变化。 对于RFE的数据来源， 可以从企业自己监控的用户行为日志获取，也可以从第三方网站分析工具获得。

基于RFE模型的实践应用

在得到用户的RFE得分之后， 跟 RFM 类似也可以有两种应用思路：

1：基于三个维度值做用户群体划分和解读，对用户的活跃度做分析。 RFE得分为 313 的会员说明其访问频率低， 但是每次访问时的交互都非常不错， 此时重点要做用户回访频率的提升，例如通过活动邀请、 精准广告投放、会员活动推荐等提升回访频率。

2：基于RFE的汇总得分评估所有会员的活跃度价值，并可以做活跃度排名； 同时，该得分还可以作为输入维 度跟其他维度一起作为其他数据分析和挖掘模型的输入变量，为分析建模提供基础。
比如：

  • 6忠诚 （1天内访问2次及以上，每次访问页面不重复）
  • 5活跃 （2天内访问至少1次）
  • 4回流 （3天内访问至少1次）
  • 3新增 （注册并访问）
  • 2不活跃 （7天内未访问）
  • 1流失 （7天以上无访问）

需求分析

根据:

  • 6忠诚 （1天内访问2次及以上，每次访问页面不重复）
  • 5活跃 （2天内访问至少1次）
  • 4回流 （3天内访问至少1次）
  • 3新增 （注册并访问）
  • 2不活跃 （7天内未访问）
  • 1流失 （7天以上无访问）

在这里插入图片描述

在这里插入图片描述

活跃度:inType=HBase##zkHosts=192.168.10.20##zkPort=2181##hbaseTable=tbl_logs##family=detail##selectFields=global_user_id,loc_url,log_time

代码实现

package cn.itcast.userprofile.up24.newexcavate

import cn.itcast.userprofile.up24.public.PublicStaticCode
import org.apache.spark.sql.{DataFrame, SparkSession}

object RFE extends PublicStaticCode{
  override def SetAppName: String = "RFE"

  override def Four_Name: String = "活跃度"

  override def compilerAdapterFactory(spark: SparkSession, five: DataFrame, tblUser: DataFrame): DataFrame = {
    five.show()

    /**
     * +------+----+
     * |tagsId|rule|
     * +------+----+
     * |    46|   1|
     * |    47|   2|
     * |    48|   3|
     * |    49|   4|
     * +------+----+
     */
    tblUser.show()

    /**
     * loc_url            	当前地址
     * log_time           	访问时间
     * +--------------+--------------------+-------------------+
     * |global_user_id|             loc_url|           log_time|
     * +--------------+--------------------+-------------------+
     * |           424|http://m.eshop.co...|2019-08-13 03:03:55|
     * |           619|http://m.eshop.co...|2019-07-29 15:07:41|
     * |           898|http://m.eshop.co...|2019-08-14 09:23:44|
     * |           642|http://www.eshop....|2019-08-11 03:20:17|
     * |           130|http://www.eshop....|2019-08-12 11:59:28|
     * |           515|http://www.eshop....|2019-07-23 14:39:25|
     * |           274|http://www.eshop....|2019-07-24 15:37:12|
     * |           772|http://ck.eshop.c...|2019-07-24 07:56:49|
     * |           189|http://m.eshop.co...|2019-07-26 19:17:00|
     * |           529|http://m.eshop.co...|2019-07-25 23:18:37|
     * |           177|http://m.eshop.co...|2019-07-23 21:01:26|
     * |           247|http://m.vip.esho...|2019-07-22 06:58:05|
     * |           702| http://m.eshop.com/|2019-08-04 11:43:11|
     * |           871|http://vip.eshop....|2019-08-11 09:38:00|
     * |           349|http://www.eshop....|2019-07-22 12:17:54|
     * |           538|http://www.eshop....|2019-07-30 11:16:57|
     * |            81|http://www.eshop....|2019-08-06 09:10:37|
     * |           308|http://www.eshop....|2019-08-06 03:54:04|
     * |           344|http://m.eshop.co...|2019-08-09 07:25:10|
     * |           796|http://member.esh...|2019-08-07 15:16:28|
     * +--------------+--------------------+-------------------+
     */
    tblUser
  }

  def main(args: Array[String]): Unit = {
    startMain()

  }
}


package cn.itcast.userprofile.up24.newexcavate

import cn.itcast.userprofile.up24.public.PublicStaticCode
import org.apache.spark.ml.clustering.KMeans
import org.apache.spark.ml.feature.{MinMaxScaler, VectorAssembler}
import org.apache.spark.sql.{DataFrame, SparkSession}

import scala.collection.immutable
/**
 * Desc 用户活跃度模型-RFE
 * Recency:最近一次访问时间,用户最后一次访问距今时间
 * Frequency:访问频率,用户一段时间内访问的页面总数,
 * Engagements:页面互动度,用户一段时间内访问的独立页面数,也可以定义为页面 浏览量、下载量、 视频播放数量等
 */

object RFE extends PublicStaticCode{
  override def SetAppName: String = "RFE"

  override def Four_Name: String = "活跃度"
  /**
   * 开始计算
   * inType=HBase##zkHosts=192.168.10.20##zkPort=2181##
   * hbaseTable=tbl_logs##family=detail##selectFields=global_user_id,loc_url,log_time
   * @param five  MySQL中的5级规则 id,rule
   * @param tblUser 根据selectFields查询出来的HBase中的数据
   * @return userid,tagIds
   */

  override def compilerAdapterFactory(spark: SparkSession, five: DataFrame, tblUser: DataFrame): DataFrame = {
//    five.show()

    /**
     * +------+----+
     * |tagsId|rule|
     * +------+----+
     * |    46|   1|
     * |    47|   2|
     * |    48|   3|
     * |    49|   4|
     * +------+----+
     */
//    tblUser.show()

    /**
     * loc_url            	当前地址
     * log_time           	访问时间
     * +--------------+--------------------+-------------------+
     * |global_user_id|             loc_url|           log_time|
     * +--------------+--------------------+-------------------+
     * |           424|http://m.eshop.co...|2019-08-13 03:03:55|
     * |           619|http://m.eshop.co...|2019-07-29 15:07:41|
     * |           898|http://m.eshop.co...|2019-08-14 09:23:44|
     * |           642|http://www.eshop....|2019-08-11 03:20:17|
     * |           130|http://www.eshop....|2019-08-12 11:59:28|
     * |           515|http://www.eshop....|2019-07-23 14:39:25|
     * |           274|http://www.eshop....|2019-07-24 15:37:12|
     * |           772|http://ck.eshop.c...|2019-07-24 07:56:49|
     * |           189|http://m.eshop.co...|2019-07-26 19:17:00|
     * |           529|http://m.eshop.co...|2019-07-25 23:18:37|
     * |           177|http://m.eshop.co...|2019-07-23 21:01:26|
     * |           247|http://m.vip.esho...|2019-07-22 06:58:05|
     * |           702| http://m.eshop.com/|2019-08-04 11:43:11|
     * |           871|http://vip.eshop....|2019-08-11 09:38:00|
     * |           349|http://www.eshop....|2019-07-22 12:17:54|
     * |           538|http://www.eshop....|2019-07-30 11:16:57|
     * |            81|http://www.eshop....|2019-08-06 09:10:37|
     * |           308|http://www.eshop....|2019-08-06 03:54:04|
     * |           344|http://m.eshop.co...|2019-08-09 07:25:10|
     * |           796|http://member.esh...|2019-08-07 15:16:28|
     * +--------------+--------------------+-------------------+
     */
    import spark.implicits._
    import scala.collection.JavaConversions._
    import org.apache.spark.sql.functions._
    //0.定义常量字符串,避免后续拼写错误
    val recencyStr = "recency"
    val frequencyStr = "frequency"
    val engagementsStr = "engagements"
    val featureStr = "feature"
    val scaleFeatureStr = "scaleFeature"
    val predictStr = "predict"
    //1.按用户id进行聚合获取用户活跃度-RFE
    //Recency:最近一次访问时间,用户最后一次访问距今时间,当前时间 - log_time
    //Frequency:访问频率,用户一段时间内访问的页面总数,count(loc_url)
    //Engagements:页面互动度,用户一段时间内访问的独立页面数,也可以定义为页面 浏览量、下载量、 视频播放数量等,distinct count(loc_url)
    var recencyAggColumn=datediff(date_sub(current_timestamp(),361),max("log_time")) as(recencyStr)
    var frequencyAggColumn=count("loc_url") as(frequencyStr)
    var engagementsAggCOlumn=countDistinct("loc_url") as engagementsStr

    val rfe_result = tblUser.groupBy("global_user_id").agg(recencyAggColumn, frequencyAggColumn, engagementsAggCOlumn)
//    rfe_result.show()
    /**
     * +--------------+-------+---------+-----------+
     * |global_user_id|recency|frequency|engagements|
     * +--------------+-------+---------+-----------+
     * |           296|     61|      380|        227|
     * |           467|     61|      405|        267|
     * |           675|     61|      370|        240|
     * |           691|     61|      387|        244|
     * |           829|     61|      404|        269|
     * |           125|     61|      375|        246|
     * |           451|     61|      347|        224|
     * +--------------+-------+---------+-----------+
     */
    // R:0-15天=5分，16-30天=4分，31-45天=3分，46-60天=2分，大于61天=1分
    // F:≥400=5分，300-399=4分，200-299=3分，100-199=2分，≤99=1分
    // E:≥250=5分，230-249=4分，210-229=3分，200-209=2分，1=1分
    var recencyScore=when(col(recencyStr).between(0,15),5)
      .when(col(recencyStr).between(16,30),4)
      .when(col(recencyStr).between(31,45),3)
      .when(col(recencyStr).between(46,60),2)
      .when(col(recencyStr).geq(61),1)
      .as(recencyStr)
    var frequencyScore= when(col(frequencyStr).geq(400),5)
      .when(col(frequencyStr).between(300,399),4)
      .when(col(frequencyStr).between(200,299),4)
      .when(col(frequencyStr).between(100,199),4)
      .when(col(frequencyStr).leq(99),1)
      .as(frequencyStr)
    var engagementsScore=when(col(engagementsStr).geq(250),5)
      .when(col(engagementsStr).between(230,249),4)
      .when(col(engagementsStr).between(210,229),3)
      .when(col(engagementsStr).between(200,209),2)
      .when(col(engagementsStr).leq(1),1)
      .as(engagementsStr)

    val ref_Score_Result = rfe_result.select('global_user_id, recencyScore, frequencyScore, engagementsScore)
//    ref_Score_Result.show()

    /**
     * +--------------+-------+---------+-----------+
     * |global_user_id|recency|frequency|engagements|
     * +--------------+-------+---------+-----------+
     * |           296|      1|        4|          3|
     * |           467|      1|        5|          5|
     * |           675|      1|        4|          4|
     * |           691|      1|        4|          4|
     * |           829|      1|        5|          5|
     * |           125|      1|        4|          4|
     * |           451|      1|        4|          3|
     * |           800|      1|        4|          4|
     * |           853|      1|        4|          5|
     */
    //3.聚类
    //为方便后续模型进行特征输入，需要部分列的数据转换为特征向量，并统一命名，VectorAssembler类就可以完成这一任务。
    //VectorAssembler是一个transformer，将多列数据转化为单列的向量列
    val vectorDF: DataFrame = new VectorAssembler()
      .setInputCols(Array(recencyStr, frequencyStr, engagementsStr))
      .setOutputCol(featureStr)
      .transform(ref_Score_Result)

//    vectorDF.show()

    /**
     * +--------------+-------+---------+-----------+-------------+
     * |global_user_id|recency|frequency|engagements|      feature|
     * +--------------+-------+---------+-----------+-------------+
     * |           296|      1|        4|          3|[1.0,4.0,3.0]|
     * |           467|      1|        5|          5|[1.0,5.0,5.0]|
     * |           675|      1|        4|          4|[1.0,4.0,4.0]|
     * |           691|      1|        4|          4|[1.0,4.0,4.0]|
     * |           829|      1|        5|          5|[1.0,5.0,5.0]|
     * |           125|      1|        4|          4|[1.0,4.0,4.0]|
     * |           451|      1|        4|          3|[1.0,4.0,3.0]|
     * |           800|      1|        4|          4|[1.0,4.0,4.0]|
     * |           853|      1|        4|          5|[1.0,4.0,5.0]|
     * |           944|      1|        4|          5|[1.0,4.0,5.0]|
     * |           666|      1|        5|          5|[1.0,5.0,5.0]|
     * |           870|      1|        5|          5|[1.0,5.0,5.0]|
     * |           919|      1|        5|          5|[1.0,5.0,5.0]|
     */
 /*   //最小最大归一化将每个特征调整到一个特定的范围,通常是（0,1）
    //(X - X.min)/(X.max - X.min)
    //归一化数据可以使各个特征维度对目标函数的影响权重一致，提高迭代的求解的收敛速度
    val scalerModel = new MinMaxScaler()
      .setInputCol(featureStr)
      .setOutputCol(scaleFeatureStr)
      .fit(vectorDF)
    val scalerDF = scalerModel.transform(vectorDF)*/
//    scalerDF.show()

    /**
     * +--------------+-------+---------+-----------+-------------+-------------+
     * |global_user_id|recency|frequency|engagements|      feature| scaleFeature|
     * +--------------+-------+---------+-----------+-------------+-------------+
     * |           296|      1|        4|          3|[1.0,4.0,3.0]|[0.5,0.0,0.0]|
     * |           467|      1|        5|          5|[1.0,5.0,5.0]|[0.5,1.0,1.0]|
     * |           675|      1|        4|          4|[1.0,4.0,4.0]|[0.5,0.0,0.5]|
     * |           691|      1|        4|          4|[1.0,4.0,4.0]|[0.5,0.0,0.5]|
     * |           829|      1|        5|          5|[1.0,5.0,5.0]|[0.5,1.0,1.0]|
     * |           125|      1|        4|          4|[1.0,4.0,4.0]|[0.5,0.0,0.5]|
     * |           451|      1|        4|          3|[1.0,4.0,3.0]|[0.5,0.0,0.0]|
     * |           800|      1|        4|          4|[1.0,4.0,4.0]|[0.5,0.0,0.5]|
     * |           853|      1|        4|          5|[1.0,4.0,5.0]|[0.5,0.0,1.0]|
     * |           944|      1|        4|          5|[1.0,4.0,5.0]|[0.5,0.0,1.0]|
     * |           666|      1|        5|          5|[1.0,5.0,5.0]|[0.5,1.0,1.0]|
     * |           870|      1|        5|          5|[1.0,5.0,5.0]|[0.5,1.0,1.0]|
     * |           919|      1|        5|          5|[1.0,5.0,5.0]|[0.5,1.0,1.0]|
     * |           926|      1|        5|          5|[1.0,5.0,5.0]|[0.5,1.0,1.0]|
     * |           124|      1|        5|          5|[1.0,5.0,5.0]|[0.5,1.0,1.0]|
     * |           447|      1|        4|          5|[1.0,4.0,5.0]|[0.5,0.0,1.0]|
     * |            51|      1|        5|          5|[1.0,5.0,5.0]|[0.5,1.0,1.0]|
     * |           591|      1|        5|          5|[1.0,5.0,5.0]|[0.5,1.0,1.0]|
     * |             7|      1|        5|          5|[1.0,5.0,5.0]|[0.5,1.0,1.0]|
     * |           307|      1|        4|          3|[1.0,4.0,3.0]|[0.5,0.0,0.0]|
     * +--------------+-------+---------+-----------+-------------+-------------+
     */
    //4.训练模型
    val model = new KMeans()
      .setK(4)
      .setMaxIter(10)
      .setSeed(10)
      .setFeaturesCol(featureStr)
      .setPredictionCol(predictStr)
      .fit(vectorDF)
    //5.预测
    val result: DataFrame = model.transform(vectorDF)
//    result.show()

    /**
     * +--------------+-------+---------+-----------+-------------+-------+
     * |global_user_id|recency|frequency|engagements|      feature|predict|
     * +--------------+-------+---------+-----------+-------------+-------+
     * |           296|      1|        4|          3|[1.0,4.0,3.0]|      3|
     * |           467|      1|        5|          5|[1.0,5.0,5.0]|      0|
     * |           675|      1|        4|          4|[1.0,4.0,4.0]|      1|
     * |           691|      1|        4|          4|[1.0,4.0,4.0]|      1|
     * |           829|      1|        5|          5|[1.0,5.0,5.0]|      0|
     * |           125|      1|        4|          4|[1.0,4.0,4.0]|      1|
     * |           451|      1|        4|          3|[1.0,4.0,3.0]|      3|
     * |           800|      1|        4|          4|[1.0,4.0,4.0]|      1|
     * |           853|      1|        4|          5|[1.0,4.0,5.0]|      2|
     * |           944|      1|        4|          5|[1.0,4.0,5.0]|      2|
     */

    //6.测试时看下聚类效果
    val ds = result
      .groupBy(predictStr)
      .agg(max(col(recencyStr) + col(frequencyStr) + col(engagementsStr)), min(col(recencyStr) + col(frequencyStr) + col(engagementsStr)))
      .sort(col(predictStr).asc)
//    ds.show()

    /**
     * +-------+------------------------------------------+------------------------------------------+
     * |predict|max(((recency + frequency) + engagements))|min(((recency + frequency) + engagements))|
     * +-------+------------------------------------------+------------------------------------------+
     * |      0|                                        11|                                        10|
     * |      1|                                         9|                                         9|
     * |      2|                                        10|                                        10|
     * |      3|                                         8|                                         8|
     * +-------+------------------------------------------+------------------------------------------+
     */

    //问题: 每一个簇的ID是无序的,但是我们将分类簇和rule进行对应的时候,需要有序
    //7.按质心排序,质心大,该类用户价值大
    //[(质心id, 质心值)]
    val center: immutable.IndexedSeq[(Int, Double)] = for (i <- model.clusterCenters.indices) yield (i, model.clusterCenters(i).toArray.sum)
//    println(center)
    /**
     * Vector((0,10.935802469135801), (1,9.0), (2,10.0), (3,8.0))
     */
    val centerSort: immutable.IndexedSeq[(Int, Double)] = center.sortBy(_._2).reverse
//    println(centerSort)
    /**
     * Vector((0,10.935802469135801), (2,10.0), (1,9.0), (3,8.0))
     */
    //[(质心id, rule值)]
    val centerAndRule: immutable.Seq[(Int, Int)] = for (i <- centerSort.indices) yield (centerSort(i)._1, i + 1)
//    println(centerAndRule)
    /**
     * Vector((0,1), (2,2), (1,3), (3,4))
     */
    val centerDF: DataFrame = centerAndRule.toDF(predictStr, "rule")
//    centerDF.show()
    /**
     * +-------+----+
     * |predict|rule|
     * +-------+----+
     * |      0|   1|
     * |      2|   2|
     * |      1|   3|
     * |      3|   4|
     * +-------+----+
     */
    //8.将rule和5级规则进行匹配
    val ruleTagDF: DataFrame = centerDF.join(five, "rule")
//    ruleTagDF.show()
    /**
     * +----+-------+------+
     * |rule|predict|tagsId|
     * +----+-------+------+
     * |   1|      0|    46|
     * |   2|      2|    47|
     * |   3|      1|    48|
     * |   4|      3|    49|
     * +----+-------+------+
     */
    //将第八步得出的结果,与K-Means预测的结果进行匹配
    val ruleMap: Map[String, String] = ruleTagDF.map(row => {
      val predict = row.getAs("predict").toString
      val tagsId = row.getAs("tagsId").toString
      (predict, tagsId)
    }).collect().toMap

    var predict_UDF=udf((predict:String)=>{
      val tag = ruleMap(predict)
      tag
    })

    val new_tag = result.select('global_user_id as ("userId"), predict_UDF('predict).as("tagsId"))
//    new_tag.show()
    /**
     * +------+------+
     * |userId|tagsId|
     * +------+------+
     * |   296|    49|
     * |   467|    46|
     * |   675|    48|
     * |   691|    48|
     * |   829|    46|
     * |   125|    48|
     * |   451|    49|
     * |   800|    48|
     * |   853|    47|
     * |   944|    47|
     * |   666|    46|
     * |   870|    46|
     * |   919|    46|
     * |   926|    46|
     * |   124|    46|
     * |   447|    47|
     * |    51|    46|
     * |   591|    46|
     * |     7|    46|
     * |   307|    49|
     * +------+------+
     */
    new_tag


  }

  def main(args: Array[String]): Unit = {
    startMain()

  }
}

以上就是用户活跃度模型RFE
若有什么正确的地方还请及时反馈,博主及时更正
如能帮助到你,希望能点个赞支持一下谢谢!
在这里插入图片描述

weixin_43563705
关注
专栏目录
大数据【企业级360°全方位用户画像】基于RFE模型的挖掘型标签开发
大数据梦想家
06-25 6459
        上一篇博客，已经为大家介绍了基于RFM（用户价值模型）的挖掘型标签开发过程（????大数据【企业级360°全方位用户画像】基于RFM模型的挖掘型标签开发），本篇博客，我们来学习基于RFE（用户活跃度模型）的挖掘型标签开发。 文章目录RFE模型引入RFE详解基于RFE模型的实践应用具体代码实现知识拓展小结 RFE模型引入        &nb
RFE用户活跃度模型
fengnzx
08-16 565
package org.example import org.apache.spark.ml.clustering.{KMeans, KMeansModel} import org.apache.spark.ml.feature.{MinMaxScaler, MinMaxScalerModel, VectorAssembler} import org.apache.spark.sql.expressions.UserDefinedFunction import org.apache.spark.sql.{
【数据挖掘】使用RFE进行特征选择
学无止境、积少成多、厚积薄发
06-07 1369
使用RFE进行特征选择
番外篇-RFE用户活跃度模型（详细实现思路可以去看RFM篇）
qq_41680016的博客
05-15 1908
在用户生命周期中，对每个用户进行群体划分，有针对性的做分群分层运营，可以更高效的提高营收转换。（用户生命周期是指：用户从注册账号建立起业务关系->完全终止关系的全过程，它动态的描述了用户在不同阶段的大致特征）。用户活跃度、用户价值度的分析在数据分析师的日常工作中会经常碰到，如何根据公司的业务情况对本公司的用户做活跃度和价值度的划分是是一种常规化的分析工作。，仅仅是讲计算指标发生变化，对于RFE的数据来源，可以从企业自己监控的用户行为日志获取，也可以从第三方网站分析工具获得。RFE：访问日志，流量数据。
【摸鱼笔记】RFE模型自动判定数据产品价值
最新发布
the_singing_towers的博客
06-28 1003
使用RFE用户活跃度模型，便可通过使用人数及使用深度（热度）这一视角，衡量报表项目、API项目等产品的价值，从而较为客观地、自动地决定设计和开发地优先级。
RFE -- 用户活跃度模型
qq_40273012的博客
08-09 2319
RFE模型概述 RFE模型基于用户普通行为（非转化或交易行为）产生，RFE模型可以说是RFM模型的变种，实现思路和RFM模型类似。 RFE详解 最近一次访问时间 R（Recency）：会员最近一次访问或到达网站的时间 访问频率 F（Frequency）：用户在特定时间周期内访问或到达的频率 页面互动度 E (Engagements)：互动度的定义可以根据不同企业或行业的交互情况而定，例如可以定义为页面浏览时间、浏览商品数量、视频播放数量、点赞数量、转发数量等。 RFE模型打分样例： R:0-15天=5
客户价值度和活跃度建模
建模分析师胡选来
07-25 9108
客户价值度和活跃度建模 目录 1. 活跃度模型 1.1 概念和计算方法 1.2 分类和解释 1.3 模型实现步骤 2. 价值度模型 2.1 概念和计算方法 2.2 价值度分类 2.3 结果解释和营销建议 2.4 模型实现步骤 1. 活跃度模型 1.1 概念和计算方法 概念：活跃度用来度量客户与公司交互程度。用加权因子分析法来做活跃度计算。 因子：用xi 表示，  (负相...
用户活跃度标签建模
技术大神之路
06-08 2751
应用场景 期望根据客户近3个月的登录行为和发帖更新贴行为，评估客户的活跃度，将活跃度分为多个等级，以根据不同的活跃等级开展不同的营销活动。 基本思路 1、采用聚类算法，特征值取最近3个月每周（一周取7天）登录次数，每周发帖次数，每周更新贴次数，按周展开列，共12周*3=36个特征值，对每个特征值按照时间周期做降权处理。 借鉴牛顿温度冷却定律： 本期温度=上期温度 * exp（-（冷却系数）*间隔的周期数） 特征值考虑时间周期作降权处理。假设，第12周的一次登录，在今日的权重变为0.05(暂定)，则，冷却系数
RFM RFE
weixin_48365923的博客
03-19 650
会员价值度模型RFM 1，定义 RFM模型是根据会员最近一次购买时间R（Recency）、购买频率F（Frequency）、购买金额M（Monetary）计算得出RFM得分， 通过这三个维度来评估客户的订单活跃价值，常用来做客户分群或价值区分。该模型常用于电子商务（即交易类）企业的会员分析。 基本实现过程： 步骤1 设置要做计算时的截止时间节点（例如2017-5-30），用来做基于该时间的数据选取和计算。 步骤2 在会员数据库中，以今天为时间界限向前推固定周期（例如1年），得到包含每个会员的会员ID、订单时
用户画像第四章(企业级360°用户画像_标签开发_挖掘标签_用户活跃度模型-RFE）
汉子一枚
07-13 650
用户活跃度模型-RFE RFE模型引入 ==RFE模型可以说是RFM模型的变体。 RFE模型基于用户的普通行为（非转化或交易行为）产生，==它跟RFM类似都是使用三个维度做价值评估。 RFE详解 RFE 模型是根据会员最近一次访问时间R（ Recency）、访问频率 F（Frequency）和页面互动度 E（Engagements）计算得出的RFE得分。 其中： a.最近一次访问时间 R（ Recency）： 会员最近一次访问或到达网站的时间。 b.访问频率 F（ Frequency）：用户在特定时间周期内
SVM-RFE algorithm：SVM-RFE算法.pdf
07-11
SVM-RFE算法在情感价值检测中的应用 本篇文章探讨了使用支持向量机递归特征消除（SVM-RFE）算法对EEG信号进行情感价值检测的方法。该方法结合全球场功率（Global Field Power，GFP）度量和SVM-RFE算法，旨在探究...
基于用户交互模型的会员网站每日活跃用户量分析 (2016年)
04-28
现有的网站往往向注册用户提供服务，而网站中的每日活跃用户量往往决定着网站建设的成败。为了描述网站中每日活跃用户的动态变化，将用户在网站上的交互行为分为响应、扩散和衰落三种类型，并提出了一种基于用户交互模型的每日活跃用户量模型。通过响应、扩散和衰落三种交互行为的定义，进一步推导出每日活跃用户随着时间的变化率。通过对每日活跃用户随着时间的变化率进行分析得到如下结论：当网站中用户的响应概率小于衰落概率时网站的活跃用户将趋向于0，反之活跃用户趋于某个固定的常数。大量的真实数据实验表明，不论网站自身的运营是否成功，
SVM-RFE.rar_RFE算法_SVM_SVM-RFE matlab_SVM-RFE算法流程_基因选择
07-15
基因选择算法 SVMRFE 基因选择算法 SVMRFE 基因选择算法 SVMRFE
RFE模型从入门到实践
weixin_43401381的博客
01-08 3529
RFE RFE模型基于用户的普通行为（非转化或交易行为）产生----采集数据得到 含义： 最近一次访问时间R（ Recency） 访问频率 F（Frequency） 页面互动度 E（Engagements） RFE模型用途 未登录用户的价值数据分析 登录用户价值数据分析 用户活跃分群或价值区分 数据来源： 对于RFE的数据来源， 从企业自己监控的用户行为日志获取。 RFE模型开发思路分析： 思路1：基于三个维度值做用户群体划分和解读，对用户的活跃度做分析。哪一个维度数值较低可以通.
基于用户标签的活跃人群特征分析_基于用户行为模型的客流量分析与预测
weixin_39658726的博客
12-24 426
基于用户行为模型的客流量分析与预测①程求江1,2,彭艳兵2【摘要】摘要：为了预测无线城市接入中商圈的短时客流量,通过分析顾客购物行为模式,提出了一种基于停留时间和区间活跃度的身份识别方案,用于区分工作人员和顾客;采用二元线性回归方法对停留时间和活跃次数进行置信水平为95%的拟合,分析了不同拟合参数对预测的影响.实验结果表明:停留时间和活跃度用于区分身份信息合理有效,且在时间阈值为3小时,活跃度阈值...
机械学习 --客户价值模型 RFM
kismet
06-19 2704
RFM模型引入 比如电商网站要做一次营销活动，需要针对不同价值的客户群体进行分群，对于高价值的用户推荐手表，珠宝等高端商品，对于低价值用户推荐打折促销的廉价商品，当然还有以下这些问题都是需要考虑的： 1.谁是我的最佳客户？ 2.谁即将要成为流失客户？ 3.谁将有潜力成为有价值的客户 4.哪些客户能够留存？ 5.哪些客户会对你目前对活动有所反应？ 那么最终的问题是如何对客户进行分群，即如何建立客户的价值模型呢？ 在传统企业和电商众多的客户细分模型中，RFM模型是被广泛提到和使用的。 RFM模
客户画像分析：CRM平台的客户画像分析与应用
程序员光剑
01-28 853
1.背景介绍 客户画像分析是一种利用数据驱动方法对客户群体进行深入分析的技术，旨在帮助企业更好地了解客户需求、优化市场营销策略、提高客户满意度，从而提高企业竞争力。在CRM平台中，客户画像分析是一项非常重要的功能，可以帮助企业更好地理解客户群体，从而更好地满足客户需求。 1. 背景介绍 客户画像分析的核心是将客户数据转化为有价值的信息，以便企业更好地了解客户群体。客户画像分析可以帮助企业了解...
如何实现 通过RFM 模型、 RFE 模型和 PSM 模型，通过 KMenas 算法完成不同用户的消费能力，活跃 度以及价格敏感的画像
06-11
首先，RFM模型是根据用户最近一次消费时间（Recency）、消费频率（Frequency）和消费金额（Monetary）三个指标来对用户进行分析的模型，可以用于刻画用户的消费能力和活跃度。 其次，RFE模型是根据用户的历史行为数据，通过逐步剔除不重要的特征，来建立一个更为精简的预测模型，可以用于刻画用户的消费能力和价格敏感度。 最后，PSM模型是根据用户的消费行为和个人属性等信息，来预测用户的购买行为，可以用于刻画用户的消费能力和价格敏感度。 在使用KMenas算法进行聚类分析时，可以将上述三个模型得到的特征作为输入，将用户分为不同的群体。通过对每个群体的特征进行分析，可以得到不同用户的消费能力、活跃度和价格敏感度的画像。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

weixin_43563705

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值