关于人工智能:Mercari数据集机器学习深度学习视角

1次阅读

共计 23773 个字符，预计需要花费 60 分钟才能阅读完成。

作者 |Yogeeshwari S
编译 |VK
起源 |Towards Data Science

我很快乐与大家分享我的机器学习和深度学习教训，同时咱们将在一个 Kaggle 比赛失去解决方案。学习过程的剖析也是十分直观，具备娱乐性和挑战性。心愿这个博客最终能给读者一些有用的学习帮忙。

目录

  1. 业务问题
  2. 误差度量
  3. 机器学习和深度学习在咱们的问题中的利用
  4. 数据起源
  5. 探索性数据分析 -EDA
  6. 现有办法
  7. 材料筹备
  8. 模型阐明
  9. 后果
  10. 我对改善 RMSLE 的尝试
  11. 将来的工作
  12. GitHub 存储库
  13. 参考援用

1. 业务问题

Mercari 是一家在日本和美国经营的电子商务公司，其次要产品是 Mercari marketplace 的应用程序。人们能够应用智能手机轻松地发售或购买物品。

应用程序的用户能够自由选择价格，同时列出商品。然而，这里的危险更高，因为如果价格表与市场价格相比过高或过低，消费者和客户都会处于亏损状态。上述问题的解决方案是主动举荐商品价格，因而，最大的社区购物应用程序心愿向卖家提供价格倡议。

目前的问题是预测任何给定产品的价格，这阐明这是一个回归问题。训练数据中的特色包含物品的train_id, name, item_condition_id, category_name, brand_name, price, shipping, item_description。

除了指标变量价格之外，咱们在测试数据中领有所有其余特色。这些特色不仅是离散的和间断的，而且蕴含卖家提供的商品的文字描述。例如，女性配饰产品的文字说明如下：

咱们能够看到，这两种产品的售价不同，第一种售价 16 美元，第二种售价 9 美元。

因而，这里的挑战是，咱们须要建设一个模型，依据上图所示的形容，以及产品名称、品牌名称、商品情况等，来预测产品的正确价格。

2. 误差度量

这个问题的误差度量是均方根对数误差（RMSLE）。请参阅此博客以理解无关度量的更多信息

https://medium.com/analytics-…

度量计算公式如下图所示：

RMSLE 计算代码如下：

def rmsle_compute(y_true, y_pred):
    #https://www.kaggle.com/gspmoreira/cnn-glove-single-model-private-lb-0-41117-35th
    assert len(y_true) == len(y_pred)
    score = np.sqrt(np.mean(np.power(np.log1p(y_pred) - np.log1p(y_true), 2)))
    return score

3. 机器学习和深度学习在咱们的问题中的利用

在这个人工智能（AI）时代，当咱们想到 AI 的时候，有两个风行词别离是机器学习和深度学习。咱们发现人工智能无处不在，它们当初是人类生存的一部分。无论是通勤（例如出租车预订）、医疗诊断、集体助理（如 Siri、Alexa）、欺诈检测、立功侦察、在线客户反对、产品举荐、主动驾驶汽车，等等。利用先进的机器学习和深度学习算法，任何类型的预测问题都能够解决。

咱们的问题是独特的，因为它是一个基于自然语言解决（NLP）的回归工作。NLP 的第一步是将文本示意为数字，行将文本转换为数字向量示意，以结构回归函数。

解决价格预测问题的一种办法是利用向量化技术，如 TF-IDF、BoW，并构建固定大小的稠密向量示意，这些示意将被经典的机器学习算法（例如简略线性回归器、基于树的回归器等）应用。

另一种办法是应用深层 NLP 体系结构（例如 CNN、LSTM、GRU 或它们的组合），这些体系结构能够独立学习特色，能够失去密集向量。在以后的剖析中，咱们正在钻研这两种办法。

4. 数据起源

这个剖析的数据集来自 Kaggle，一个风行的在线社区或者数据科学家的数据平台。

理解数据

训练集由 140 多万件产品组成，第二阶段测试集由 340 多万件产品组成。

列出训练 / 测试数据中的字段名：

  • train_id 或者test_id — 列表的惟一 id
  • name — 卖方提供的产品名称。请留神，为防止数据透露，此字段中的价格被删除并示意为[rm]
  • item_condition_id — 这里卖家提供物品条件
  • category_name — 每个物品的类别列表
  • brand_name — 每个商品所属的相应品牌
  • price — 这是咱们的指标变量，以美元示意（不在测试集中)
  • shipping — 1，如果运费由卖方领取，否则为 0
  • item_description — 此处给出了每个物品的形容，价格被删除并示意为[rm]

以下数据的局部截图：

5. 探索性数据分析 -EDA

EDA 是数据迷信过程中的一个重要步骤，是一种统计办法，通常应用可视化办法从数据集中取得更多的见解。在深入研究 EDA 之前，让咱们疾速查看数据以理解更多信息。上面是查看空值的代码段：

print(train.isnull().sum())

从下面的输入中，咱们发现三列，即类别名称 (category name)、品牌名称(brand name) 和物品形容 (item description) 携带空值。其中，品牌名称蕴含了很多缺失的值（~632k）。列类别名称蕴含~6.3k 个空值，而物品形容只有 4 个空值。让咱们稍后在创立模型时再解决它们，当初咱们一一深入研究 EDA 个性。

