Kaggle competition: Two Sigma Connect: Rental Listing Inquiries
<SOS> metric: MulticlassLoss Kaggle data source: two-sigma-connect:-rental-listing-inquiries<count_missing_values>
train_df=pd.read_json('.. /input/train.json')
 test_df=pd.read_json('.. /input/test.json' )
print('Number of missing values in',m, 'examples')
 display(df_all.isnull().sum() )<drop_column>
train_df["price_t"] =train_df["price"]/train_df["bedrooms"]
test_df["price_t"] = test_df["price"]/test_df["bedrooms"]
train_df["room_sum"] = train_df["bedrooms"]+train_df["bathrooms"]
test_df["room_sum"] = test_df["bedrooms"]+test_df["bathrooms"]
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(" ")))
 features_to_use=["bathrooms", "bedrooms", "latitude", "longitude", "price","price_t","num_photos", "num_features", "num_description_words","listing_id"]
df_all.drop('Name', axis =1, inplace=True)
 df_all.drop('Ticket', axis =1, inplace=True)
 df_all.drop('PassengerId', axis=1, inplace = True)
 display(df_all )<categorify>
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.03
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
Sex = {"male": 0, "female":1}
df_all["Sex"] = df_all.Sex.map(Sex)
 df_all['Partner'] = df_all['SibSp'] + df_all['Parch']
df_all.drop(['SibSp', 'Parch'], axis=1, inplace=True)
 df_all = pd.get_dummies(df_all, columns = ['Title','Embarked'])
 display(df_all.head() )<categorify>
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 )
def logistic_regression(X, y, alpha=1e-3, num_iter=30,random_state=42):
np.random.seed(random_state)
 d, m = X.shape
K = np.max(y)+ 1
w = np.random.randn(d, K)
 def softmax(x):
s = np.exp(x)/ np.sum(np.exp(x))
return s
def one_hot(y, k):
y_one_hot = np.eye(k)[y]
return y_one_hot
def h(x, w):
p = softmax(w.T @ x)
 return p
def cost(pred, y):
c = np.sum(- one_hot(y, K ).T * np.log(pred))
return c
def grad(w, x, y):
Y = one_hot(y, K ).T
b = h(x, w)- Y
b = np.reshape(b,(-1, 1))
x = x.reshape(-1, 1)
 g = x @ np.reshape(b,(-1, 1)).T
return g
for i in range(num_iter):
id = np.random.permutation(m)
 for j in id:
gradient = grad(w, X[:, j], y[j])
 w -= alpha * gradient
return w 
<compute_test_metric>
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"] )
def ridge_classifier(X, y, lambd=1e-4):
d, m = X.shape
k = np.max(y)+ 1
w = np.linalg.inv(X @ X.T + lambd * np.eye(d)) @ X @ np.eye(k)[y]
return w<compute_test_metric>
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 )
def error(X, y, w):
m = np.shape(y)
 y_pred = w.T @ X
y_pred = np.argmax(y_pred, axis=0)
 err = np.sum(y_pred == y)/ m
return err<prepare_x_and_y>
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
<compute_train_metric><EOS> 
preds, model = runXGB(train_X, train_y, test_X, num_rounds=1000)
 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_starter2.csv", index=False )