计算广告

Posted 2023-04-05 爱学习的菜鸟罢了

GBDT＋LR

GBDT+LR是一种融合梯度提升决策树（Gradient Boosting Decision Tree，简称GBDT）和逻辑回归（Logistic Regression，简称LR）的机器学习方法。这种方法的主要目的是充分利用GBDT和LR的优势，提高模型的预测性能。

GBDT（Gradient Boosting Decision Tree）：

GBDT是一种基于梯度提升（Gradient Boosting）的集成学习方法。GBDT通过迭代训练多个决策树模型，并将它们组合在一起，形成一个强大的预测模型。在每一轮迭代中，GBDT会训练一个新的决策树，该决策树试图纠正前面已训练的决策树的预测误差。通过这种方式，GBDT能够不断提高模型的预测能力。

LR（Logistic Regression）：

逻辑回归是一种广泛应用于分类问题的线性模型。LR通过使用对数几率函数（logistic function）将线性回归的输出映射到概率空间，从而得到属于某一类别的概率。然后，可以根据概率阈值对样本进行分类。

GBDT+LR的融合方法：

GBDT+LR方法的核心思想是先使用GBDT对原始特征进行特征转换，然后将转换后的特征输入到LR模型中进行分类。

具体步骤如下：

（1）使用GBDT训练模型：首先，使用GBDT对训练数据进行训练，得到多个决策树模型。

（2）特征转换：将训练数据通过GBDT模型，得到每个样本在每棵树上的叶子节点。这些叶子节点可以看作是原始特征的高阶组合。将叶子节点编码成一种称为“one-hot encoding”的形式。这样，每个样本就会被转换成一个高维稀疏向量，向量中的每个元素代表该样本在某个叶子节点上的取值。

（3）训练LR模型：使用转换后的特征作为输入，训练逻辑回归模型。由于特征已经经过了GBDT的处理，这个过程可以看作是在学习GBDT所捕捉到的特征组合之间的线性关系。

（4）预测：对于新的样本，首先将其通过GBDT进行特征转换，然后将转换后的特征输入到LR模型中，得到分类结果。

GBDT+LR的优势：

特征工程：GBDT可以自动学习到有效的特征组合，降低了手动进行特征工程的难度和工作量。

稀疏特征处理：经过GBDT特征转换后，特征变得稀疏且高维，逻辑回归对稀疏特征的处理能力较强，有助于提高模型性能。

优化模型性能：GBDT和LR的组合可以充分利用非线性和线性模型的优势，提高模型的预测性能。

应用场景：

GBDT+LR模型适用于各种分类问题，特别是在广告点击率预测、金融风险控制、推荐系统等领域有着广泛的应用。

总结：

GBDT+LR是一种结合了梯度提升决策树和逻辑回归的机器学习方法。通过使用GBDT进行特征转换和逻辑回归进行分类，该方法充分发挥了两者的优势，提高了模型的预测性能。GBDT+LR模型在各种分类问题中均有良好的表现，尤其适用于广告点击率预测、金融风险控制和推荐系统等

单独的使用GBDT模型，容易出现过拟合，在实际应用中往往使用 GBDT＋LR的方式做模型训练

首先根据样本训练出GBDT树，对于每个叶子节点，回溯到根节点都可以得到一组组合特征，所以用叶子节点的标号可以代表一个新的组合特征。结合上面的图，用一个样本为例，直观的表达如下

​

编辑切换为居中

添加图片注释，不超过 140 字（可选）

其中 0号 组合特征的含义是：ageLessThan15AndIsMale，该样本取值 0

其中 1号 组合特征的含义是：ageLessThan15AndIsNotMale，该样本取值 1

其中 2号 组合特征的含义是：ageLargerOrEqualThan15，该样本取值 0

其中 3号 组合特征的含义是：useComputerDaily，该样本取值 0

其中 4号 组合特征的含义是：notUseComputerDaily，该样本取值 1

这部分特征是GBDT生成的组合特征，再结合LR固有的稀疏特征，就组成了 GBDT ＋ LR 模型。