5.1 类别名称的单变量剖析

训练数据集中共有 1287 个类别。上面是用于计数的代码段：

category_count = train['category_name'].value_counts()

类别计数图如下所示：

下面的条形图显示了呈现频率最高的 10 个类别。人们会留神到，女装在所有群体中占据着制高点。

每个类别名称由 3 个子局部组成，用“/”分隔，并有主类别 / 子类别 1 / 子类别 2 名称。重要的是要将它们离开，并将它们作为新的特色蕴含进来，这样咱们的模型就能做出更好的预测。

划分类别

在咱们的剖析中，咱们应用以下函数将每个类别的名称划分为主类别、子类别 1、子类别 2。

def split_categories(category):
    '''函数在数据集中划分类别列并创立 3 个新列:'main_category','sub_cat_1','sub_cat_2''''
    try:
      sub_cat_1,sub_cat_2,sub_cat_3 = category.split("/")
      return sub_cat_1,sub_cat_2,sub_cat_3
    except:
      return ("No label","No label","No label")

def create_split_categories(data):
    '''
    应用 split_categories 函数创立 3 个新列的函数
    : 'main_category','sub_cat_1','sub_cat_2'
    '''
    #https://medium.com/analytics-vidhya/mercari-price-suggestion-challenge-a-machine-learning-regression-case-study-9d776d5293a0
    data['main_category'],data['sub_cat_1'],data['sub_cat_2']=zip(*data['category_name'].\
                                                                  apply(lambda x: split_categories(x)))

此外，应用上面的代码行计算三列中每个列中的类别数：

main_category_count_te = test['main_category'].value_counts()
sub_1_count_te = test['sub_cat_1'].value_counts()
sub_2_count_te = test['sub_cat_2'].value_counts()

上述分析表明，训练数据中有 11 个次要类别，这些类别又分为 114 个子类别（子类别 1），这些子类别又被进一步调配到 865 个特定类别（子类别 2）。绘制类别的代码如下所示：

def plot_categories(category,title):
  '''这个函数承受一个类别和题目作为输出，并绘制条形图。'''
  #https://seaborn.pydata.org/generated/seaborn.barplot.html
  sns.set(style="darkgrid")
  sns.barplot(x=category[:10].values, y=category[:10].index)
  plt.title(title)
  plt.xlabel('Counts', fontsize=12)
  plt.show()
#https://www.datacamp.com/community/tutorials/categorical-data

plot_categories(category_count,"Frequency Distribution of top 10 categories")

拆分后该类别每列前 10 项的条形图如下：

5.2 品牌名称的单变量剖析

共有 4807 个品牌，其中最常呈现的前 10 个品牌如下图所示：

绘图代码在这里：

#https://www.datacamp.com/community/tutorials/categorical-data
sns.barplot(x=brand_count[:10].values, y=brand_count[:10].index)
plt.title('Frequency Distribution of top 10 brand names')
plt.xlabel('Counts', fontsize=12)
plt.show()

值得注意的是 PINK 和 NIKE 品牌，紧随其后的是维多利亚的机密。

5.3 价格单变量剖析

因为价格是数值的，所以咱们应用 describe()函数来查看摘要。上面是代码片段：

train.price.describe()

任何产品的最高价格为 2009 美元，最低价格为 0。还应留神的是，75% 的产品价格低于 29 美元，50% 的产品价格低于 17 美元，而 25% 的产品价格低于 10 美元。平均价格区间为 26.7 美元。

价格变量散布

指标的散布

plt.title("Distribution of Price variable")
plt.xlabel("Price(USD)")
plt.ylabel("No. of products")
plt.hist(train['price'],bins=30)

价格特色遵循右偏散布，如上图所示。正如这里所探讨的，因为散布的另一侧的点，歪斜散布会导致较高的均方误差（MSE）值，如果数据是正态分布，则 MSE 就不会那么大。

因而，对 price 特色进行 log 转换是不可避免的，如果数据是正态分布的，那么模型的性能也会更好（参见这里）。这是通过以下代码片段实现的：

def log_price(price):
    return np.log1p(price)

下图为对数转换后的价格变量图。

5.4 物品形容的单变量剖析

咱们正在绘制词云以理解形容中常见的单词。对应的代码段，图如下：

word_counter = Counter(train['item_description'])
most_common_words = word_counter.most_common(500)

#https://www.geeksforgeeks.org/generating-word-cloud-python/
# 创立并生成一个词云图像:
stopwords = get_stop_words('en')
#https://github.com/Alir3z4/python-stop-words/issues/19
stopwords.extend(['rm'])
wordcloud = WordCloud(stopwords=stopwords,background_color="white").generate(str(most_common_words))

# 显示生成的图像:
plt.figure(figsize=(10,15))
plt.imshow(wordcloud, interpolation='bilinear')
plt.title("Word cloud generated from the item_descriptions\n")
plt.axis("off")
plt.show()

从下面的单词 cloud 中，咱们能够留神到在咱们的 item_description 中经常出现的单词。

形容的字数

独自的文本形容可能是这个问题（参考）的一个重要特色，即对于机器学习模型，并且将有助于嵌入深度学习模型的过程。

train['description_wc'] = [len(str(i).split()) for i in train['item_description']]

为了进一步钻研该特色，咱们绘制了如下所示的箱线图和分布图，上面是代码：

