kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
2,403,150 | gc.collect()
batch_size = 500
n_epochs = 1000
max_epochs_without_improving = 50
max_epochs_wo_lr_change = 7
max_time = 5.5
acc_data = {'acc_train':[], 'acc_val':[]}
batch_acc_data = []
batch_lr_data = []
start_time = datetime.datetime.now()
with tf.Session() as sess:
init.run()
max_val_acc = 0
epochs_wo_improvement = 0... | ticket_counts = all['Ticket'].value_counts()
all['GrSize'] = all.apply(lambda s: ticket_counts.loc[s['Ticket']], axis=1)
all['Cabin'].fillna('U',inplace=True)
all['hasCabin'] = all.apply(lambda s: 0 if s['Cabin'] == 'U' else 1,axis = 1 ) | Titanic - Machine Learning from Disaster |
2,403,150 | def generate_val_comp_data(X, gap):
if X.shape[0] > gap:
X = X.sort_values(by=['winPlacePerc'])
group_data = X[group_cols].values
part0 = X[['matchId', 'groupId']].values[gap:,:]
part0 = np.c_[part0, X[['matchId', 'groupId']].values[:-gap,:]]
part1 = group_data[gap:,:]
part2 = group_data[:-gap,:]
part3 = X[other_cols]... | all['Fname'] = all.Name.str.extract('^ (.+?),', expand=False)
Pas_wSib = []
all_x_0 = all[(all['SibSp'] > 0)&(all['Parch'] == 0)]
name_counts_SibSp = all_x_0['Fname'].value_counts()
for label, value in name_counts_SibSp.items() :
entries = all_x_0[all_x_0['Fname'] == label]
if(entries.shape[0] > 1 and(not(entries['Tit... | Titanic - Machine Learning from Disaster |
2,403,150 | def reorder_val(data, ids, y_comp_pred):
df = pd.DataFrame(np.c_[ids, y_comp_pred.reshape(-1,1)], columns=['matchId', 'groupId', 'ordered'])
data = data.merge(df, on=['matchId', 'groupId'], how='left')
data['ordered'].fillna(1, inplace=True)
data.sort_values(by=['matchId','winPlacePerc'], inplace=True)
zero_inds = ... | all = all.drop(['Fname','Name','Cabin','Ticket','Fare','SibSp','Parch'], axis = 1 ) | Titanic - Machine Learning from Disaster |
2,403,150 | train = None
train_idx = None
train_ids = None
gc.collect()<data_type_conversions> | all[all['Pclass'] == 1].groupby(['Title','isAlone','wSib','wSp','wCh','wPar'])['Survived'].agg(['count','size','mean'] ) | Titanic - Machine Learning from Disaster |
2,403,150 | test, test_ids = pipeline.transform(test_path)
for num, col in enumerate(test.columns):
if col not in ['winPlacePerc', 'groupId', 'matchId']:
test[col] = test[col].astype(np.float32)
test[col] =(( test[col] - mean_vals[col])/std_vals[col] ).astype(np.float32)
gc.collect()<prepare_x_and_y> | all[(all['Pclass'] == 1)&(all['Title'] == 'Mr')].groupby(['hasCabin','isAlone','wSib','wSp','wCh','wPar'])['Survived'].agg(['count','size','mean'] ) | Titanic - Machine Learning from Disaster |
2,403,150 | y_test_dnn = pd.DataFrame(np.zeros(shape=[1,3]), columns=['matchId', 'groupId', 'winPlacePerc_pred'])
predict_batch_size = 10000
tf.reset_default_graph()
saver = tf.train.import_meta_graph('.. /DNN_data/dnn_state.ckpt.meta')
X = tf.get_default_graph().get_tensor_by_name('X:0')
output = tf.get_default_graph().get_ten... | all[all['Pclass'] == 2].groupby(['Title','isAlone','wSib','wSp','wCh','wPar'])['Survived'].agg(['count','size','mean'] ) | Titanic - Machine Learning from Disaster |
2,403,150 | def rank_align_predictions(X, y, scaled=False):
X['winPlacePerc'] = y
X['rank'] = X.groupby(['matchId'])['winPlacePerc'].rank(method='dense')
X['max_rank'] = X.groupby(['matchId'])['rank'].transform(np.max)
adj_winPlacePerc =(X['rank'] - 1)/(X['max_rank'] - 1 + 0.0000000001)
X.drop(columns=['winPlacePerc', 'rank', '... | all[all['Pclass'] == 3].groupby(['Title','isAlone','wSib','wSp','wCh','wPar'])['Survived'].agg(['count','size','mean'] ) | Titanic - Machine Learning from Disaster |
2,403,150 | y_test_dnn['winPlacePerc_pred'] = rank_align_predictions(y_test_dnn.drop(columns=['winPlacePerc_pred']), y_test_dnn['winPlacePerc_pred'])
y_test_dnn = y_test_dnn.merge(test[['matchId', 'groupId', 'numGroups', 'maxPlace']], on=['matchId', 'groupId'])
y_test_dnn['winPlacePerc_pred'] = fix_predictions(y_test_dnn.drop(co... | all[(all['Pclass'] == 3)&(all['Title'] != 'Mr')].groupby(['Title','FamSize'])['Survived'].agg(['count','size','mean'] ) | Titanic - Machine Learning from Disaster |
2,403,150 | test = test.merge(y_test_dnn[['matchId', 'groupId', 'winPlacePerc_pred']], on=['matchId', 'groupId'])
test.rename(columns={'winPlacePerc_pred':'winPlacePerc'}, inplace=True )<prepare_x_and_y> | all[(all['Pclass'] == 3)&(all['Title'] != 'Mr')].groupby(['Title','FamSizeBin','isAlone','wSib','wSp','wCh','wPar'])['Survived'].agg(['count','size','mean'] ) | Titanic - Machine Learning from Disaster |
2,403,150 | n_epochs = 6
batch_size = 10000
comp_thresh = [-0.1, 0, -0.1]
y_comp_diff_data = {}
y_comp_pred_data = {}
tf.reset_default_graph()
saver_comp = tf.train.import_meta_graph('.. /DNN_data/dnn_state_comp.ckpt.meta')
X1 = tf.get_default_graph().get_tensor_by_name('X1:0')
X2 = tf.get_default_graph().get_tensor_by_name('X2:... | def get_survived_1(row):
if row['Pclass'] in [1,2]:
if row['Title'] == 'Mr':
survived = 0
else:
survived = 1
else:
if row['Title'] == 'Mr' or row['FamSizeBin'] == 1:
survived = 0
else:
survived = 1
return survived | Titanic - Machine Learning from Disaster |
2,403,150 | def create_submission_table(X, y, id_table):
out = X[['matchId', 'groupId']]
out['winPlacePerc'] = y
out = id_table.merge(out, on=['matchId', 'groupId'])
out = out.drop(columns=['groupId', 'matchId'])
return out<save_to_csv> | X_train = all.iloc[:891,:]
X_test = all.iloc[891:,:]
y_train = all.iloc[:891,:]['Survived']
y_train_hat = X_train.apply(lambda s: get_survived_1(s), axis = 1)
predictions = pd.DataFrame({'PassengerId': test['PassengerId'], 'Survived': 0})
predictions['Survived'] = X_test.apply(lambda s: get_survived_1(s), axis = 1)
... | Titanic - Machine Learning from Disaster |
2,403,150 | submission = create_submission_table(test, test['winPlacePerc'], test_ids)
submission.to_csv('submission.csv', index=False)
submission.head(50 )<import_modules> | all[(all['Pclass'] == 3)&(all['Title'] != 'Mr')&(all['FamSizeBin'] == 0)].groupby(['Title','Embarked'])['Survived'].agg(['count','size','mean'] ) | Titanic - Machine Learning from Disaster |
2,403,150 | import gc
import sys
import numpy as np
import pandas as pd<categorify> | def get_survived_2(row):
if row['Pclass'] in [1,2]:
if row['Title'] == 'Mr':
survived = 0
else:
survived = 1
else:
if row['Title'] == 'Mr' or row['FamSizeBin'] == 1 or(row['Title'] == 'Miss' and row['Embarked'] == 'S'):
survived = 0
else:
survived = 1
return survived | Titanic - Machine Learning from Disaster |
2,403,150 | def df_footprint_reduce(df, skip_obj=False, skip_int=False, skip_float=False, print_comparison=True):
if print_comparison:
print(f"Dataframe size before shrinking column types into smallest possible: {round(( sys.getsizeof(df)/1024/1024),4)} MB")
for column in df.columns:
if(skip_obj is False)and(str(df[column].dtyp... | y_train_hat = X_train.apply(lambda s: get_survived_2(s), axis = 1)
predictions['Survived'] = X_test.apply(lambda s: get_survived_2(s), axis = 1)
predictions.to_csv('submission-2.csv', index=False)
score = metrics.accuracy_score(y_train_hat, y_train)
print('Train Accuracy: {}'.format(score)) | Titanic - Machine Learning from Disaster |
2,403,150 | def feature_engineering(df,is_train=True):
if is_train:
df = df[df['maxPlace'] > 1].copy()
target = 'winPlacePerc'
print('Grouping similar match types together')
df.loc[(df['matchType'] == 'solo'), 'matchType'] = 1
df.loc[(df['matchType'] == 'normal-solo'), 'matchType'] = 1
df.loc[(df['matchType'] == 'solo-fpp'), 'mat... | all[(all['Pclass'] == 3)&(all['Title'] == 'Miss')&(all['FamSizeBin'] == 0)].groupby(['Title','wPar','Embarked'])['Survived'].agg(['count','size','mean'] ) | Titanic - Machine Learning from Disaster |
2,403,150 | X_train = pd.read_csv('.. /input/train_V2.csv', engine='c' )<concatenate> | def get_survived_3(row):
if row['Pclass'] in [1,2]:
if row['Title'] == 'Mr':
survived = 0
else:
survived = 1
else:
if row['Title'] == 'Mr' or row['FamSizeBin'] == 1 or \
(row['Title'] == 'Miss' and row['Embarked'] == 'S' and row['wPar'] == 0):
survived = 0
else:
survived = 1
return survived | Titanic - Machine Learning from Disaster |
2,403,150 | X_train = df_footprint_reduce(X_train, skip_obj=True)
gc.collect()<feature_engineering> | y_train_hat = X_train.apply(lambda s: get_survived_3(s), axis = 1)
predictions['Survived'] = X_test.apply(lambda s: get_survived_3(s), axis = 1)
predictions.to_csv('submission-3.csv', index=False)
score = metrics.accuracy_score(y_train_hat, y_train)
print('Train Accuracy: {}'.format(score)) | Titanic - Machine Learning from Disaster |
2,403,150 | X_train, y_train = feature_engineering(X_train, True)
gc.collect()<concatenate> | all['Sex'] = all['Sex'].map({'male': 0, 'female': 1} ).astype(int)
all['Embarked'].fillna(all['Embarked'].value_counts().index[0], inplace=True)
all_dummies = pd.get_dummies(all, columns = ['Title','Pclass','Embarked'],\
prefix=['Title','Pclass','Embarked'], drop_first = True)
all_dummies = all_dummies.drop(['Passen... | Titanic - Machine Learning from Disaster |
2,403,150 | X_train = df_footprint_reduce(X_train, skip_obj=True)
gc.collect()<import_modules> | all_dummies_i = pd.DataFrame(data=KNN(k=3, verbose = False ).fit_transform(all_dummies ).astype(int),
columns=all_dummies.columns, index=all_dummies.index ) | Titanic - Machine Learning from Disaster |
2,403,150 | from sklearn.model_selection import train_test_split, GridSearchCV<split> | all_dummies_i['isAlwSib'] = all_dummies_i.apply(lambda s: 1 if(s['isAlone'] == 1)|(s['wSib'] == 1)else 0 ,axis = 1)
all_dummies_i = all_dummies_i.drop(['isAlone','wSib','Sex','GrSize'], axis = 1 ) | Titanic - Machine Learning from Disaster |
2,403,150 | X_train, X_validation, y_train, y_validation = train_test_split(X_train,
y_train,
test_size=0.2)
gc.collect()<import_modules> | X_train = all_dummies_i.iloc[:891,:]
X_test = all_dummies_i.iloc[891:,:] | Titanic - Machine Learning from Disaster |
2,403,150 | import lightgbm as lgb<train_model> | scaler = StandardScaler()
scaler.fit(X_train[['Age']])
X_train['Age'] = scaler.transform(X_train[['Age']])
X_test['Age'] = scaler.transform(X_test[['Age']] ) | Titanic - Machine Learning from Disaster |
2,403,150 | parameters = { 'objective': 'regression_l1',
'learning_rate': 0.01
}<train_on_grid> | cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=10, random_state=1 ) | Titanic - Machine Learning from Disaster |
2,403,150 | def find_best_hyperparameters(model):
gridParams = {
'learning_rate' : [0.1, 0.01 , 0.05],
'n_estimators ' : [1000, 10000, 20000],
'bagging_fraction' : [0.5, 0.6 ,0.7],
'feature_fraction' : [0.5, 0.6 ,0.7],
'num_leaves' : [31, 80, 140]
}
grid = GridSearchCV(model,
gridParams,
verbose=5,
cv=3)
grid.fit(X_train, y_train... | svm_grid = {'C': [10,11,12,13,14,15,16,17,18,19,20], 'gamma': ['auto']}
svm_search = GridSearchCV(estimator = SVC() , param_grid = svm_grid, cv = cv, refit=True, n_jobs=1 ) | Titanic - Machine Learning from Disaster |
2,403,150 | X_train = lgb.Dataset(X_train, label=y_train)
X_validation = lgb.Dataset(X_validation, label=y_validation)
gc.collect()<train_model> | svm_search.fit(X_train, train['Survived'])
svm_best = svm_search.best_estimator_
print("Cross-validation accuracy: {}, standard deviation: {}, with parameters {}"
.format(svm_search.best_score_, svm_search.cv_results_['std_test_score'][svm_search.best_index_],
svm_search.best_params_)) | Titanic - Machine Learning from Disaster |
2,403,150 | %%time
model = lgb.train(parameters,
X_train,
num_boost_round = 40000,
valid_sets=[X_validation,X_train] )<compute_test_metric> | y_train_hat = svm_best.predict(X_train)
print('Train Accuracy: {}'
.format(metrics.accuracy_score(y_train_hat, y_train)))
predictions['Survived'] = svm_best.predict(X_test)
predictions.to_csv('submission-svm.csv', index=False ) | Titanic - Machine Learning from Disaster |
2,403,150 | <import_modules><EOS> | def get_survived_svm_rule(row):
if row['Pclass'] in [1,2]:
if row['Title'] == 'Mr':
survived = 0
else:
survived = 1
else:
if row['Title'] == 'Mr' or row['FamSizeBin'] == 1 or \
(row['Title'] == 'Miss' and row['Embarked'] == 'S' and row['Age'] >= 18):
survived = 0
else:
survived = 1
return survived | Titanic - Machine Learning from Disaster |
6,786,557 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<filter> | warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
6,786,557 | feature_imp[feature_imp['Value']==0]<drop_column> | warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
6,786,557 | del X_train, X_validation, y_train, y_validation, feature_imp
gc.collect()<load_from_csv> | gender_submission = pd.read_csv(".. /input/titanic/gender_submission.csv")
test = pd.read_csv(".. /input/titanic/test.csv")
train = pd.read_csv(".. /input/titanic/train.csv")
test["Survived"] = np.nan | Titanic - Machine Learning from Disaster |
6,786,557 | test_x = pd.read_csv('.. /input/test_V2.csv', engine='c' )<concatenate> | dataset = pd.concat([train,test],axis=0 ).reset_index(drop=True)
dataset = dataset.fillna(np.nan ) | Titanic - Machine Learning from Disaster |
6,786,557 | test_x = df_footprint_reduce(test_x, skip_obj=True)
gc.collect()<feature_engineering> | dataset.isnull().sum(axis = 0 ) | Titanic - Machine Learning from Disaster |
6,786,557 | test_x = feature_engineering(test_x, False)
gc.collect()<predict_on_test> | dataset["Family"] = dataset["SibSp"] + dataset["Parch"] + 1
train["Family"] = train["SibSp"] + train["Parch"] + 1
test["Family"] = test["SibSp"] + test["Parch"] + 1 | Titanic - Machine Learning from Disaster |
6,786,557 | pred_test = model.predict(test_x, num_iteration=model.best_iteration)
del test_x
gc.collect()<load_from_csv> | dataset = dataset.drop(columns=["SibSp","Parch"])
train = train.drop(columns=["SibSp","Parch"])
test = test.drop(columns=["SibSp","Parch"] ) | Titanic - Machine Learning from Disaster |
6,786,557 | test_set = pd.read_csv('.. /input/test_V2.csv', engine='c' )<merge> | dataset.Family = list(map(lambda x: 'Big' if x > 4 else('Single' if x == 1 else 'Medium'), dataset.Family))
train.Family = list(map(lambda x: 'Big' if x > 4 else('Single' if x == 1 else 'Medium'), train.Family))
test.Family = list(map(lambda x: 'Big' if x > 4 else('Single' if x == 1 else 'Medium'), test.Family)) | Titanic - Machine Learning from Disaster |
6,786,557 | submission = pd.read_csv(".. /input/sample_submission_V2.csv")
submission['winPlacePerc'] = pred_test
submission.loc[submission.winPlacePerc < 0, "winPlacePerc"] = 0
submission.loc[submission.winPlacePerc > 1, "winPlacePerc"] = 1
submission = submission.merge(test_set[["Id", "matchId", "groupId", "maxPlace", "numGroup... | dataset.Sex = dataset.Sex.map({'male': 0, 'female': 1})
train.Sex = train.Sex.map({'male': 0, 'female': 1})
test.Sex = test.Sex.map({'male': 0, 'female': 1} ) | Titanic - Machine Learning from Disaster |
6,786,557 | import numpy as np
import pandas as pd
import tqdm
import matplotlib.pyplot as plt
import keras
from keras.layers.core import Dense
from keras.layers.normalization import BatchNormalization
from sklearn.preprocessing import MinMaxScaler, RobustScaler, MaxAbsScaler<load_from_csv> | dataset["Fare"] = dataset["Fare"].fillna(dataset["Fare"].median())
train["Fare"] = train["Fare"].fillna(dataset["Fare"].median())
test["Fare"] = test["Fare"].fillna(dataset["Fare"].median() ) | Titanic - Machine Learning from Disaster |
6,786,557 | train = pd.read_csv(".. /input/train_V2.csv" )<create_dataframe> | dataset.Fare = list(map(lambda x: 'Very Low' if x <= 10
else('Low' if(x > 10 and x < 26)
else('Medium' if(x >= 26 and x <= 50)else 'High')) , dataset.Fare))
train.Fare = list(map(lambda x: 'Very Low' if x <= 10
else('Low' if(x > 10 and x < 26)
else('Medium' if(x >= 26 and x <= 50)else 'High')) , train.Fare))
test.Far... | Titanic - Machine Learning from Disaster |
6,786,557 | pd.DataFrame(train.dtypes, columns=["Type"] )<count_unique_values> | dataset.Embarked = dataset.Embarked.fillna('S')
train.Embarked = train.Embarked.fillna('S')
test.Embarked = test.Embarked.fillna('S' ) | Titanic - Machine Learning from Disaster |
6,786,557 | print("Number of record:", len(train), "
Number of Unique Id:", len(pd.unique(train.Id)) )<count_unique_values> | title = []
for i in dataset.Name.str.split(', '):
title.append(i[1].split('.')[0])
dataset["Title"] = title
title = []
for i in train.Name.str.split(', '):
title.append(i[1].split('.')[0])
train["Title"] = title
title = []
for i in test.Name.str.split(', '):
title.append(i[1].split('.')[0])
test["Title"] = title | Titanic - Machine Learning from Disaster |
6,786,557 | print("Number of match: ", len(pd.unique(train.matchId)) , "
Number of match(<9): ", sum(train.groupby("matchId" ).size() < 9))<groupby> | dataset = dataset.drop(columns=["Name"])
train = train.drop(columns=["Name"])
test = test.drop(columns=["Name"] ) | Titanic - Machine Learning from Disaster |
6,786,557 | temp = train.loc[train.matchId.isin(train.groupby("matchId" ).size() [train.groupby("matchId" ).size() < 9].index), :]
temp.loc[temp.matchId == "e263f4a227313a"]<create_dataframe> | cabin = []
for i in dataset.Cabin:
if type(i)!= float:
cabin.append(i[0])
else:
cabin.append('Z')
dataset.Cabin = cabin
cabin = []
for i in train.Cabin:
if type(i)!= float:
cabin.append(i[0])
else:
cabin.append('Z')
train.Cabin = cabin
cabin = []
for i in test.Cabin:
if type(i)!= float:
cabin.append(i[0])
else:
ca... | Titanic - Machine Learning from Disaster |
6,786,557 | temp = pd.DataFrame(train.groupby("matchId" ).size() , columns=["player"])
temp.reset_index(level=0, inplace=True )<merge> | dataset.Cabin = dataset.Cabin.map({'B':'BCDE','C':'BCDE','D':'BCDE','E':'BCDE','A':'AFG','F':'AFG','G':'AFG','Z':'Z','T':'Z'})
train.Cabin = train.Cabin.map({'B':'BCDE','C':'BCDE','D':'BCDE','E':'BCDE','A':'AFG','F':'AFG','G':'AFG','Z':'Z','T':'Z'})
test.Cabin = test.Cabin.map({'B':'BCDE','C':'BCDE','D':'BCDE','E':'B... | Titanic - Machine Learning from Disaster |
6,786,557 | train = train.merge(temp, left_on="matchId", right_on="matchId" )<count_unique_values> | tickets = []
for i in dataset.Ticket:
tickets.append(i.split(' ')[-1][0])
dataset.Ticket = tickets
tickets = []
for i in train.Ticket:
tickets.append(i.split(' ')[-1][0])
train.Ticket = tickets
tickets = []
for i in test.Ticket:
tickets.append(i.split(' ')[-1][0])
test.Ticket = tickets | Titanic - Machine Learning from Disaster |
6,786,557 | print("Type: ", pd.unique(train.matchType), "
Count: ", len(pd.unique(train.matchType)) )<feature_engineering> | dataset.Ticket = list(map(lambda x: 4 if(x == 'L' or int(x)>= 4)else int(x), dataset.Ticket))
train.Ticket = list(map(lambda x: 4 if(x == 'L' or int(x)>= 4)else int(x), train.Ticket))
test.Ticket = list(map(lambda x: 4 if(x == 'L' or int(x)>= 4)else int(x), test.Ticket)) | Titanic - Machine Learning from Disaster |
6,786,557 | train["matchType_1"] = "-"
train.loc[(train.matchType == "solo-fpp")|
(train.matchType == "solo")|
(train.matchType == "normal-solo-fpp")|
(train.matchType == "normal-solo"), "matchType_1"] = "solo"
train.loc[(train.matchType == "duo-fpp")|
(train.matchType == "duo")|
(train.matchType == "normal-duo-fpp")|
(train... | medians = pd.DataFrame(dataset.groupby(['Pclass', 'Title'])['Age'].median())
medians | Titanic - Machine Learning from Disaster |
6,786,557 | train["matchType_2"] = "-"
train.loc[(train.matchType == "solo-fpp")|
(train.matchType == "duo-fpp")|
(train.matchType == "squad-fpp")|
(train.matchType == "normal-solo-fpp")|
(train.matchType == "normal-duo-fpp")|
(train.matchType == "normal-squad-fpp")|
(train.matchType == "crashfpp")|
(train.matchType == "fla... | ages = []
for i in dataset[dataset.Age.isnull() == True][["Pclass","Title"]].values:
ages.append(medians.ix[(i[0], i[1])].Age)
dataset.Age[dataset.Age.isnull() == True] = ages | Titanic - Machine Learning from Disaster |
6,786,557 | train["solo"] = 0
train["duo"] = 0
train["squad"] = 0
train["etc"] = 0
train.loc[train.matchType_1 == "solo", "solo"] = 1
train.loc[train.matchType_1 == "duo", "duo"] = 1
train.loc[train.matchType_1 == "squad", "squad"] = 1
train.loc[train.matchType_1 == "etc", "etc"] = 1<feature_engineering> | index = dataset[dataset.Age.isnull() == True].index
train_idx = index[index <= 890]
test_idx = index[index > 890]
train['Age'][train.index.isin(train_idx)] = dataset['Age'][dataset.index.isin(train_idx)].values
test['Age'][test.index.isin(test_idx - 891)] = dataset['Age'][dataset.index.isin(test_idx)].values | Titanic - Machine Learning from Disaster |
6,786,557 | train["fpp"] = 0
train["tpp"] = 0
train.loc[train.matchType_2 == "fpp", "fpp"] = 1
train.loc[train.matchType_2 == "tpp", "tpp"] = 1<filter> | ages = []
for i in dataset.Age:
if i < 18:
ages.append('less_18')
elif i >= 18 and i < 50:
ages.append('18_50')
else:
ages.append('greater_50')
dataset.Age = ages
ages = []
for i in train.Age:
if i < 18:
ages.append('less_18')
elif i >= 18 and i < 50:
ages.append('18_50')
else:
ages.append('greater_50')
train.Age... | Titanic - Machine Learning from Disaster |
6,786,557 | print(list(train.columns[train.dtypes != "O"]))<define_variables> | x_train = train.loc[:, ~train.columns.isin(['PassengerId', 'Survived', 'Sex'])]
y_train = train.Survived
x_test = test.loc[:, ~test.columns.isin(['PassengerId', 'Survived', 'Sex'])] | Titanic - Machine Learning from Disaster |
6,786,557 | feature = ["assists", "boosts", "damageDealt", "DBNOs", "headshotKills", "heals",
"killPlace", "killPoints", "kills", "killStreaks", "longestKill",
"matchDuration", "maxPlace", "rankPoints", "revives", "rideDistance",
"roadKills", "swimDistance", "teamKills", "vehicleDestroys", "walkDistance", "weaponsAcquired", "winPo... | x_train = pd.get_dummies(x_train)
x_train["Sex"] = train.Sex
x_test = pd.get_dummies(x_test)
x_test["Sex"] = test.Sex | Titanic - Machine Learning from Disaster |
6,786,557 | feature_1 = ["matchId", "assists", "boosts", "damageDealt", "DBNOs", "headshotKills", "heals",
"killPlace", "killPoints", "kills", "killStreaks", "longestKill",
"revives", "rideDistance", "roadKills", "swimDistance", "teamKills",
"vehicleDestroys", "walkDistance", "weaponsAcquired", "winPoints"]<define_variables> | rf = RandomForestClassifier()
rf.fit(x_train, y_train ) | Titanic - Machine Learning from Disaster |
6,786,557 | feature_2 = ["matchDuration", "maxPlace", "rankPoints", "player", "fpp", "tpp"]<count_missing_values> | ABC = AdaBoostClassifier(DecisionTreeClassifier())
ABC_param_grid = {"base_estimator__criterion" : ["gini", "entropy"],
"base_estimator__splitter" : ["best", "random"],
"algorithm" : ["SAMME","SAMME.R"],
"n_estimators" :[5,6,7,8,9,10,20],
"learning_rate": [0.001, 0.01, 0.1, 0.3]}
gsABC = GridSearchCV(ABC, param_grid =... | Titanic - Machine Learning from Disaster |
6,786,557 | for i in list(train.columns[train.dtypes != "O"]):
print(i, ":", sum(train[i].isna()))<feature_engineering> | ExtC = ExtraTreesClassifier()
ex_param_grid = {"max_depth": [3, 4, 5],
"max_features": [3, 10, 15],
"min_samples_split": [2, 3, 4],
"min_samples_leaf": [1, 2],
"bootstrap": [False,True],
"n_estimators" :[100,200,300],
"criterion": ["gini","entropy"]}
gsExtC = GridSearchCV(ExtC, param_grid = ex_param_grid, cv = 10, scor... | Titanic - Machine Learning from Disaster |
6,786,557 |
<feature_engineering> | rf_test = {"max_depth": [24,26],
"max_features": [6,8,10],
"min_samples_split": [3,4],
"min_samples_leaf": [3,4],
"bootstrap": [True],
"n_estimators" :[50,80],
"criterion": ["gini","entropy"],
"max_leaf_nodes":[26,28],
"min_impurity_decrease":[0.0],
"min_weight_fraction_leaf":[0.0]}
tuning = GridSearchCV(estimator = Ra... | Titanic - Machine Learning from Disaster |
6,786,557 |
<count_missing_values> | GBM = GradientBoostingClassifier()
gb_param_grid = {'loss' : ["deviance"],
'n_estimators' : [450,460,500],
'learning_rate': [0.1,0.11],
'max_depth': [7,8],
'min_samples_leaf': [30,40],
'max_features': [0.1,0.4,0.6]}
gsGBC = GridSearchCV(GBM, param_grid = gb_param_grid, cv = 10, scoring = "accuracy", n_jobs = 6, verbose... | Titanic - Machine Learning from Disaster |
6,786,557 | np.sum(train.winPlacePerc.isna() )<filter> | SVMC = SVC(probability=True)
svc_param_grid = {'kernel': ['rbf'],
'gamma': [0.027,0.029,0.03,0.031],
'C': [45,55,76,77,78,85,95,100],
'tol':[0.001,0.0008,0.0009,0.0011]}
gsSVMC = GridSearchCV(SVMC, param_grid = svc_param_grid, cv = 10, scoring = "accuracy", n_jobs = 6, verbose = 1)
gsSVMC.fit(x_train,y_train)
svm_be... | Titanic - Machine Learning from Disaster |
6,786,557 | train = train.loc[train.winPlacePerc.notna() , :]<train_model> | XGB = XGBClassifier()
xgb_param_grid = {'learning_rate': [0.1,0.04,0.01],
'max_depth': [5,6,7],
'n_estimators': [350,400,450,2000],
'gamma': [0,1,5,8],
'subsample': [0.8,0.95,1.0]}
gsXBC = GridSearchCV(XGB, param_grid = xgb_param_grid, cv = 10, scoring = "accuracy", n_jobs = 6, verbose = 1)
gsXBC.fit(x_train,y_train)
... | Titanic - Machine Learning from Disaster |
6,786,557 |
<categorify> | voting = VotingClassifier(estimators=[('rfc', rf_best),
('extc', ext_best),
('svc', svm_best),
('gbc',gbm_best),
('xgbc',xgb_best),
('ada',ada_best)])
v_param_grid = {'voting':['soft',
'hard']}
gsV = GridSearchCV(voting,
param_grid =
v_param_grid,
cv = 10,
scoring = "accuracy",
n_jobs = 6,
verbose = 1)
gsV.fit(x... | Titanic - Machine Learning from Disaster |
6,786,557 |
<create_dataframe> | pred = v_best.predict(x_test)
submission = pd.DataFrame(test.PassengerId)
submission["Survived"] = pd.Series(pred ) | Titanic - Machine Learning from Disaster |
6,786,557 |
<feature_engineering> | submission.to_csv("submission.csv",index=False ) | Titanic - Machine Learning from Disaster |
2,817,510 |
<rename_columns> | train_df = pd.read_csv('.. /input/train.csv', index_col='PassengerId')
test_df = pd.read_csv('.. /input/test.csv', index_col='PassengerId')
train_df.head() | Titanic - Machine Learning from Disaster |
2,817,510 | train.set_index("Id", inplace=True)
train.index.name = "Id"<prepare_x_and_y> | print('Train dataset:')
print(train_df.isna().sum() [train_df.isna().any() ])
print('
Test dataset:')
print(test_df.isna().sum() [test_df.isna().any() ] ) | Titanic - Machine Learning from Disaster |
2,817,510 | temp_1 = train.loc[:, feature_1]
temp_2 = train.loc[:, feature_2]<feature_engineering> | cat_feat = ['Sex', 'Embarked']
for cf in cat_feat:
if cf != cat_feat[0]:
print()
print(train_df[cf].value_counts() / train_df[cf].count() ) | Titanic - Machine Learning from Disaster |
2,817,510 | temp_1.groupby("matchId" ).transform(minmax)
for i in temp_2.columns[:4]:
temp_2[i] =(temp_2[i] - min(temp_2[i])) /(max(temp_2[i])- min(temp_2[i]))<merge> | train_df = train_df.drop(['Ticket', 'Cabin'], axis=1)
test_df = test_df.drop(['Ticket', 'Cabin'], axis=1 ) | Titanic - Machine Learning from Disaster |
2,817,510 | X = pd.merge(temp_1, temp_2, on="Id")
X = pd.merge(X, train.loc[:, ["matchType_1", "winPlacePerc"]], on="Id" )<feature_engineering> | extract_title = lambda df: df.Name.str.extract(r'([A-Za-z]+)\.', expand=False)
train_df['Title'] = extract_title(train_df)
test_df['Title'] = extract_title(test_df)
train_df.Title.value_counts() | Titanic - Machine Learning from Disaster |
2,817,510 |
<feature_engineering> | def replace_titles(df):
df['Title'] = df['Title'].replace(['Lady', 'Countess','Capt', 'Col',\
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
df['Title'] = df['Title'].replace('Mlle', 'Miss')
df['Title'] = df['Title'].replace('Ms', 'Miss')
df['Title'] = df['Title'].replace('Mme', 'Mrs')
return df
... | Titanic - Machine Learning from Disaster |
2,817,510 |
<feature_engineering> | def add_family(df):
df['Family'] = df.SibSp + df.Parch
return df
train_df = add_family(train_df)
test_df = add_family(test_df ) | Titanic - Machine Learning from Disaster |
2,817,510 |
<filter> | family_feat = ['SibSp', 'Parch']
train_df = train_df.drop(family_feat, axis=1)
test_df = test_df.drop(family_feat, axis=1 ) | Titanic - Machine Learning from Disaster |
2,817,510 |
<count_values> | def fill_ages(df):
df.loc[(df.Age.isnull())&(df.Title == 'Master'), 'Age'] = df[df.Title == 'Master'].Age.median()
df.loc[(df.Age.isnull())&(df.Title != 'Master'), 'Age'] = df[df.Title != 'Master'].Age.median()
return df
def fill_embarked(df):
df['Embarked'] = df.Embarked.fillna('S')
return df
train_df = fill_ages(fil... | Titanic - Machine Learning from Disaster |
2,817,510 | print("Name: ", feature, "
Count: ", len(feature))<define_variables> | def add_bands(df):
df['AgeBand'] = pd.cut(df.Age, bins=5)
df['FareBand'] = pd.qcut(df.Fare, q=4)
return df
train_df = add_bands(train_df)
test_df = add_bands(test_df)
train_df = train_df.drop(['Age', 'Fare'], axis=1)
test_df = test_df.drop(['Age', 'Fare'], axis=1 ) | Titanic - Machine Learning from Disaster |
2,817,510 | list_feat = ["assists", "boosts", "damageDealt", "DBNOs", "headshotKills", "heals",
"killPlace", "killPoints", "kills", "killStreaks", "longestKill",
"matchDuration", "maxPlace", "rankPoints", "revives", "rideDistance",
"roadKills", "swimDistance", "teamKills", "vehicleDestroys", "walkDistance",
"weaponsAcquired", "win... | def factorize(df):
df['Sex'] = df.Sex.factorize() [0]
df['AgeBand'] = df.AgeBand.factorize(sort=True)[0]
df['FareBand'] = df.FareBand.factorize(sort=True)[0]
return df
def one_hot_encode(df):
return pd.get_dummies(df, columns=['Embarked', 'Title'])
train_df = one_hot_encode(factorize(train_df))
test_df = one_hot_encod... | Titanic - Machine Learning from Disaster |
2,817,510 | list_feat_1 = ["assists", "boosts", "damageDealt", "DBNOs", "headshotKills", "heals",
"killPlace", "killPoints", "kills", "killStreaks", "longestKill",
"matchDuration", "maxPlace", "rankPoints", "revives", "rideDistance",
"roadKills", "swimDistance", "teamKills", "vehicleDestroys", "walkDistance",
"weaponsAcquired", "w... | X = train_df.drop('Survived', axis=1)
y = train_df.Survived | Titanic - Machine Learning from Disaster |
2,817,510 | train = X<choose_model_class> | param_grid = {
'n_estimators': [90, 95, 100],
'learning_rate': [0.009, 0.01],
'max_depth': [3],
'min_child_weight' :range(1, 3),
'gamma': [0, 0.001, 0.005]
}
gsearch = GridSearchCV(cv=5, estimator=XGBClassifier() , param_grid=param_grid, n_jobs=-1)
gsearch.fit(X, y)
gsearch.best_params_, gsearch.best_score_
| Titanic - Machine Learning from Disaster |
2,817,510 | model_1 = keras.models.Sequential()
model_1.add(Dense(32, input_dim=len(list_feat), activation="elu", kernel_initializer="he_normal"))
model_1.add(Dense(64, activation="elu", kernel_initializer="he_normal"))
model_1.add(Dense(128, activation="elu", kernel_initializer="he_normal"))
model_1.add(keras.layers.Dropout(0.25)... | param_grid = {
'C': np.arange(0.99, 1.1, 0.01)
}
model = SVC(gamma='auto')
gsearch = GridSearchCV(cv=5, estimator=model, param_grid=param_grid, n_jobs=-1)
gsearch.fit(X, y)
print(f'Best params: {gsearch.best_params_}')
print(f'Best score: {gsearch.best_score_}')
| Titanic - Machine Learning from Disaster |
2,817,510 | x_train = train.loc[train.matchType_1 == "solo", list_feat]
y_train = train.loc[train.matchType_1 == "solo", ["winPlacePerc"]]<train_model> | param_grid = {
'n_estimators': range(200, 300, 50),
'max_depth': range(2, 5),
'min_samples_split': [2, 3, 4],
'bootstrap': [True, False]
}
model = RandomForestClassifier()
gsearch = GridSearchCV(cv=5, estimator=model, param_grid=param_grid, n_jobs=-1)
gsearch.fit(X, y)
print(f'Best params: {gsearch.best_params_}')
p... | Titanic - Machine Learning from Disaster |
2,817,510 | model_1.fit(x=x_train, y=y_train, epochs=50, batch_size=10000, validation_split=0.2, shuffle=True)
model_1.fit(x=x_train, y=y_train, epochs=30, batch_size=2000, validation_split=0.2, shuffle=True )<train_model> | model = SVC(C = 1.26, gamma = 0.09)
model.fit(X, y)
predictions = model.predict(test_df ) | Titanic - Machine Learning from Disaster |
2,817,510 |
<save_model> | submit_df = pd.DataFrame({
'PassengerId': test_df.index.values,
'Survived': predictions
})
submit_df.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
3,048,663 | model_1.save("model_1_solo.h5")
<choose_model_class> | datrn = pd.read_csv('.. /input/train.csv')
datst = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
3,048,663 | model_2 = keras.models.Sequential()
model_2.add(Dense(32, input_dim=len(list_feat), activation="elu", kernel_initializer="he_normal"))
model_2.add(Dense(64, activation="elu", kernel_initializer="he_normal"))
model_2.add(Dense(128, activation="elu", kernel_initializer="he_normal"))
model_2.add(keras.layers.Dropout(0.25)... | datsub = pd.read_csv('.. /input/gender_submission.csv' ) | Titanic - Machine Learning from Disaster |
3,048,663 | x_train = train.loc[train.matchType_1 == "duo", list_feat]
y_train = train.loc[train.matchType_1 == "duo", ["winPlacePerc"]]<train_model> | outcome = datrn['Survived']
data = datrn.drop('Survived',axis=1 ) | Titanic - Machine Learning from Disaster |
3,048,663 | model_2.fit(x=x_train, y=y_train, epochs=50, batch_size=10000, validation_split=0.2, shuffle=True)
model_2.fit(x=x_train, y=y_train, epochs=40, batch_size=2000, validation_split=0.2, shuffle=True )<train_model> | def accuracy_score(truth, pred):
if len(truth)== len(pred):
return "Predictions have an accuracy of {:.2f}%.".format(( truth == pred ).mean() *100)
else:
return "Number of predictions does not match number of outcomes!" | Titanic - Machine Learning from Disaster |
3,048,663 |
<save_model> | warnings.filterwarnings("ignore", category = UserWarning, module = "matplotlib")
get_ipython().run_line_magic('matplotlib', 'inline')
def filter_data(data, condition):
field, op, value = condition.split(" ")
try:
value = float(value)
except:
value = value.strip("'"")
if op == ">":
matches = data[field] > value
e... | Titanic - Machine Learning from Disaster |
3,048,663 | model_2.save("model_2_duo.h5")
<choose_model_class> | survival_stats(data, outcome, 'Sex' ) | Titanic - Machine Learning from Disaster |
3,048,663 | model_3 = keras.models.Sequential()
model_3.add(Dense(32, input_dim=len(list_feat), activation="elu", kernel_initializer="he_normal"))
model_3.add(Dense(64, activation="elu", kernel_initializer="he_normal"))
model_3.add(Dense(128, activation="elu", kernel_initializer="he_normal"))
model_3.add(keras.layers.Dropout(0.25)... | survival_stats(data, outcome, 'Age', ["Sex == 'female'"] ) | Titanic - Machine Learning from Disaster |
3,048,663 | x_train = train.loc[train.matchType_1 == "squad", list_feat]
y_train = train.loc[train.matchType_1 == "squad", ["winPlacePerc"]]<train_model> | survival_stats(data, outcome, "Age",["Sex == 'male'","Embarked == 'C'"] ) | Titanic - Machine Learning from Disaster |
3,048,663 | model_3.fit(x=x_train, y=y_train, epochs=60, batch_size=10000, validation_split=0.2, shuffle=True)
model_3.fit(x=x_train, y=y_train, epochs=50, batch_size=3000, validation_split=0.2, shuffle=True )<train_model> | survival_stats(data, outcome, "Age",["Sex == 'male'","Embarked == 'S'"] ) | Titanic - Machine Learning from Disaster |
3,048,663 |
<save_model> | def predict(data):
predictions = []
for _, passenger in data.iterrows() :
if passenger['Sex'] == 'female':
if passenger['Embarked']== 'C' and passenger['Pclass'] <=3 :predictions.append(1)
elif passenger['Embarked']== 'S' and passenger['Pclass'] <3:predictions.append(1)
else:
if(passenger['SibSp'] <2)and(passenger[... | Titanic - Machine Learning from Disaster |
3,048,663 | model_3.save("model_3_squad.h5")
<choose_model_class> | pred = predict(data ) | Titanic - Machine Learning from Disaster |
3,048,663 | model_4 = keras.models.Sequential()
model_4.add(Dense(32, input_dim=len(list_feat), activation="elu", kernel_initializer="he_normal"))
model_4.add(Dense(64, activation="elu", kernel_initializer="he_normal"))
model_4.add(Dense(128, activation="elu", kernel_initializer="he_normal"))
model_4.add(keras.layers.Dropout(0.25)... | print(accuracy_score(outcome,pred)) | Titanic - Machine Learning from Disaster |
3,048,663 | x_train = train.loc[train.matchType_1 == "etc", list_feat]
y_train = train.loc[train.matchType_1 == "etc", ["winPlacePerc"]]<train_model> | predtst = predict(datst ) | Titanic - Machine Learning from Disaster |
3,048,663 | model_4.fit(x=x_train, y=y_train, epochs=70, batch_size=10000, validation_split=0.2, shuffle=True)
model_4.fit(x=x_train, y=y_train, epochs=150, batch_size=1000, validation_split=0.2, shuffle=True )<define_variables> | Past = datst.iloc[:,0] | Titanic - Machine Learning from Disaster |
3,048,663 |
<save_model> | dst = []
i=0
while i<len(predtst):
dst.append(( Past[i],predtst[i]))
i+=1 | Titanic - Machine Learning from Disaster |
3,048,663 | model_4.save("model_4_etc.h5")
<drop_column> | d = pd.DataFrame(dst,columns=['PassengerId','Survived'] ) | Titanic - Machine Learning from Disaster |
3,048,663 | <load_from_csv><EOS> | d.to_csv('gender_submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
1,316,433 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<count_missing_values> | %matplotlib inline
py.init_notebook_mode(connected=True)
warnings.filterwarnings('ignore')
GradientBoostingClassifier, ExtraTreesClassifier)
print(os.listdir(".. /input"))
| Titanic - Machine Learning from Disaster |
1,316,433 | print("Check The NA value in test data")
for i in list(test.columns[test.dtypes != "O"]):
print(i, ":", sum(test[i].isna()))<count_unique_values> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
1,316,433 | len(pd.unique(test.matchId)) , sum(test.groupby("matchId" ).size() < 9 )<merge> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
1,316,433 | temp = pd.DataFrame(test.groupby("matchId" ).size() , columns=["player"])
temp.reset_index(level=0, inplace=True)
test = test.merge(temp, left_on="matchId", right_on="matchId" )<feature_engineering> | train.columns[train.isnull().any() ].tolist() | Titanic - Machine Learning from Disaster |
1,316,433 | test["matchType_1"] = "-"
test.loc[(test.matchType == "solo-fpp")|
(test.matchType == "solo")|
(test.matchType == "normal-solo-fpp")|
(test.matchType == "normal-solo"), "matchType_1"] = "solo"
test.loc[(test.matchType == "duo-fpp")|
(test.matchType == "duo")|
(test.matchType == "normal-duo-fpp")|
(test.matchType ... | print(train[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean() ) | 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.