生成样本向量阶段，样本首先过GBDT模型，生成组合特征部分的输入向量，再结合固有的稀疏特征向量，组成新的特征向量，再以它训练LR，示例如下：

Sklearn

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score

# 生成模拟数据的函数
def generate_data(n_samples=10000, n_features=10, random_state=None):
    np.random.seed(random_state)
    X = np.random.rand(n_samples, n_features)
    y = (np.random.rand(n_samples) > 0.5).astype(int)
    return pd.DataFrame(X, columns=[f'feature_i' for i in range(n_features)]), y

# 生成模拟数据
X, y = generate_data(n_samples=10000, n_features=10, random_state=42)

# 划分数据集为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 训练GBDT模型
gbdt = GradientBoostingClassifier(n_estimators=50, random_state=42)
gbdt.fit(X_train, y_train)

# 对训练数据进行GBDT特征变换
train_leaves = gbdt.apply(X_train)[:, :, 0]
test_leaves = gbdt.apply(X_test)[:, :, 0]

# 对GBDT生成的叶子节点特征进行One-Hot编码
encoder = OneHotEncoder()
encoder.fit(train_leaves)
train_leaves_encoded = encoder.transform(train_leaves)
test_leaves_encoded = encoder.transform(test_leaves)

# 训练LR模型
lr = LogisticRegression(solver='lbfgs', max_iter=1000, random_state=42)
lr.fit(train_leaves_encoded, y_train)

# 对测试集进行预测并计算AUC
y_pred = lr.predict_proba(test_leaves_encoded)[:, 1]
auc = roc_auc_score(y_test, y_pred)
print(f'Test AUC: auc:.4f')

Sklearn

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import roc_auc_score

# 生成模拟数据的函数
def generate_data(n_samples=10000, n_features=10, random_state=None):
    np.random.seed(random_state)
    X = np.random.rand(n_samples, n_features)
    y = (np.random.rand(n_samples) > 0.5).astype(int)
    return pd.DataFrame(X, columns=[f'feature_i' for i in range(n_features)]), y

# 逻辑回归底层实现
class LogisticRegression:
    def __init__(self, learning_rate=0.01, epochs=10, batch_size=32):
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.batch_size = batch_size

    def _sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def fit(self, X, y):
        self.w = np.random.rand(X.shape[1] + 1)
        X = np.c_[np.ones(X.shape[0]), X]

        for epoch in range(self.epochs):
            for i in range(0, len(X), self.batch_size):
                X_batch = X[i:i + self.batch_size]
                y_batch = y[i:i + self.batch_size]
                y_pred = self._sigmoid(np.dot(X_batch, self.w))

                gradient = np.dot(X_batch.T, y_pred - y_batch) / len(y_batch)
                self.w -= self.learning_rate * gradient

    def predict_proba(self, X):
        X = np.c_[np.ones(X.shape[0]), X]
        return self._sigmoid(np.dot(X, self.w))

# 生成模拟数据
X, y = generate_data(n_samples=10000, n_features=10, random_state=42)

# 划分数据集为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 训练GBDT模型
gbdt = GradientBoostingClassifier(n_estimators=50, random_state=42)
gbdt.fit(X_train, y_train)

# 对训练数据进行GBDT特征变换
train_leaves = gbdt.apply(X_train)[:, :, 0]
test_leaves = gbdt.apply(X_test)[:, :, 0]

# 对GBDT生成的叶子节点特征进行One-Hot编码
encoder = OneHotEncoder()
encoder.fit(train_leaves)
train_leaves_encoded = encoder.transform(train_leaves).toarray()
test_leaves_encoded = encoder.transform(test_leaves).toarray()

# 训练自定义逻辑回归模型
lr = LogisticRegression(learning_rate=0.01, epochs=10, batch_size=32)
lr.fit(train_leaves_encoded, y_train)

# 对测试集进行预测并计算AUC
y_pred_proba = lr.predict_proba(test_leaves_encoded)
auc = roc_auc_score(y_test, y_pred_proba)
print(f'Test AUC: auc:.4f')