箱线图
sns.boxplot(train['description_wc'],orient='v')
plt.title("Box plot of description word count")
plt.xlabel("item_description")
plt.ylabel("No. of words")
plt.show()

咱们能够留神到，大多数形容蕴含大概少于 40 个单词。

分布图
plt.figure(figsize=(10,3))
sns.distplot(train['description_wc'], hist=False)
plt.title('Plot of the word count for each item description')
plt.xlabel('Number of words in each description')
plt.show()

形容字数的密度图是右偏的。

统计数据摘要

Summary stats 表明 item_description 的最小长度为 1，而最大长度为 245。均匀长度约为 25 个单词。多数形容比拟长，而大多数形容蕴含不到 40 个单词，正如咱们在箱线图中看到的那样。

5.5 物品条件的单变量剖析

离散特色item_condition_id 的范畴是 1 到 5。该特色具备程序性，1 的物品是“最好的”，条件 5 的物品是“最差的”。item_condition_id 的条形图如下所示：

大多数待售商品状况良好，如上图所示。因而，条件 1 的物品较高，其次是条件 3 和 2，而条件 4 和 5 的物品较低。

5.6 双变量剖析

理解指标变量与其余特色的关联类型将有助于特色工程。因而，将价格变量与其余两个变量进行比拟。

价格与运费

和平常一样，图表有助于咱们更好地了解事物。代码和绘图如下所示：

#https://seaborn.pydata.org/generated/seaborn.boxplot.html

ax = sns.boxplot(x=train['shipping'],y=train['log_price'],palette="Set3",hue=train['shipping'])
handles, _ = ax.get_legend_handles_labels()
ax.legend(handles, ["seller pays", "Buyer pays"])
plt.title('Price distribution', fontsize=15)
plt.show()

咱们能够察看到，当商品价格较高时，卖方领取运费，反之亦然。

价格与形容长度

咱们下面所做的两个变量的绘图。

plt.scatter(train['description_wc'],train['price'],alpha=0.4)
plt.title("Price Vs Description length")
plt.xlabel("Description length")
plt.ylabel("Price(USD)")
plt.show()

值得注意的是，形容长度较短的商品价格往往高于形容长度较长的商品。

6. 现有办法

有一些博客和论文曾经应用简略的机器学习或深度学习办法提出了解决方案。咱们将简要介绍其中一些：

MLP

Pawel 和 Konstantin 以他们惊人的解决方案博得了这场较量。他们应用了一种基于前馈神经网络的办法，即一种简略的 MLP，它能够无效地解决稠密特色。

他们所执行的一些预处理技巧包含对分类列进行一次 one-hot 编码、应用 PorterStemmer 进行词干剖析、BoW-1,2-grams（带和不带 TF-IDF）、将不同字段（如名称、品牌名称和物品形容）串联到单个字段中。他们的最终得分是 0.37：https://www.kaggle.com/lopuhi…

CNN

在本钻研中，作者应用了 CNN 架构，联合 max-pooling，别离对名称和物品形容进行向量化。他应用预训练好的 GloVE 向量进行词嵌入，嵌入是在名称和物品形容中失去的。一些有用的技巧是在最初一个全连贯层之前应用跳跃连贯并且进行一些离散特色的连贯，以及应用了词嵌入的均匀池层。作者通过一个繁多的深度学习模型获得了 0.41 的惊人问题：https://www.kaggle.com/gspmor…

LGBM + Ridge

在这里，作者利用了一个基于树的梯度晋升框架 LightGBM，以实现更快的训练和更高的效率。该钻研还应用了一种简略、疾速的岭回归模型进行训练。一些特色技术包含：应用 CountVectorizer 对 name 和 category_name 列进行向量化，TfidfVectorizer 用于 item_description，dummy 变量创立用于 item_condition_id 和 shipping_id，以及 LabelBinarizer 用于品牌名。两个模型合二为一后，作者失去了 0.44 分：https://www.kaggle.com/tunguz…

GRU+2 Ridge

在这项钻研中，作者应用 RNN、Ridge 和 RidgeCV 构建了一个关联模型，其 RMSLE 约为 0.427。这里利用的一些有用的技巧包含应用 GRU 层实现文本特色，为 RNN 训练采纳早停策略，在两个 epoch 应用小批量大小，以及用于岭回归模型的超过 300k 个特色：https://www.kaggle.com/valkli…

7. 数据筹备

清理数据

依据这一参考资料，Mercari 网站上的最低价格为 3 美元。因而，在咱们的训练数据中，咱们保留价格高于 3 美元的物品。上面显示的是雷同的代码段：

#https://www.kaggle.com/valkling/mercari-rnn-2ridge-models-with-notes-0-42755
train = train.drop(train[(train.price < 3.0)].index)

解决空值 / 缺失值

从 EDA 中，咱们晓得 3 列，即 category_name, brand_name, 和item_description 蕴含空值。因而，咱们用适当的值来代替它们。咱们应用以下函数执行此操作：

def fill_nan(dataset):
  '''函数填充各列中的 NaN 值'''
  dataset["item_description"].fillna("No description yet",inplace=True)
  dataset["brand_name"].fillna("missing",inplace=True)
  dataset["category_name"].fillna("missing",inplace=True)

训练测试集拆分

在咱们的剖析中，价格是指标变量 y。基于误差函数来评估回归模型的拟合度是很重要的，咱们须要对 y 进行察看和预测。训练数据分为训练集和测试集。

