kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,729,659 | y_train_data = visit_data.loc[visit_data['visit_date']<'2017-04-01','visitors']
y_test_data = visit_data.loc[visit_data['visit_date']>='2017-04-01','visitors']
<feature_engineering> | for dataset in combine:
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
dataset['Title'] = dataset['Titl... | Titanic - Machine Learning from Disaster |
9,729,659 | train_data['visitors'] = train_data.visitors.map(pd.np.log1p)
wmean = lambda x:(( x.weight * x.visitors ).sum() / x.weight.sum())
visitors = train_data.groupby(['air_store_id', 'day_of_week', 'holiday_flg'] ).apply(wmean ).reset_index()
visitors.rename(columns={0:'visitors'}, inplace=True )<merge> | title_mapping = {'Mrs': 1, 'Miss': 2, 'Master': 3, 'Mr': 4, 'Rare': 5}
for dataset in combine:
dataset['Title'] = dataset['Title'].map(title_mapping ) | Titanic - Machine Learning from Disaster |
9,729,659 | test_data['visitors_predict'] = test_data.merge(visitors[visitors.holiday_flg==0], \
on=('air_store_id', 'day_of_week'), how='left')['visitors_y']<merge> | train_df.drop(columns=['Name'], inplace=True)
test_df.drop(columns=['Name'], inplace=True ) | Titanic - Machine Learning from Disaster |
9,729,659 | missings = test_data.visitors_predict.isnull()
test_data.loc[missings, 'visitors_predict'] = test_data[missings].merge(
visitors[['air_store_id', 'visitors']].groupby('air_store_id' ).\
mean().reset_index() , on='air_store_id', how='left')['visitors_y'].values
<feature_engineering> | gender_mapping = {'female': 1, 'male': 0}
for dataset in combine:
dataset['Sex'] = dataset['Sex'].map(gender_mapping ).astype(int ) | Titanic - Machine Learning from Disaster |
9,729,659 | test_data['visitors'] = test_data['visitors'].map(np.log1p )<filter> | for dataset in combine:
dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1
train_df.groupby('FamilySize')['Survived'].mean() | Titanic - Machine Learning from Disaster |
9,729,659 | test_data[test_data['visitors_predict'].isnull() ]<import_modules> | for dataset in combine:
dataset['IsAlone'] = 0
dataset.loc[dataset['FamilySize'] == 1, 'IsAlone'] = 1
| Titanic - Machine Learning from Disaster |
9,729,659 | import sklearn.metrics<compute_train_metric> | train_df['IsAlone'].value_counts() | Titanic - Machine Learning from Disaster |
9,729,659 | sklearn.metrics.mean_squared_error(
np.array([2.3]),np.array([3]))<compute_test_metric> | train_df.drop(columns=['SibSp', 'Parch', 'FamilySize'], inplace=True)
test_df.drop(columns=['SibSp', 'Parch', 'FamilySize'], inplace=True ) | Titanic - Machine Learning from Disaster |
9,729,659 | sklearn.metrics.mean_squared_error(\
test_data.loc[~test_data.visitors_predict.isnull() ,'visitors']
,test_data.loc[~test_data.visitors_predict.isnull() ,'visitors_predict'] )<compute_test_metric> | train_df.groupby('Embarked')['Survived'].mean() | Titanic - Machine Learning from Disaster |
9,729,659 | sklearn.metrics.mean_squared_error(\
test_data['visitors']
,test_data['visitors_predict'] )<merge> | port_mapping = {'S': 0, 'Q': 1, 'C': 2}
for dataset in combine:
dataset['Embarked'] = dataset['Embarked'].map(port_mapping)
train_df.info() | Titanic - Machine Learning from Disaster |
9,729,659 | print('prepare to merge with date_info and visitors')
sample_submission['air_store_id'] = sample_submission.id.map(lambda x: '_'.join(x.split('_')[:-1]))
sample_submission['calendar_date'] = sample_submission.id.map(lambda x: x.split('_')[2])
sample_submission.drop('visitors', axis=1, inplace=True)
sample_submission... | train_df['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
9,729,659 | dfs = { re.search('/([^/\.]*)\.csv', fn ).group(1):pd.read_csv(fn)for fn in glob.glob('.. /input/*.csv')}
print('data frames read:{}'.format(list(dfs.keys())))
print('local variables with the same names are created.')
for k, v in dfs.items() : locals() [k] = v<merge> | train_df['Embarked'].fillna(value=0, inplace=True ) | Titanic - Machine Learning from Disaster |
9,729,659 | print('holidays at weekends are not special, right?')
wkend_holidays = date_info.apply(( lambda x:(x.day_of_week=='Sunday' or x.day_of_week=='Saturday')and x.holiday_flg==1), axis=1)
date_info.loc[wkend_holidays, 'holiday_flg'] = 0
print('add decreasing weights from now')
date_info['weight'] =(( date_info.index + 1)... | train_df['Embarked'] = train_df['Embarked'].apply(lambda x: int(x)) | Titanic - Machine Learning from Disaster |
9,729,659 | ora1= sample_submission
print('split date')
ora1['year'] = ora1.calendar_date.map(lambda x:(x.split('-')[0]))
ora1['month'] = ora1.calendar_date.map(lambda x:(x.split('-')[1]))
ora1['day'] = ora1.calendar_date.map(lambda x:(x.split('-')[2]))
ora1['mhend_flg'] = ora1.day.map(lambda x: 1 if int(x)>=25 else 0)
ora1=pd.g... | test_df['Fare'].fillna(value=test_df['Fare'].median() , inplace=True ) | Titanic - Machine Learning from Disaster |
9,729,659 | missings = ora1.visitors.isnull()
test = ora1[missings].copy()
test.drop(['visitors'], axis=1, inplace=True)
test.drop(['id'], axis=1, inplace=True)
test.drop(['calendar_date'], axis=1, inplace=True)
x = ora1[-missings].copy()
y = x['visitors'].copy()
x.drop(['visitors'], axis=1, inplace=True)
x.drop(['id'], axis=1... | guess_ages = np.zeros(( 2,3))
for dataset in combine:
for i in range(0, 2):
for j in range(0, 3):
guess_df = dataset[(dataset['Sex'] == i)& \
(dataset['Pclass'] == j+1)]['Age'].dropna()
age_guess = guess_df.median()
guess_ages[i,j] = int(age_guess/0.5 + 0.5)* 0.5
for i in range(0, 2):
for j in range(0, 3):
dataset.loc... | Titanic - Machine Learning from Disaster |
9,729,659 | model = RandomForestRegressor(max_depth = 1000,
max_features =834,
min_samples_split = 20,
n_estimators = 50,
n_jobs = -1,
random_state = 0)
model.fit(x, y)
output = model.predict(test)
model.score(x, y )<save_to_csv> | for dataset in combine:
dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0
dataset.loc[(dataset['Age'] > 16)&(dataset['Age'] <= 32), 'Age'] = 1
dataset.loc[(dataset['Age'] > 32)&(dataset['Age'] <= 48), 'Age'] = 2
dataset.loc[(dataset['Age'] > 48)&(dataset['Age'] <= 64), 'Age'] = 3
dataset.loc[ dataset['Age'] > 64, 'Age']
tr... | Titanic - Machine Learning from Disaster |
9,729,659 | ora1.loc[missings,'visitors'] =output
ora1['visitors'] = ora1.visitors.map(pd.np.expm1)
sub = pd.DataFrame({ 'id': ora1['id'],
'visitors':ora1['visitors'] })
sub.to_csv('random_result.csv', float_format='%.4f', index=None)
print("done")
ora1.head()<define_variables> | train_df.drop(columns=['AgeBand'], inplace=True ) | Titanic - Machine Learning from Disaster |
9,729,659 | The first is a w<feature_engineering> | for dataset in combine:
dataset.loc[ dataset['Fare'] <= 7.91, 'Fare'] = 0
dataset.loc[(dataset['Fare'] > 7.91)&(dataset['Fare'] <= 14.454), 'Fare'] = 1
dataset.loc[(dataset['Fare'] > 14.454)&(dataset['Fare'] <= 31.0), 'Fare'] = 2
dataset.loc[(dataset['Fare'] > 31.0)&(dataset['Fare'] <= 512.329), 'Fare'] = 3
train_df.he... | Titanic - Machine Learning from Disaster |
9,729,659 | dfs = { re.search('/([^/\.]*)\.csv', fn ).group(1):pd.read_csv(fn)for fn in glob.glob('.. /input/*.csv')}
print('data frames read:{}'.format(list(dfs.keys())))
print('local variables with the same names are created.')
for k, v in dfs.items() : locals() [k] = v
print('holidays at weekends are not special, right?')
wk... | train_df.drop(columns=['FareBand'], inplace=True ) | Titanic - Machine Learning from Disaster |
9,729,659 | print('weighted mean visitors for each(air_store_id, day_of_week, holiday_flag)or(air_store_id, day_of_week)')
visit_data = air_visit_data.merge(date_info, left_on='visit_date', right_on='calendar_date', how='left')
visit_data.drop('calendar_date', axis=1, inplace=True)
visit_data['visitors'] = visit_data.visitors.m... | for dataset in combine:
dataset['Fare'] = dataset['Fare'].astype(int ) | Titanic - Machine Learning from Disaster |
9,729,659 | sample_submission2 = sample_submission.copy()<load_from_csv> | for dataset in combine:
dataset['Age*Pclass'] = dataset['Age'] * dataset['Pclass']
| Titanic - Machine Learning from Disaster |
9,729,659 | test_df = pd.read_csv('.. /input/sample_submission.csv')
test_df['store_id'], test_df['visit_date'] = test_df['id'].str[:20], test_df['id'].str[21:]
test_df.drop(['visitors'], axis=1, inplace=True)
test_df['visit_date'] = pd.to_datetime(test_df['visit_date'])
air_data = pd.read_csv('.. /input/air_visit_data.csv', pa... | y = train_df['Survived']
X = train_df.drop('Survived', axis=1)
| Titanic - Machine Learning from Disaster |
9,729,659 | new = sub_file.copy()<feature_engineering> | X_train, X_val, y_train, y_val = train_test_split(X, y ) | Titanic - Machine Learning from Disaster |
9,729,659 | new['visitors'] = sub_file['visitors']*.2 + sample_submission2['visitors']*.8<save_to_csv> | linreg = LogisticRegression(random_state=1)
linreg.fit(X_train, y_train)
| Titanic - Machine Learning from Disaster |
9,729,659 | new.to_csv("four_kernel_weighted.csv", float_format='%.4f', index=None )<import_modules> | predictions = linreg.predict(X_val)
accuracy_score(y_val, predictions)
round(linreg.score(X_train, y_train), 3), round(linreg.score(X_val, y_val), 3 ) | Titanic - Machine Learning from Disaster |
9,729,659 | import lightgbm
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import mean_absolute_error, mean_squared_error<categorify> | X_test = test_df.drop(columns=['PassengerId'] ) | Titanic - Machine Learning from Disaster |
9,729,659 | def match_normalize(match):
match = match.groupby('groupId' ).mean()
for head in match.columns.values:
if head != 'winPlacePerc':
match[head] /= match[head].max()
match = match.drop(columns=['maxPlace', 'numGroups'])
return match
def rearrange(t_order, p_orders):
flag = True
while flag:
flag = False
for p_order in p_o... | X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2)
D_train = xgb.DMatrix(X_train, label=y_train)
D_test = xgb.DMatrix(X_val, label=y_val)
clf = xgb.XGBClassifier()
parameters = {
"eta" : [0.05, 0.10, 0.16, 0.13, 0.14, 0.15,] ,
"max_depth" : [ 3, 4, 5, 6, 8, 10, 12, 15],
"min_child_weight" : [ 3, ... | Titanic - Machine Learning from Disaster |
9,729,659 | train = pd.read_csv('/kaggle/input/pubg-finish-placement-prediction/train_V2.csv' ).dropna()<groupby> | grid.best_params_ | Titanic - Machine Learning from Disaster |
9,729,659 | train = train.drop(['swimDistance', 'headshotKills', 'killPoints', 'matchDuration', 'rankPoints', 'teamKills', 'winPoints'], axis=1)
train = train.groupby('matchId')
train_groupwise = train.apply(match_normalize )<prepare_x_and_y> | param_3 = {'colsample_bytree': 0.7,
'eta': 0.14,
'gamma': 0.15,
'max_depth': 6,
'min_child_weight': 5} | Titanic - Machine Learning from Disaster |
9,729,659 | train_matchId = list(train.groups.keys())
split = train_groupwise.index.get_loc(train_matchId[round(len(train_matchId)* 0.8)] ).start
train_X = train_groupwise.drop('winPlacePerc', axis=1 ).iloc[:split]
train_Y = train_groupwise['winPlacePerc'].iloc[:split]
valid_X = train_groupwise.drop('winPlacePerc', axis=1 ).iloc[... | D_train = xgb.DMatrix(X_train, label=y_train)
D_test = xgb.DMatrix(X_val, label=y_val)
param = {
'eta': 0.1,
'max_depth': 3,
'objective': 'multi:softprob',
'num_class': 3}
steps = 20
model = xgb.train(param, D_train, steps)
preds = model.predict(D_test)
best_preds = np.asarray([np.argmax(line)for line in preds])
p... | Titanic - Machine Learning from Disaster |
9,729,659 | model = lightgbm.LGBMRegressor()
model.fit(train_X, train_Y, eval_set=(valid_X, valid_Y), eval_metric='l1' )<load_from_csv> | D_test = xgb.DMatrix(X_test)
param = {
'eta': 0.1,
'max_depth': 3,
'objective': 'multi:softprob',
'num_class': 3}
steps = 20
model = xgb.train(param, D_train, steps)
preds = model.predict(D_test ) | Titanic - Machine Learning from Disaster |
9,729,659 | test = pd.read_csv('/kaggle/input/pubg-finish-placement-prediction/test_V2.csv' )<groupby> | predictions = []
for pred in preds:
result = max(pred)
if result > 0.5:
result = 1
else:
result = 0
predictions.append(result ) | Titanic - Machine Learning from Disaster |
9,729,659 | test = test.drop(['swimDistance', 'headshotKills', 'killPoints', 'matchDuration', 'rankPoints', 'teamKills', 'winPoints'], axis=1)
test = test.groupby('matchId')
test_groupwise = test.apply(match_normalize )<predict_on_test> | output = pd.DataFrame({'PassengerId': test_df.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,578,345 | predict_groupwise = model.predict(test_groupwise )<load_from_csv> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
14,578,345 | submission = pd.read_csv('/kaggle/input/pubg-finish-placement-prediction/sample_submission_V2.csv')
submission = submission.astype({'winPlacePerc': 'float64'} )<groupby> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
14,578,345 | for test_matchId, test_indices in test.groups.items() :
loc = test_groupwise.index.get_loc(test_matchId)
groups = [index[1] for index in test_groupwise.index.values[loc]]
t_order = np.array(groups)[predict_groupwise[loc].argsort() ].tolist()
p_orders = [kill[1]['groupId'].values[kill[1]['killPlace'].values.argsort() [... | train_data.groupby('Sex' ).Survived.mean() | Titanic - Machine Learning from Disaster |
14,578,345 | submission.to_csv('submission.csv', index=False )<save_to_csv> | train_data.groupby('Pclass' ).Survived.mean() | Titanic - Machine Learning from Disaster |
14,578,345 | submission.to_csv('submission.csv', index=False )<set_options> | train_data['Age'] = train_data[['Age','Pclass']].apply(cal_age,axis=1 ) | Titanic - Machine Learning from Disaster |
14,578,345 | pd.options.display.float_format = '{:,.3f}'.format<load_from_csv> | Titanic - Machine Learning from Disaster | |
14,578,345 | train = pd.read_csv('/kaggle/input/pubg-finish-placement-prediction/train_V2.csv')
train =reduce_mem_usage(train)
test = pd.read_csv('/kaggle/input/pubg-finish-placement-prediction/test_V2.csv')
test = reduce_mem_usage(test)
print(train.shape,test.shape )<filter> | train_data.isnull() | Titanic - Machine Learning from Disaster |
14,578,345 | train[train['winPlacePerc'].isnull() ]<drop_column> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,578,345 | train.drop(2744604,inplace=True )<feature_engineering> | train_data.drop(["Name","Cabin"], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,578,345 |
mapper = lambda x: 'solo' if('solo'in x)else 'duo' if('duo' in x)or('crash'in x)else 'squad'
train['matchType'] = train['matchType'].apply(mapper)
match_type_counts_2=train.groupby('matchId')['matchType'].first().value_counts().sort_values(ascending=False )<concatenate> | train_data['Embarked'] = train_data['Embarked'].fillna(value=train_data['Embarked'].mode() [0] ) | Titanic - Machine Learning from Disaster |
14,578,345 | all_data = train.append(test, sort=False ).reset_index(drop=True)
del train, test
gc.collect()<feature_engineering> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,578,345 | match = all_data.groupby('matchId')
all_data['killsPerc'] = match['kills'].rank(pct=True ).values
all_data['killPlacePerc'] = match['killPlace'].rank(pct=True ).values
all_data['walkDistancePerc'] = match['walkDistance'].rank(pct=True ).values
all_data['walkPerc_killsPerc'] = all_data['walkDistancePerc'] / all_data['k... | train_data['Sex'] = train_data['Sex'].replace(['male', 'female'],[1,0])
train_data.rename(columns = {'Sex' : 'gender'}, inplace = True ) | Titanic - Machine Learning from Disaster |
14,578,345 | def fillInf(df, val):
numcols = df.select_dtypes(include='number' ).columns
cols = numcols[numcols != 'winPlacePerc']
df[df == np.Inf] = np.NaN
df[df == np.NINF] = np.NaN
for c in cols: df[c].fillna(val, inplace=True )<feature_engineering> | train_data['Embarked'] = train_data['Embarked'].replace(['S','C','Q'],[0,1,2])
train_data.rename(columns = {'Embarked' : 'port'}, inplace = True ) | Titanic - Machine Learning from Disaster |
14,578,345 | all_data['_healthItems'] = all_data['heals'] + all_data['boosts']
all_data['_headshotKillRate'] = all_data['headshotKills'] / all_data['kills']
all_data['_killPlaceOverMaxPlace'] = all_data['killPlace'] / all_data['maxPlace']
all_data['_killsOverWalkDistance'] = all_data['kills'] / all_data['walkDistance']<drop_column> | train_data.rename(columns = {'Pclass' : 'passenger_cls'} ) | Titanic - Machine Learning from Disaster |
14,578,345 | all_data.drop(['boosts','heals','killStreaks','DBNOs'], axis=1, inplace=True)
all_data.drop(['headshotKills','roadKills','vehicleDestroys'], axis=1, inplace=True)
all_data.drop(['rideDistance','swimDistance','matchDuration'], axis=1, inplace=True)
all_data.drop(['rankPoints','killPoints','winPoints'], axis=1, inplac... | train_data['family_members'] = train_data['SibSp'] + train_data['Parch']
train_data.drop(['SibSp', 'Parch'], axis = 1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,578,345 | match = all_data.groupby(['matchId'])
group = all_data.groupby(['matchId','groupId','matchType'])
agg_col = list(all_data.columns)
exclude_agg_col = ['Id','matchId','groupId','matchType','maxPlace','numGroups','winPlacePerc']
for c in exclude_agg_col:
agg_col.remove(c)
sum_col = ['kills','killPlace','damageDealt','... | train_data.loc[ train_data['Age'] <= 21, 'Age'] = 0
train_data.loc[(train_data['Age'] > 21)&(train_data['Age'] <= 34), 'Age'] = 1
train_data.loc[(train_data['Age'] > 34)&(train_data['Age'] <= 54), 'Age'] = 2
train_data.loc[(train_data['Age'] > 60)&(train_data['Age'] <= 75), 'Age'] = 3
train_data.loc[ train_data['Age'] ... | Titanic - Machine Learning from Disaster |
14,578,345 | minKills = all_data.sort_values(['matchId','groupId','kills','killPlace'] ).groupby(
['matchId','groupId','kills'] ).first().reset_index().copy()
for n in np.arange(4):
c = 'kills_' + str(n)+ '_Place'
nKills =(minKills['kills'] == n)
minKills.loc[nKills, c] = minKills[nKills].groupby(['matchId'])['killPlace'].rank().... | train_data.loc[ train_data['Fare'] <= 7.5, 'Fare'] = 0
train_data.loc[(train_data['Fare'] > 15)&(train_data['Fare'] <= 21.5), 'Fare'] = 1
train_data.loc[(train_data['Fare'] > 21.5)&(train_data['Age'] <= 29), 'Fare'] = 2
train_data.loc[(train_data['Fare'] > 29)&(train_data['Fare'] <= 36.5), 'Fare'] = 3
train_data.loc[ t... | Titanic - Machine Learning from Disaster |
14,578,345 |
all_data = pd.merge(all_data, match_data)
del match_data
gc.collect()
all_data['enemy.players'] = all_data['m.players'] - all_data['players']
for c in sum_col:
all_data['p.max_msum.' + c] = all_data['max.' + c] / all_data['m.sum.' + c]
all_data['p.max_mmax.' + c] = all_data['max.' + c] / all_data['m.max.' + c]
all_d... | train_data.drop(['Ticket'], axis = 1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,578,345 | match = all_data.groupby('matchId')
matchRank = match[numcols].rank(pct=True ).rename(columns=lambda s: 'rank.' + s)
all_data = reduce_mem_usage(pd.concat([all_data, matchRank], axis=1))
rank_col = matchRank.columns
del matchRank
gc.collect()
match = all_data.groupby('matchId')
matchRank = match[rank_col].max().rena... | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,578,345 | killMinorRank = all_data[['matchId','min.kills','max.killPlace']].copy()
group = killMinorRank.groupby(['matchId','min.kills'])
killMinorRank['rank.minor.maxKillPlace'] = group.rank(pct=True ).values
all_data = pd.merge(all_data, killMinorRank)
killMinorRank = all_data[['matchId','max.kills','min.killPlace']].copy()
... | test_data.drop(['Name', 'Ticket','Cabin'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
14,578,345 | constant_column = [col for col in all_data.columns if all_data[col].nunique() == 1]
all_data.drop(constant_column, axis=1, inplace=True )<feature_engineering> | test_data['Age'] = test_data[['Age','Pclass']].apply(cal_age,axis=1)
| Titanic - Machine Learning from Disaster |
14,578,345 |
all_data['matchType'] = all_data['matchType'].apply(mapper)
all_data = pd.concat([all_data, pd.get_dummies(all_data['matchType'])], axis=1)
all_data.drop(['matchType'], axis=1, inplace=True)
all_data['matchId'] = all_data['matchId'].apply(lambda x: int(x,16))
all_data['groupId'] = all_data['groupId'].apply(lambda ... | Titanic - Machine Learning from Disaster | |
14,578,345 | null_cnt = all_data.isnull().sum().sort_values()<categorify> | test_data['Fare'].fillna(value=test_data['Fare'].mean() , inplace=True ) | Titanic - Machine Learning from Disaster |
14,578,345 | cols = [col for col in all_data.columns if col not in ['Id','matchId','groupId']]
for i, t in all_data.loc[:, cols].dtypes.iteritems() :
if t == object:
all_data[i] = pd.factorize(all_data[i])[0]
all_data = reduce_mem_usage(all_data )<prepare_x_and_y> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,578,345 | X_train = all_data[all_data['winPlacePerc'].notnull() ].reset_index(drop=True)
X_test = all_data[all_data['winPlacePerc'].isnull() ].drop(['winPlacePerc'], axis=1 ).reset_index(drop=True)
del all_data
gc.collect()
Y_train = X_train.pop('winPlacePerc')
X_test_grp = X_test[['matchId','groupId']].copy()
train_matchId =... | test_data['Sex'] = test_data['Sex'].replace(['male', 'female'],[1,0])
test_data.rename(columns = {'Sex' : 'gender'}, inplace = True ) | Titanic - Machine Learning from Disaster |
14,578,345 | params={'learning_rate': 0.05,
'objective':'mae',
'metric':'mae',
'num_leaves': 128,
'verbose': 1,
'random_state':42,
'bagging_fraction': 0.7,
'feature_fraction': 0.7
}
reg = lgb.LGBMRegressor(**params, n_estimators=10000)
reg.fit(X_train, Y_train)
pred = reg.predict(X_test, num_iteration=reg.best_iteration_ )<concat... | test_data['Embarked'] = test_data['Embarked'].replace(['S','C','Q'],[0,1,2])
test_data.rename(columns = {'Embarked' : 'port'}, inplace = True ) | Titanic - Machine Learning from Disaster |
14,578,345 | X_test_grp['_nofit.winPlacePerc'] = pred
group = X_test_grp.groupby(['matchId'])
X_test_grp['winPlacePerc'] = pred
X_test_grp['_rank.winPlacePerc'] = group['winPlacePerc'].rank(method='min')
X_test = pd.concat([X_test, X_test_grp], axis=1 )<feature_engineering> | test_data.rename(columns = {'Pclass' : 'passenger cls'} ) | Titanic - Machine Learning from Disaster |
14,578,345 | fullgroup =(X_test['numGroups'] == X_test['maxPlace'])
subset = X_test.loc[fullgroup]
X_test.loc[fullgroup, 'winPlacePerc'] =(subset['_rank.winPlacePerc'].values - 1)/(subset['maxPlace'].values - 1)
subset = X_test.loc[~fullgroup]
gap = 1.0 /(subset['maxPlace'].values - 1)
new_perc = np.around(subset['winPlacePerc']... | test_data['family_members'] = test_data['SibSp'] + test_data['Parch']
test_data.drop(['SibSp', 'Parch'], axis = 1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,578,345 | X_test.loc[X_test['maxPlace'] == 0, 'winPlacePerc'] = 0
X_test.loc[X_test['maxPlace'] == 1, 'winPlacePerc'] = 1
X_test.loc[(X_test['maxPlace'] > 1)&(X_test['numGroups'] == 1), 'winPlacePerc'] = 0<save_to_csv> | test_data.loc[ test_data['Age'] <= 21, 'Age'] = 0
test_data.loc[(test_data['Age'] > 21)&(test_data['Age'] <= 34), 'Age'] = 1
test_data.loc[(test_data['Age'] > 34)&(test_data['Age'] <= 54), 'Age'] = 2
test_data.loc[(test_data['Age'] > 60)&(test_data['Age'] <= 75), 'Age'] = 3
test_data.loc[ test_data['Age'] > 75, 'Age'] ... | Titanic - Machine Learning from Disaster |
14,578,345 | test = pd.read_csv('/kaggle/input/pubg-finish-placement-prediction/test_V2.csv')
test['matchId'] = test['matchId'].apply(lambda x: int(x,16))
test['groupId'] = test['groupId'].apply(lambda x: int(x,16))
submission = pd.merge(test, X_test[['matchId','groupId','winPlacePerc']])
submission = submission[['Id','winPlacePe... | test_data.loc[ test_data['Fare'] <= 7.5, 'Fare'] = 0
test_data.loc[(test_data['Fare'] > 15)&(test_data['Fare'] <= 21.5), 'Fare'] = 1
test_data.loc[(test_data['Fare'] > 21.5)&(test_data['Age'] <= 29), 'Fare'] = 2
test_data.loc[(test_data['Fare'] > 29)&(test_data['Fare'] <= 36.5), 'Fare'] = 3
test_data.loc[ test_data['Fa... | Titanic - Machine Learning from Disaster |
14,578,345 | gc.enable()<load_from_csv> | x = train_data.drop("Survived", axis = 1 ) | Titanic - Machine Learning from Disaster |
14,578,345 | def feature_engineering(is_train=True):
if is_train:
print("processing train.csv")
df = pd.read_csv(".. /input/pubg-finish-placement-prediction/train_V2.csv")
df = df[df['maxPlace'] > 1]
else:
print("processing test.csv")
df = pd.read_csv(".. /input/pubg-finish-placement-prediction/test_V2.csv")
df['totalDistance']... | y = train_data["Survived"] | Titanic - Machine Learning from Disaster |
14,578,345 | x_train, y, feature_names = feature_engineering(True )<split> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
14,578,345 | X_train, X_val, y_train, y_val = train_test_split(x_train, y, test_size=0.33, random_state=42 )<set_options> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
14,578,345 | warnings.filterwarnings("ignore")
<train_model> | x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.4, random_state = 12 ) | Titanic - Machine Learning from Disaster |
14,578,345 | train_data=lgb.Dataset(X_train, label=y_train)
val_data= lgb.Dataset(X_val, label=y_val)
params = {
'num_leaves': 144,
'learning_rate': 0.1,
'n_estimators': 1500,
'max_depth':12,
'max_bin':55,
'bagging_fraction':0.8,
'bagging_freq':5,
'feature_fraction':0.9,
'verbose':50,
'early_stopping_rounds':100
}
params['metric'... | dtree = DecisionTreeClassifier()
dtree.fit(x_train, y_train)
y_pred = dtree.predict(x_test)
dtree_accuracy = round(accuracy_score(y_pred, y_test)* 100, 2)
print(dtree_accuracy ) | Titanic - Machine Learning from Disaster |
14,578,345 | y_pred=lgb_model.predict(X_val)
print(mean_absolute_error(y_val,y_pred))
del X_val
del y_val<prepare_x_and_y> | rf = RandomForestClassifier(n_estimators=50, max_depth = 8)
rf.fit(x_train, y_train)
y_pred = rf.predict(x_test)
acc_rf = round(accuracy_score(y_pred, y_test)* 100, 2)
print(acc_rf ) | Titanic - Machine Learning from Disaster |
14,578,345 | x_test, y_test, feature_names = feature_engineering(False )<predict_on_test> | lr = LogisticRegression(solver='liblinear', dual = False)
lr.fit(x_train, y_train)
y_pred = lr.predict(x_test)
acc_log = round(lr.score(x_train, y_train)* 100, 2)
acc_log
accuracy_score(y_test, y_pred ) | Titanic - Machine Learning from Disaster |
14,578,345 | y_test_pred=lgb_model.predict(x_test )<save_to_csv> | rf = RandomForestClassifier(n_estimators=50, max_depth = 8 ) | Titanic - Machine Learning from Disaster |
14,578,345 | df=pd.read_csv(".. /input/pubg-finish-placement-prediction/test_V2.csv")
var=pd.DataFrame(columns=['Id','winPlacePerc'])
var['Id']= df['Id']
var['winPlacePerc'] = y_test_pred
submission = var[['Id', 'winPlacePerc']]
submission.to_csv('submission.csv', index=False )<load_from_csv> | rf.fit(x_train, y_train ) | Titanic - Machine Learning from Disaster |
14,578,345 | train=pd.read_csv('/kaggle/input/pubg-finish-placement-prediction/train_V2.csv')
test=pd.read_csv('/kaggle/input/pubg-finish-placement-prediction/test_V2.csv')
sample_submission=pd.read_csv('/kaggle/input/pubg-finish-placement-prediction/sample_submission_V2.csv')
<count_missing_values> | x_test = test_data | Titanic - Machine Learning from Disaster |
14,578,345 | train.isnull().sum()<count_missing_values> | y_test_predict = rf.predict(x_test ) | Titanic - Machine Learning from Disaster |
14,578,345 | train.isnull().sum()<correct_missing_values> | output_data = pd.DataFrame({'PassengerId' : test_data.PassengerId, 'Survived' : y_test_predict})
output_data.to_csv('Titanic_Survival.csv', index = False)
print("Submission is successfully" ) | Titanic - Machine Learning from Disaster |
13,440,752 | train.dropna(axis=0,inplace=True )<count_missing_values> | fastai.__version__ | Titanic - Machine Learning from Disaster |
13,440,752 | test.isnull().sum()<count_missing_values> | pd.options.display.max_rows = 20
pd.options.display.max_columns = None | Titanic - Machine Learning from Disaster |
13,440,752 | test.isnull().sum()<set_options> | path = Path('/kaggle/input/titanic-extended' ) | Titanic - Machine Learning from Disaster |
13,440,752 | plt.figure(figsize=(10,6))
sns.distplot(train["DBNOs"],hist=True)
plt.show()<feature_engineering> | path.ls() | Titanic - Machine Learning from Disaster |
13,440,752 | train['boosts+heals'] = train['boosts']+train['heals']
train['matchDuration_min'] = train['matchDuration']/60
train['teamwork'] = train['assists'] + train['revives']
train['revives-teamKills'] = train['revives'] - train['teamKills']
train['total_distance'] = train['swimDistance'] + train['rideDistance'] + train['walkDi... | df = pd.read_csv(path/'train.csv', low_memory=False)
df_test = pd.read_csv(path/'test.csv', low_memory=False ) | Titanic - Machine Learning from Disaster |
13,440,752 | test['boosts+heals'] = test['boosts']+test['heals']
test['matchDuration_min'] = test['matchDuration']/60
test['teamwork'] = test['assists'] + test['revives']
test['revives-teamKills'] = test['revives'] - test['teamKills']
test['total_distance'] = test['swimDistance'] + test['rideDistance'] + test['walkDistance']
test['... | procs = [Categorify, FillMissing] | Titanic - Machine Learning from Disaster |
13,440,752 | dropped_cols = ["Id", "matchId", "groupId", "matchType"]
train.drop(dropped_cols,axis=1,inplace=True)
test.drop(dropped_cols,axis=1,inplace=True )<prepare_x_and_y> | splits = RandomSplitter(valid_pct=0.2 )(range_of(df)) | Titanic - Machine Learning from Disaster |
13,440,752 | X = train.drop('winPlacePerc',axis=1)
y = train['winPlacePerc']<split> | dep_var='Survived' | Titanic - Machine Learning from Disaster |
13,440,752 | test_size=0.20
seed=42
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=seed )<set_options> | cont,cat = cont_cat_split(df, 1, dep_var=dep_var ) | Titanic - Machine Learning from Disaster |
13,440,752 | del train
gc.collect()<init_hyperparams> | to = TabularPandas(df, procs, cat, cont, y_names=dep_var, splits=splits, y_block=CategoryBlock() ) | Titanic - Machine Learning from Disaster |
13,440,752 | params2 = {
"objective" : "regression",
"metric" : "mae",
"num_leaves" : 150,
"learning_rate" : 0.03,
"bagging_fraction" : 0.9,
"bagging_seed" : 0,
"num_threads" : 4,
"colsample_bytree" : 0.5,
'min_data_in_leaf':1900,
'lambda_l2':9
}<choose_model_class> | X_train, y_train = to.train.xs,to.train.y
X_valid, y_valid = to.valid.xs,to.valid.y | Titanic - Machine Learning from Disaster |
13,440,752 | reg2 = lgb.LGBMRegressor(**params2, n_estimators=2000 )<train_model> | m = RandomForestClassifier(n_estimators=100, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
13,440,752 | reg2.fit(X_train, y_train )<predict_on_test> | m.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
13,440,752 | pred2 = reg2.predict(X_test, num_iteration=reg2.best_iteration_ )<compute_test_metric> | from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
13,440,752 | mean_absolute_error(y_test, pred2 )<predict_on_test> | y_pred=m.predict(X_valid ) | Titanic - Machine Learning from Disaster |
13,440,752 | predictions = reg2.predict(test, num_iteration=reg2.best_iteration_ )<prepare_output> | accuracy_score(y_valid, y_pred ) | Titanic - Machine Learning from Disaster |
13,440,752 | sample_submission['winPlacePerc'] = predictions<save_to_csv> | to_test = TabularPandas(df_test, procs, cat, cont ) | Titanic - Machine Learning from Disaster |
13,440,752 | sample_submission.to_csv('submission.csv',index=False )<import_modules> | predicted_result = m.predict(to_test.xs.drop('Fare_na', axis=1)) | Titanic - Machine Learning from Disaster |
13,440,752 | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from catboost import CatBoostRegressor
from sklearn.metrics import mean_absolute_error
from sklearn.preprocessing import StandardScaler,MinMaxScaler<load_from_csv> | output= pd.DataFrame({'PassengerId':df_test.PassengerId, 'Survived': predicted_result.astype(int)})
output.to_csv('submission_titanic.csv', index=False)
output.head() | Titanic - Machine Learning from Disaster |
10,029,649 | train=pd.read_csv('.. /input/train_V2.csv')
test=pd.read_csv('.. /input/test_V2.csv')
ID=test['Id']<correct_missing_values> | import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import *
from sklearn.model_selection import *
from sklearn.svm import *
from sklearn.linear_model import *
from sklearn.ensemble import *
from sklearn.neighbors import KNeighborsClassifier | Titanic - Machine Learning from Disaster |
10,029,649 | train=train.dropna(axis=0 )<prepare_x_and_y> | csv_names = ['PassengerId', 'Survived', 'Pclass', 'Name', 'Sex', 'Age', 'SibSp', 'Parch', 'Ticket', 'Fare', 'Cabin', 'Embarked'] | Titanic - Machine Learning from Disaster |
10,029,649 | y_train=train['winPlacePerc']
train=train.drop(['winPlacePerc'],axis=1 )<categorify> | dataset = pd.read_csv('/kaggle/input/titanic/train.csv', names= csv_names , header = 0 ,skipinitialspace=True ) | Titanic - Machine Learning from Disaster |
10,029,649 | train["players_Match"] = train.groupby("matchId")["Id"].transform("count")
train["players_Group"] = train.groupby("groupId")["Id"].transform("count")
test["players_Match"] = test.groupby("matchId")["Id"].transform("count")
test["players_Group"] = test.groupby("groupId")["Id"].transform("count" )<categorify> | dataset.isnull().sum() | Titanic - Machine Learning from Disaster |
10,029,649 | train['Total_Kills'] = train.groupby('groupId')['kills'].transform('sum')
test['Total_Kills'] = test.groupby('groupId')['kills'].transform('sum' )<categorify> | dataset1 = dataset.dropna(axis= 1 ) | Titanic - Machine Learning from Disaster |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.