kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,263,527 |
<feature_engineering> | train_data['Title'] = train_data['Name'].apply(lambda x: x.split(',')[1].split('.')[0].strip())
test_data['Title'] = test_data['Name'].apply(lambda x: x.split(',')[1].split('.')[0].strip() ) | Titanic - Machine Learning from Disaster |
9,263,527 |
<merge> | train_data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
9,263,527 |
<feature_engineering> | test_data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
9,263,527 |
<merge> | train_data['Title'].replace(['Mme', 'Ms', 'Lady', 'Mlle', 'the Countess', 'Dona'], 'Miss', inplace=True)
test_data['Title'].replace(['Mme', 'Ms', 'Lady', 'Mlle', 'the Countess', 'Dona'], 'Miss', inplace=True)
train_data['Title'].replace(['Major', 'Col', 'Capt', 'Don', 'Sir', 'Jonkheer'], 'Mr', inplace=True)
test_dat... | Titanic - Machine Learning from Disaster |
9,263,527 |
<merge> | train_data.groupby('Title' ).Survived.mean() | Titanic - Machine Learning from Disaster |
9,263,527 |
<feature_engineering> | train_data['Ticket_lett'] = train_data.Ticket.apply(lambda x: x[:2])
test_data['Ticket_lett'] = test_data.Ticket.apply(lambda x: x[:2])
train_data['Ticket_len'] = train_data.Ticket.apply(lambda x: len(x))
test_data['Ticket_len'] = test_data.Ticket.apply(lambda x: len(x)) | Titanic - Machine Learning from Disaster |
9,263,527 |
<merge> | train_data['Fam_size'] = train_data['SibSp'] + train_data['Parch'] + 1
test_data['Fam_size'] = test_data['SibSp'] + test_data['Parch'] + 1 | Titanic - Machine Learning from Disaster |
9,263,527 |
<merge> | y = train_data['Survived']
features = ['Pclass', 'Fare', 'Title', 'Embarked', 'Fam_type', 'Ticket_len', 'Ticket_lett']
X = train_data[features]
X.head() | Titanic - Machine Learning from Disaster |
9,263,527 |
<feature_engineering> | numerical_cols = ['Fare']
categorical_cols = ['Pclass', 'Title', 'Embarked', 'Fam_type', 'Ticket_len', 'Ticket_lett']
numerical_transformer = SimpleImputer(strategy='median')
categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='most_frequent')) ,
('onehot', OneHotEncoder(handle_unknown='ign... | Titanic - Machine Learning from Disaster |
9,263,527 |
<merge> | predictions = titanic_pipeline.predict(X_test ) | Titanic - Machine Learning from Disaster |
9,263,527 | <merge><EOS> | output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print('Your submission was successfully saved!' ) | Titanic - Machine Learning from Disaster |
1,155,388 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
1,155,388 |
<feature_engineering> | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
submission = pd.read_csv('.. /input/submission/final submission.csv')
submission.to_csv('test_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
1,155,388 |
<drop_column> | def find_missing(data):
count_missing = data.isnull().sum().values
total = data.shape[0]
ratio_missing = count_missing/total
return pd.DataFrame(data={'missing_count':count_missing, 'missing_ratio':ratio_missing}, index=data.columns.values)
find_missing(train ) | Titanic - Machine Learning from Disaster |
1,155,388 |
<drop_column> | def find_cabin(cabin_list):
find_cabin = []
nan_find = cabin_list.isnull()
for i in range(len(cabin_list)) :
if nan_find[i]:
temp = cabin_list[i]
else:
temp = cabin_list[i][0]
find_cabin.append(temp)
return find_cabin
train['Cabin_first_letter'] = find_cabin(train.Cabin ) | Titanic - Machine Learning from Disaster |
1,155,388 |
<set_options> | def feature_engineering(df):
df2 = df.copy()
df2['is_class3'] = [1 if i == 3 else 0 for i in df2.Pclass]
df2['is_child'] = [1 if i <= 10 else 0 for i in df2.Age]
df2['no_parch'] = [1 if i == 0 else 0 for i in df2.Parch]
df2['low_fare'] = [1 if i < 5 else 0 for i in df2.Fare]
df2['Cabin_exist'] = cabin_exist(df2.Cabin)
... | Titanic - Machine Learning from Disaster |
1,155,388 | %matplotlib inline
%pylab inline
print(os.listdir(".. /input"))
warnings.filterwarnings(action='ignore' )<load_from_csv> | train_use[train_use.columns.tolist() ] = MICEImputer(initial_strategy='median', n_imputations=50, n_nearest_features=20, verbose=False ).fit_transform(train_use)
test_use[test_use.columns.tolist() ] = MICEImputer(initial_strategy='median', n_imputations=50, n_nearest_features=20, verbose=False ).fit_transform(test_use... | Titanic - Machine Learning from Disaster |
1,155,388 | df_train = pd.read_csv('.. /input/train_V2.csv')
df = reduce_mem_usage(df_train)
df.info()<import_modules> | X = train_use.iloc[:, 2:]
y = train_use.Survived
X_pred = test_use.iloc[:, 1:] | Titanic - Machine Learning from Disaster |
1,155,388 | from pandas_summary import DataFrameSummary
from sklearn.ensemble import RandomForestRegressor
from IPython.display import display
from sklearn import metrics
from scipy.cluster import hierarchy as hc
from pdpbox import pdp
from plotnine import *
from fastai.imports import *
from fastai.structured import *<filter> | params1 = {'learning_rate':np.arange(0.01,0.3, 0.01)}
gdbt = GradientBoostingClassifier(n_estimators=100, min_samples_split=300,
min_samples_leaf=20,max_depth=10, subsample=0.8,random_state=10)
gridscgdbt = GridSearchCV(gdbt, params1, cv=5)
gridscgdbt.fit(X, y)
print(gridscgdbt.best_params_)
print(gridscgdbt.best_s... | Titanic - Machine Learning from Disaster |
1,155,388 | df[df['winPlacePerc'].isnull() ]<drop_column> | params2 = {'max_depth':range(2,8,1), 'min_samples_split':range(20,200,20)}
gdbt2 = GradientBoostingClassifier(n_estimators=100, learning_rate=gridscgdbt.best_params_['learning_rate'],
subsample=0.8,random_state=10)
gridscgdbt2 = GridSearchCV(gdbt2, params2, cv=5)
gridscgdbt2.fit(X, y)
print(gridscgdbt2.best_params_)... | Titanic - Machine Learning from Disaster |
1,155,388 | df.drop(2744604, inplace=True)
df[df['winPlacePerc'].isnull() ]<define_variables> | params3 = {'max_features':np.arange(0.5,1,0.1), 'subsample':np.arange(0.5, 1, 0.1)}
gdbt3= GradientBoostingClassifier(n_estimators=100, learning_rate=gridscgdbt.best_params_['learning_rate'],
max_depth=gridscgdbt2.best_params_['max_depth'],
min_samples_split=gridscgdbt2.best_params_['min_samples_split'],
subsample=0.8,... | Titanic - Machine Learning from Disaster |
1,155,388 | train = df<feature_engineering> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
gbdt_best = GradientBoostingClassifier(n_estimators=100, learning_rate=gridscgdbt.best_params_['learning_rate'],
max_depth=gridscgdbt2.best_params_['max_depth'],
min_samples_split=50,
subsample=gridscgdbt3.best_params_['subsample... | Titanic - Machine Learning from Disaster |
1,155,388 | train['killsNorm'] = train['kills']*(( 100-train['playersJoined'])/100 + 1)
train['damageDealtNorm'] = train['damageDealt']*(( 100-train['playersJoined'])/100 + 1)
train['maxPlaceNorm'] = train['maxPlace']*(( 100-train['playersJoined'])/100 + 1)
train['matchDurationNorm'] = train['matchDuration']*(( 100-train['playe... | pd.DataFrame({'importance':gbdt_best.feature_importances_}, index=X.columns ) | Titanic - Machine Learning from Disaster |
1,155,388 | train['healsandboosts'] = train['heals'] + train['boosts']
train[['heals', 'boosts', 'healsandboosts']].tail()<feature_engineering> | test_ID = test.PassengerId
y_pred_test = gbdt_best.predict(X_pred)
final = pd.DataFrame({'PassengerId': test_ID, 'Survived': y_pred_test})
final.Survived = final.Survived.astype(int)
final.to_csv('final submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
12,185,937 | train['totalDistance'] = train['rideDistance'] + train['walkDistance'] + train['swimDistance']
train['killsWithoutMoving'] =(( train['kills'] > 0)&(train['totalDistance'] == 0))<feature_engineering> | gs = pd.read_csv("/kaggle/input/titanic/gender_submission.csv" ) | Titanic - Machine Learning from Disaster |
12,185,937 | train['headshot_rate'] = train['headshotKills'] / train['kills']
train['headshot_rate'] = train['headshot_rate'].fillna(0 )<drop_column> | train = pd.read_csv("/kaggle/input/titanic/train.csv")
train.head() | Titanic - Machine Learning from Disaster |
12,185,937 | train.drop(train[train['killsWithoutMoving'] == True].index, inplace=True )<filter> | test = pd.read_csv("/kaggle/input/titanic/test.csv")
test.head() | Titanic - Machine Learning from Disaster |
12,185,937 | train[train['roadKills'] > 10]<drop_column> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
12,185,937 | train.drop(train[train['roadKills'] > 10].index, inplace=True )<filter> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
12,185,937 | display(train[train['kills'] > 30].shape)
train[train['kills'] > 30]<drop_column> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
12,185,937 | train.drop(train[train['kills'] > 30].index, inplace=True )<drop_column> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
12,185,937 | train.drop(train[train['longestKill'] >= 1000].index, inplace=True )<drop_column> | pd.pivot_table(train, index = 'Survived', values = ['Age','SibSp','Parch','Fare'] ) | Titanic - Machine Learning from Disaster |
12,185,937 | train.drop(train[train['walkDistance'] >= 10000].index, inplace=True )<filter> | pd.pivot_table(train, index = 'Survived', columns = 'Pclass', values = 'Ticket' ,aggfunc ='count' ) | Titanic - Machine Learning from Disaster |
12,185,937 | train[train['rideDistance'] >= 20000]<drop_column> | pd.pivot_table(train, index = 'Survived', columns = 'Sex', values = 'Ticket' ,aggfunc ='count' ) | Titanic - Machine Learning from Disaster |
12,185,937 | train.drop(train[train['rideDistance'] >= 20000].index, inplace=True )<filter> | pd.pivot_table(train, index = 'Survived', columns = 'Embarked', values = 'Ticket' ,aggfunc ='count' ) | Titanic - Machine Learning from Disaster |
12,185,937 | train[train['swimDistance'] >= 2000]<drop_column> | train['Fam'] = train['SibSp'] + train['Parch']
train.head() | Titanic - Machine Learning from Disaster |
12,185,937 | train.drop(train[train['swimDistance'] >= 2000].index, inplace=True )<filter> | train[train['cabin_adv'] == 'T'].index
train.drop(index = 339, inplace = True)
train.cabin_adv.value_counts() | Titanic - Machine Learning from Disaster |
12,185,937 | train[train['weaponsAcquired'] >= 80]<drop_column> | train['numeric_ticket'] = train.Ticket.apply(lambda x: 1 if x.isnumeric() else 0)
train['ticket_letters'] = train.Ticket.apply(lambda x: ''.join(x.split(' ')[:-1] ).replace('.','' ).replace('/','' ).lower() if len(x.split(' ')[:-1])>0 else 0)
pd.set_option("max_rows", None)
train['ticket_letters'].value_counts() | Titanic - Machine Learning from Disaster |
12,185,937 | train.drop(train[train['weaponsAcquired'] >= 80].index, inplace=True )<drop_column> | train.Name.head(50)
train['name_title'] = train.Name.apply(lambda x: x.split(',')[1].split('.')[0].strip())
train['name_title'].value_counts() | Titanic - Machine Learning from Disaster |
12,185,937 | train.drop(train[train['heals'] >= 40].index, inplace=True )<drop_column> | test['Fam'] = test['SibSp'] + test['Parch']
test['cabin_adv'] = test.Cabin.apply(lambda x: str(x)[0])
test['numeric_ticket'] = test.Ticket.apply(lambda x: 1 if x.isnumeric() else 0)
test['ticket_letters'] = test.Ticket.apply(lambda x: ''.join(x.split(' ')[:-1] ).replace('.','' ).replace('/','' ).lower() if len(x.spli... | Titanic - Machine Learning from Disaster |
12,185,937 | train = train.drop(columns = ['matchType', 'Id', 'groupId', 'matchId'] )<prepare_x_and_y> | train.Age = train.Age.fillna(train.Age.median())
train.Fare = train.Fare.fillna(train.Fare.median())
train.dropna(subset=['Embarked'],inplace = True)
train.drop(columns=['Name', 'PassengerId', 'Cabin'], inplace = True)
train.head() | Titanic - Machine Learning from Disaster |
12,185,937 | df = df_sample.drop(columns = ['winPlacePerc'])
y = df_sample['winPlacePerc']<split> | test.Age = test.Age.fillna(train.Age.median())
test.Fare = test.Fare.fillna(train.Fare.median())
test.dropna(subset=['Embarked'],inplace = True)
passid = test['PassengerId'].copy()
test.drop(columns=['Name', 'PassengerId', 'Cabin'], inplace = True)
test.head() | Titanic - Machine Learning from Disaster |
12,185,937 | def split_vals(a, n : int):
return a[:n].copy() , a[n:].copy()
val_perc = 0.12
n_valid = int(val_perc * sample)
n_trn = len(df)-n_valid
raw_train, raw_valid = split_vals(df_sample, n_trn)
X_train, X_valid = split_vals(df, n_trn)
y_train, y_valid = split_vals(y, n_trn)
print('Sample train shape: ', X_train.shape,
'S... | df = pd.concat([train.assign(ind=1), test.assign(ind=0)])
df_hot = pd.get_dummies(df[['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Ticket', 'Fare', 'Embarked', 'Fam', 'cabin_adv', 'numeric_ticket', 'ticket_letters', 'name_title', 'ind']])
df_hot.head() | Titanic - Machine Learning from Disaster |
12,185,937 | def print_score(m : RandomForestRegressor):
res = ['mae train: ', mean_absolute_error(m.predict(X_train), y_train),
'mae val: ', mean_absolute_error(m.predict(X_valid), y_valid)]
if hasattr(m, 'oob_score_'): res.append(m.oob_score_)
print(res )<train_model> | test_hot, train_hot = df_hot[df_hot["ind"].eq(0)], df_hot[df_hot["ind"].eq(1)]
| Titanic - Machine Learning from Disaster |
12,185,937 | m1 = RandomForestRegressor(n_estimators=40, min_samples_leaf=3, max_features='sqrt',
n_jobs=-1)
m1.fit(X_train, y_train)
print_score(m1 )<compute_train_metric> | scale = StandardScaler()
train_hot[['Age','SibSp','Parch','Fare', 'Fam']]= scale.fit_transform(train_hot[['Age','SibSp','Parch','Fare', 'Fam']])
train_hot.head() | Titanic - Machine Learning from Disaster |
12,185,937 | fi = rf_feat_importance(m1, df); fi[:10]<features_selection> | scale = StandardScaler()
test_hot[['Age','SibSp','Parch','Fare', 'Fam']]= scale.fit_transform(test_hot[['Age','SibSp','Parch','Fare', 'Fam']])
test_hot.head() | Titanic - Machine Learning from Disaster |
12,185,937 | to_keep = fi[fi.imp>0.005].cols
print('Significant features: ', len(to_keep))
to_keep<split> | Y_train = train['Survived']
Y_train.head() | Titanic - Machine Learning from Disaster |
12,185,937 | df_keep = df[to_keep].copy()
X_train, X_valid = split_vals(df_keep, n_trn )<train_model> | from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC | Titanic - Machine Learning from Disaster |
12,185,937 | m2 = RandomForestRegressor(n_estimators=80, min_samples_leaf=3, max_features='sqrt',
n_jobs=-1)
m2.fit(X_train, y_train)
print_score(m2 )<split> | xgb = XGBClassifier(random_state =1, learning_rate = 0.5, min_child_weight = 0.03)
cv = cross_val_score(xgb,train_hot,Y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
12,185,937 | val_perc_full = 0.12
n_valid_full = int(val_perc_full * len(train))
n_trn_full = len(train)-n_valid_full
df_full = train.drop(columns = ['winPlacePerc'])
y = train['winPlacePerc']
df_full = df_full[to_keep]
X_train, X_valid = split_vals(df_full, n_trn_full)
y_train, y_valid = split_vals(y, n_trn_full)
print('Sample ... | rfc = RandomForestClassifier(n_estimators=100, max_depth=3, random_state=2)
cv = cross_val_score(rfc,train_hot,Y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
12,185,937 | m3 = RandomForestRegressor(n_estimators=60, min_samples_leaf=3, max_features=0.5, n_jobs=-1)
m3.fit(X_train, y_train)
print_score(m3 )<load_from_csv> | svc = SVC(probability = True)
cv = cross_val_score(svc,train_hot,Y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
12,185,937 | test = pd.read_csv('.. /input/test_V2.csv' )<feature_engineering> | X_train, X_valid, y_train, y_valid = train_test_split(
train_hot, Y_train, test_size=0.33, random_state=42 ) | Titanic - Machine Learning from Disaster |
12,185,937 | test['headshot_rate'] = test['headshotKills'] / test['kills']
test['headshot_rate'] = test['headshot_rate'].fillna(0)
test['totalDistance'] = test['rideDistance'] + test['walkDistance'] + test['swimDistance']
test['playersJoined'] = test.groupby('matchId')['matchId'].transform('count')
test['killsNorm'] = test['kills... | svc = SVC(probability = True)
svc.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
12,185,937 | predictions = np.clip(a = m3.predict(test_pred), a_min = 0.0, a_max = 1.0)
pred_df = pd.DataFrame({'Id' : test['Id'], 'winPlacePerc' : predictions})
pred_df.to_csv("submission.csv", index=False )<define_variables> | xgb = XGBClassifier(random_state =1, learning_rate = 0.5, min_child_weight = 0.03)
xgb.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
12,185,937 | np.random.seed(7777 )<load_from_csv> | dl1 = Sequential()
dl1.add(Dense(1002, activation='relu'))
dl1.add(Dense(512, activation='relu'))
dl1.add(Dense(1, activation='sigmoid'))
dl1.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
dl1.fit(X_train, y_train, epochs=150, batch_size=10)
_, accuracy = dl1.evaluate(X_train, y_train)
p... | Titanic - Machine Learning from Disaster |
12,185,937 | train_df = pd.read_csv(".. /input/train_V2.csv")
test_df = pd.read_csv(".. /input/test_V2.csv" )<categorify> | dl2 = Sequential()
dl2.add(Dense(1002, activation='relu'))
dl2.add(Dense(512, activation='relu'))
dl2.add(Dense(256, activation='relu'))
dl2.add(Dense(1, activation='sigmoid'))
dl2.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
dl2.fit(X_train, y_train, epochs=150, batch_size=10)
_, accur... | Titanic - Machine Learning from Disaster |
12,185,937 | matchTyp = ['squad-fpp', 'duo', 'solo-fpp', 'squad', 'duo-fpp', 'solo',
'normal-squad-fpp', 'crashfpp', 'flaretpp', 'normal-solo-fpp',
'flarefpp', 'normal-duo-fpp', 'normal-duo', 'normal-squad',
'crashtpp', 'normal-solo']
mapping = {}
for i, j in enumerate(matchTyp):
mapping[i] = j
train_df["matchTypeMap"] = train_df["... | knn = KNeighborsClassifier(algorithm= 'auto', n_neighbors = 7,weights= 'uniform')
knn.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
12,185,937 | train_df.drop(["matchType"], axis =1, inplace=True)
test_df.drop(["matchType"], axis =1, inplace=True)
train_df.dropna(inplace = True)
train_df.isnull().any().any()<prepare_x_and_y> | lr = LogisticRegression(max_iter = 2000,
solver = 'liblinear')
lr.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
12,185,937 | X = train_df.drop(["Id", "groupId", "matchId", "winPlacePerc"], axis = 1)
y = train_df["winPlacePerc"]
test = test_df.drop(["Id", "groupId", "matchId"], axis = 1 )<split> | rf = RandomForestClassifier(random_state = 1)
rf.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
12,185,937 | X_train_s, X_val_s, y_train_s, y_val_s = train_test_split(X, y, test_size = 0.5)
del X
del y<train_model> | valid_preds1 = svc.predict(X_valid)
valid_preds2 = xgb.predict(X_valid)
valid_preds_ur3 = dl1.predict(X_valid)
valid_preds3 = [round(x[0])for x in valid_preds_ur3]
valid_preds_ur4 = dl2.predict(X_valid)
valid_preds4 = [round(x[0])for x in valid_preds_ur4]
valid_preds5 = knn.predict(X_valid)
valid_preds6 = lr.predi... | Titanic - Machine Learning from Disaster |
12,185,937 | params = {
'learning_rate': 0.3,
'num_leaves': 20,
'feature_fraction': 0.9,
'min_data_in_leaf': 100,
'lambda_l2': 4,
'objective': 'regression_l2',
'metric': 'mae',
'seed': 123}
lgb_dataset = lightgbm.Dataset(X_train_s, y_train_s)
lgb_valid = lightgbm.Dataset(X_val_s, y_val_s)
lgb_model = lightgbm.train(params, lgb_da... | print("SVC:", accuracy_score(y_valid, valid_preds1))
print("XGB:", accuracy_score(y_valid, valid_preds2))
print("DL1:", accuracy_score(y_valid, valid_preds3))
print("DL2:", accuracy_score(y_valid, valid_preds4))
print("KNN:", accuracy_score(y_valid, valid_preds5))
print("LR:", accuracy_score(y_valid, valid_preds5))
pri... | Titanic - Machine Learning from Disaster |
12,185,937 | kfold = 15
skf = KFold(n_splits=kfold, random_state=42)
pred2 = pd.DataFrame()
pred2['winPlacePerc'] = np.zeros(len(X_val_s))<train_model> | test_preds1 = svc.predict(test_hot)
test_preds2 = xgb.predict(test_hot)
test_preds_ur3 = dl1.predict(test_hot)
test_preds3 = [round(x[0])for x in test_preds_ur3]
test_preds_ur4 = dl2.predict(test_hot)
test_preds4 = [round(x[0])for x in test_preds_ur4]
test_preds5 = knn.predict(test_hot)
test_preds6 = lr.predict(te... | Titanic - Machine Learning from Disaster |
12,185,937 | cat_model = CatBoostRegressor(iterations=50, depth=3, learning_rate=0.1, loss_function='RMSE')
cat_model.fit(X_train_s, y_train_s)
pred3 = cat_model.predict(X_val_s )<predict_on_test> | stacked_predictions = np.column_stack([valid_preds1,valid_preds2,valid_preds3,valid_preds4, valid_preds5, valid_preds6, valid_preds7])
stacked_test_predictions = np.column_stack([test_preds1,test_preds2,test_preds3,test_preds4, test_preds5, test_preds6, test_preds7] ) | Titanic - Machine Learning from Disaster |
12,185,937 | xgb_model = xgboost.XGBRegressor(max_depth=11)
for i,(train_index, test_index)in enumerate(skf.split(X_train_s, y_train_s)) :
X_train, X_valid = X_train_s.iloc[train_index], X_train_s.iloc[test_index]
y_train, y_valid = y_train_s.iloc[train_index], y_train_s.iloc[test_index]
xgb_model.fit(X_train, y_train, eval_set=[(... | meta_model = LinearRegression()
meta_model.fit(stacked_predictions, y_valid)
meta_predictions_ur = meta_model.predict(stacked_test_predictions)
preds = [round(x)for x in meta_predictions_ur]
preds | Titanic - Machine Learning from Disaster |
12,185,937 | test_pred_lgm = lgb_model.predict(test)
test_pred_xgb = xgb_model.predict(test)
test_pred_cat = cat_model.predict(test )<concatenate> | df = pd.DataFrame({'PassengerId': passid,
'Survived' : preds})
df.Survived = df.Survived.astype(int)
print(df.shape)
df.head() | Titanic - Machine Learning from Disaster |
12,185,937 | <choose_model_class><EOS> | df.to_csv('submission_final.csv', index =False ) | Titanic - Machine Learning from Disaster |
10,628,396 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<create_dataframe> | warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
10,628,396 | test_id = test_df["Id"].map(str)
submit_xg = pd.DataFrame({'Id': test_id, "winPlacePerc": test_stack_model} , columns=['Id', 'winPlacePerc'] )<save_to_csv> | train = pd.read_csv(".. /input/titanic/train.csv")
test = pd.read_csv(".. /input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
10,628,396 | submit_xg.to_csv("submission.csv", index = False )<set_options> | train =train.astype({"Pclass":"category"})
test =test.astype({"Pclass":"category"} ) | Titanic - Machine Learning from Disaster |
10,628,396 | %load_ext autoreload
%autoreload 2
%matplotlib inline<import_modules> | y=train["Survived"].values
test_index = len(y)-1
data = pd.concat([train,test],sort=False ).reset_index(drop=True)
data.info() | Titanic - Machine Learning from Disaster |
10,628,396 | from fastai.imports import *
from pandas_summary import DataFrameSummary
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from IPython.display import display
from sklearn import metrics
from sklearn.model_selection import train_test_split
import gc<set_options> | data["Title"]= data["Name"].str.split(", ",expand=True)[1].str.split(".",expand=True)[0]
mapping = {'Mlle': 'Miss', 'Major': 'Mr', 'Col': 'Mr', 'Sir': 'Mr', 'Don': 'Mr', 'Mme': 'Miss',
'Jonkheer': 'Mr', 'Lady': 'Mrs', 'Capt': 'Mr', 'Countess': 'Mrs', 'Ms': 'Miss', 'Dona': 'Mrs'}
data.replace({'Title': mapping}, inplace... | Titanic - Machine Learning from Disaster |
10,628,396 | def set_plot_sizes(sml, med, big):
plt.rc('font', size=sml)
plt.rc('axes', titlesize=sml)
plt.rc('axes', labelsize=med)
plt.rc('xtick', labelsize=sml)
plt.rc('ytick', labelsize=sml)
plt.rc('legend', fontsize=sml)
plt.rc('figure', titlesize=big)
def parallel_trees(m, fn, n_jobs=8):
return list(ProcessPoolExecutor... | data["Fam_size"] = data["SibSp"]+data["Parch"]+1
def mapping(title,tick_size):
for(ind,val)in zip(age_impute,age_impute.values()):
if(( ind[0]==title)&(ind[1]==tick_size)) :
return val
age_impute=data.groupby(["Title","Fam_size"])["Age"].median().astype("float64" ).to_dict() | Titanic - Machine Learning from Disaster |
10,628,396 | PATH_INPUT = "/kaggle/input/"
PATH_WORKING = "/kaggle/working/"
PATH_TMP = "/tmp/"<load_from_csv> | data.loc[data["Age"].isnull() ,"Age"]= data.loc[data["Age"].isnull() ,["Title","Fam_size"]].apply(lambda x: mapping(x[0],x[1]),axis=1 ) | Titanic - Machine Learning from Disaster |
10,628,396 | df_raw = pd.read_csv(f'{PATH_INPUT}train_V2.csv' )<load_from_csv> | data["Age_bin"] = pd.qcut(data["Age"],10,duplicates="drop")
label = LabelEncoder()
data['Age_bin'] = label.fit_transform(data['Age_bin'].astype(str)) | Titanic - Machine Learning from Disaster |
10,628,396 | df_test_raw = pd.read_csv(f'{PATH_INPUT}test_V2.csv' )<categorify> | data["Fare"].fillna(data[~data["Fare"].isnull() ].groupby("Pclass")["Fare"].mean() [3],inplace=True)
data['Last_Name'] = data['Name'].apply(lambda x: str.split(x, ",")[0])
data['Family_Survival'] = 0.5
for grp, grp_data in data[['Survived','Name', 'Last_Name', 'Fare', 'Ticket', 'PassengerId',
'SibSp', 'Parch', 'Age',... | Titanic - Machine Learning from Disaster |
10,628,396 | df_raw.to_feather(f'{PATH_TMP}train_raw')
df_test_raw.to_feather(f'{PATH_TMP}test_raw' )<feature_engineering> | data["Embarked"].fillna(data["Embarked"].mode() [0],inplace=True)
data["Fare"]=data["Fare"]/data["Fam_size"]
data["Fare"].fillna(data[~data["Fare"].isnull() ].groupby("Pclass")["Fare"].mean() [3],inplace=True ) | Titanic - Machine Learning from Disaster |
10,628,396 | df_raw["winPlace"] = round(df_raw["winPlacePerc"] /(1.0/(df_raw["maxPlace"] - 1)) )<drop_column> | data["Fare_bin"] = pd.qcut(data["Fare"],13)
label = LabelEncoder()
data['Fare_bin'] = label.fit_transform(data['Fare_bin'].astype(str)) | Titanic - Machine Learning from Disaster |
10,628,396 | df_raw.drop(labels="winPlace", axis=1, inplace=True )<sort_values> | data.drop(["Name","SibSp","Parch","Ticket","Age","Fare","PassengerId","Last_Name","Survived","Title","Cabin"],inplace=True,axis=1 ) | Titanic - Machine Learning from Disaster |
10,628,396 | df_raw.isnull().sum().sort_values(ascending=False)/len(df_raw )<correct_missing_values> | data.isnull().sum() /data.shape[0]*100 | Titanic - Machine Learning from Disaster |
10,628,396 | df_raw.dropna(inplace=True)
df_raw.shape<count_missing_values> | data = pd.get_dummies(data,drop_first=True ) | Titanic - Machine Learning from Disaster |
10,628,396 | df_test_raw.isnull().sum().any()<concatenate> | train_1 = data.iloc[:test_index+1,:]
test_1 = data.iloc[test_index+1:,:] | Titanic - Machine Learning from Disaster |
10,628,396 | train_cats(df_raw )<define_variables> | X_train,X_test,y_train,y_test = train_test_split(train_1,y,test_size=0.2, random_state=42 ) | Titanic - Machine Learning from Disaster |
10,628,396 | ids = df_test_raw["Id"]<concatenate> | sk_fold = StratifiedKFold(10,shuffle=True, random_state=42)
sc =StandardScaler()
X_train= sc.fit_transform(X_train)
X_train_1= sc.transform(train_1.values)
X_test= sc.transform(X_test)
X_submit= sc.transform(test_1.values)
log_reg = LogisticRegression()
ran_for = RandomForestClassifier()
ada_boost = AdaBoostClassi... | Titanic - Machine Learning from Disaster |
10,628,396 | apply_cats(df_test_raw, df_raw )<prepare_x_and_y> | stack_list[7].fit(X_train_1,y)
y_submit = stack_list[7].predict(X_submit)
submit = pd.DataFrame({
"PassengerId": test.PassengerId,
"Survived": y_submit
} ) | Titanic - Machine Learning from Disaster |
10,628,396 | df, y, _ = proc_df(df_raw, 'winPlacePerc', skip_flds=["Id","groupId","matchId"], subset=100000 )<categorify> | submit.PassengerId = submit.PassengerId.astype(int)
submit.Survived = submit.Survived.astype(int)
submit.to_csv("titanic_submit.csv", index=False)
| Titanic - Machine Learning from Disaster |
10,562,196 | df_test, _, _ = proc_df(df_test_raw, skip_flds=["Id","groupId","matchId"] )<split> | train_data=pd.read_csv('/kaggle/input/titanic/train.csv')
train_data | Titanic - Machine Learning from Disaster |
10,562,196 | X_train, X_valid, y_train, y_valid = train_test_split(df, y, test_size=0.2)
print(X_train.shape, X_valid.shape, y_train.shape, y_valid.shape )<compute_train_metric> | test_data=pd.read_csv('/kaggle/input/titanic/test.csv')
test_data | Titanic - Machine Learning from Disaster |
10,562,196 | def mae(x,y): return abs(x-y ).mean()
def fixWinPlacePerc(X,y):
y = round(y /(1.0/(X - 1)))/(X - 1)
return y
def print_score(m):
res = [mae(fixWinPlacePerc(X_train["maxPlace"], m.predict(X_train)) , y_train),
mae(fixWinPlacePerc(X_valid["maxPlace"], m.predict(X_valid)) , y_valid)]
print(res )<train_model> | train_results = train_data["Survived"].copy()
train_data.drop("Survived", axis=1, inplace=True, errors="ignore")
titanic = pd.concat([train_data, test_data])
traindex = train_data.index
testdex = test_data.index | Titanic - Machine Learning from Disaster |
10,562,196 | %%time
m = RandomForestRegressor(n_estimators=10, n_jobs=-1)
m.fit(X_train, y_train)
print_score(m )<set_options> | titanic[titanic['Cabin']=='B51 B53 B55']
| Titanic - Machine Learning from Disaster |
10,562,196 | gc.collect()<set_options> | titanic.index=range(len(titanic))
| Titanic - Machine Learning from Disaster |
10,562,196 | set_rf_samples(20000 )<train_model> | titanic[pd.isnull(titanic['Fare'])] | Titanic - Machine Learning from Disaster |
10,562,196 | %%time
m = RandomForestRegressor(n_estimators=10, n_jobs=-1)
m.fit(X_train, y_train)
print_score(m )<train_model> | mean=titanic[titanic['Pclass']==3][titanic['Embarked']=='S'][titanic['Sex']=='male'][titanic['Age']>=40][titanic['SibSp']==0][titanic['Parch']==0]
mean['Fare'].describe() | Titanic - Machine Learning from Disaster |
10,562,196 | %%time
m = RandomForestRegressor(n_estimators=80, max_features=0.5, n_jobs=-1)
m.fit(X_train, y_train)
print_score(m )<train_model> | titanic[['Fare']]=titanic[['Fare']].fillna(value=7.69 ) | Titanic - Machine Learning from Disaster |
10,562,196 | %%time
m = RandomForestRegressor(n_estimators=80, max_features=0.5, min_samples_leaf=3, n_jobs=-1)
m.fit(X_train, y_train)
print_score(m )<train_model> | titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
10,562,196 | %%time
m = RandomForestRegressor(n_estimators=120, max_features=0.5, min_samples_leaf=3, n_jobs=-1)
m.fit(X_train, y_train)
print_score(m )<train_model> | titanic["Title"] = titanic.Name.str.extract('([A-Za-z]+)\.', expand=False)
pd.crosstab(titanic['Title'], titanic['Sex'])
| Titanic - Machine Learning from Disaster |
10,562,196 | %%time
reset_rf_samples()
m = RandomForestRegressor(n_estimators=120, max_features=0.5, min_samples_leaf=3, n_jobs=-1)
m.fit(X_train, y_train)
print_score(m )<set_options> | titanic['Title'] = titanic['Title'].replace('Mlle', 'Miss')
titanic['Title'] = titanic['Title'].replace('Ms', 'Miss')
titanic['Title'] = titanic['Title'].replace('Mme', 'Mrs')
| Titanic - Machine Learning from Disaster |
10,562,196 | gc.collect()<compute_test_metric> | titanic['Title'] = titanic['Title'].replace(['Lady', 'Countess','Capt','Col','Don', 'Dr', 'Major','Rev', 'Sir', 'Jonkheer', 'Dona'], 'Not married' ) | Titanic - Machine Learning from Disaster |
10,562,196 | fi = rf_feat_importance(m, df); fi<train_model> | titanic['Title'] = titanic['Title'].replace(['Mr', 'Mrs'], 'Married' ) | Titanic - Machine Learning from Disaster |
10,562,196 | %%time
reset_rf_samples()
m = RandomForestRegressor(n_estimators=120, max_features=0.5, min_samples_leaf=3, n_jobs=-1)
m.fit(X_train, y_train)
print_score(m )<train_model> | titanic["Surname"] = titanic.Name.str.split(',' ).str.get(0 ) | Titanic - Machine Learning from Disaster |
10,562,196 | def get_oob(X):
set_rf_samples(20000)
m = RandomForestRegressor(n_estimators=120, max_features=0.5, min_samples_leaf=3, n_jobs=-1, oob_score=True)
m.fit(X, y_train)
return m.oob_score_<define_variables> | titanic=titanic.drop(['Name'],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.