PySpark之电商广告推荐(3)

最新推荐文章于 2020-12-23 06:32:33 发布
最新推荐文章于 2020-12-23 06:32:33 发布
阅读量715 收藏
点赞数 1
分类专栏： 推荐系统 文章标签： 数据分析 机器学习 大数据 推荐系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35154281/article/details/108431061
版权

基于LR的点击率预测模型训练

数据处理

raw_sample表

数据读入与标准化

# 数据读取
_raw_sample_df1 = spark.read.csv("./data/raw_sample.csv", header=True)

# 更改表结构，转换为对应的数据类型
from pyspark.sql.types import StructType, StructField, IntegerType, FloatType, LongType, StringType
  
# 更改df表结构：更改列类型和列名称
_raw_sample_df2 = _raw_sample_df1.\
    withColumn("user", _raw_sample_df1.user.cast(IntegerType())).withColumnRenamed("user", "userId").\
    withColumn("time_stamp", _raw_sample_df1.time_stamp.cast(LongType())).withColumnRenamed("time_stamp", "timestamp").\
    withColumn("adgroup_id", _raw_sample_df1.adgroup_id.cast(IntegerType())).withColumnRenamed("adgroup_id", "adgroupId").\
    withColumn("pid", _raw_sample_df1.pid.cast(StringType())).\
    withColumn("nonclk", _raw_sample_df1.nonclk.cast(IntegerType())).\
    withColumn("clk", _raw_sample_df1.clk.cast(IntegerType()))
    
# 样本数据pid特征处理
from pyspark.ml.feature import OneHotEncoder
from pyspark.ml.feature import StringIndexer
from pyspark.ml import Pipeline

stringindexer = StringIndexer(inputCol='pid', outputCol='pid_feature')
encoder = OneHotEncoder(dropLast=False, inputCol='pid_feature', outputCol='pid_value')
pipeline = Pipeline(stages=[stringindexer, encoder])
pipeline_fit = pipeline.fit(_raw_sample_df2)
raw_sample_df = pipeline_fit.transform(_raw_sample_df2)

raw_sample_df.show(5)

+------+----------+---------+-----------+------+---+-----------+-------------+
|userId| timestamp|adgroupId|        pid|nonclk|clk|pid_feature|    pid_value|
+------+----------+---------+-----------+------+---+-----------+-------------+
|581738|1494137644|        1|430548_1007|     1|  0|        0.0|(2,[0],[1.0])|
|449818|1494638778|        3|430548_1007|     1|  0|        0.0|(2,[0],[1.0])|
|914836|1494650879|        4|430548_1007|     1|  0|        0.0|(2,[0],[1.0])|
|914836|1494651029|        5|430548_1007|     1|  0|        0.0|(2,[0],[1.0])|
|399907|1494302958|        8|430548_1007|     1|  0|        0.0|(2,[0],[1.0])|
+------+----------+---------+-----------+------+---+-----------+-------------+
only showing top 5 rows
ad_feature表

数据读入与标准化

from pyspark.sql.types import StructType, StructField, IntegerType, FloatType

# 更改表结构，转换为对应的数据类型
_ad_feature_df = spark.read.csv("./data/ad_feature.csv", header=True)

# 替换掉NULL字符串
_ad_feature_df = _ad_feature_df.replace("NULL", "-1")

# 更改df表结构：更改列类型和列名称
ad_feature_df = _ad_feature_df.\
    withColumn("adgroup_id", _ad_feature_df.adgroup_id.cast(IntegerType())).withColumnRenamed("adgroup_id", "adgroupId").\
    withColumn("cate_id", _ad_feature_df.cate_id.cast(IntegerType())).withColumnRenamed("cate_id", "cateId").\
    withColumn("campaign_id", _ad_feature_df.campaign_id.cast(IntegerType())).withColumnRenamed("campaign_id", "campaignId").\
    withColumn("customer", _ad_feature_df.customer.cast(IntegerType())).withColumnRenamed("customer", "customerId").\
    withColumn("brand", _ad_feature_df.brand.cast(IntegerType())).withColumnRenamed("brand", "brandId").\
    withColumn("price", _ad_feature_df.price.cast(FloatType()))

