Mercari資料集——機器學習&深度學習視角

阿新 • • 發佈：2020-09-15

作者|Yogeeshwari S
編譯|VK
來源|Towards Data Science

我很高興與大家分享我的機器學習和深度學習經驗，同時我們將在一個Kaggle競賽得到解決方案。學習過程的分析也是非常直觀，具有娛樂性和挑戰性。希望這個部落格最終能給讀者一些有用的學習幫助。

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-vidhya/root-mean-square-log-error-rmse-vs-rmlse-935c6cc1802a

度量計算公式如下圖所示：

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/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-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/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

下面是我們的網路：

深度學習模型

共訓練了四個不同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.未來工作

可以通過探索以下選項來提高分數：

使用多層感知器是解決這一問題的常用方法
利用CNN與RNN結合處理文字資料
新增更多GRU層或進一步微調

這些是我們隨後將要探討的一些可能性。

12.GitHub儲存庫

請參考我的GitHub儲存庫檢視完整程式碼:https://github.com/syogeeshwari/Mercari_price_prediction

13.參考引用

原文連結：https://towardsdatascience.com/pricing-objects-in-mercari-machine-learning-deep-learning-perspectives-6aa80514b2c8

歡迎關注磐創AI部落格站：
http://panchuang.net/

sklearn機器學習中文官方文件：
http://sklearn123.com/

歡迎關注磐創部落格資源彙總站：
http://docs.panchuang.net/