Конкуренция Kaggle по продвинутому прогнозированию цен на жилье

## Count of top 20 Fields of train data having null values
train_data.isnull().sum().sort_values(ascending=False).iloc[:20]
## Count of top 35 Fields of test data having null values
test_data.isnull().sum().sort_values(ascending=False).iloc[:35]

Теперь для нулевых значений я следую некоторым правилам, основанным на моем опыте:

1. Если у вас большие данные, вы, вероятно, можете удалить строки с нулевыми значениями, но помните, что если какой-то прогнозируемый класс встречается гораздо реже, то вместо удаления этой строки попробуйте заменить нулевые значения, как определено на шаге 4. Это step обычно не используется, так как может привести к удалению некоторых важных данных.
2. Если вы видите значение атрибута (столбца) с нулевыми значениями, и если некоторые атрибуты имеют большую долю нулевых значений, чем фактические данные, вы можете выбрать соотношение и удалить те атрибуты, которые имеют отношение нулевых значений к общему количеству данных больше, чем определенное соотношение (например, если вы решите 0,7 как соотношение, и у вас есть 1000 записей, из которых 800 имеют нулевые значения, чем вы можете удалить атрибут). (см. 3.ipynb ниже)
3. Вы также можете создать классификатор для прогнозирования этих нулевых значений, широко используемый метод KNN. Но это очень утомительный процесс.
4. Возможно, вы думаете, как заменить нулевые значения, и для этого мы изучаем типы данных атрибутов, если атрибут - int или float, тогда мы можем заменить нулевые значения средним значением атрибута.

dataset[col].fillna(dataset[col].mean(),inplace=True)

иначе, если это объект, мы можем заменить его наиболее часто используемым. Теперь это можно сделать разными способами. Ниже я перечисляю 2 способа. Оба дают одинаковый результат.

i) из sklearn_pandas.CategoricalImputer

ii) путем замены на режим (см. 4.ipynb ниже)

dataset[col].fillna(dataset[col].mode()[0],inplace=True)

Мы можем получить общее количество нулевых значений, используя приведенный ниже код.

## Top 5 Fields of test data having null values
test_data.isnull().sum().sort_values(ascending=False).iloc[:5]
## Top 5 Fields of test data having null values
train_data.isnull().sum().sort_values(ascending=False).iloc[:5]

Затем я обнаружил, что есть много атрибутов, которые имеют 3 класса в обучающих данных, в то время как более или менее трех классов в тестовых данных. Это может привести к несбалансированной классификации, так как в конечном итоге мы разделим класс на одну горячую форму кодировщика. Функция category_onehot_multcols используется для создания одного горячего кодировщика всех категориальных переменных, присутствующих в наборе данных, указанном в качестве аргумента. Также позаботились о ловушке-пустышке.

total= pd.concat([train_data.drop(['SalePrice'],axis=1),test_data]
,axis=0)

## func to convert into one hot encoder form
def category_onehot_multcols(multcolumns):
    df_final=total
    i=0
    for fields in multcolumns:
        
        print(fields)
        df1=pd.get_dummies(total[fields],drop_first=True)
        
        total.drop([fields],axis=1,inplace=True)
        if i==0:
            df_final=df1.copy()
        else:
            df_final=pd.concat([df_final,df1],axis=1)
        i=i+1
       
    df_final=pd.concat([total,df_final],axis=1) 
    return df_final
## passing our total Dataframe for one hot encoder
total=category_onehot_multcols(column)
save_cols=total.columns

Теперь, когда все категориальные значения находятся в форме int, мы можем выполнить самый важный шаг, который вы всегда должны помнить, - это масштабирование данных с помощью StandardScaler из из sklearn .preprocessing import StandardScaler. Это помогает в преобразовании данных из -1 в 1, и я пробовал прогнозировать с помощью StandardScaler и без него и обнаружил существенную разницу в результатах, поэтому я предлагаю вам обязательно использовать его в задачах регрессии.