ad_feature_df.printSchema()
ad_feature_df.show(5)

root
 |-- adgroupId: integer (nullable = true)
 |-- cateId: integer (nullable = true)
 |-- campaignId: integer (nullable = true)
 |-- customerId: integer (nullable = true)
 |-- brandId: integer (nullable = true)
 |-- price: float (nullable = true)

+---------+------+----------+----------+-------+-----+
|adgroupId|cateId|campaignId|customerId|brandId|price|
+---------+------+----------+----------+-------+-----+
|    63133|  6406|     83237|         1|  95471|170.0|
|   313401|  6406|     83237|         1|  87331|199.0|
|   248909|   392|     83237|         1|  32233| 38.0|
|   208458|   392|     83237|         1| 174374|139.0|
|   110847|  7211|    135256|         2| 145952|32.99|
+---------+------+----------+----------+-------+-----+
only showing top 5 rows
user_profile表

数据读入与标准化

from pyspark.sql.types import StructType, StructField, StringType, IntegerType, LongType, FloatType

# 构建表结构schema对象
schema = StructType([
    StructField("userId", IntegerType()),
    StructField("cms_segid", IntegerType()),
    StructField("cms_group_id", IntegerType()),
    StructField("final_gender_code", IntegerType()),
    StructField("age_level", IntegerType()),
    StructField("pvalue_level", IntegerType()),
    StructField("shopping_level", IntegerType()),
    StructField("occupation", IntegerType()),
    StructField("new_user_class_level", IntegerType())
])

_user_profile_df1 = spark.read.csv("./data/user_profile.csv", header=True, schema=schema)
# 填补缺失值
_user_profile_df2 = _user_profile_df1.na.fill(-1)

# 热编码时，必须先将待处理字段转为字符串类型才可处理(这两个特征增加了一个新的空值类别)
_user_profile_df3 = _user_profile_df2.withColumn("pvalue_level", _user_profile_df2.pvalue_level.cast(StringType()))\
    .withColumn("new_user_class_level", _user_profile_df2.new_user_class_level.cast(StringType()))
    
# 对pvalue_level进行热编码，也即一种缺失值填充
# 运行过程是先将pvalue_level转换为一列新的特征数据，然后对该特征数据求出的热编码值，存在了新的一列数据中，类型为一个稀疏矩阵
stringindexer = StringIndexer(inputCol='pvalue_level', outputCol='pl_onehot_feature')
encoder = OneHotEncoder(dropLast=False, inputCol='pl_onehot_feature', outputCol='pl_onehot_value')
pipeline = Pipeline(stages=[stringindexer, encoder])
pipeline_fit = pipeline.fit(_user_profile_df3)
_user_profile_df4 = pipeline_fit.transform(_user_profile_df3)

# 使用热编码转换new_user_class_level的一维数据为多维
stringindexer = StringIndexer(inputCol='new_user_class_level', outputCol='nucl_onehot_feature')
encoder = OneHotEncoder(dropLast=False, inputCol='nucl_onehot_feature', outputCol='nucl_onehot_value')
pipeline = Pipeline(stages=[stringindexer, encoder])
pipeline_fit = pipeline.fit(_user_profile_df4)
user_profile_df = pipeline_fit.transform(_user_profile_df4)
user_profile_df.printSchema()
user_profile_df.show(5)

root
 |-- userId: integer (nullable = true)
 |-- cms_segid: integer (nullable = true)
 |-- cms_group_id: integer (nullable = true)
 |-- final_gender_code: integer (nullable = true)
 |-- age_level: integer (nullable = true)
 |-- pvalue_level: string (nullable = true)
 |-- shopping_level: integer (nullable = true)
 |-- occupation: integer (nullable = true)
 |-- new_user_class_level: string (nullable = true)
 |-- pl_onehot_feature: double (nullable = false)
 |-- pl_onehot_value: vector (nullable = true)
 |-- nucl_onehot_feature: double (nullable = false)
 |-- nucl_onehot_value: vector (nullable = true)

