[Pour les débutants] kaggle exercice (merucari)

Cette fois, dans le cadre de la formation, j'ai travaillé sur la dernière compétition de kaggle. J'ai essayé de le résumer brièvement.

・ Mercari Price Suggestion Challenge

À partir des informations produit de Mercari, nous prédirons le prix en utilisant la régression Ridge.

1. Préparation du module

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')

Vérifiez le nombre de données.

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

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

Combinez les données de train et de test.

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

Vérifiez les informations de base des données.

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

Examinez le numéro unique de chaque colonne de données (ne comptez pas les doublons).

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

Comme il y a beaucoup de données de caractères cette fois, nous organiserons les données en utilisant le vecteur BoW et TF-IDF.

À ce moment-là, la quantité de données pour d'autres entités codées par étiquette devient trop importante. Convertissez-le en une matrice creuse (matrice avec de nombreux 0 composants = matrice creuse) et compressez-la.

# 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))

Enfin, combinez ces données et convertissez-les en données matricielles éparses.

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

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

Étant donné que y (données de prix) présente des variations dans les données, cela affecte les résultats des prévisions. La normalisation est bien, mais cette fois je vais faire une conversion logarithmique.

De plus, la conversion est effectuée avec $ \ log (y + 1) $ afin qu'il n'y ait pas de problème même si la valeur de y est 0.

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)

Cette fois, nous évaluerons à l'aide de l'indice RMSE (légèrement amélioré pour la concurrence).

J'ai converti y logarithmiquement avant la modélisation, je dois donc l'annuler après la modélisation. Le traitement est effectué dans la formule d'évaluation.

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

À partir de ce qui précède, nous avons pu prédire et évaluer le prix à partir des informations produit de Mercari.

Cette fois, j'ai compilé un article pour les débutants. Si vous le trouvez utile, je vous serais reconnaissant si vous pouviez faire des LGBT.

Merci pour la lecture.