请选择 进入手机版 | 继续访问电脑版
 找回密码
 立即注册
搜索

Mercari数据集——机器学习&深度学习视角

目录

    业务成绩误差度量机器学习和深度学习在我们的成绩中的运用数据来源探求性数据分析-EDA现有方法材料预备模型阐明结果我对改善RMSLE的尝试将来的工作GitHub存储库参考援用

Mercari数据集——机器学习&深度学习视角-1.jpg


1.业务成绩

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

运用程序的用户可以自在选择价格,同时列出商品。但是,这里的风险更高,由于假如价格表与市场价格相比过高或过低,消费者和客户都会处于盈余形状。上述成绩的处理方案是自动引荐商品价格,因此,最大的社区购物运用程序希望向卖家提供价格建议。

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

除了目的变量价格之外,我们在测试数据中拥有一切其他特征。这些特征不只是团圆的和延续的,而且包含卖家提供的商品的文字描画。例如,女性配饰产品的文字阐明如下:

Mercari数据集——机器学习&深度学习视角-2.jpg



我们可以看到,这两种产品的售价不同,第一种售价16美元,第二种售价9美元。

因此,这里的应战是,我们需求建立一个模型,根据上图所示的描画,以及产品称号、品牌称号、商品状况等,来预测产品的正确价格。
2.误差度量

这个成绩的误差度量是均方根对数误差(RMSLE)。请参阅此博客以了解有关度量的更多信息

https://medium.com/analytics-vidhya/root-mean-square-log-error-rmse-vs-rmlse-935c6cc1802a

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

Mercari数据集——机器学习&深度学习视角-3.jpg



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 score3.机器学习和深度学习在我们的成绩中的运用

在这个人工智能(AI)时代,当我们想到AI的时分,有两个盛行词分别是机器学习和深度学习。我们发现人工智能无处不在,它们如今是人类生活的一部分。无论是通勤(例如出租车预订)、医疗诊断、个人助理(如Siri、Alexa)、欺诈检测、犯罪侦查、在线客户支持、产品引荐、自动驾驶汽车,等等。应用先进的机器学习和深度学习算法,任何类型的预测成绩都可以处理。

我们的成绩是独特的,由于它是一个基于自然言语处理(NLP)的回归义务。NLP的第一步是将文本表示为数字,即将文本转换为数字向量表示,以构造回归函数。

Mercari数据集——机器学习&深度学习视角-4.jpg



处理价格预测成绩的一种方法是应用向量化技术,如TF-IDF、BoW,并构建固定大小的稀疏向量表示,这些表示将被经典的机器学习算法(例如简单线性回归器、基于树的回归器等)运用。

另一种方法是运用深层NLP体系结构(例如CNN、LSTM、GRU或它们的组合),这些体系结构可以独立学习特征,可以得到密集向量。在当前的分析中,我们正在研讨这两种方法。
4.数据来源

这个分析的数据集来自Kaggle,一个盛行的在线社区或者数据迷信家的数据平台。

Mercari数据集——机器学习&深度学习视角-5.jpg


了解数据

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

列出训练/测试数据中的字段名:
    train_id 或者test_id — 列表的独一idname — 卖方提供的产品称号。请留意,为避免数据走漏,此字段中的价格被删除并表示为[rm]item_condition_id — 这里卖家提供物品条件category_name — 每个物品的类别列表brand_name — 每个商品所属的相应品牌price — 这是我们的目的变量,以美元表示(不在测试集中)shipping — 1,假如运费由卖方支付,否则为0item_description — 此处给出了每个物品的描画,价格被删除并表示为[rm]

以下数据的部分截图:

Mercari数据集——机器学习&深度学习视角-6.jpg


5.探求性数据分析-EDA

EDA是数据迷信过程中的一个重要步骤,是一种统计方法,通常运用可视化方法从数据集中获得更多的见解。在深化研讨EDA之前,让我们疾速查看数据以了解更多信息。下面是检查空值的代码段:
print(train.isnull().sum())
Mercari数据集——机器学习&深度学习视角-7.jpg