+------+---------+------------+-----------------+---------+------------+--------------+----------+--------------------+-----------------+---------------+-------------------+-----------------+
|userId|cms_segid|cms_group_id|final_gender_code|age_level|pvalue_level|shopping_level|occupation|new_user_class_level|pl_onehot_feature|pl_onehot_value|nucl_onehot_feature|nucl_onehot_value|
+------+---------+------------+-----------------+---------+------------+--------------+----------+--------------------+-----------------+---------------+-------------------+-----------------+
|   234|        0|           5|                2|        5|          -1|             3|         0|                   3|              0.0|  (4,[0],[1.0])|                2.0|    (5,[2],[1.0])|
|   523|        5|           2|                2|        2|           1|             3|         1|                   2|              2.0|  (4,[2],[1.0])|                1.0|    (5,[1],[1.0])|
|   612|        0|           8|                1|        2|           2|             3|         0|                  -1|              1.0|  (4,[1],[1.0])|                0.0|    (5,[0],[1.0])|
|  1670|        0|           4|                2|        4|          -1|             1|         0|                  -1|              0.0|  (4,[0],[1.0])|                0.0|    (5,[0],[1.0])|
|  2545|        0|          10|                1|        4|          -1|             3|         0|                  -1|              0.0|  (4,[0],[1.0])|                0.0|    (5,[0],[1.0])|
+------+---------+------------+-----------------+---------+------------+--------------+----------+--------------------+-----------------+---------------+-------------------+-----------------+
only showing top 5 rows

查看编码后的对应关系

# 查看标签转换后的对应关系(注意:不是一一对应关系)
user_profile_df.groupBy("pvalue_level").min("pl_onehot_feature").show()
user_profile_df.groupBy("new_user_class_level").min("nucl_onehot_feature").show()

+------------+----------------------+
|pvalue_level|min(pl_onehot_feature)|
+------------+----------------------+
|          -1|                   0.0|
|           3|                   3.0|
|           1|                   2.0|
|           2|                   1.0|
+------------+----------------------+
+--------------------+------------------------+
|new_user_class_level|min(nucl_onehot_feature)|
+--------------------+------------------------+
|                  -1|                     0.0|
|                   3|                     2.0|
|                   1|                     4.0|
|                   4|                     3.0|
|                   2|                     1.0|
+--------------------+------------------------+
合并表
# 数据合并
condition = [raw_sample_df.adgroupId == ad_feature_df.adgroupId]
_ = raw_sample_df.join(ad_feature_df, on=condition, how="outer")

condition2 = [_.userId==user_profile_df.userId]
datasets = _.join(user_profile_df, condition2, "outer")

datasets.printSchema()

root
 |-- userId: integer (nullable = true)
 |-- timestamp: long (nullable = true)
 |-- adgroupId: integer (nullable = true)
 |-- pid: string (nullable = true)
 |-- nonclk: integer (nullable = true)
 |-- clk: integer (nullable = true)
 |-- pid_feature: double (nullable = true)
 |-- pid_value: vector (nullable = true)
 |-- adgroupId: integer (nullable = true)
 |-- cateId: integer (nullable = true)
 |-- campaignId: integer (nullable = true)
 |-- customerId: integer (nullable = true)
 |-- brandId: integer (nullable = true)
 |-- price: float (nullable = true)
 |-- userId: integer (nullable = true)
 |-- cms_segid: integer (nullable = true)
 |-- cms_group_id: integer (nullable = true)
 |-- final_gender_code: integer (nullable = true)
 |-- age_level: integer (nullable = true)
 |-- pvalue_level: string (nullable = true)
 |-- shopping_level: integer (nullable = true)
 |-- occupation: integer (nullable = true)
 |-- new_user_class_level: string (nullable = true)
 |-- pl_onehot_feature: double (nullable = true)
 |-- pl_onehot_value: vector (nullable = true)
 |-- nucl_onehot_feature: double (nullable = true)
 |-- nucl_onehot_value: vector (nullable = true)

建模