对于根本线性回归模型，测试集蕴含 10% 的数据，对于深度学习模型，测试集蕴含总数据的 20%。

缩放指标变量

指标变量的标准化是应用 sklearn 的 StandardScaler 函数。预处理如下图所示：

global y_scalar
y_scalar = StandardScaler()
y_train = y_scalar.fit_transform(log_price(X_train['price']).values.reshape(-1, 1))
y_test = y_scalar.transform(log_price(X_test['price']).values.reshape(-1, 1))

因为咱们的指标变量是应用上述函数进行标准化的，所以在计算误差度量之前，将预测进行逆变换是很重要的。这是通过应用以下函数来实现的：

def scale_back(x):
    '''函数对缩放值进行逆变换'''
    x= np.expm1(y_scalar.inverse_transform(x.reshape(-1,1))[:,0])
    return x

8. 模型阐明

让咱们具体介绍机器学习和深度学习管道。

8.1 机器学习管道

在这一剖析中，自然语言解决的概念，如 BoW，TFIDF 等被用来向量化文本的机器学习回归模型。

构建特色

在执行 EDA 时，咱们增加了四个新特色，即通过拆分列 category 生成三个新列，并从 item_description 中增加文本形容的字数。另外，咱们依据名称文本的长度再创立一个列。所以，咱们有五个新特色。

咱们的数据集包含离散特色、数字特色和文本特色。必须对离散特色进行编码，并将文本特征向量化，以创立模型应用的特色矩阵。

离散特色编码

咱们应用 sci 工具包中的 CountVectorizer 函数对离散特色（如 category_name, main_category,sub_cat_1,sub_cat_2,brand_name）进行 one-hot 编码，并应用 get_dummies() 函数对shipping_id 和item_condition_id 进行编码。其代码如下：

def one_hot_encode(train,test):
    '''函数对离散列进行 one-hot 编码'''
    vectorizer = CountVectorizer(token_pattern='.+')
    
    vectorizer = vectorizer.fit(train['category_name'].values) # 只在训练数据上拟合
    column_cat = vectorizer.transform(test['category_name'].values)

    #向量化 main_category 列
    vectorizer = vectorizer.fit(train['main_category'].values) # 只在训练数据上拟合
    column_mc = vectorizer.transform(test['main_category'].values)
    
    #向量化 sub_cat_1 列
    vectorizer = vectorizer.fit(train['sub_cat_1'].values) # 只在训练数据上拟合
    column_sb1 = vectorizer.transform(test['sub_cat_1'].values)
    
    #向量化 sub_cat_2 列
    vectorizer = vectorizer.fit(train['sub_cat_2'].values) # 只在训练数据上拟合
    column_sb2 = vectorizer.transform(test['sub_cat_2'].values)

    #向量化 brand 列
    vectorizer = vectorizer.fit(train['brand_name'].astype(str)) # 只在训练数据上拟合
    brand_encodes = vectorizer.transform(test['brand_name'].astype(str))
   
    print("created OHE columns for main_category,sub_cat_1,sub_cat_2\n")
    print(column_cat.shape)
    print(column_mc.shape)
    print(column_sb1.shape)
    print(column_sb2.shape)
    print(brand_encodes.shape)
    print("="*100)
    return column_cat,column_mc,column_sb1,column_sb2,brand_encodes

def get_dummies_item_id_shipping(df):
    df['item_condition_id'] = df["item_condition_id"].astype("category")
    df['shipping'] = df["shipping"].astype("category")
    item_id_shipping = csr_matrix(pd.get_dummies(df[['item_condition_id', 'shipping']],\
                                                      sparse=True).values)
    return item_id_shipping
文本特征向量化

咱们别离应用 BoW（用 uni- 和 bi-grams）和 TFIDF（用 uni-、bi- 和 tri-grams）对文本特色名称和条目形容进行编码。其函数如下：

def vectorizer(train,test,column,no_of_features,n_range,vector_type):
    '''函数应用 TFIDF/BoW 对文本进行向量化'''
    if str(vector_type) == 'bow':
        vectorizer = CountVectorizer(ngram_range=n_range,max_features=no_of_features).fit(train[column])  #拟合
    else:
        vectorizer = TfidfVectorizer(ngram_range=n_range, max_features=no_of_features).fit(train[column]) # 只在训练数据上拟合
    
    # 咱们应用 vectorizer 将文本转换为矢量
    transformed_text = vectorizer.transform(tqdm(test[column]))
    ###############################
    print("After vectorizations")
    print(transformed_text.shape)
    print("="*100)
    return transformed_text

应用上述函数的代码如下：

X_train_bow_name = vectorizer(X_train,X_train,'name',100000,(1,2),'bow')
X_test_bow_name = vectorizer(X_train,X_test,'name',100000,(1,2),'bow')
X_train_tfidf_desc = vectorizer(X_train,X_train,'item_description',100000,(1,3),'tfidf')
X_test_tfidf_desc = vectorizer(X_train,X_test,'item_description',100000,(1,3),'tfidf')
特色矩阵

最初的矩阵是通过将所有编码特色（包含离散特色和文本特色）以及两个数字特色（即文本形容的字数和名称）串联起来生成的。参考代码如下：

