kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,420,076 | for f in train.columns:
if train[f].dtype=='object':
lbl = LabelEncoder()
lbl.fit(list(train[f].values)+ list(test[f].values))
train[f] = lbl.transform(list(train[f].values))
test[f] = lbl.transform(list(test[f].values))
train = train.reset_index()
test = test.reset_index()
<drop_column> | for dataset in all_data:
dataset['IsAlone'] = 0
dataset.loc[dataset['FamilySize'] == 1, 'IsAlone'] = 1 | Titanic - Machine Learning from Disaster |
14,420,076 | features = list(train)
features.remove('isFraud')
target = 'isFraud'<split> | for dataset in all_data:
dataset['Sex'] = dataset['Sex'].map({'female': 0, 'male': 1} ).astype(int)
train.head() | Titanic - Machine Learning from Disaster |
14,420,076 | bayesian_tr_idx, bayesian_val_idx = train_test_split(train, test_size = 0.3, random_state = 42, stratify = train[target])
bayesian_tr_idx = bayesian_tr_idx.index
bayesian_val_idx = bayesian_val_idx.index<choose_model_class> | for dataset in all_data:
dataset['Title'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False)
pd.crosstab(train['Title'], train['Sex'] ) | Titanic - Machine Learning from Disaster |
14,420,076 | def LGB_bayesian(
num_leaves,
bagging_fraction,
feature_fraction,
min_child_weight,
min_data_in_leaf,
max_depth,
reg_alpha,
reg_lambda
):
num_leaves = int(num_leaves)
min_data_in_leaf = int(min_data_in_leaf)
max_depth = int(max_depth)
assert type(num_leaves)== int
assert type(min_data_in_leaf)== int
assert type(ma... | for dataset in all_data:
dataset['Title'] = dataset['Title'].replace(['Capt', 'Col', 'Countess', 'Don', 'Dr', \
'Jonkheer', 'Major', 'Rev', 'Sir'], 'Rare')
dataset['Title'] = dataset['Title'].replace(['Ms', 'Mlle'], 'Miss')
dataset['Title'] = dataset['Title'].replace(['Mme','Lady'], 'Mrs')
train[['Title', 'Survived'... | Titanic - Machine Learning from Disaster |
14,420,076 | bounds_LGB = {
'num_leaves':(31, 500),
'min_data_in_leaf':(20, 200),
'bagging_fraction' :(0.1, 0.9),
'feature_fraction' :(0.1, 0.9),
'min_child_weight':(0.00001, 0.01),
'reg_alpha':(1, 2),
'reg_lambda':(1, 2),
'max_depth':(-1,50),
}<choose_model_class> | title_mapping = {'Mr': 1,'Mrs': 2, 'Miss': 3, 'Master': 4, 'Rare': 5}
for dataset in all_data:
dataset['Title'] = dataset['Title'].map(title_mapping)
dataset['Title'] = dataset['Title'].fillna(0)
train.head() | Titanic - Machine Learning from Disaster |
14,420,076 | LGB_BO = BayesianOptimization(LGB_bayesian, bounds_LGB, random_state=42 )<define_variables> | title_mapping = {"S": 1, "C": 2, "Q": 3}
for dataset in all_data:
dataset['Embarked'] = dataset['Embarked'].map(title_mapping)
dataset['Embarked'] = dataset['Embarked'].fillna(0)
train.head() | Titanic - Machine Learning from Disaster |
14,420,076 | init_points = 10
n_iter = 15<find_best_params> | for dataset in all_data:
dataset['Fare'] = dataset['Fare'].fillna(train['Fare'].median() ) | Titanic - Machine Learning from Disaster |
14,420,076 | with warnings.catch_warnings() :
warnings.filterwarnings('ignore')
LGB_BO.maximize(init_points=init_points, n_iter=n_iter, acq='ucb', xi=0.0, alpha=1e-6 )<load_from_csv> | train = train.drop(['Ticket', 'Cabin', 'Name', 'PassengerId'], axis=1)
test = test.drop(['Ticket', 'Cabin', 'Name'], axis=1)
all_data = [train, test] | Titanic - Machine Learning from Disaster |
14,420,076 | train_identity = pd.read_csv('.. /input/train_identity.csv')
train_transaction = pd.read_csv('.. /input/train_transaction.csv')
train = train_transaction.merge(train_identity, on='TransactionID', how='left')
del train_identity, train_transaction
gc.collect()
test_identity = pd.read_csv('.. /input/test_identity.csv')... | y = train['Survived']
features = ['Pclass', 'Sex', 'Embarked', 'Title', 'Parch']
X = pd.get_dummies(train[features])
X_test = pd.get_dummies(test[features])
model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=1)
model.fit(X, y)
predictions = model.predict(X_test)
output = pd.DataFrame({'Pass... | Titanic - Machine Learning from Disaster |
14,420,076 | <prepare_x_and_y><EOS> | np.count_nonzero(predictions==1)/np.count_nonzero(predictions==0 ) | Titanic - Machine Learning from Disaster |
14,550,817 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<init_hyperparams> | pd.plotting.register_matplotlib_converters()
%matplotlib inline
print('Setup complete')
| Titanic - Machine Learning from Disaster |
14,550,817 | params = {'num_leaves': int(LGB_BO.max['params']['num_leaves']),
'min_child_weight': LGB_BO.max['params']['min_child_weight'],
'feature_fraction': LGB_BO.max['params']['feature_fraction'],
'bagging_fraction': LGB_BO.max['params']['bagging_fraction'],
'min_data_in_leaf': int(LGB_BO.max['params']['min_data_in_leaf']),
'o... | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
train.head() | Titanic - Machine Learning from Disaster |
14,550,817 | NFOLDS = 5
folds = KFold(n_splits=NFOLDS)
columns = X.columns
splits = folds.split(X, y)
y_preds = np.zeros(X_test.shape[0])
y_oof = np.zeros(X.shape[0])
score = 0
for fold_n,(train_index, valid_index)in enumerate(splits):
X_train, X_valid = X[columns].iloc[train_index], X[columns].iloc[valid_index]
y_train, y_vali... | train.isnull() | Titanic - Machine Learning from Disaster |
14,550,817 | sub = pd.read_csv('.. /input/sample_submission.csv')
sub['isFraud'] = y_preds
sub.to_csv('submission.csv', index=False )<set_options> | train.isna().sum() | Titanic - Machine Learning from Disaster |
14,550,817 | seed = 10
np.random.seed(seed)
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
<load_from_csv> | train['Survived'].value_counts(normalize=True)
| Titanic - Machine Learning from Disaster |
14,550,817 | %%time
train_transaction = pd.read_csv('.. /input/ieee-fraud-detection/train_transaction.csv', index_col='TransactionID')
test_transaction = pd.read_csv('.. /input/ieee-fraud-detection/test_transaction.csv', index_col='TransactionID')
sample_submission = pd.read_csv('.. /input/ieee-fraud-detection/sample_submission.c... | train.groupby('Pclass' ).mean() ['Survived']*100 | Titanic - Machine Learning from Disaster |
14,550,817 | train_transaction['hour'] = train_transaction['TransactionDT'].map(lambda x:(x//3600)%24)
test_transaction['hour'] = test_transaction['TransactionDT'].map(lambda x:(x//3600)%24)
train_transaction['weekday'] = train_transaction['TransactionDT'].map(lambda x:(x//(3600 * 24)) %7)
test_transaction['weekday'] = test_tran... | train.groupby(['Pclass', 'Sex'] ).Survived.mean() | Titanic - Machine Learning from Disaster |
14,550,817 | cols = "TransactionDT,TransactionAmt,ProductCD,card1,card2,card3,card4,card5,card6,addr1,addr2,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,M1,M2,M3,M4,M5,M6,M7,M8,M9".split(",")
train_test = train_transaction[cols].append(test_transaction[cols])
for col in "ProductCD,card1,card2,card3,card4,card5,card6,addr1,addr2... | test['Titles'] = test['Name'].apply(lambda x: x.split(',')[1].split('.')[0].strip())
train['Titles'] = train['Name'].apply(lambda x: x.split(',')[1].split('.')[0].strip())
test['Titles'].value_counts() | Titanic - Machine Learning from Disaster |
14,550,817 | train_identity = pd.read_csv('.. /input/ieee-fraud-detection/train_identity.csv', index_col='TransactionID')
test_identity = pd.read_csv('.. /input/ieee-fraud-detection/test_identity.csv', index_col='TransactionID')
<drop_column> | train['Titles'].value_counts()
| Titanic - Machine Learning from Disaster |
14,550,817 | col_del = []
for i in range(339):
col = "V" + str(i+1)
s = train_transaction[col].fillna(0 ).map(lambda x:0 if x%1 == 0 else 1 ).sum()
if s > 100:
print(col,s)
col_del.append(col)
<categorify> | train['Titles'].replace(['Mme', 'Ms', 'Lady', 'Mlle', 'the Countess', 'Dona'], 'Miss', inplace=True)
test['Titles'].replace(['Mme', 'Ms', 'Lady', 'Mlle', 'the Countess', 'Dona'], 'Miss', inplace=True)
train['Titles'].replace(['Major', 'Col', 'Capt', 'Don', 'Sir', 'Jonkheer'], 'Mr', inplace=True)
test['Titles'].repla... | Titanic - Machine Learning from Disaster |
14,550,817 | train = train_transaction.merge(train_identity, how='left', left_index=True, right_index=True)
test = test_transaction.merge(test_identity, how='left', left_index=True, right_index=True)
print(train.shape)
print(test.shape)
y_train = train['isFraud'].copy()
del train_transaction, train_identity, test_transaction, t... | train['Ticket_letters'] = train.Ticket.apply(lambda x: x[:2])
test['Ticket_letters'] = test.Ticket.apply(lambda x: x[:2])
train['Ticket_length'] = train.Ticket.apply(lambda x: len(x))
test['Ticket_length'] = test.Ticket.apply(lambda x: len(x)) | Titanic - Machine Learning from Disaster |
14,550,817 | %%time
X_train = reduce_mem_usage(X_train)
X_test = reduce_mem_usage(X_test)
debug = False
if debug:
split_pos = X_train.shape[0]*4//5
y_test = y_train.iloc[split_pos:]
y_train = y_train.iloc[:split_pos]
X_test = X_train.iloc[split_pos:,:]
X_train = X_train.iloc[:split_pos,:]<set_options> | y = train['Survived']
features = ['Pclass', 'Fare', 'Titles', 'Embarked', 'Fam_group', 'Ticket_length', 'Ticket_letters']
X = train[features]
X.head() | Titanic - Machine Learning from Disaster |
14,550,817 | gc.collect()<train_model> | numerical_cols = ['Fare']
categorical_cols = ['Pclass', 'Titles', 'Embarked', 'Fam_group', 'Ticket_length', 'Ticket_letters']
numerical_transformer = SimpleImputer(strategy='median')
categorical_transformer = Pipeline(steps=[('imputer', SimpleImputer(strategy='most_frequent')) ,('onehot', OneHotEncoder(handle_unknown=... | Titanic - Machine Learning from Disaster |
14,550,817 | %%time
folds = 3
kf = KFold(n_splits = folds, shuffle = True, random_state=seed)
y_preds = np.zeros(X_test.shape[0])
i = 0
for tr_idx, val_idx in kf.split(X_train, y_train):
i+=1
clf = xgb.XGBClassifier(
n_estimators=700,
max_depth=9,
learning_rate=0.03,
subsample=0.9,
colsample_bytree=0.9,
tree_method='gpu_hist'
)... | predictions = titanic_pipeline.predict(X_test ) | Titanic - Machine Learning from Disaster |
14,550,817 | <init_hyperparams><EOS> | o = pd.DataFrame({'PassengerId': test.PassengerId, 'Survived': predictions})
o.to_csv('my_submission.csv', index=False)
print('Your submission was successfully saved!' ) | Titanic - Machine Learning from Disaster |
14,341,846 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<compute_test_metric> | !pip install seaborn==0.11.0 | Titanic - Machine Learning from Disaster |
14,341,846 | if debug:
print("debug:",roc_auc_score(y_test, y_preds))
print("debug:",roc_auc_score(y_test, y_preds2))
print("debug:",roc_auc_score(y_test,(y_preds + y_preds2)*0.5))<prepare_x_and_y> | pd.options.display.max_rows=200
pd.set_option('mode.chained_assignment', None)
simplefilter("ignore", category=ConvergenceWarning)
simplefilter("ignore", category=RuntimeWarning ) | Titanic - Machine Learning from Disaster |
14,341,846 | features = [x for x in X_train.columns]
cate = [x for x in X_train.columns if(x == 'ProductCD' or x in ['card1','card2'] or x.startswith("addr")or
x.endswith("domain")or x.startswith("Device")) and not x.endswith("count")and not x == "id_11" ]
print(cate)
verbose_eval = 30
num_rounds = 800
folds = 3
kf = KFold(n_split... | train = pd.read_csv('/kaggle/input/titanic/train.csv', index_col='PassengerId')
test = pd.read_csv('/kaggle/input/titanic/test.csv', index_col='PassengerId' ) | Titanic - Machine Learning from Disaster |
14,341,846 | if debug:
print("debug:",roc_auc_score(y_test, y_preds))
print("debug:",roc_auc_score(y_test, y_preds2))
print("debug:",roc_auc_score(y_test, y_preds3))
print("debug:",roc_auc_score(y_test,(y_preds + y_preds3)*0.5))
print("debug:",roc_auc_score(y_test,(y_preds + y_preds2 + y_preds3*0.5)*0.33))
print("debug:",roc_auc_sc... | train.isna().sum() | Titanic - Machine Learning from Disaster |
14,341,846 | if not debug:
sample_submission['isFraud'] =(y_preds11*0.5 + y_preds*0.5 + y_preds2 + y_preds3*0.5)*0.33
sample_submission.to_csv('simple_ensemble6.csv')
<set_options> | test.isna().sum() | Titanic - Machine Learning from Disaster |
14,341,846 | print('loading libs...')
warnings.filterwarnings("ignore")
print('done' )<load_from_csv> | def imputer(df):
age_impute_series = df.groupby(['Pclass', 'Sex'] ).Age.transform('mean')
df.Age.fillna(age_impute_series, inplace=True)
df.Cabin = df.Cabin.str.extract(pat='([A-Z])')
df.Cabin.fillna('M', inplace=True)
df['Deck'] = df.Cabin.replace({'A':'ABC', 'B':'ABC', 'C':'ABC', 'D':'DE', 'E':'DE', 'F':'FG',
'G'... | Titanic - Machine Learning from Disaster |
14,341,846 | %%time
print('loading data...')
train = pd.read_pickle('.. /input/ieee-fe-with-some-eda/train_df.pkl')
test = pd.read_pickle('.. /input/ieee-fe-with-some-eda/test_df.pkl')
remove_features = pd.read_pickle('.. /input/ieee-fe-with-some-eda/remove_features.pkl')
sample_submission = pd.read_csv('.. /input/ieee-fraud-de... | train_imputed = imputer(train.copy())
test_imputed = imputer(test.copy() ) | Titanic - Machine Learning from Disaster |
14,341,846 | %%time
print('dropping target...')
y_train = train['isFraud'].copy()
X_train = train.drop('isFraud', axis=1)
X_test = test.copy()
train_cols = list(train.columns)
del train, test
gc.collect()
print('selecting features...')
remove_features = list(remove_features['features_to_remove'].values)
features_columns = [col... | def ticket_extractor(ticket):
alpha = re.sub('\d', '', ticket)
if alpha:
return alpha
else:
num = re.search('\d{1,9}', ticket)
return ticket
temp = train_imputed.copy()
temp['Ticket_extracted'] = temp.Ticket.apply(ticket_extractor)
for i in range(len(temp.Ticket)) :
try:
int(temp.Ticket_extracted.iloc[i])
temp.Tick... | Titanic - Machine Learning from Disaster |
14,341,846 | X_train = reduce_mem_usage(X_train)
X_test = reduce_mem_usage(X_test )<init_hyperparams> | temp = train_imputed.copy()
temp['Title'] = temp.Name.str.extract(pat='([a-zA-Z]+\.) ')
temp.Title[~temp.Title.isin(['Mr.', 'Miss.', 'Mrs.', 'Master.'])] = 'rare' | Titanic - Machine Learning from Disaster |
14,341,846 | params = {
'objective':'binary',
'boosting_type':'gbdt',
'metric':'auc',
'n_jobs':-1,
'max_depth':-1,
'tree_learner':'serial',
'min_data_in_leaf':30,
'n_estimators':1800,
'max_bin':255,
'verbose':-1,
'seed': 1229,
'learning_rate': 0.01,
'early_stopping_rounds':200,
'colsample_bytree': 0.5,
'num_leaves': 256,
'reg_alpha... | def feature_creator(df_train, df_test):
df_train['Fare_cat'] = pd.qcut(df_train['Fare'], 7)
df_test['Fare_cat'] = pd.qcut(df_test['Fare'], 7)
df_train['Fare_cat'] = LabelEncoder().fit_transform(df_train['Fare_cat'])
df_test['Fare_cat'] = LabelEncoder().fit_transform(df_test['Fare_cat'])
df_train['Age_cat'] = pd.cut... | Titanic - Machine Learning from Disaster |
14,341,846 | %%time
NFOLDS = 6
folds = KFold(n_splits=NFOLDS)
columns = X_train.columns
splits = folds.split(X_train, y_train)
y_preds = np.zeros(X_test.shape[0])
y_oof = np.zeros(X_train.shape[0])
score = 0
for fold_n,(train_index, valid_index)in enumerate(splits):
X_tr, X_val = X_train[columns].iloc[train_index], X_train[colu... | X_train, y_train, X_test = feature_creator(train_imputed.copy() , test_imputed.copy())
y_train = y_train.astype(int ) | Titanic - Machine Learning from Disaster |
14,341,846 | train_identity = pd.read_csv('/kaggle/input/ieee-fraud-detection/train_identity.csv', index_col = 'TransactionID')
print('Successfully loaded train_identity')
train_transaction = pd.read_csv('/kaggle/input/ieee-fraud-detection/train_transaction.csv', index_col = 'TransactionID')
print('Successfully loaded train_tran... | class FeatureEngineering(BaseEstimator, TransformerMixin):
def __init__(self, bin_fare=False, bin_age=True, family_size=True, bin_family_size=True,
drop_Name_length=False, drop_Ticket_frequency=False, drop_all=True, drop_Family_Survival=True,
drop_Ticket_extracted=False, scaling='StandardScaler', target_encode_title=Tr... | Titanic - Machine Learning from Disaster |
14,341,846 | def missing_values(df):
df1 = pd.DataFrame(df.isnull().sum() ).reset_index()
df1.columns = ['features', 'freq']
df1['percentage'] = df1['freq']/df.shape[0]
df1.sort_values('percentage', ascending = False, inplace = True)
return df1
missing_train = missing_values(train)
missing_train.columns = ['features', 'freq_tr', ... | param_grid_pipeline = {'feature_engineering__bin_fare':[True, False],
'feature_engineering__bin_age':[True, False],
'feature_engineering__family_size':[True, False],
'feature_engineering__bin_family_size':[True, False],
'feature_engineering__drop_Name_length':[False],
'feature_engineering__drop_Ticket_frequency':[False... | Titanic - Machine Learning from Disaster |
14,341,846 | missing_test = missing_values(test)
missing_test.columns = ['features', 'freq_te', 'percentage_te']
missing_test<merge> | pd.DataFrame(grid.cv_results_)['mean_test_score'].isna().sum() | Titanic - Machine Learning from Disaster |
14,341,846 | missing = missing_train.merge(missing_test, on = 'features')
missing.head(10 )<count_values> | X_train_fe = fe.fit_transform(X_train.copy())
X_train_fe | Titanic - Machine Learning from Disaster |
14,341,846 | train['id_24'].value_counts(normalize = True, dropna = False )<count_values> | fe.test = True | Titanic - Machine Learning from Disaster |
14,341,846 | test['id_24'].value_counts(normalize = True, dropna = False )<concatenate> | X_test_fe = fe.transform(X_test.copy())
X_test_fe | Titanic - Machine Learning from Disaster |
14,341,846 | drop_features = []
drop_features.append('id_24' )<drop_column> | def learning_curve_plotter(Model, X, y, params_1, params_2, step=50):
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
plt.figure(figsize=(16, 7))
for i,(name, params)in enumerate([params_1, params_2]):
train_score = []
val_score = []
plt.subplot(1, 2, i+1)
for j in range(100,... | Titanic - Machine Learning from Disaster |
14,341,846 | for i in ['id_24', 'id_25', 'id_08', 'id_07', 'id_21', 'id_26', 'id_27', 'id_23', 'id_22']:
drop_features.append(i)
drop_features<count_values> | param_grid_logreg = {'penalty':['elasticnet'],
'C':0.01 * np.arange(100),
'l1_ratio':0.1 * np.arange(10),
'solver':['saga']} | Titanic - Machine Learning from Disaster |
14,341,846 | train['dist2'].value_counts(normalize = True, dropna = False ).head()<count_values> | grid_logreg = GridSearchCV(LogisticRegression() , param_grid_logreg,
cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
14,341,846 | test['dist2'].value_counts(normalize = True, dropna = False ).head()<define_variables> | grid_logreg.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,341,846 | check_features = ['dist2']<filter> | params_logreg = {'C': 0.28, 'l1_ratio': 0.9, 'penalty': 'elasticnet', 'solver': 'saga'} | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='D7']<concatenate> | param_grid_knn = {'n_neighbors':np.arange(50),
'weights':['uniform'],
'algorithm':['ball_tree'],
'leaf_size':np.arange(1, 40, 2)} | Titanic - Machine Learning from Disaster |
14,341,846 | check_features.append('D7' )<filter> | grid_knn = GridSearchCV(KNeighborsClassifier() , param_grid_knn,
cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='id_18']<concatenate> | grid_knn.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,341,846 | drop_features.append('id_18' )<filter> | params_knn = {'algorithm': 'ball_tree', 'leaf_size': 1, 'n_neighbors': 7, 'weights': 'uniform'} | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='D13']<filter> | param_grid_svc = {'C':[0.001, 0.01, 0.1, 1, 5],
'kernel':['rbf'],
'gamma':0.01 * np.arange(100),
'probability':[True]} | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='D14']<filter> | grid_svc = GridSearchCV(SVC() , param_grid_svc, cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='D12']<filter> | grid_svc.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='id_04']<filter> | params_svc = {'C': 1, 'gamma': 0.09, 'kernel': 'rbf', 'probability': True} | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='id_03']<filter> | param_grid_random = {'n_estimators':[300, 500, 1000],
'max_depth':[5, 9],
'max_samples':[0.5, 0.7, 0.9],
'max_features':[0.5, 0.7, 0.9],
'min_samples_split':[2, 5, 8]
} | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='D6']<filter> | grid_random = GridSearchCV(RandomForestClassifier() , param_grid_random,
cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='id_33']<filter> | grid_random.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='id_09']<filter> | params_random = {'max_depth': 5, 'max_features': 0.5, 'max_samples': 0.9,
'min_samples_split': 8, 'n_estimators': 300} | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='id_10']<concatenate> | param_grid_gradient = {'max_depth':[3, 4],
'n_estimators':[300, 400, 500],
'learning_rate':[0.01, 0.03, 0.05],
'subsample':[0.5, 0.7],
'max_features':[0.5, 0.7],
} | Titanic - Machine Learning from Disaster |
14,341,846 | check_features.append('id_10' )<filter> | grid_gradient = GridSearchCV(GradientBoostingClassifier() , param_grid_gradient,
cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='D9']<filter> | grid_gradient.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='D8']<filter> | params_gradient = {'learning_rate': 0.01, 'max_depth': 3, 'max_features': 0.5, 'n_estimators': 500, 'subsample': 0.5} | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='id_30']<filter> | param_grid_xgb = {'n_estimators':[400, 600],
'learning_rate':[0.01, 0.03, 0.05],
'max_depth':[3, 4],
'subsample':[0.5, 0.7],
'colsample_bylevel':[0.5, 0.7],
'reg_lambda':[15, None],
} | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='id_32']<filter> | grid_xgb = GridSearchCV(XGBClassifier() , param_grid_xgb,
cv=RepeatedStratifiedKFold(n_splits=10, n_repeats=2, random_state=42),
scoring='accuracy', verbose=2, n_jobs=-1 ) | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='id_34']<concatenate> | grid_xgb.fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,341,846 | drop_features.append('id_34' )<filter> | params_xgb = {'colsample_bylevel': 0.7, 'learning_rate': 0.03, 'max_depth': 3,
'n_estimators': 400, 'reg_lambda': 15, 'subsample': 0.5} | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='id_14']<filter> | logreg = LogisticRegression(**params_logreg)
svc = SVC(**params_svc)
knn = KNeighborsClassifier(**params_knn)
rfc = RandomForestClassifier(**params_random)
gradient = GradientBoostingClassifier(**params_gradient)
xgb = XGBClassifier(**params_xgb)
estimators = [('logreg', logreg),('knn', knn),('svc', svc),('rfc', ... | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='V141']<concatenate> | model = XGBClassifier(**{'colsample_bylevel': 0.7, 'learning_rate': 0.03, 'max_depth': 3, 'n_estimators': 400,
'reg_lambda': 15, 'subsample': 0.5} ).fit(X_train_fe, y_train ) | Titanic - Machine Learning from Disaster |
14,341,846 | drop_features.append('V141' )<filter> | y_preds = model.predict(X_test_fe ) | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='V157']<concatenate> | submission = pd.DataFrame({'PassengerId':test.index,
'Survived':y_preds} ) | Titanic - Machine Learning from Disaster |
14,341,846 | check_features.append('V157' )<filter> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,341,846 | missing[missing['features']=='V162']<filter> | submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
14,341,846 | <filter><EOS> | pd.read_csv('submission.csv' ) | Titanic - Machine Learning from Disaster |
14,484,446 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<concatenate> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sb | Titanic - Machine Learning from Disaster |
14,484,446 | check_features.append('V158' )<filter> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
14,484,446 | missing[missing['features']=='V156']<concatenate> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
14,484,446 | check_features.append('V156' )<define_variables> | full_data = pd.concat([train_data, test_data])
full_data.head() | Titanic - Machine Learning from Disaster |
14,484,446 | V = ['V142', 'V155', 'V154', 'V140', 'V149', 'V148', 'V147', 'V146', 'V153', 'V163', 'V139', 'V138', 'V151', 'V152',
'V145','V144', 'V143', 'V160', 'V159', 'V164', 'V165', 'V166', 'V150', 'V337', 'V333', 'V336', 'V335', 'V334', 'V338',
'V339', 'V325', 'V332', 'V324', 'V330', 'V329', 'V328', 'V327', 'V326', 'V322', 'V32... | full_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,484,446 | V1drop = ['V142', 'V146', 'V138', 'V151', 'V152', 'V333', 'V338', 'V339', 'V325', 'V332', 'V324', 'V330', 'V329', 'V322',
'V323', 'V278', 'V277', 'V252', 'V253', 'V254', 'V260']
for i in V1drop:
drop_features.append(i )<drop_column> | full_data['Fare'] = full_data['Fare'].fillna(full_data['Fare'].median())
full_data['Embarked'] = full_data['Embarked'].fillna(full_data['Embarked'].mode() [0])
full_data.isnull().sum() | Titanic - Machine Learning from Disaster |
14,484,446 | V2drop = ['V263', 'V249', 'V266', 'V267', 'V268', 'V273', 'V276', 'V275', 'V247', 'V241', 'V240', 'V237', 'V235', 'V225',
'V224', 'V224', 'V248', 'V211', 'V213', 'V196', 'V205', 'V183', 'V206', 'V192']
for i in V2drop:
drop_features.append(i )<drop_column> | age_df = full_data[['Age', 'Pclass','Sex','Title']]
age_df=pd.get_dummies(age_df)
known_age = age_df[age_df.Age.notnull() ].values
unknown_age = age_df[age_df.Age.isnull() ].values
y = known_age[:, 0]
X = known_age[:, 1:]
rfr = RandomForestRegressor(random_state=0, n_estimators=100, n_jobs=-1)
rfr.fit(X, y)
predicte... | Titanic - Machine Learning from Disaster |
14,484,446 | V3drop = ['V191', 'V181', 'V193', 'V172', 'V173', 'V202', 'V203', 'V177', 'V179', 'V194', 'V185', 'V184', 'V175', 'V174',
'V195', 'V197', 'V198', 'V208', 'V210', 'V227', 'V251', 'V250', 'V271', 'V270', 'V225']
for i in V3drop:
drop_features.append(i )<define_variables> | PassengerId = test_data['PassengerId']
features = ['Survived','Sex','Pclass','Embarked','Age','Title','FamilyLabel','TicketLabel','CabinLabel']
full_data = pd.get_dummies(full_data[features])
train_data = full_data[full_data.Survived.notnull() ]
test_data = full_data[full_data.Survived.isnull() ]
X = train_data.values... | Titanic - Machine Learning from Disaster |
14,642,180 | V4drop = ['V89', 'V256', 'V3', 'V1', 'V2', 'V4', 'V5', 'V6', 'V7', 'V8', 'V9', 'V10', 'V11', 'V46', 'V42', 'V43', 'V47',
'V41', 'V39', 'V36', 'V35', 'V51', 'V50', 'V49', 'V48', 'V88', 'V93', 'V85', 'V84', 'V83', 'V81', 'V90', 'V91',
'V92', 'V94', 'V80', 'V79', 'V75', 'V75']
for i in V4drop:
drop_features.append(i )<def... | train= pd.read_csv("/kaggle/input/titanic/train.csv")
train.head() | Titanic - Machine Learning from Disaster |
14,642,180 | V5drop = ['V68', 'V27', 'V28', 'V53', 'V74', 'V73', 'V72', 'V66', 'V54', 'V67', 'V64', 'V63', 'V62', 'V61', 'V71', 'V69',
'V55', 'V60', 'V59', 'V58', 'V57', 'V65', 'V56', 'V70', 'V22', 'V23', 'V24', 'V34', 'V33', 'V32', 'V31', 'V30',
'V29', 'V26', 'V25', 'V15', 'V21', 'V14', 'V16', 'V17', 'V18', 'V19', 'V12', 'V20', 'V... | test=pd.read_csv("/kaggle/input/titanic/test.csv")
test.head() | Titanic - Machine Learning from Disaster |
14,642,180 | V6drop = ['V114', 'V110', 'V105', 'V104', 'V103', 'V102', 'V101', 'V100', 'V95', 'V99', 'V98', 'V107', 'V111', 'V112', 'V106',
'V113', 'V108', 'V134', 'V133', 'V135', 'V132', 'V131', 'V130', 'V129', 'V126', 'V125', 'V124', 'V123', 'V122',
'V121', 'V120', 'V119', 'V118', 'V117', 'V116', 'V115', 'V109', 'V294']
for i in ... | train.groupby("Sex")["Survived"].mean() | Titanic - Machine Learning from Disaster |
14,642,180 | V7drop = ['V305', 'V304', 'V303', 'V302', 'V299', 'V298', 'V297', 'V295', 'V293', 'V292', 'V291', 'V290', 'V287', 'V286',
'V285', 'V289', 'V279', 'V309', 'V316', 'V318', 'V319']
for i in V7drop:
drop_features.append(i )<filter> | train.pivot_table("Survived",index='Sex',columns='Pclass' ) | Titanic - Machine Learning from Disaster |
14,642,180 | D_done = ['D7', 'D13', 'D14', 'D12', 'D6', 'D9', 'D8']
D_not_done = missing['features'].apply(lambda x: x if x[0]=='D' else 0)
D_not_done = pd.DataFrame(D_not_done)
D_not_done = D_not_done[D_not_done['features']!=0]
D_not_done = D_not_done[~D_not_done['features'].isin(D_done)]
D_not_done = D_not_done[~D_not_done['fea... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
14,642,180 | C_not_done = missing['features'].apply(lambda x: x if x[0]=='C' else 0)
C_not_done = pd.DataFrame(C_not_done)
C_not_done = C_not_done[C_not_done['features']!=0]
C_not_done = list(C_not_done['features'])
C_not_done<concatenate> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
14,642,180 | drop_features.append('C3' )<create_dataframe> | train.drop("Cabin", axis=1,inplace=True)
test.drop("Cabin", axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
14,642,180 | id_done = ['id_24', 'id_25', 'id_08', 'id_07', 'id_21', 'id_26', 'id_27', 'id_23', 'id_22', 'id_18', 'id_04', 'id_03',
'id_33', 'id_09', 'id_30', 'id_32', 'id_32', 'id_34', 'id_14']
id_not_done = missing['features'].apply(lambda x: x if x[0]=='i' else 0)
id_not_done = pd.DataFrame(id_not_done)
id_not_done = id_not_do... | test["Age"].fillna(round(test['Age'].median()),inplace=True ) | Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('id_10' )<concatenate> | most_commn='S'
data = [train, test]
for data in train:
train["Embarked"]= train["Embarked"].fillna(most_commn)
| Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('id_16' )<concatenate> | data = [train, test]
for d in data:
d['Fare'] = d['Fare'].fillna(d["Fare"].median())
d['Fare'] = d['Fare'].astype(int ) | Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('id_28' )<concatenate> | gender = {"male": 0, "female": 1}
data = [train,test]
for d in data:
d['Sex'] = d['Sex'].map(gender ) | Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('id_29' )<concatenate> | boarding = {"S": 0, "C": 1, "Q": 2}
data = [train, test]
for d in data:
d['Embarked'] = d['Embarked'].map(boarding ) | Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('id_38' )<concatenate> | train.drop(['PassengerId','Name','SibSp','Parch','Ticket'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('id_37' )<concatenate> | test.drop(['Name','SibSp','Parch','Ticket'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('id_36' )<concatenate> | x= train.drop("Survived", axis=1)
y= train["Survived"]
target = test.drop("PassengerId", axis=1 ) | Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('id_35' )<create_dataframe> | k_fold= KFold(n_splits=10,shuffle=True,random_state=0 ) | Titanic - Machine Learning from Disaster |
14,642,180 | c_not_done = missing['features'].apply(lambda x: x if x[0]=='c' else 0)
c_not_done = pd.DataFrame(c_not_done)
c_not_done = c_not_done[c_not_done['features']!=0]
list(c_not_done['features'] )<concatenate> | knn=KNeighborsClassifier(n_neighbors=13)
score= cross_val_score(knn,x,y,cv=k_fold,n_jobs=1,scoring='accuracy')
print(score ) | Titanic - Machine Learning from Disaster |
14,642,180 | check_features.append('card4' )<concatenate> | round(np.mean(score)*100,2 ) | 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.