from sklearn.preprocessing import StandardScaler
x = total.values
x = StandardScaler().fit_transform(x)
x=pd.DataFrame(x,columns=save_cols)

## naming columns to ease the operations
cols=[]
for i in range(0,233):
    name = "col"+str(i)
    cols.append(str(name))
x=pd.DataFrame(x,columns=cols)
# splitting scaled total data into train and test data
train = x.iloc[:1460]
test = x.iloc[1460:]
# getting predicting values i.e SalePrice into "y" and scaling it .. 
# separately 
y = train_data['SalePrice'].values
sc=StandardScaler()
y = pd.DataFrame(sc.fit_transform(y.reshape(-1,1)))
y.columns=['SalePrice']
train = pd.concat([train,y],axis=1)

Выбор функций

Я использовал корреляционную матрицу, чтобы увидеть, насколько атрибут коррелирует с SalePrice (который должен быть предсказан).

Коэффициенты корреляции используются в статистике, чтобы измерить, насколько сильна связь между двумя переменными. Существует несколько типов коэффициента корреляции. Корреляция Пирсона (также называемая R Пирсона) - это коэффициент корреляции, обычно используемый в линейной регрессии. Существует ограничение на использование коэффициентов корреляции, поскольку они предназначены только для непрерывных значений, а не для классов, поэтому мы фактически создали одну форму горячего кодировщика, которая преобразовала ее в непрерывную форму, чтобы мы могли применить к ней коэффициенты корреляции.

Формулы коэффициента корреляции используются, чтобы определить, насколько сильна связь между данными. Формулы возвращают значение от -1 до 1, где:

• 1 указывает на сильные положительные отношения.
• -1 указывает на сильные отрицательные отношения.
• Нулевой результат указывает на отсутствие связи.

Коэффициенты корреляции можно получить с помощью следующего кода:

train.corr().reset_index()[['index','SalePrice']]

Я взял любой атрибут, коэффициент которого больше +0,15 и меньше -0,15. Это было поэкспериментировано как от 0,6 до 0,15, так как оно показало улучшенные результаты. Также, как вы увидите, я сохранил столбцы, которые больше коррелируют с SalePrice, в столбцы, которые я буду использовать в дальнейшем.

Теперь часть выбора алгоритма регрессии для нашей постановки задачи, и вы почти закончили до этого шага, поскольку предварительная обработка данных - очень утомительный процесс, и согласно некоторым данным опроса ученые тратят 90% своего времени на предварительную обработку данные.

Списки алгоритмов, которые я использовал:

1. Искусственные нейронные сети (получили оценку ошибки 0,21339 около 4800 ранга с использованием корреляции и посредством предварительной обработки данных и с 1000 эпохами). И после игры с параметрами, то есть 760 эпох, я завершил Энн с результатом 0,18528, что было неплохо. Я заметил, что добавление выпадения в каждом слое не сработает, так как ошибка была увеличена, поэтому я добавил только один слой с выпадением, который был 1-м слоем.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import LeakyReLU,PReLU,ELU
from tensorflow.keras.layers import Dropout
# Initialising the ANN
classifier = Sequential()
# Adding dropout layer
classifier.add(Dropout(0.2))
# Adding the input layer and the first hidden layer
classifier.add(Dense(50, kernel_initializer = 'he_uniform', activation='relu',input_dim = 146))
# Adding the second hidden layer
classifier.add(Dense(25, kernel_initializer = 'he_uniform', activation='relu'))
# Adding the third hidden layer
classifier.add(Dense(50, kernel_initializer = 'he_uniform', activation='relu'))
# Adding the output layer
classifier.add(Dense(1, kernel_initializer = 'he_uniform', use_bias=True))
# Compiling the ANN
classifier.compile(loss=root_mean_squared_error, optimizer='Adamax')
# Fitting the ANN to the Training set
model_history=classifier.fit(train.values, y.values,validation_split=0.20, batch_size = 10, epochs = 760)