x_train_set = hstack((X_train_bow_name,X_train_tfidf_desc,tr_cat,X_train['wc_name'].values.reshape(-1,1),X_train['wc_desc'].values.reshape(-1,1))).tocsr()
x_test_set = hstack((X_test_bow_name,X_test_tfidf_desc,te_cat,X_test['wc_name'].values.reshape(-1,1),X_test['wc_desc'].values.reshape(-1,1))).tocsr()

最终生成的矩阵蕴含 206k 多个特色。事实上，这有很多特色。

首次抉择模型

为这个问题抉择一个适合的算法可能是一项艰巨的工作，尤其是对初学者来说。

咱们学习依据数据维度、线性度、训练工夫、问题类型等来抉择算法，如这里所探讨的。

在咱们的剖析中，咱们首先试验简略的线性模型，如线性回归，反对向量回归，对于这两个模型，咱们抉择了来自 scikit-learn 的 SGDRegressor。接下来，咱们训练岭回归。

咱们应用以下函数应用 GridSearchCV 超参数调整所有模型的参数：

def hyperparameter_tuning_random(x,y,model_estimator,param_dict,cv_no):
    start = time.time()
    hyper_tuned = GridSearchCV(estimator = model_estimator, param_grid = param_dict,\
                                    return_train_score=True, scoring = 'neg_mean_squared_error',\
                                    cv = cv_no, \
                                    verbose=2, n_jobs = -1)
    hyper_tuned.fit(x,y)
    print("\n######################################################################\n")
    print ('Time taken for hyperparameter tuning is {} sec\n'.format(time.time()-start))
    print('The best parameters_: {}'.format(hyper_tuned.best_params_))
    return hyper_tuned.best_params_
线性回归

线性回归的目标是缩小预测与理论数据之间的误差。咱们应用带有“squared_loss”和超参数调整的 SGDregressor 训练简略线性回归模型。上面显示了代码：

# 超参数调优
parameters = {'alpha':[10**x for x in range(-10, 7)],
              }
model_lr_reg = SGDRegressor(loss = "squared_loss",fit_intercept=False,l1_ratio=0.6)
best_parameters_lr = hyperparameter_tuning_random(x_train_set,y_train,model_lr_reg,parameters,3)

model_lr_best_param = SGDRegressor(loss = "squared_loss",alpha = best_parameters_lr['alpha'],\
                                   fit_intercept=False)
model_lr_best_param.fit(x_train_set,y_train)
y_train_pred = model_lr_best_param.predict(x_train_set)
y_test_pred = model_lr_best_param.predict(x_test_set)

在咱们的测试数据中，这个简略的模型得出了最佳 α =0.001 的 RMSLE 为 0.513。

SVR：

反对向量回归（SVR）是指用不超过 ε 的值来预测偏离理论数据的函数。咱们应用 SGDRegressor 训练一个 SVR，“epsilon_unsensitive”作为损失，alphas 作为超参数。依据咱们的测试数据，该模型产生了 α =0.0001 的 RMSLE 为 0.632。在咱们的例子中，简略的线性回归比反对向量机的性能要好得多。SVR 代码如下：

# 超参数调优
parameters_svr = {'alpha':[10**x for x in range(-4, 4)]}
model_svr = SGDRegressor(loss = "epsilon_insensitive",fit_intercept=False)
best_parameters_svr = hyperparameter_tuning_random(x_train_set,y_train,model_svr,parameters_svr,3)

model_svr_best_param = SGDRegressor(loss = "epsilon_insensitive",alpha = 0.0001,\
                                    fit_intercept=False)
model_svr_best_param.fit(x_train_set,y_train[:,0])
y_train_pred_svr = model_svr_best_param.predict(x_train_set)
y_test_pred_svr = model_svr_best_param.predict(x_test_set)
岭回归

岭回归是线性回归的远亲，通过 L2 范数给出一些正则化来避免适度拟合。咱们在线性模型下应用 scikit-learn 的 Ridge 失去了很好的拟合，α=6.0 的 RMSLE 为 0.490。上面是具备超参数调整的 Ridge 模型代码：

# 超参数调优
parameters_ridge = {'alpha':[0.0001,0.001,0.01,0.1,1.0,2.0,4.0,5.0,6.0]}
model_ridge = Ridge(
    solver='auto', fit_intercept=True,
    max_iter=100, normalize=False, tol=0.05, random_state = 1,
)
rs_ridge = hyperparameter_tuning_random(x_train_set,y_train,model_ridge,parameters_ridge,3)

ridge_model = Ridge(
    solver='auto', fit_intercept=True,
    max_iter=100, normalize=False, tol=0.05, alpha=6.0,random_state = 1,
)
ridge_model.fit(x_train_set, y_train)
RidgeCV

它是一个穿插验证预计器，能够主动抉择最佳超参数。换言之，具备内置穿插验证的岭回归。对于咱们的问题，这比 Ridge 体现得更好，咱们构建了 RidgeCV 模型，依据咱们的测试数据，alpha6.0 的 RMSLE 为 0.442。代码如下：

from sklearn.linear_model import RidgeCV
print("Fitting Ridge model on training examples...")
ridge_modelCV = RidgeCV(fit_intercept=True, alphas=[6.0],
    normalize=False, cv = 2, scoring='neg_mean_squared_error',
)
ridge_modelCV.fit(x_train_set1, y_train)
preds_ridgeCV = ridge_modelCV.predict(x_test_set1)