从下面的输入中,我们发现三列,即类别称号(category name)、品牌称号(brand name)和物品描画(item description)携带空值。其中,品牌称号包含了很多缺失的值(~632k)。列类别称号包含~6.3k个空值,而物品描画只要4个空值。让我们稍后在创建模型时再处理它们,如今我们逐一深化研讨EDA特性。
5.1 类别称号的单变量分析

训练数据集中共有1287个类别。下面是用于计数的代码段:
category_count = train['category_name'].value_counts()
Mercari数据集——机器学习&深度学习视角-8.jpg



类别计数图如下所示:

Mercari数据集——机器学习&深度学习视角-9.jpg



下面的条形图显示了出现频率最高的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-dataplot_categories(category_count,"Frequency Distribution of top 10 categories")
拆分后该类别每列前10项的条形图如下:

Mercari数据集——机器学习&深度学习视角-10.jpg



Mercari数据集——机器学习&深度学习视角-11.jpg



Mercari数据集——机器学习&深度学习视角-12.jpg


5.2品牌称号的单变量分析

共有4807个品牌,其中最常出现的前10个品牌如下图所示:

Mercari数据集——机器学习&深度学习视角-13.jpg



绘图代码在这里:
#https://www.datacamp.com/community/tutorials/categorical-datasns.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()
Mercari数据集——机器学习&深度学习视角-14.jpg



任何产品的最高价格为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)
Mercari数据集——机器学习&深度学习视角-15.jpg



价格特征遵照右偏分布,如上图所示。正如这里所讨论的,由于分布的另一侧的点,倾斜分布会导致较高的均方误差(MSE)值,假如数据是正态分布,则MSE就不会那么大。

因此,对price特征停止log转换是不可避免的,假如数据是正态分布的,那么模型的功能也会更好(参见这里)。这是经过以下代码片段完成的:
def log_price(price):    return np.log1p(price)
下图为对数转换后的价格变量图。

Mercari数据集——机器学习&深度学习视角-16.jpg


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/19stopwords.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()
Mercari数据集——机器学习&深度学习视角-17.jpg



从下面的单词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()
Mercari数据集——机器学习&深度学习视角-18.jpg



我们可以留意到,大多数描画包含大约少于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()
Mercari数据集——机器学习&深度学习视角-19.jpg



描画字数的密度图是右偏的。
统计数据摘要


Mercari数据集——机器学习&深度学习视角-20.jpg



Summary stats表明item_description的最小长度为1,而最大长度为245。平均长度约为25个单词。多数描画比较长,而大多数描画包含不到40个单词,正如我们在箱线图中看到的那样。
5.5物品条件的单变量分析

团圆特征item_condition_id 的范围是1到5。该特征具有顺序性,1的物品是“最好的”,条件5的物品是“最差的”。item_condition_id的条形图如下所示:

Mercari数据集——机器学习&深度学习视角-21.jpg



大多数待售商品状况良好,如上图所示。因此,条件1的物品较高,其次是条件3和2,而条件4和5的物品较低。
5.6双变量分析

了解目的变量与其他特征的关联类型将有助于特征工程。因此,将价格变量与其他两个变量停止比较。
价格与运费

和往常一样,图表有助于我们更好地了解事物。代码和绘图如下所示:
#https://seaborn.pydata.org/generated/seaborn.boxplot.htmlax = 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()
Mercari数据集——机器学习&深度学习视角-22.jpg



我们可以观察到,当商品价格较高时,卖方支付运费,反之亦然。
价格与描画长度

我们下面所做的两个变量的绘图。
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()
Mercari数据集——机器学习&深度学习视角-23.jpg



值得留意的是,描画长度较短的商品价格往往高于描画长度较长的商品。
6.现有方法

有一些博客和论文曾经运用简单的机器学习或深度学习方法提出了处理方案。我们将简要引见其中一些:
MLP

Pawel和Konstantin以他们惊人的处理方案博得了这场比赛。他们运用了一种基于前馈神经网络的方法,即一种简单的MLP,它可以有效地处理稀疏特征。