2. Затем я использовал Алгоритм повышения градиента, но и получил оценку 0,16394 около 3400 ранга, но после изменения параметров оценка осталась почти такой же.

from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error
regressor = GradientBoostingRegressor(
    max_depth=10,
    n_estimators=500,
    learning_rate=1.0
)
regressor.fit(X_train, y_train)
errors = [root_mean_squared_error(y_train, y_pred) for y_pred in regressor.staged_predict(X_train)]
best_n_estimators = np.argmin(errors)
best_regressor = GradientBoostingRegressor(
    max_depth=2,
    n_estimators=best_n_estimators,
    learning_rate=1.0
)
best_regressor.fit(X_train, y_train)
y_pred = best_regressor.predict(X_test)

3. Затем я использовал Random Forest Regressor и получил новый балл 0,16282, что было небольшим улучшением.

from sklearn.ensemble import RandomForestRegressor 
 
 # create regressor object 
regressor = RandomForestRegressor(n_estimators = 500, random_state = 0) 
 
# fit the regressor with x and y data 
regressor.fit(X_train, y_train)
y_pred = regressor.predict(X_test)

4. Затем я попробовал SVR (Support Vector Regressor) и PCA с 2,5,10,20 компонентами, но безуспешно. они были худшими моделями.

from sklearn.decomposition import PCA
pca = PCA(n_components=20)
principalComponents = pca.fit_transform(train[columns])
Df = pd.DataFrame(data = principalComponents, columns = [‘pc1’, ‘pc2’,’pc3',’pc4',’pc5',’pc6',’pc7',’pc8',’pc9',’pc10',’pc11', ‘pc12’,’pc13',’pc14',’pc15',’pc16',’pc17',’pc18',’pc19',’pc20'])
print(‘Explained variation per principal component: {}’.format(pca.explained_variance_ratio_))

5. Затем я попробовал XGBoost Regression и получил результат 0,14847 с 500 оценками, и это был большой скачок по сравнению с Random Forest Regressor. У меня было около 2800 очков, что также было огромным скачком по сравнению с предыдущим.

import xgboost as xgb

xg_reg = xgb.XGBRegressor(objective ='reg:linear', colsample_bytree = 0.3, learning_rate = 0.1,max_depth = 5, alpha = 10, n_estimators = 1000)

xg_reg.fit(train[columns],y)

y_pred = xg_reg.predict(test[columns])

Примерно после 20 представлений я получил оценку 0,13933 и рейтинг 2465 с 500 оценками и отсечкой значения корреляции как (+/-) 0,15. Я пробовал разные значения оценщиков, и, возможно, вы также можете попробовать другие. Также вы можете опробовать многие другие методы регрессии, такие как полиномиальная регрессия, логистическая регрессия, линейная регрессия и т. Д.

Наконец, нам нужно отправить заявку в том же формате, что и sample_submission.csv, и вот код для нее.

## as we have transformed the prediction price between -1 to 1 we 
## need to inversely transform it back to original values.
pred=pd.DataFrame(sc.inverse_transform(y_pred))
sub_df=pd.read_csv('sample_submission.csv')
datasets=pd.concat([sub_df['Id'],pred],axis=1)
datasets.columns=['Id','SalePrice']

datasets.isnull()
datasets.to_csv('sample_submission.csv',index=False)

datasets.head()

Большое спасибо за то, что прочитали сообщение, и если вы цените усилия, приложенные к публикации, непременно хлопните в ладоши.

В случае запроса или возможности улучшения, вот мой идентификатор электронной почты: [email protected], вы можете написать мне, я отвечу вам как можно скорее.

подписывайтесь на меня в Twitter: https://twitter.com/PanwalaKalp

свяжитесь со мной в LinkedIn: https://www.linkedin.com/in/kalp-panwala-72284018a

подписывайтесь на меня на Github: https://github.com/kpanwala