咱们能够察看到 RidgeCV 体现得最好。为了进一步提高分数，咱们正在摸索应用深度学习来解决这个问题

8.2 深度学习

递归神经网络（RNN）善于解决序列数据信息。咱们应用门控递归单元（GRU），它是一种新型的 RNN，训练速度更快。

从 GRU 中，咱们在 name, item_description 列获取文本特征向量，对于其余类别字段，咱们应用嵌入后再展平向量。所有这些独特形成了咱们的深度学习模型的 80 维特征向量。

嵌入

除了训练测试的划分，深度学习（DL）管道的数据筹备遵循与 ML 管道雷同的例程。如前所述，DL 管道须要密集向量，而神经网络嵌入是将离散变量示意为密集向量的无效办法

标识化和填充

嵌入层要求输出是整数编码的。因而，咱们应用 Tokenizer API 对文本数据进行编码，上面是代码片段：

def tokenize_text(train,test,column):
    #参考 AAIC 课程
    global t
    t = Tokenizer()
    t.fit_on_texts(train[column].str.lower())
    vocab_size = len(t.word_index) + 1
    #对文档进行整数编码
    encoded_text_tr = t.texts_to_sequences(train[column].str.lower())
    encoded_text_te = t.texts_to_sequences(test[column].str.lower())
    return encoded_text_tr,encoded_text_te,vocab_size

标识化后的样本形容数据截图如下：

在标识化之后，咱们填充序列。名称和形容文本的长度不同，Keras 心愿输出序列的长度雷同。咱们计算超出特定范畴的数据点的百分比，以确定填充的长度。

上面显示了抉择形容文本填充长度的代码：

print("% of sequence containing len > 160 is")
len(X_train[X_train.wc_desc > 160])/X_train.shape[0]*100

从下面的图像咱们能够看到长度在 160 以上的点的百分比为 0.7，即 <1%。因而咱们用 160 填充形容文本。相似地，咱们计算 name 列，失去 10。对应的代码片段如下所示：

print("% of name containing len > 10 is")
len(X_train[X_train.wc_name > 10])/X_train.shape[0]*100

此外，咱们对离散变量进行编码，代码片段如下：

def rank_category(dataset,column_name):
    '''这个函数承受列名，并返回具备排名后类别'''
    counter = dataset[column_name].value_counts().index.values
    total = list(dataset[column_name])
    ranked_cat = {}
    for i in range(1,len(counter)+1):
        ranked_cat.update({counter[i-1] : i})
    return ranked_cat,len(counter)

def encode_ranked_category(train,test,column):
    '''这个函数调用 rank_category 函数并返回已编码的列'''
    train[column] = train[column].astype('category')
    test[column] = test[column].astype('category')
    
    cat_list = list(train[column].unique())
    ranked_cat_tr,count = rank_category(train,column)

    encoded_col_tr = []
    encoded_col_te = []

    for category in train[column]:
        encoded_col_tr.append(ranked_cat_tr[category])

    for category in test[column]:
        if category in cat_list:
            encoded_col_te.append(ranked_cat_tr[category])
        else:
            encoded_col_te.append(0)
    
    encoded_col_tr = np.asarray(encoded_col_tr)
    encoded_col_te = np.asarray(encoded_col_te)
    return encoded_col_tr,encoded_col_te,count

留神：所有的嵌入都是和模型自身一起学习的。

整个数据筹备管道以及编码、标识化和填充都由以下函数执行：

def data_gru(train,test):
    global max_length,desc_size,name_size
    encoded_brand_tr,encoded_brand_te,brand_len = encode_ranked_category(train,test,'brand_name')
    encoded_main_cat_tr,encoded_main_cat_te,main_cat_len = encode_ranked_category(train,test,'main_category')
    encoded_sub_cat_1_tr,encoded_sub_cat_1_te,sub_cat1_len = encode_ranked_category(train,test,'sub_cat_1')
    encoded_sub_cat_2_tr,encoded_sub_cat_2_te,sub_cat2_len = encode_ranked_category(train,test,'sub_cat_2')
    
    tokenized_desc_tr,tokenized_desc_te,desc_size = tokenize_text(train,test,'item_description')
     
    tokenized_name_tr,tokenized_name_te,name_size = tokenize_text(train,test,'name')
      
    max_length = 160
    desc_tr_padded = pad_sequences(tokenized_desc_tr, maxlen=max_length, padding='post')
    desc_te_padded = pad_sequences(tokenized_desc_te, maxlen=max_length, padding='post')
    del tokenized_desc_tr,tokenized_desc_te

    name_tr_padded = pad_sequences(tokenized_name_tr, maxlen=10, padding='post')
    name_te_padded = pad_sequences(tokenized_name_te, maxlen=10, padding='post')
    del tokenized_name_tr,tokenized_name_te

    gc.collect()

    train_inputs = [name_tr_padded,desc_tr_padded,encoded_brand_tr.reshape(-1,1),\
                    encoded_main_cat_tr.reshape(-1,1),encoded_sub_cat_1_tr.reshape(-1,1),\
                    encoded_sub_cat_2_tr.reshape(-1,1),train['shipping'],\
                    train['item_condition_id'],train['wc_desc'],\
                    train['wc_name']]
    test_inputs = [name_te_padded,desc_te_padded,encoded_brand_te.reshape(-1,1),\
                    encoded_main_cat_te.reshape(-1,1),encoded_sub_cat_1_te.reshape(-1,1),\
                    encoded_sub_cat_2_te.reshape(-1,1),test['shipping'],\
                    test['item_condition_id'],test['wc_desc'],\
                    test['wc_name']]
    
    item_condition_counter = train['item_condition_id'].value_counts().index.values

    list_var = [brand_len,main_cat_len,sub_cat1_len,sub_cat2_len,len(item_condition_counter)]
    
    return train_inputs,test_inputs,list_var

