qscqesze
Published on 2017-09-02 11:31 in 暂未分类 with qscqesze

# 机器学习算法讲堂（一） 十分钟入门机器学习算法竞赛

import pandas as pd
import numpy as np

file = pd.read_csv('./data/train.csv', nrows = 1000000)

print(file.shape)

file = file.dropna(how = 'any', axis = 'rows')
#Clean dataset
def clean_df(df):
return df[(df.fare_amount > 0) &
# (df.pickup_longitude > -80) & (df.pickup_longitude < -70) &
# (df.pickup_latitude > 35) & (df.pickup_latitude < 45) &
# (df.dropoff_longitude > -80) & (df.dropoff_longitude < -70) &
# (df.dropoff_latitude > 35) & (df.dropoff_latitude < 45) &
(df.passenger_count > 0) & (df.passenger_count < 10)]
file = clean_df(file)
print(len(file))
print(file.shape)

def sphere_dist(pickup_lat, pickup_lon, dropoff_lat, dropoff_lon):
"""
Return distance along great radius between pickup and dropoff coordinates.
"""
R_earth = 6371
pickup_lat, pickup_lon, dropoff_lat, dropoff_lon = map(np.radians,
[pickup_lat, pickup_lon,
dropoff_lat, dropoff_lon])
#Compute distances along lat, lon dimensions
dlat = dropoff_lat - pickup_lat
dlon = dropoff_lon - pickup_lon

#Compute haversine distance
a = np.sin(dlat/2.0)**2 + np.cos(pickup_lat) * np.cos(dropoff_lat) * np.sin(dlon/2.0)**2

return 2 * R_earth * np.arcsin(np.sqrt(a))

"""
Return minumum distance from pickup or dropoff coordinates to each airport.
JFK: John F. Kennedy International Airport
EWR: Newark Liberty International Airport
LGA: LaGuardia Airport
"""
jfk_coord = (40.639722, -73.778889)
ewr_coord = (40.6925, -74.168611)
lga_coord = (40.77725, -73.872611)
Washington_Square = (40.4351,-73.5951)

pickup_lat = dataset['pickup_latitude']
dropoff_lat = dataset['dropoff_latitude']
pickup_lon = dataset['pickup_longitude']
dropoff_lon = dataset['dropoff_longitude']

pickup_jfk = sphere_dist(pickup_lat, pickup_lon, jfk_coord[0], jfk_coord[1])
dropoff_jfk = sphere_dist(jfk_coord[0], jfk_coord[1], dropoff_lat, dropoff_lon)
pickup_ewr = sphere_dist(pickup_lat, pickup_lon, ewr_coord[0], ewr_coord[1])
dropoff_ewr = sphere_dist(ewr_coord[0], ewr_coord[1], dropoff_lat, dropoff_lon)
pickup_lga = sphere_dist(pickup_lat, pickup_lon, lga_coord[0], lga_coord[1])
dropoff_lga = sphere_dist(lga_coord[0], lga_coord[1], dropoff_lat, dropoff_lon)
pickup_square = sphere_dist(pickup_lat, pickup_lon, Washington_Square[0], Washington_Square[1])
dropoff_square = sphere_dist(Washington_Square[0], Washington_Square[1], dropoff_lat, dropoff_lon)

dataset['jfk_dist'] = pd.concat([pickup_jfk, dropoff_jfk], axis=1).min(axis=1)
dataset['ewr_dist'] = pd.concat([pickup_ewr, dropoff_ewr], axis=1).min(axis=1)
dataset['lga_dist'] = pd.concat([pickup_lga, dropoff_lga], axis=1).min(axis=1)
dataset['washington_dist'] = pd.concat([pickup_square, dropoff_square], axis=1).min(axis=1)

dataset['longitude_distance'] = abs(dataset['pickup_longitude'] - dataset['dropoff_longitude'])
dataset['latitude_distance'] = abs(dataset['pickup_latitude'] - dataset['dropoff_latitude'])