他们所执行的一些预处理技巧包括对分类列停止一次one-hot编码、运用PorterStemmer停止词干分析、BoW-1,2-grams(带和不带TF-IDF)、将不同字段(如称号、品牌称号和物品描画)串联到单个字段中。他们的最终得分是0.37:https://www.kaggle.com/lopuhin/mercari-golf-0-3875-cv-in-75-loc-1900-s
CNN

在本研讨中,作者运用了CNN架构,结合max-pooling,分别对称号和物品描画停止向量化。他运用预训练好的GloVE向量停止词嵌入,嵌入是在称号和物品描画中得到的。一些有用的技巧是在最后一个全衔接层之前运用腾跃衔接并且停止一些团圆特征的衔接,以及运用了词嵌入的平均池层。作者经过一个单一的深度学习模型获得了0.41的惊人成绩:https://www.kaggle.com/gspmoreira/cnn-glove-single-model-private-lb-0-41117-35th
LGBM + Ridge

在这里,作者运用了一个基于树的梯度提升框架LightGBM,以完成更快的训练和更高的效率。该研讨还运用了一种简单、疾速的岭回归模型停止训练。一些特征技术包括:运用CountVectorizer对name和category_name列停止向量化,TfidfVectorizer用于item_description,dummy 变量创建用于item_condition_id和shipping_id,以及LabelBinarizer用于品牌名。两个模型合二为一后,作者得到了0.44分:https://www.kaggle.com/tunguz/more-effective-ridge-lgbm-script-lb-0-44823
GRU+2 Ridge

在这项研讨中,作者运用RNN、Ridge和RidgeCV构建了一个关联模型,其RMSLE约为0.427。这里运用的一些有用的技巧包括运用GRU层完成文本特征,为RNN训练采用早停策略,在两个epoch运用小批量大小,以及用于岭回归模型的超过300k个特征:https://www.kaggle.com/valkling/mercari-rnn-2ridge-models-with-notes-0-42755#RNN-Model
7.数据预备

清算数据

根据这一参考材料,Mercari网站上的最低价格为3美元。因此,在我们的训练数据中,我们保留价格高于3美元的物品。下面显示的是相反的代码段:
#https://www.kaggle.com/valkling/mercari-rnn-2ridge-models-with-notes-0-42755train = 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_scalary_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 x8.模型阐明

让我们详细引见机器学习和深度学习管道。
8.1机器学习管道


Mercari数据集——机器学习&深度学习视角-24.jpg



在这一分析中,自然言语处理的概念,如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_iditem_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_encodesdef 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多个特征。理想上,这有很多特征。

Mercari数据集——机器学习&深度学习视角-25.jpg


初次选择模型

为这个成绩选择一个合适的算法能够是一项艰巨的义务,尤其是对初学者来说。

Mercari数据集——机器学习&深度学习视角-26.jpg



我们学习根据数据维度、线性度、训练工夫、成绩类型等来选择算法,如这里所讨论的。