LR模型（未对名义变量进行one hot编码）
# 剔除冗余、不需要的字段
useful_cols = [
    # 时间字段，划分训练集和测试集
    "timestamp",
    
    # label目标值字段
    "clk",  
    
    # 特征值字段
    "pid_value",       # 资源位的特征向量
    "price",    # 广告价格
    
    "cms_segid",    # 用户微群ID
    "cms_group_id",    # 用户组ID
    "final_gender_code",    # 用户性别特征，[1,2]
    "age_level",    # 年龄等级，1-
    "shopping_level",
    "occupation",
    
    "pl_onehot_value",
    "nucl_onehot_value"
]

# datasets_1已选择的特征
datasets_1 = datasets.select(*useful_cols)
datasets_1 = datasets_1.dropna()  # 消除外连接表后所产生的空值

from pyspark.ml.feature import VectorAssembler

datasets_1 = VectorAssembler().setInputCols(useful_cols[2:]).setOutputCol("features").transform(datasets_1)

# 以时间为划分线,划分测试集和训练集(最后一天为测试集)
train_datasets = datasets_1.filter(datasets_1.timestamp <= (1494691186-24*60*60))
test_datasets = datasets_1.filter(datasets_1.timestamp > (1494691186-24*60*60))

# LR模型预测
from pyspark.ml.classification import LogisticRegression

lr = LogisticRegression(labelCol="clk", featuresCol="features")
model = lr.fit(train_datasets)

result = model.transform(test_datasets)
result.select("clk", "price", "probability", "prediction").sort("probability").show(10)