网络体系结构

对以后网络设计的剖析正是受到了这个的启发（https://www.kaggle.com/valkli…）。此外，咱们在这个框架中对 Dropout 层和 batch-normalization 层进行了试验。以下是构建咱们网络的代码片段：

def construct_GRU(train,var_list,drop_out_list):
    #name 的 GRU 输出层
    input_name =  tf.keras.layers.Input(shape=(10,), name='name')
    embedding_name = tf.keras.layers.Embedding(name_size, 20)(input_name)
    gru_name = tf.keras.layers.GRU(8)(embedding_name)
    
    #description 的 GRU 输出层
    input_desc =  tf.keras.layers.Input(shape=(max_length,), name='desc')
    embedding_desc = tf.keras.layers.Embedding(desc_size, 60)(input_desc)
    gru_desc = tf.keras.layers.GRU(16)(embedding_desc)

    #input layer for brand_name 的输出层
    input_brand =  tf.keras.layers.Input(shape=(1,), name='brand')
    embedding_brand = tf.keras.layers.Embedding(var_list[0] + 1, 10)(input_brand)
    flatten1 = tf.keras.layers.Flatten()(embedding_brand)

    #main_category 的输出层
    input_cat = tf.keras.layers.Input(shape=(1,), name='main_cat')
    Embed_cat = tf.keras.layers.Embedding(var_list[1] + 1, \
                                          10,input_length=1)(input_cat)
    flatten2 = tf.keras.layers.Flatten()(Embed_cat)

    #sub_cat_1 的输出层
    input_subcat1 = tf.keras.layers.Input(shape=(1,), name='subcat1')
    Embed_subcat1 = tf.keras.layers.Embedding(var_list[2] + 1, \
                                              10,input_length=1)(input_subcat1)
    flatten3 = tf.keras.layers.Flatten()(Embed_subcat1)

    #sub_cat_2 的输出层
    input_subcat2 = tf.keras.layers.Input(shape=(1,), name='subcat2')
    Embed_subcat2 = tf.keras.layers.Embedding(var_list[3] + 1, \
                                              10,input_length=1)(input_subcat2)
    flatten4 = tf.keras.layers.Flatten()(Embed_subcat2)

    #shipping 的输出层
    input_shipping = tf.keras.layers.Input(shape=(1,), name='shipping')
    
    #item_condition_id 的输出层
    input_item = tf.keras.layers.Input(shape=(1,), name='item_condition_id')
    Embed_item = tf.keras.layers.Embedding(var_list[4] + 1, \
                                           5,input_length=1)(input_item)
    flatten5 = tf.keras.layers.Flatten()(Embed_item)

    #数字特色的输出层
    desc_len_input = tf.keras.layers.Input(shape=(1,), name='description_length')
    desc_len_embd = tf.keras.layers.Embedding(DESC_LEN,5)(desc_len_input)
    flatten6 = tf.keras.layers.Flatten()(desc_len_embd)

    #name_len 的输出层
    name_len_input = tf.keras.layers.Input(shape=(1,), name='name_length')
    name_len_embd = tf.keras.layers.Embedding(NAME_LEN,5)(name_len_input)
    flatten7 = tf.keras.layers.Flatten()(name_len_embd)

    # 级联
    concat_layer = tf.keras.layers.concatenate(inputs=[gru_name,gru_desc,flatten1,flatten2,flatten3,flatten4,input_shipping,flatten5,\
                                                       flatten6,flatten7],name="concatenate")
    #全连贯层
    Dense_layer1 = tf.keras.layers.Dense(units=512,activation='relu',kernel_initializer='he_normal',\
                                         name="Dense_l")(concat_layer)
    dropout_1 = tf.keras.layers.Dropout(drop_out_list[0],name='dropout_1')(Dense_layer1)
    batch_n1 = tf.keras.layers.BatchNormalization()(dropout_1)
    
    Dense_layer2 = tf.keras.layers.Dense(units=128,activation='relu',kernel_initializer='he_normal',\
                                         name="Dense_2")(batch_n1)
    dropout_2 = tf.keras.layers.Dropout(drop_out_list[1],name='dropout_2')(Dense_layer2)
    batch_n2 = tf.keras.layers.BatchNormalization()(dropout_2)

    Dense_layer3 = tf.keras.layers.Dense(units=128,activation='relu',kernel_initializer='he_normal',\
                                         name="Dense_3")(batch_n2)
    dropout_3 = tf.keras.layers.Dropout(drop_out_list[2],name='dropout_3')(Dense_layer3)

    Dense_layer4 = tf.keras.layers.Dense(units=64,activation='relu',kernel_initializer='he_normal',\
                                         name="Dense_4")(dropout_3)
    dropout_4 = tf.keras.layers.Dropout(drop_out_list[3],name='dropout_4')(Dense_layer4)
    
    #输入层
    final_output = tf.keras.layers.Dense(units=1,activation='linear',name='output_layer')(dropout_4)

    model = tf.keras.Model(inputs=[input_name,input_desc,input_brand,input_cat,input_subcat1,input_subcat2,\
                                   input_shipping,input_item,desc_len_input,name_len_input],
                           outputs=[final_output])
    #咱们指定了模型的输出和输入
    print(model.summary())
    img_path = "GRU_model_2_lr.png"
    plot_model(model, to_file=img_path, show_shapes=True, show_layer_names=True) 
    return model