在我们的分析中,我们首先实验简单的线性模型,如线性回归,支持向量回归,对于这两个模型,我们选择了来自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 RidgeCVprint("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维特征向量。

Mercari数据集——机器学习&深度学习视角-27.jpg


嵌入

除了训练测试的划分,深度学习(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
标识化后的样本描画数据截图如下:

Mercari数据集——机器学习&深度学习视角-28.jpg



在标识化之后,我们填充序列。称号和描画文本的长度不同,Keras希望输入序列的长度相反。我们计算超出特定范围的数据点的百分比,以确定填充的长度。

下面显示了选择描画文本填充长度的代码:
print("% of sequence containing len > 160 is")len(X_train[X_train.wc_desc > 160])/X_train.shape[0]*100
Mercari数据集——机器学习&深度学习视角-29.jpg



从下面的图像我们可以看到长度在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
Mercari数据集——机器学习&深度学习视角-30.jpg



此外,我们对团圆变量停止编码,代码片段如下:
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/valkling/mercari-rnn-2ridge-models-with-notes-0-42755#RNN-Model)。此外,我们在这个框架中对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
下面是我们的网络:

Mercari数据集——机器学习&深度学习视角-31.jpg


深度学习模型

共训练了四个不同Dropout和学习率的模型。每个网络由四个Dropout层组成,对于每一层,我们尝试对一切模型运用不同的Dropout率(有关详细信息,请参阅结果)。
训练

对于训练模型1和模型2,我们使用具有默许学习率的Adam优化器。此外,这些模型被训练为3个epoch,batch量大小加倍。模型1和模型2的实验数据的RMSLE分别为0.436和0.441。模型训练阐明如下:

Mercari数据集——机器学习&深度学习视角-32.jpg



模型3和4运用Adam优化器和预定学习率停止训练,batch大小为1024个。对于epoch 1和2,学习率为0.005,对于最后一个epoch,我们将其降低到0.001。模型4的训练如下:

Mercari数据集——机器学习&深度学习视角-33.jpg


模型平均集成

模型平均是一种降低神经网络高方差的集成学习技术。在当前的分析中,我们对在不同条件下训练的模型停止集成,这些模型的正则化程度不同。每一款模型的训练工夫约为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训练过的模型的截图:

Mercari数据集——机器学习&深度学习视角-34.jpg



Mercari数据集——机器学习&深度学习视角-35.jpg



对这两个模型的平均模型在我们的最终测试数据(包含约340万个产品)中产生0.428的Kaggle分数。因此,我们的得分排名前10%。

Mercari数据集——机器学习&深度学习视角-36.jpg


9.结果

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

机器学习管道的输入

Mercari数据集——机器学习&深度学习视角-37.jpg



深度学习管道的输入:

Mercari数据集——机器学习&深度学习视角-38.jpg



集成模型的输入

Mercari数据集——机器学习&深度学习视角-39.jpg



Kaggle提交分数:

Mercari数据集——机器学习&深度学习视角-40.jpg


10.改善RMSLE的尝试

提高我们得分的策略如下:
    不去除停用词:这个成绩的一个关键是删除停用词会影响RMSLE分数。保留停用词可以提高分数。思索到更多的文本特征用于模型构建:我们总共得到206k个特征,其中包括仅从文本数据中提取的200k个特征。在这个成绩中,愈加注重文本信息可以提高分数。bigram和Tri-gram:在NLP中,假如我们打算在向量化过程中添加一些语义,通常会包含n-gram,如bigram、Tri-gram等。根据价格过滤数据:Mercari不允许发布低于3美元的商品。因此,那些产品价格低于3美元的是错误的。删除它们将有助于模型的功能更好。小批量和少epoch的模型训练:运用1024的batch和更好的学习率调度程序提高了分数整合两个神经网络模型:这一策略是目前研讨所独有的,它将抢先者的得分推得更高。我们经过训练两个神经网络模型并建立它们的集成来停止预测分析。
11.将来工作

可以经过探求以下选项来提高分数:
    运用多层感知器是处理这一成绩的常用方法应用CNN与RNN结合处理文本数据添加更多GRU层或进一步微调

这些是我们随后将要讨论的一些能够性。
12.GitHub存储库

请参考GitHub查看残缺代码:https://github.com/syogeeshwari/Mercari_price_prediction
13.参考援用

    https://github.com/pjankiewicz/mercarisolution/blob/master/presentation/build/yandex.pdfhttps://www.kaggle.com/valkling/mercari-rnn-2ridge-models-with-notes-0-42755https://medium.com/analytics-vidhya/mercari-price-suggestion-challenge-66500ac1f88ahttps://medium.com/analytics-vidhya/mercari-price-suggestion-challenge-a-machine-learning-regression-case-study-9d776d5293a0https://machinelearningmastery.com/ensemble-methods-for-deep-learning-neural-networks/https://machinelearningmastery.com/model-averaging-ensemble-for-deep-learning-neural-networks/https://medium.com/unstructured/how-i-lost-a-silver-medal-in-kaggles-mercari-price-suggestion-challenge-using-cnns-and-tensorflow-4013660fcdedhttps://www.appliedaicourse.com/course/11/Applied-Machine-learning-course
回复

使用道具 举报

大神点评3

为毛老子总也抢不到沙发?!!
回复

使用道具 举报

不后悔_太难 2020-9-17 13:16:43 来自手机 显示全部楼层
顶起顶起顶起
回复

使用道具 举报

愣着干嘛,鼓掌啊
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册