Pyspark

import numpy as np
from pyspark.ml import Pipeline
from pyspark.ml.classification import LogisticRegression
from pyspark.ml.feature import VectorAssembler
from pyspark.ml.regression import GBTRegressor
from pyspark.sql import SparkSession
from pyspark.sql.functions import col

# 数据生成函数
def generate_data(n_samples=10000, n_features=20, random_state=None):
    if random_state:
        np.random.seed(random_state)
    X = np.random.rand(n_samples, n_features)
    w = np.random.rand(n_features)
    b = np.random.rand()
    y = np.dot(X, w) + b
    y = 1 / (1 + np.exp(-y))
    y = np.round(y)
    return X, y

# 生成数据
n_samples = 10000
n_features = 20
X, y = generate_data(n_samples=n_samples, n_features=n_features, random_state=42)

# 创建Spark会话
spark = SparkSession.builder.appName("GBDT_LR_Example").getOrCreate()

# 将数据转换为Spark DataFrame
data = np.column_stack((X, y))
data = spark.createDataFrame(data.tolist(), ["feature_".format(i) for 根据投放页面的内容，推送相关的广告。

1、内容提供商自定义：

　　DSP预先人工定义一些网页的类型标签（“科技”、“文学”）。

　　SSP自己从中选择自己网页属于的类型。

　　投放时，根据这些人工选定的类型标签推送广告。

　　广告库中的广告则按照竞价词进行索引。

　　因此，需要通过建立类型标签与竞价词的相似度联系，才能在检索到广告。

2、页面关键字提取：

　　需要爬虫抽取网页中的内容，进行一定的内容分析，从中抽取可以精确匹配（模糊匹配）上的竞价词，然后再到广告库中检索广告。

3、网页聚类：

　　同样需要使用爬虫抽取网页中的内容，然后对网页库进行文本聚类。然后汇总同一聚簇下的网页内容，匹配竞价词。

 

三、受众定向：

1、概念：

给当前的用户流量打标签的过程。标签的形式可以是“体育——NBA”，“连衣裙——雪纺连衣裙”等，用于区分用户的兴趣点。

展示广告中，会显式或隐式的使用到这些用户标签。

显式应用标签：按照标签售卖流量，广告主可以按照人群的标签进行加价。例如，广告主的产品主要是女装，就可以对女性用户进行加价，在这一人群上争取更多的流量。

隐式应用标签：并不按照用户标签显式售卖流量，但是在系统会按照用户标签和广告的匹配程度，动态的分配流量，提高广告系统的点击率。

2、受众定向的方法：用户背景资料调查和行为定向。

（1）用户背景资料调查：

用户使用系统时，系统让用户提供的各种自身信息，如性别、年龄、学历等，

可以单独用来作为显式流量售卖，

也可以用来后续的CTR预估模型中，作为重要特征提高精度。

但这种背景信息难以定位用户对于某一类广告的偏好。如，26岁的女性是否喜欢体育。

（2）行为定向：

根据用户的历史行为，给其打上兴趣点标签。

涉及的行为包括搜索的关键字，在特定类目内容上的点击、浏览行为等。

行为定向的方法可以分为：监督的行为定向算法和非监督的算法。

①监督的行为定向：

　　使用预先定义好的兴趣点，这些兴趣点的定义跟系统中已有的广告类型有关。

　　用户对于某个兴趣点的兴趣值可通过用户对该类型的预估CTR来表达。【CTR = click/show】

②非监督的行为定向：

将用户进行向量化表示，比较常见的表达方式：

基于item的向量表达法【多用于电子商务的广告系统】，根据用户的历史浏览、点击、购买等行为日志，将用户表示成item的向量。

基于query的向量表示法【多用于搜索引擎的广告系统】，根据用户的历史query进行分词，同义词归一化等操作后，将用户表示成词的向量。

向量化后，可以将用户按照其历史行为进行聚类。

聚类完成后，就可以汇总统计同类用户对广告的CTR，选择CTR高的广告投放给用户。