# Straight distance
dataset['distance_travelled'] = (dataset['longitude_distance'] ** 2 + dataset['latitude_distance'] ** 2) ** .5
dataset['distance_travelled_sin'] = np.sin((dataset['longitude_distance'] ** 2 * dataset['latitude_distance'] ** 2) ** .5)
dataset['distance_travelled_cos'] = np.cos((dataset['longitude_distance'] ** 2 * dataset['latitude_distance'] ** 2) ** .5)
dataset['distance_travelled_sin_sqrd'] = np.sin((dataset['longitude_distance'] ** 2 * dataset['latitude_distance'] ** 2) ** .5) ** 2
dataset['distance_travelled_cos_sqrd'] = np.cos((dataset['longitude_distance'] ** 2 * dataset['latitude_distance'] ** 2) ** .5) ** 2

# dataset["fare_to_dist_ratio"] = dataset["fare_amount"] / ( dataset["distance_travelled"]+0.0001)
# dataset["fare_npassenger_to_dist_ratio"] = (dataset["fare_amount"] / dataset["passenger_count"]) /( dataset["distance_travelled"]+0.0001)

dataset['jfk'] = 0
dataset.loc[(dataset['pickup_longitude'] >= -73.7841) & (dataset['pickup_longitude'] <= -73.7721) &
(dataset['pickup_latitude'] <= 40.6613) & (dataset['pickup_latitude'] >= 40.6213),'jfk'] = 1
dataset.loc[(dataset['dropoff_longitude'] >= -73.7841) & (dataset['dropoff_longitude'] <= -73.7721) &
(dataset['dropoff_latitude'] <= 40.6613) & (dataset['dropoff_latitude'] >= 40.6213),'jfk'] = 1

dataset['lga'] = 0
dataset.loc[(dataset['pickup_longitude'] >= -73.8870) & (dataset['pickup_longitude'] <= -73.8580) &
(dataset['pickup_latitude'] <= 40.7800) & (dataset['pickup_latitude'] >= 40.7680),'lga'] = 1
dataset.loc[(dataset['dropoff_longitude'] >= -73.8870) & (dataset['dropoff_longitude'] <= -73.8580) &
(dataset['dropoff_latitude'] <= 40.7800) & (dataset['dropoff_latitude'] >= 40.7680),'lga'] = 1

dataset['ewr'] = 0
dataset.loc[(dataset['pickup_longitude'] >= -74.192) & (dataset['pickup_longitude'] <= -74.172) &
(dataset['pickup_latitude'] <= 40.708) & (dataset['pickup_latitude'] >= 40.676),'ewr'] = 1
dataset.loc[(dataset['dropoff_longitude'] >= -74.192) & (dataset['dropoff_longitude'] <= -74.172) &
(dataset['dropoff_latitude'] <= 40.708) & (dataset['dropoff_latitude'] >= 40.676),'ewr'] = 1

return dataset

#Convert to datetime format
dataset['pickup_datetime'] = pd.to_datetime(dataset['pickup_datetime'],format="%Y-%m-%d %H:%M:%S UTC")

# dataset['second'] = dataset.pickup_datetime.dt.second
dataset['hour'] = dataset.pickup_datetime.dt.hour
dataset['day'] = dataset.pickup_datetime.dt.day
dataset['month'] = dataset.pickup_datetime.dt.month
dataset['weekday'] = dataset.pickup_datetime.dt.weekday
dataset['year'] = dataset.pickup_datetime.dt.year
# dataset['all_time'] = dataset['second'] + 60*dataset['hour'] + 24*60*dataset['day']+30*24*60*dataset['month']

return dataset

file = file.drop(columns=['pickup_datetime']) #'distance_travelled_sin_sqrd','passenger_count','distance_travelled_cos_sqrd'])
file['distance'] = sphere_dist(file['pickup_latitude'], file['pickup_longitude'],
file['dropoff_latitude'] , file['dropoff_longitude'])

test_file = test_file.drop(columns=['pickup_datetime']) #, 'distance_travelled_sin_sqrd','passenger_count','distance_travelled_cos_sqrd'])

