Kaggle competition: Two Sigma Connect: Rental Listing Inquiries
<SOS> metric: MulticlassLoss Kaggle data source: two-sigma-connect:-rental-listing-inquiries<save_to_csv>
df_sample_sub.loc[:, 'Survived'] =(np.round(df_sub_copy.loc[:,'Survived']/ 5)).astype(int)
 display(df_sample_sub.head())
 df_sample_sub.to_csv('submission4.csv', index=False)
<save_to_csv>
import os
import sys
import operator
import numpy as np
import pandas as pd
from scipy import sparse
import xgboost as xgb
from sklearn import model_selection, preprocessing, ensemble
from sklearn.metrics import log_loss
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
sub0= pd.read_csv('submission0.csv')
 sub1 = pd.read_csv('submission1.csv')
 sub2 = pd.read_csv('submission2.csv')
 sub3 = pd.read_csv('submission3.csv')
 sub4 = pd.read_csv('submission4.csv')
 sub_vot = np.round(( sub0['Survived']+sub1['Survived']+sub2['Survived']+sub3['Survived']+sub4['Survived'])/5 ).astype(int)
 df_sample_sub.loc[:, 'Survived'] = sub_vot
df_sample_sub.to_csv('submission5.csv', index=False)
 display(df_sample_sub.head() )<import_modules>
def runXGB(train_X, train_y, test_X, test_y=None, feature_names=None, seed_val=0, num_rounds=1000):
param = {}
param['objective'] = 'multi:softprob'
param['eta'] = 0.1
param['max_depth'] = 6
param['silent'] = 1
param['num_class'] = 3
param['eval_metric'] = "mlogloss"
param['min_child_weight'] = 1
param['subsample'] = 0.7
param['colsample_bytree'] = 0.7
param['seed'] = seed_val
num_rounds = num_rounds
plst = list(param.items())
 xgtrain = xgb.DMatrix(train_X, label=train_y)
 if test_y is not None:
xgtest = xgb.DMatrix(test_X, label=test_y)
 watchlist = [(xgtrain,'train'),(xgtest, 'test')]
model = xgb.train(plst, xgtrain, num_rounds, watchlist, early_stopping_rounds=20)
 else:
xgtest = xgb.DMatrix(test_X)
 model = xgb.train(plst, xgtrain, num_rounds)
 pred_test_y = model.predict(xgtest)
 return pred_test_y, model
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename)) 
<load_from_csv>
data_path = ".. /input/"
train_file = data_path + "train.json"
test_file = data_path + "test.json"
train_df = pd.read_json(train_file)
 test_df = pd.read_json(test_file)
 print(train_df.shape)
 print(test_df.shape )
train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
 test_data = pd.read_csv('/kaggle/input/titanic/test.csv')
 train_data.head(10 )<categorify>
features_to_use = ["bathrooms", "bedrooms", "latitude", "longitude", "price"]
obj_imputer = SimpleImputer(missing_values = np.nan,strategy = 'most_frequent')
 train_data['Embarked'] = obj_imputer.fit_transform(train_data[['Embarked']])
 train_data<feature_engineering>
train_df["num_photos"] = train_df["photos"].apply(len)
 test_df["num_photos"] = test_df["photos"].apply(len)
 train_df["num_features"] = train_df["features"].apply(len)
 test_df["num_features"] = test_df["features"].apply(len)
 train_df["num_description_words"] = train_df["description"].apply(lambda x: len(x.split(" ")))
 test_df["num_description_words"] = test_df["description"].apply(lambda x: len(x.split(" ")))
 train_df["created"] = pd.to_datetime(train_df["created"])
 test_df["created"] = pd.to_datetime(test_df["created"])
 train_df["created_year"] = train_df["created"].dt.year
test_df["created_year"] = test_df["created"].dt.year
train_df["created_month"] = train_df["created"].dt.month
test_df["created_month"] = test_df["created"].dt.month
train_df["created_day"] = train_df["created"].dt.day
test_df["created_day"] = test_df["created"].dt.day
train_df["created_hour"] = train_df["created"].dt.hour
test_df["created_hour"] = test_df["created"].dt.hour
train_df['num_exclamations'] = train_df['description'].apply(lambda x: len(x.split('!')))
 test_df['num_exclamations'] = test_df['description'].apply(lambda x: len(x.split('!')))
 features_to_use.extend(["num_photos", "num_features", "num_description_words",
"created_year", "created_month", "created_day", "created_hour",
"listing_id"] )
split_one = train_data['Name'].str.split('.', n=1, expand = True)
 train_data['Name'] = split_one[0]
