[PYTHON] [Für Anfänger] Kaggle-Übung (Merucari)

Dieses Mal habe ich im Rahmen des Trainings am vergangenen Kaggle-Wettbewerb gearbeitet. Ich habe versucht, es kurz zusammenzufassen.

・ Mercari Price Suggestion Challenge

Aus den Produktinformationen von Mercari werden wir den Preis mithilfe der Ridge-Regression vorhersagen.

1. Vorbereitung des Moduls

import numpy as np
import pandas as pd
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.preprocessing import LabelBinarizer
from scipy.sparse import csr_matrix, hstack
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_log_error

train = pd.read_csv('train.tsv', sep='\t')
test = pd.read_csv('test.tsv', sep='\t')

Überprüfen Sie die Anzahl der Daten.

print(train.shape)
print(test.shape)

# (1482535, 8)
# (693359, 7)

Zug- und Testdaten kombinieren.

all_data = pd.concat([train, test])
all_data.head()

Überprüfen Sie die grundlegenden Informationen der Daten.

all_data.info(null_counts=True)

'''
<class 'pandas.core.frame.DataFrame'>
Int64Index: 2175894 entries, 0 to 693358
Data columns (total 9 columns):
brand_name           1247687 non-null object
category_name        2166509 non-null object
item_condition_id    2175894 non-null int64
item_description     2175890 non-null object
name                 2175894 non-null object
price                1482535 non-null float64
shipping             2175894 non-null int64
test_id              693359 non-null float64
train_id             1482535 non-null float64
dtypes: float64(3), int64(2), object(4)
memory usage: 166.0+ MB
'''

Untersuchen Sie die eindeutige Anzahl der einzelnen Spaltendaten (keine Duplikate zählen).

print(all_data.brand_name.nunique())
print(all_data.category_name.nunique())
print(all_data.name.nunique())
print(all_data.item_description.nunique())

# 5289
# 1310
# 1750617
# 1862037

Da es diesmal viele Zeichendaten gibt, werden wir die Daten mit BoW-Vektor und TF-IDF anordnen.

Zu diesem Zeitpunkt wird die Datenmenge für andere kennzeichnungscodierte Features zu groß. Konvertieren Sie es in eine Sparse-Matrix (Matrix mit vielen 0 Komponenten = Sparse-Matrix) und komprimieren Sie es.

# name

cv = CountVectorizer()
name = cv.fit_transform(all_data.name)

# item_description

all_data.item_description.fillna(value='null', inplace=True)

tv = TfidfVectorizer()
item_description = tv.fit_transform(all_data.item_description)

# category_name

all_data.category_name.fillna(value='null', inplace=True)

lb = LabelBinarizer(sparse_output=True)
category_name = lb.fit_transform(all_data.category_name)

# brand_name

all_data.brand_name.fillna(value='null', inplace=True)

brand_name = lb.fit_transform(all_data.brand_name)

# item_condition_id, shipping

onehot_cols = ['item_condition_id', 'shipping']
onehot_data = csr_matrix(pd.get_dummies(all_data[onehot_cols], sparse=True))

Kombinieren Sie diese Daten schließlich und konvertieren Sie sie in spärliche Matrixdaten.

X_sparse = hstack((name, item_description, category_name, brand_name, onehot_data)).tocsr()

nrows = train.shape[0]
X = X_sparse[:nrows]

Da y (Preisdaten) Abweichungen in den Daten aufweist, wirkt sich dies auf die Prognoseergebnisse aus. Standardisierung ist in Ordnung, aber dieses Mal werde ich eine logarithmische Konvertierung durchführen.

Zusätzlich wird die Konvertierung mit $ \ log (y + 1) $ durchgeführt, so dass es kein Problem gibt, selbst wenn der Wert von y 0 ist.

y = np.log1p(train.price)
y[:5]

'''
0    2.397895
1    3.970292
2    2.397895
3    3.583519
4    3.806662
Name: price, dtype: float64
'''

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

ridge = Ridge()
ridge.fit(X_train, y_train)

'''
Ridge(alpha=1.0, copy_X=True, fit_intercept=True, max_iter=None,
   normalize=False, random_state=None, solver='auto', tol=0.001)
'''

y_pred = ridge.predict(X_test)

Dieses Mal werden wir anhand des RMSE-Index (für den Wettbewerb leicht verbessert) bewerten.

Ich habe y vor dem Modellieren logarithmisch konvertiert, daher muss ich es nach dem Modellieren rückgängig machen. Die Verarbeitung erfolgt in der Bewertungsformel.

def rmse(y_test, y_pred):
    return np.sqrt(mean_squared_log_error(np.expm1(y_test), np.expm1(y_pred)))

rmse(y_test, y_pred)

# 0.4745184301527575

Aus dem oben Gesagten konnten wir den Preis anhand der Produktinformationen von Mercari vorhersagen und bewerten.

Dieses Mal habe ich einen Artikel für Anfänger zusammengestellt. Wenn Sie es hilfreich finden, würde ich es begrüßen, wenn Sie LGBT machen könnten.

Danke fürs Lesen.