test_file['distance'] = sphere_dist(test_file['pickup_latitude'], test_file['pickup_longitude'],
test_file['dropoff_latitude'] , test_file['dropoff_longitude'])

import datetime as dt
from sklearn.model_selection import train_test_split
import xgboost as xgb
import os

train_x = file.drop(columns=['fare_amount'])
y = file['fare_amount']
new_test = test_file

from sklearn.preprocessing import LabelEncoder
for c in train_x.columns:
if train_x[c].dtype == 'datetime64[ns]' or train_x[c].dtype == 'object':
lbl = LabelEncoder()
lbl.fit(list(train_x[c].values) + list(test_file[c].values))
train_x[c] = lbl.transform(list(train_x[c].values))
test_file[c] = lbl.transform(list(test_file[c].values))
x_train,x_test,y_train,y_test = train_test_split(train_x,y,random_state=0,test_size=0.01)

'''

for x in range(0,len(x_train['pickup_datetime'])):
try:
time = ''
for time_ac in str(x_train['pickup_datetime'].loc[x]):
if time_ac <= '9' and time_ac >= '0':
time = time + time_ac
x_train['pickup_datetime'].loc[x] = time
except:
x_train['pickup_datetime'].loc[x] = 0
x_train['pickup_datetime'].astype('int64')
'''
print(x_train.dtypes)

'''

dtrain = xgb.DMatrix(x_train, y_train)
dtest = xgb.DMatrix(x_test, y_test)
eta = 0.1
max_depth = 8
subsample = 0.8
colsample_bytree = 0.8

print('XGBoost params. ETA: {}, MAX_DEPTH: {}, SUBSAMPLE: {}, COLSAMPLE_BY_TREE: {}'.format(eta, max_depth, subsample, colsample_bytree))
params = {
"objective": "reg:linear",
"booster" : "gbtree",
"eval_metric": "rmse",
"eta": eta,
"max_depth": max_depth,
"subsample": subsample,
"colsample_bytree": colsample_bytree,
"silent": 1,
"seed": 19960429
}

watchlist  = [(dtrain,'train'),(dtest,'val')]
num_round = 3000
early_stopping_rounds=50
bst = xgb.train(params, dtrain, num_round, watchlist,early_stopping_rounds=early_stopping_rounds)
'''
import lightgbm as lgb
from sklearn.model_selection import train_test_split
from sklearn import metrics
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import KFold

import matplotlib.pylab as plt

# Keep Relevant Variables..
trainshape = train_x.shape
testshape = test_file.shape

# print("\nTrain DF..")
# train = reduce_mem_usage(train)
# print("\nTest DF..")
# test_df = reduce_mem_usage(test_df)

# LGBM Dataset Formating
dtrain = lgb.Dataset(train_x, label=y, free_raw_data=False)

lgbm_params =  {
'boosting_type': 'gbdt',
'objective': 'regression',
'metric': 'rmse',
'max_depth':7,
'learning_rate':.1,
'subsample': 0.8,
'colsample_bytree': 0.8
}

folds = KFold(n_splits=5, shuffle=True, random_state=1)
fold_preds = np.zeros(testshape[0])
oof_preds = np.zeros(trainshape[0])
dtrain.construct()

# Fit 5 Folds
modelstart = time.time()
for trn_idx, val_idx in folds.split(file):
clf = lgb.train(
params=lgbm_params,
train_set=dtrain.subset(trn_idx),
valid_sets=dtrain.subset(val_idx),
num_boost_round=17000,
early_stopping_rounds=250,
verbose_eval=500
)
oof_preds[val_idx] = clf.predict(dtrain.data.iloc[val_idx])
fold_preds += clf.predict(test_file) / folds.n_splits
print(mean_squared_error(y.iloc[val_idx], oof_preds[val_idx]) ** .5)
# lgb.plot_importance(clf, max_num_features=30)

print("Model Runtime: %0.2f Minutes"%((time.time() - modelstart)/60))

import time
Ttest = xgb.DMatrix(test_file)
# ypred = bst.predict(Ttest)
ypred = fold_preds
output.to_csv('.//data//ans'+str(dt)+'.csv', index = False)