split_two = train_data['Name'].str.split(',', n=1, expand = True)
 train_data['Name'] = split_two[1]
train_data['Title'] = train_data['Name'].apply(set_title)
 train_data<categorify>
train_df["price_t"] = train_df["price"] / train_df["bedrooms"]
test_df["price_t"] = test_df["price"] / test_df["bedrooms"]
train_df["room_dif"] = train_df["bedrooms"] - train_df["bathrooms"]
train_df["room_sum"] = train_df["bedrooms"] + train_df["bathrooms"]
train_df["price_t1"] = train_df["price"] / train_df["room_sum"]
test_df["room_dif"] = test_df["bedrooms"] - test_df["bathrooms"]
test_df["room_sum"] = test_df["bedrooms"] + test_df["bathrooms"]
test_df["price_t1"] = test_df["price"] / test_df["room_sum"]
col_names = ['Female','Male','St_C','St_Q','St_S']
col_names.extend(( list(train_data.columns)))
 col_names.remove('Embarked')
 col_names.remove('Sex')
 ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder() , [2,7])],
remainder='passthrough')
 train_data = pd.DataFrame(data = np.array(ct.fit_transform(train_data.values)) ,
columns = col_names)
 train_data<filter>
features_to_use.extend(["price_t", 'room_dif', 'room_sum', 'price_t1'] )
missing_val_data = train_data[train_data['Age'].isnull() ]
nonmissing_val_data = train_data[train_data['Age'].notnull() ]
missing_val_data.info()<split>
categorical = ["display_address", "manager_id", "building_id", "street_address"]
for f in categorical:
if train_df[f].dtype=='object':
lbl = preprocessing.LabelEncoder()
lbl.fit(list(train_df[f].values)+ list(test_df[f].values))
train_df[f] = lbl.transform(list(train_df[f].values))
test_df[f] = lbl.transform(list(test_df[f].values))
features_to_use.append(f )
X_MD = missing_val_data.drop(['Survived','Age'], axis = 1 ).values
y_MD = missing_val_data['Survived'].values.astype('int')
 r_state = 3
md_colnames = missing_val_data.drop(['Survived','Age'], axis = 1 ).columns
X_train, X_test, y_train, y_test = train_test_split(X_MD,
y_MD,
test_size = 0.3,
random_state = r_state)
 X_train<create_dataframe>
train_df['features'] = train_df["features"].apply(lambda x: " ".join(["_".join(i.split(" ")) for i in x]))
test_df['features'] = test_df["features"].apply(lambda x: " ".join(["_".join(i.split(" ")) for i in x]))
print(train_df["features"].head())
 tfidf = CountVectorizer(stop_words='english', max_features=200)
 tr_sparse = tfidf.fit_transform(train_df["features"])
 te_sparse = tfidf.transform(test_df["features"] )
pd.DataFrame(X_train )<normalization>
train_X = sparse.hstack([train_df[features_to_use], tr_sparse] ).tocsr()
test_X = sparse.hstack([test_df[features_to_use], te_sparse] ).tocsr()
target_num_map = {'high':0, 'medium':1, 'low':2}
train_y = np.array(train_df['interest_level'].apply(lambda x: target_num_map[x]))
print(train_X.shape, test_X.shape )
sc_MD = StandardScaler()
X_train[:, 5:] = sc_MD.fit_transform(X_train[:, 5:])
 X_test[:, 5:] = sc_MD.transform(X_test[:, 5:])
 X_train = pd.DataFrame(X_train)
 X_test = pd.DataFrame(X_test)
 print(X_train.head(3))
print(X_test.head(3))<predict_on_test>
cv_scores = []
kf = model_selection.KFold(n_splits=5, shuffle=True, random_state=2016)
 for dev_index, val_index in kf.split(range(train_X.shape[0])) :
dev_X, val_X = train_X[dev_index,:], train_X[val_index,:]
dev_y, val_y = train_y[dev_index], train_y[val_index]
preds, model = runXGB(dev_X, dev_y, val_X, val_y)
 cv_scores.append(log_loss(val_y, preds))
print(cv_scores)
 break
<train_model><EOS> 
preds, model = runXGB(train_X, train_y, test_X, num_rounds=400)
 out_df = pd.DataFrame(preds)
 out_df.columns = ["high", "medium", "low"]
out_df["listing_id"] = test_df.listing_id.values
out_df.to_csv("xgb_starter3.csv", index=False )