+---+-----------+--------------------+----------+
|clk|      price|         probability|prediction|
+---+-----------+--------------------+----------+
|  0|      1.0E8|[0.86822033579080...|       0.0|
|  0|      1.0E8|[0.88410456898285...|       0.0|
|  0|      1.0E8|[0.89175497524430...|       0.0|
|  1|5.5555556E7|[0.92481456348734...|       0.0|
|  0|      1.5E7|[0.93741450416609...|       0.0|
|  0|      1.5E7|[0.93757135053513...|       0.0|
|  0|      1.5E7|[0.93834723068486...|       0.0|
|  0|     1099.0|[0.93972095737025...|       0.0|
|  0|      338.0|[0.93972135016259...|       0.0|
|  0|      311.0|[0.93972136409867...|       0.0|
+---+-----------+--------------------+----------+
only showing top 10 rows

result.filter(result.clk == 1).select("clk", "price", "probability", "prediction").sort("probability").show(20)

+---+-----------+--------------------+----------+
|clk|      price|         probability|prediction|
+---+-----------+--------------------+----------+
|  1|5.5555556E7|[0.92481456348734...|       0.0|
|  1|      138.0|[0.93972145339276...|       0.0|
|  1|       35.0|[0.93972150655624...|       0.0|
|  1|      149.0|[0.93999389734424...|       0.0|
|  1|     5608.0|[0.94001892235042...|       0.0|
|  1|      275.0|[0.94002166220536...|       0.0|
|  1|       35.0|[0.94002178550379...|       0.0|
|  1|       49.0|[0.94004219522449...|       0.0|
|  1|      915.0|[0.94021082866896...|       0.0|
|  1|      598.0|[0.94021099104461...|       0.0|
|  1|      568.0|[0.94021100641137...|       0.0|
|  1|      398.0|[0.94021109348960...|       0.0|
|  1|      368.0|[0.94021110885634...|       0.0|
|  1|      299.0|[0.94021114419981...|       0.0|
|  1|      278.0|[0.94021115495652...|       0.0|
|  1|      259.0|[0.94021116468878...|       0.0|
|  1|      258.0|[0.94021116520100...|       0.0|
|  1|      258.0|[0.94021116520100...|       0.0|
|  1|      258.0|[0.94021116520100...|       0.0|
|  1|      195.0|[0.94021119747110...|       0.0|
+---+-----------+--------------------+----------+
only showing top 20 rows
LR模型（one hot编码）

分析：

训练CTRModel_AllOneHot

  • “pid_value”, 类别型特征，已被转换为多维特征==> 2维
  • “price”, 统计型特征 ===> 1维
  • “cms_segid”, 类别型特征，约97个分类 ===> 1维
  • “cms_group_id”, 类别型特征，约13个分类 ==> 1维
  • “final_gender_code”, 类别型特征，2个分类 ==> 1维
  • “age_level”, 类别型特征，7个分类 ==> 1维
  • “shopping_level”, 类别型特征，3个分类 ==> 1维
  • “occupation”, 类别型特征，2个分类 ==> 1维
  • “pl_onehot_value”, 类别型特征，已被转换为多维特征 ==> 4维
  • “nucl_onehot_value” 类别型特征，已被转换为多维特征 ==> 5维

类别性特征都可以考虑进行热独编码，将单一变量变为多变量，相当于增加了相关特征的数量

  • “cms_segid”, 类别型特征，约97个分类 ===> 97维 舍弃
  • “cms_group_id”, 类别型特征，约13个分类 ==> 13维
  • “final_gender_code”, 类别型特征，2个分类 ==> 2维
  • “age_level”, 类别型特征，7个分类 ==>7维
  • “shopping_level”, 类别型特征，3个分类 ==> 3维
  • “occupation”, 类别型特征，2个分类 ==> 2维

但由于cms_segid分类过多，这里考虑舍弃，避免数据过于稀疏

one hot编码
# 构造onehot编码,首先将相对应的特征转换为字符串类型的

datasets_2 = datasets.withColumn("cms_group_id", datasets.cms_group_id.cast(StringType()))\
    .withColumn("final_gender_code", datasets.final_gender_code.cast(StringType()))\
    .withColumn("age_level", datasets.age_level.cast(StringType()))\
    .withColumn("shopping_level", datasets.shopping_level.cast(StringType()))\
    .withColumn("occupation", datasets.occupation.cast(StringType()))
    
useful_cols_2 = [
    # 时间值，划分训练集和测试集
    "timestamp",
    
    # label目标值
    "clk", 
    
    # 特征值
    "price",
    "cms_group_id",
    "final_gender_code",
    "age_level",
    "shopping_level",
    "occupation",
    "pid_value", 
    "pl_onehot_value",
    "nucl_onehot_value"
]

datasets_2 = datasets_2.select(*useful_cols_2)
datasets_2 = datasets_2.dropna()

# 热编码处理函数封装
def oneHotEncoder(col1, col2, col3, data):
    
    stringindexer = StringIndexer(inputCol=col1, outputCol=col2)
    encoder = OneHotEncoder(dropLast=False, inputCol=col2, outputCol=col3)
    pipeline = Pipeline(stages=[stringindexer, encoder])
    pipeline_fit = pipeline.fit(data)
    
    return pipeline_fit.transform(data)

# 对这五个字段进行热独编码
#     "cms_group_id",
#     "final_gender_code",
#     "age_level",
#     "shopping_level",
#     "occupation",

datasets_2 = oneHotEncoder("cms_group_id", "cms_group_id_feature", "cms_group_id_value", datasets_2)
datasets_2 = oneHotEncoder("final_gender_code", "final_gender_code_feature", "final_gender_code_value", datasets_2)
datasets_2 = oneHotEncoder("age_level", "age_level_feature", "age_level_value", datasets_2)
datasets_2 = oneHotEncoder("shopping_level", "shopping_level_feature", "shopping_level_value", datasets_2)
datasets_2 = oneHotEncoder("occupation", "occupation_feature", "occupation_value", datasets_2)

## 查看编码一一对应关系
datasets_2.groupBy("cms_group_id").min("cms_group_id_feature").show()
# datasets_2.groupBy("final_gender_code").min("final_gender_code_feature").show()
# datasets_2.groupBy("age_level").min("age_level_feature").show()
# datasets_2.groupBy("shopping_level").min("shopping_level_feature").show()
# datasets_2.groupBy("occupation").min("occupation_feature").show()

+------------+-------------------------+
|cms_group_id|min(cms_group_id_feature)|
+------------+-------------------------+
|           7|                      9.0|
|          11|                      6.0|
|           3|                      0.0|
|           8|                      8.0|
|           0|                     12.0|
|           5|                      3.0|
|           6|                     10.0|
|           9|                      5.0|
|           1|                      7.0|
|          10|                      4.0|
|           4|                      1.0|
|          12|                     11.0|
|           2|                      2.0|
+------------+-------------------------+
建模
# 由于热独编码后，特征字段不再是之前的字段，重新定义特征值字段
feature_cols = [
    # 特征值
    "price",
    
    "cms_group_id_value",
    "final_gender_code_value",
    "age_level_value",
    "shopping_level_value",
    "occupation_value",
    
    "pid_value",
    "pl_onehot_value",
    "nucl_onehot_value"
]

from pyspark.ml.feature import VectorAssembler

datasets_2 = VectorAssembler(inputCols=feature_cols, outputCol="features").transform(datasets_2)
# 划分数据集
train_datasets2 = datasets_2.filter(datasets_2.timestamp<=(1494691186-24*60*60))
test_datasets2 = datasets_2.filter(datasets_2.timestamp>(1494691186-24*60*60))
print("train_datasets2:", train_datasets2.select("clk", "features").show(5, truncate=False))

# 模型training
lr2 = LogisticRegression(featuresCol="features", labelCol="clk")
model2 = lr2.fit(train_datasets2)
result2 = model2.transform(test_datasets2)
print("result1", result2.select("clk", "price", "probability", "prediction").sort("probability").show(20))

train_datasets2:
+---+------------------------------------------------------------------------+
|clk|features                                                                |
+---+------------------------------------------------------------------------+
|0  |(39,[0,7,15,18,23,26,29,30,35],[108.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0]) |
|0  |(39,[0,7,15,18,23,26,29,30,35],[1880.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0])|
|1  |(39,[0,1,14,16,23,26,29,31,35],[1990.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0])|
|0  |(39,[0,1,14,16,23,26,29,31,35],[2200.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0])|
|0  |(39,[0,1,14,16,23,26,29,31,35],[5649.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0])|
+---+------------------------------------------------------------------------+
only showing top 5 rows
result1:
+---+-----------+--------------------+----------+
|clk|      price|         probability|prediction|
+---+-----------+--------------------+----------+
|  0|      1.0E8|[0.85524418892857...|       0.0|
|  0|      1.0E8|[0.88353143762124...|       0.0|
|  0|      1.0E8|[0.89169808985616...|       0.0|
|  1|5.5555556E7|[0.92511743960350...|       0.0|
|  0|     179.01|[0.93239951738308...|       0.0|
|  1|      159.0|[0.93239952905660...|       0.0|
|  0|      118.0|[0.93239955297535...|       0.0|
|  0|      688.0|[0.93451506165953...|       0.0|
|  0|      339.0|[0.93451525933626...|       0.0|
|  0|      335.0|[0.93451526160190...|       0.0|
|  0|      220.0|[0.93451532673881...|       0.0|
|  0|      176.0|[0.93451535166074...|       0.0|
|  0|      158.0|[0.93451536185607...|       0.0|
|  0|      158.0|[0.93451536185607...|       0.0|
|  1|      149.0|[0.93451536695374...|       0.0|
|  0|      122.5|[0.93451538196353...|       0.0|
|  0|       99.0|[0.93451539527410...|       0.0|
|  0|       88.0|[0.93451540150458...|       0.0|
|  0|       79.0|[0.93451540660224...|       0.0|
|  0|       75.0|[0.93451540886787...|       0.0|
+---+-----------+--------------------+----------+
only showing top 20 rows

参考

推荐系统

黑马python5.0

推荐系统（一）：个性化电商广告推荐系统介绍、数据集介绍、项目效果展示、项目实现分析、点击率预测(CTR–Click-Through-Rate)概念

张先生-您好
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark电商推荐项目源码.zip
09-28
spark电商推荐源码
基于pyspark的个性化电商广告推荐系统
cjl的博客
11-05 1683
个性化电商广告推荐系统1. 数据介绍2. 项目实现分析2.1 数据概况2.2 业务流程3. 预处理behavior_log数据集3.1 创建spark session3.2 读取文件并修改schema3.3 查看数据情况3.4 透视表操作3.5 把btag中的操作转化为打分3.6 根据用户对类目偏好打分训练ALS模型3.7 ALS模型预测 初步存储到redis中4. 分析处理raw_sample数据集4.1 加载数据并修改schema4.2 查看数据情况4.3 广告展示位进行热度编码4.4 根据时间戳划分
推荐系统（四）：LR实现CTR预估、Spark逻辑回归(LR)训练点击率预测模型
汪雯琦的博客
03-15 2708
文章目录四 LR实现CTR预估4.1 Spark逻辑回归(LR)训练点击率预测模型 四 LR实现CTR预估 4.1 Spark逻辑回归(LR)训练点击率预测模型 本小节主要根据广告点击样本数据集(raw_sample)、广告基本特征数据集(ad_feature)、用户基本信息数据集(user_profile)构建出了一个完整的样本数据集，并按日期划分为了训练集(前七天)和测试集(最后一天)，利...
Spark_Linear_Regression:Spark（pyspark）点击率（CTR）预测表格Kaggle的线性回归
05-16
标题 作者 日期 输出 自述文件 Dusan Grubjesic电子邮件：grubjesic.dusan@gmail.com 2015年8月11日 html_document 点击率预测算法 这是使用点击率预测算法，写在spark： python API中。 数据 数据来自 ，是Kaggle展示广告挑战数据集的示例。 您可以在接受协议后下载该文件。 它被构造为观察线，其中首先是单击或没有单击（1,0），其余是要素 开始之前 您必须已安装apache spark和python。 另外，如果要将示例从本地更改为群集，还必须将示例在ClickRate.py中的位置更改为下载位置，并激发上下文。 Sh文件仅用于更简单的启动，如果要使用它，则必须更改设置。 我已经安装了hadoop 2.6，python 3.4和numpy软件包的apache spark pre-bult 过程 样本首先被解析
python 聚类 客户细分_KMeans聚类：商城客户细分数据
weixin_35907638的博客
12-23 1625
数据集来自DataFountain，一共包含200名顾客，记录包含顾客的ID，性别，年龄，收入和支出分数。首先先查看一下数据的前五行1、描述分析df = pd.read_csv('Mall_Customers.csv', index_col=0)df.columns = [ 'Gender', 'Age', 'Income', 'Score']df.head()在进行聚类之前，首先进行描述性分析，...
推荐系统：Pyspark，ALS推荐系统
02-18
在本主题中，我们将深入探讨如何使用Pyspark和ALS（ Alternating Least Squares）算法来构建推荐系统。Pyspark是Apache Spark的Python接口，它提供了一个强大的分布式计算框架，适合处理大规模数据。 首先，了解ALS...
pyspark 数据处理样例数据
06-14
pyspark 数据处理样例数据
pycharm编写spark程序，导入pyspark包的3中实现方法
09-18
然后会弹出新的窗口，用户需要点击“OK”后，选择Spark安装目录下的Python路径，通常位于“/path/to/spark/python/lib/py4j-版本号-py2.7.egg”或者对应的Python3版本路径。完成这些步骤后，可以在Python文件中尝试...
pyspark-xgboost.zip
06-25
'max_depth': 3, 'objective': 'binary:logistic', 'eval_metric': 'logloss' } xgb_model = XGBoostEstimator(featuresCol='features', labelCol='label', params=params) xgb_model.fit(data) ``` 最后，...
Learning PySpark
11-14
《Learning PySpark》这本书深入浅出地介绍了如何利用Python接口来操作Apache Spark，进而处理大规模数据，构建机器学习模型，并进行图像处理和数据流的读取。PySpark是Python编程语言与Spark框架的结合，它使得数据...
《深度实践Spark机器学习 》第11章 pyspark决策树模型
weixin_39423653的博客
07-12 2260
由于此书不配代码，以下代码都是本宝宝在ipynb测试过的。
CTR预估算法小结
热门推荐
bitcarmanlee的博客
08-06 1万+
1.常用的CTR方法常用的ctr预测的算法包括LR（Logistic Regression）， FM(Factorization Machines)， GBDT等等。像LR和GBDT， Spark Mllib都提供了相应的实现，另外台湾大学的Liblinear也有一个Spark版本的LR算法的实现。Mllib的LR是基于LBFGS的实现，而Liblinear是基于TRON的实现。实际当中我们测试过
pyspark-ml学习笔记：一些比较不错的资料
MachineLP的专栏
08-13 1557
子雨大数据之Spark入门教程(Python版): http://dblab.xmu.edu.cn/blog/1709-2/ 子雨大数据之Spark入门教程（Scala版）: http://dblab.xmu.edu.cn/blog/spark/ https://blog.csdn.net/FlySky1991 PySpark pandas udf: https://www.imooc...
[雪峰磁针石博客]pyspark工具机器学习(自然语言处理和推荐系统)1数据演进 ...
测试0901-1
01-28 253
在早期员工将数据输入系统，数据点非常有限，只占用少数几个字段。然后是互联网，每个人都可以轻松获取信息。现在，用户可输入并生成自己的数据。随着互联网用户数量呈指数级增长，用户创造的高数据增长率。例如：登录/注册表单允许用户填写自己的详细信息，在各种社交平台上上传照片和视频。这导致了巨大的数据生成以及快速处理数据量的且可扩展的框架的需求。 数据生成 设备都...
pyspark系列--pandas和pyspark对比
leofionn的博客
09-22 2904
目录 pandas和pyspark对比 1.1. 工作方式 1.2. 延迟机制 1.3. 内存缓存 1.4. DataFrame可变性 1.5. 创建 1.6. index索引 1.7. 行结构 1.8. 列结构 1.9. 列名称 1.10. 列添加 1.11. 列修改 1.12. 显示 1.13. 排序 1.14. 选择或切片 1.15. 过滤 1.16. 整合 1.17. 统计 1.18. ...
pyspark构建简单模型(RandomForest&LogisticRegression)
诗蕊的专栏
07-11 4305
本文记录了用pyspark构建一个简单的模型的过程。 1. 读取数据集 from pyspark.sql import SparkSession from pyspark.ml.feature import StringIndexer from pyspark.ml.classification import LogisticRegression from pyspark.ml impor...
基于Spark的电商推荐系统
清风竹雨
07-16 6052
ECommerceRecommendSystem 基于spark的商品推荐系统 项目体系架构设计 1.1 项目系统架构 项目以推荐系统建设领域知名的经过修改过的中文亚马逊电商数据集作为依托，以某电商网站真实业务数据架构为基础，构建了符合教学体系的一体化的电商推荐系统，包含了离线推荐与实时推荐体系，综合利用了协同过滤算法以及基于内容的推荐方法来提供混合推荐。提供了从前端应用、后台服务、算法设计实现、...
文章排序-pyspark LR模型（三）
qq_29153321的博客
03-30 993
最基础的模型目前都是基于LR的点击率预估策略，目前在工业使用模型做预估的有这么几种类型 宽模型 + 特征⼯程 LR/MLR + 非ID类特征(⼈⼯离散/GBDT/FM) 宽模型 + 深模型 wide&deep,DeepFM 使用TensorFlow进行训练 深模型： DNN + 特征embedding 使用TensorFlow进行训练 一、构造训练集，用户和文章特征作为训练集特...
python数据分析实战-在线零售业务的交易-电商平台零售数据分析（附源代码）
梁先森的博客
02-23 4491
电商平台零售数据分析 前面的博客中已经有使用在线零售业务数据进行数据分析，但是在这一篇，我们以不同的角度重新对这些数据进行分析。 数据来源及数据结构 国外的在线零售业务的交易数据，数据下载地址 现在以表格的形式解释一下里面的字段： 字段 说明 InvoiceNo 订单编号，含有6个整数，退货订单编号开头有字母C StockCode 产品编号，由5个整数构成 Descri...
电商跳失率pyspark实现计算
最新发布
05-28
在 PySpark 中，可以使用 DataFrame 和 Spark SQL 的方法来计算电商跳失率。以下是一个简单的示例代码： ```python from pyspark.sql.functions import count, when # 读取电商网站访问日志数据 log_df = spark....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值