上面是咱们的网络：

深度学习模型

共训练了四个不同 Dropout 和学习率的模型。每个网络由四个 Dropout 层组成，对于每一层，咱们尝试对所有模型应用不同的 Dropout 率（无关详细信息，请参阅后果）。

训练

对于训练模型 1 和模型 2，咱们应用具备默认学习率的 Adam 优化器。此外，这些模型被训练为 3 个 epoch，batch 量大小加倍。模型 1 和模型 2 的试验数据的 RMSLE 别离为 0.436 和 0.441。模型训练阐明如下：

模型 3 和 4 应用 Adam 优化器和预约学习率进行训练，batch 大小为 1024 个。对于 epoch 1 和 2，学习率为 0.005，对于最初一个 epoch，咱们将其升高到 0.001。模型 4 的训练如下：

模型均匀集成

模型均匀是一种升高神经网络高方差的集成学习技术。在以后的剖析中，咱们对在不同条件下训练的模型进行集成，这些模型的正则化水平不同。每一款模型的训练工夫约为 30 至 35 分钟。思考到训练工夫，咱们只蕴含了两个模型。因而，在四个模型中，创立了两个模型组，即一个来自模型 1 和模型 2，实现后 RMSLE 0.433，另一个来自模型 3 和 4，RMSLE 为 0.429

集成模型 1 和 2 的代码如下所示：

#https://machinelearningmastery.com/model-averaging-ensemble-for-deep-learning-neural-networks/
y_hats = np.array([preds_m1_te,te_preds_m2]) #making an array out of all the predictions
# 均匀集成
mean_preds = np.mean(y_hats, axis=0)
print("RMSLE on test: {}".format(rmsle_compute(X_test['price'],scale_back(mean_preds))))

咱们察看到模型 3 和 4 的集成体现最好。

最终模型

为了取得 Kaggle 的最终分数，咱们当初在 Kaggle 中进行训练。咱们建设了两个模型雷同的模型模型 3 和 4 进行拆卸。上面展现的是在 Kaggle 训练过的模型的截图：

对这两个模型的均匀模型在咱们的最终测试数据（蕴含约 340 万个产品）中产生 0.428 的 Kaggle 分数。因而，咱们的得分排名前 10%。

9. 后果

以下是模型输入的摘要截图：

机器学习管道的输入：

深度学习管道的输入：

集成模型的输入

Kaggle 提交分数：

10. 改善 RMSLE 的尝试

进步咱们得分的策略如下：

  • 不去除停用词：这个问题的一个要害是删除停用词会影响 RMSLE 分数。保留停用词能够进步分数。
  • 思考到更多的文本特色用于模型构建：咱们总共失去 206k 个特色，其中包含仅从文本数据中提取的 200k 个特色。在这个问题中，更加器重文本信息能够进步分数。
  • bigram 和 Tri-gram：在 NLP 中，如果咱们打算在向量化过程中增加一些语义，通常会蕴含 n -gram，如 bigram、Tri-gram 等。
  • 依据价格过滤数据：Mercari 不容许公布低于 3 美元的商品。因而，那些产品价格低于 3 美元的是谬误的。删除它们将有助于模型的性能更好。
  • 小批量和少 epoch 的模型训练：应用 1024 的 batch 和更好的学习率调度程序进步了分数
  • 整合两个神经网络模型：这一策略是目前研究所独有的，它将领先者的得分推得更高。咱们通过训练两个神经网络模型并建设它们的集成来进行预测剖析。

11. 将来工作

能够通过摸索以下选项来进步分数：

  1. 应用多层感知器是解决这一问题的罕用办法
  2. 利用 CNN 与 RNN 联合解决文本数据
  3. 增加更多 GRU 层或进一步微调

这些是咱们随后将要探讨的一些可能性。

12.GitHub 存储库

请参考我的 GitHub 存储库查看残缺代码:https://github.com/syogeeshwa…

13. 参考援用

  • https://github.com/pjankiewic…
  • https://www.kaggle.com/valkli…
  • https://medium.com/analytics-…
  • https://medium.com/analytics-…
  • https://machinelearningmaster…
  • https://machinelearningmaster…
  • https://medium.com/unstructur…
  • https://www.appliedaicourse.c…

原文链接：https://towardsdatascience.co…

欢送关注磐创 AI 博客站：
http://panchuang.net/

sklearn 机器学习中文官网文档：
http://sklearn123.com/

欢送关注磐创博客资源汇总站：
http://docs.panchuang.net/

正文完
人工智能
发表至： 人工智能
2020-09-15
 0
关于人工智能:神经网络激活函数
关于人工智能:爬虫程序部署后常见问题整理
关于人工智能:快讯-整数智能携手格拉斯哥大学举办AI圆桌分享会
关于人工智能:只能用于文本与图像数据No看TabTransformer对结构化业务数据精准建模

站内搜索

-「」