kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,963,250 | %%time
missing_data(test_df )<count_values> | train = train.fillna({"Embarked": "S"})
embarked_mapping = {"S": 1, "C": 2, "Q": 3}
train['Embarked'] = train['Embarked'].map(embarked_mapping)
test['Embarked'] = test['Embarked'].map(embarked_mapping)
train.head() | Titanic - Machine Learning from Disaster |
11,963,250 | print("There are {}% target values with 1".format(100 * train_df["target"].value_counts() [1]/train_df.shape[0]))<sort_values> | train['Sex'] = train['Sex'].map({"male": 0, "female": 1})
test['Sex'] = test['Sex'].map({"male": 0, "female": 1})
train.head() | Titanic - Machine Learning from Disaster |
11,963,250 | %%time
correlations = train_df[features].corr().abs().unstack().sort_values(kind="quicksort" ).reset_index()
correlations = correlations[correlations['level_0'] != correlations['level_1']]
correlations.head(10 )<count_unique_values> | train = train.drop(['Cabin'], axis = 1)
test = test.drop(['Cabin'], axis = 1 ) | Titanic - Machine Learning from Disaster |
11,963,250 | %%time
features = train_df.columns.values[2:202]
unique_max_train = []
unique_max_test = []
for feature in features:
values = train_df[feature].value_counts()
unique_max_train.append([feature, values.max() , values.idxmax() ])
values = test_df[feature].value_counts()
unique_max_test.append([feature, values.max() , val... | train = train.drop(['Ticket'], axis = 1)
test = test.drop(['Ticket'], axis = 1 ) | Titanic - Machine Learning from Disaster |
11,963,250 | %%time
idx = features = train_df.columns.values[2:202]
for df in [test_df, train_df]:
df['sum'] = df[idx].sum(axis=1)
df['min'] = df[idx].min(axis=1)
df['max'] = df[idx].max(axis=1)
df['mean'] = df[idx].mean(axis=1)
df['std'] = df[idx].std(axis=1)
df['skew'] = df[idx].skew(axis=1)
df['kurt'] = df[idx].kurtosis(ax... | train = train.drop(['Name'], axis = 1)
test = test.drop(['Name'], axis = 1 ) | Titanic - Machine Learning from Disaster |
11,963,250 | print('Train and test columns: {} {}'.format(len(train_df.columns), len(test_df.columns)) )<define_variables> | train.Age.fillna(value=train.Age.mean() , inplace=True)
train.Fare.fillna(value=train.Fare.mean() , inplace=True)
test.Age.fillna(value=test.Age.mean() , inplace=True)
test.Fare.fillna(value=test.Fare.mean() , inplace=True ) | Titanic - Machine Learning from Disaster |
11,963,250 | features = [c for c in train_df.columns if c not in ['ID_code', 'target']]
target = train_df['target']<init_hyperparams> | train['CabinBool'] = train['CabinBool'].map({True: 0, False: 1})
test['CabinBool'] = test['CabinBool'].map({True: 0, False: 1} ) | Titanic - Machine Learning from Disaster |
11,963,250 | param = {
'tree_method': 'gpu_hist',
'objective': 'binary:logitraw',
'eta':0.01,
'gamma':0.01,
'max_depth':10,
'min_child_weight':20,
'subsample':0.05,
'max_leaves':20,
'eval_metric':'auc',
'verbosity':1
}<train_model> | age_mapping = {'Baby': 1, 'Child': 2, 'Teenager': 3, 'Student': 4, 'Young': 5, 'Adult': 6, 'Senior': 7}
train['AgeGroup'] = train['AgeGroup'].map(age_mapping)
test['AgeGroup'] = test['AgeGroup'].map(age_mapping ) | Titanic - Machine Learning from Disaster |
11,963,250 | folds = StratifiedKFold(n_splits=10, shuffle=False, random_state=44000)
oof = np.zeros(len(train_df))
predictions = np.zeros(len(test_df))
feature_importance_df = pd.DataFrame()
for fold_,(trn_idx, val_idx)in enumerate(folds.split(train_df.values, target.values)) :
print("Fold {}".format(fold_))
trn_data = xgb.DMatrix... | train=train.drop(['Age'],axis =1)
test =test.drop(['Age'],axis=1)
train.head() | Titanic - Machine Learning from Disaster |
11,963,250 | sub_df = pd.DataFrame({"ID_code":test_df["ID_code"].values})
sub_df["target"] = predictions
sub_df.to_csv("submission.csv", index=False )<load_from_csv> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
11,963,250 | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' )<load_from_csv> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
11,963,250 | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' )<categorify> | X = train.drop(['Survived', 'PassengerId'], axis=1)
y = train["Survived"]
x_train, x_val, y_train, y_val = train_test_split(X, y)
| Titanic - Machine Learning from Disaster |
11,963,250 | def augment(x,y,t=2):
xs,xn = [],[]
for i in range(t):
mask = y>0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
np.random.shuffle(ids)
x1[:,c] = x1[ids][:,c]
xs.append(x1)
for i in range(t//2):
mask = y==0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
... | log_model = LogisticRegression()
log_model.fit(x_train, y_train)
y_pred = log_model.predict(x_val)
acc_log=accuracy_score(y_pred, y_val)* 100
print(acc_log ) | Titanic - Machine Learning from Disaster |
11,963,250 | %time
idx = features = train.columns.values[2:202]
for i,df in enumerate([train, test]):
df['sum'] = df[idx].sum(axis=1)
df['min'] = df[idx].min(axis=1)
df['max'] = df[idx].max(axis=1)
df['mean'] = df[idx].mean(axis=1)
df['std'] = df[idx].std(axis=1)
df['skew'] = df[idx].skew(axis=1)
df['kurt'] = df[idx].kurtosis... | svm_model =SVC()
svm_model.fit(x_train,y_train)
y_pred =svm_model.predict(x_val)
acc_svc =accuracy_score(y_pred,y_val)*100
print(acc_svc)
| Titanic - Machine Learning from Disaster |
11,963,250 | X = train.iloc[:,2:].values
y = train.iloc[:,1].values
test = test.iloc[:,1:].values<train_model> | decisiontree_model =DecisionTreeClassifier()
decisiontree_model.fit(x_train,y_train)
y_pred =decisiontree_model.predict(x_val)
acc_decisiontree_model=accuracy_score(y_pred, y_val)*100
print(acc_decisiontree_model ) | Titanic - Machine Learning from Disaster |
11,963,250 | lgb.train()<create_dataframe> | randomforest_model = RandomForestClassifier()
randomforest_model.fit(x_train, y_train)
y_pred = randomforest_model.predict(x_val)
acc_randomforest =accuracy_score(y_pred, y_val)* 100
print(acc_randomforest ) | Titanic - Machine Learning from Disaster |
11,963,250 | pred = pd.DataFrame()
for i in range(1, 5):
param = {
'bagging_freq': 5,
'bagging_fraction': 0.4,
'boost_from_average':'false',
'boost': 'gbdt',
'feature_fraction': 0.05,
'learning_rate': 0.01,
'max_depth': -1,
'metric':'auc',
'min_data_in_leaf': 80,
'min_sum_hessian_in_leaf': 10.0,
'num_leaves': 13,
'num_threads': 8,
... | knn_model = KNeighborsClassifier()
knn_model.fit(x_train, y_train)
y_pred = knn_model.predict(x_val)
acc_knn_model = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_knn_model ) | Titanic - Machine Learning from Disaster |
11,963,250 | filename = 'subm_{}_{}_'.format(ver, datetime.now().strftime('%Y-%m-%d'))
filename<save_to_csv> | sgd_model = SGDClassifier()
sgd_model.fit(x_train, y_train)
y_pred = sgd_model.predict(x_val)
acc_sgd_model = accuracy_score(y_pred, y_val)* 100
print(acc_sgd_model ) | Titanic - Machine Learning from Disaster |
11,963,250 | submission_ = pd.read_csv('.. /input/sample_submission.csv')
submission_['target'] = pred.mean(axis=1)
submission_.to_csv(filename+'_blend.csv', index=False )<load_from_csv> | gbk_model = GradientBoostingClassifier()
gbk_model.fit(x_train, y_train)
y_pred = gbk_model.predict(x_val)
acc_gbk_model= accuracy_score(y_pred, y_val)* 100
print(acc_gbk_model ) | Titanic - Machine Learning from Disaster |
11,963,250 | train_df = pd.read_csv(".. /input/train.csv" )<init_hyperparams> | compare =pd.DataFrame({
'model':['Support Vector Machines', 'KNN', 'Logistic Regression',
'Random Forest',
'Decision Tree', 'Stochastic Gradient Descent', 'Gradient Boosting Classifier'],
'Score': [acc_svc, acc_knn_model, acc_log,
acc_randomforest, acc_decisiontree_model,
acc_sgd_model, acc_gbk_model]
} ) | Titanic - Machine Learning from Disaster |
11,963,250 | params = {
'boosting':'gbdt',
'bagging_freq':5,
'bagging_fraction':0.5,
'num_leaves':2,
'reg_lambda':100.0,
'learning_rate':0.01,
'max_bin':1023,
'seed':3366
}<train_on_grid> | ids = test['PassengerId']
predictions = gbk_model.predict(test.drop('PassengerId', axis=1))
output_file = pd.DataFrame({ 'PassengerId' : ids, 'Survived': predictions })
output_file.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
10,525,083 | def optimal_rounds(X, verbose=False):
rounds = []
for i in range(200):
if verbose:
print("Feature ", i)
cv_res = lgb.cv(params,
lgb.Dataset(X[['var_'+str(i)]], X['target']),
nfold=3,
num_boost_round=100000,
metrics='binary_logloss',
verbose_eval=100 if verbose else None,
early_stopping_rounds=100
)
rounds.append(l... | pd.read_csv("/kaggle/input/titanic/train.csv" ) | Titanic - Machine Learning from Disaster |
10,525,083 | opt_rounds = optimal_rounds(train_df, verbose=True )<train_model> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
10,525,083 | print("Optimal number of rounds: ", opt_rounds)
print("Optimal number of rounds for var_108: ", opt_rounds[108])
print("Optimal number of rounds for var_30: ", opt_rounds[30] )<train_model> | train_data['Log_Fare']=np.log(train_data['Fare']+1)
diagnostic_plots(train_data,'Log_Fare')
| Titanic - Machine Learning from Disaster |
10,525,083 | num_ones = np.sum(train_df['target'] == 1)
num_zeros = np.sum(train_df['target'] == 0)
class LGBNaiveBayes:
def fit(self,X_train, y_train, opt_rounds):
self.clfs = []
for i in range(200):
if i%20 == 0:
print("Fitting var_"+ str(i)+"...")
params['n_estimators'] = opt_rounds[i]
lgb_clf = lgb.LGBMClassifier(**params)
... | train_data['Rec'] = 1/(train_data['Fare']+1 ) | Titanic - Machine Learning from Disaster |
10,525,083 | clf = LGBNaiveBayes()<find_best_model_class> | train_data['Fare'] = np.log(train_data['Fare']+1 ) | Titanic - Machine Learning from Disaster |
10,525,083 | features = train_df.columns[2:].values
def cross_validate(nfolds):
sss = StratifiedShuffleSplit(nfolds)
aucs = []
for train, test in sss.split(train_df[features], train_df['target']):
clf.fit(train_df.loc[train][features], train_df.loc[train]['target'], opt_rounds)
y_true = train_df.loc[test]['target']
y_pred = clf.p... | def inpute(col):
Age = col[0]
Pclass= col[1]
if pd.isnull(Age):
if Pclass==1:
return 37
elif Pclass == 2:
return 29
else:
return 24
else:
return Age | Titanic - Machine Learning from Disaster |
10,525,083 | test_df = pd.read_csv('.. /input/test.csv')
clf.fit(train_df[features], train_df['target'], opt_rounds)
pred = clf.predict_proba(test_df.iloc[:][features])
sub_df = pd.DataFrame({"ID_code":test_df["ID_code"].values})
sub_df["target"] = pred[:,1]
sub_df.to_csv("submission.csv", index=False )<load_from_csv> | train_data['Age'] = train_data[['Age','Pclass']].apply(inpute,axis=1)
test_data['Age'] = test_data[['Age','Pclass']].apply(inpute,axis=1 ) | Titanic - Machine Learning from Disaster |
10,525,083 | train_data = pd.read_csv('.. /input/train.csv')
test_data = pd.read_csv('.. /input/test.csv' )<sort_values> | train_data.drop('Cabin',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
10,525,083 | def missing_value(data, head=False):
missing = pd.DataFrame(data.isnull().sum() ).rename(columns={0:'total'})
if head:
return missing.sort_values('total', ascending=False ).head(10)
else:
return missing.sort_values('total', ascending=False )<count_missing_values> | train_data.Age=train_data.Age.astype(int)
test_data.Age = test_data.Age.astype(int ) | Titanic - Machine Learning from Disaster |
10,525,083 | missing_value(test_data, head=True )<import_modules> | for dataset in combine:
dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0
dataset.loc[(dataset['Age'] > 16)&(dataset['Age'] <= 32), 'Age'] = 1
dataset.loc[(dataset['Age'] > 32)&(dataset['Age'] <= 48), 'Age'] = 2
dataset.loc[(dataset['Age'] > 48)&(dataset['Age'] <= 64), 'Age'] = 3
dataset.loc[ dataset['Age'] > 64, 'Age'] = ... | Titanic - Machine Learning from Disaster |
10,525,083 | from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split,cross_val_score,StratifiedKFold,GridSearchCV
from sklearn.feature_selection import RFECV
from sklearn.preprocessing import StandardScaler, normalize, MinMaxScaler
from sklearn.ensemble import RandomForestClassifier
... | y = train_data["Survived"]
features = ["Pclass", "Sex", "Age", "Parch",'SibSp']
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=0)
model.fit(X, y)
predictions = model.predict(X_test)
acc_random_forest =... | Titanic - Machine Learning from Disaster |
10,525,083 |
<categorify> | pd.read_csv("/kaggle/input/titanic/train.csv" ) | Titanic - Machine Learning from Disaster |
10,525,083 |
<concatenate> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
10,525,083 | def _add_decomposition(df, decomp, ncomp, flag):
for i in range(1, ncomp+1):
df[flag+"_"+str(i)] = decomp[:,i-1]
<train_model> | train_data['Log_Fare']=np.log(train_data['Fare']+1)
diagnostic_plots(train_data,'Log_Fare')
| Titanic - Machine Learning from Disaster |
10,525,083 |
<feature_engineering> | train_data['Rec'] = 1/(train_data['Fare']+1 ) | Titanic - Machine Learning from Disaster |
10,525,083 | idx = features = train_data.columns.values[2:]
for df in [train_data, test_data]:
df['sum'] = df[idx].sum(axis=1)
df['min'] = df[idx].min(axis=1)
df['max'] = df[idx].max(axis=1)
df['mean'] = df[idx].mean(axis=1)
df['std'] = df[idx].std(axis=1)
df['skew'] = df[idx].skew(axis=1)
df['kurt'] = df[idx].kurt(axis=1)
d... | train_data['Fare'] = np.log(train_data['Fare']+1 ) | Titanic - Machine Learning from Disaster |
10,525,083 | features = train_data.drop(columns=['target','ID_code'] ).columns
for feature in features:
train_data['r2_'+feature] = np.round(train_data[feature], 2)
test_data['r2_'+feature] = np.round(test_data[feature], 2)
train_data['r1_'+feature] = np.round(train_data[feature], 1)
test_data['r1_'+feature] = np.round(test_data... | def inpute(col):
Age = col[0]
Pclass= col[1]
if pd.isnull(Age):
if Pclass==1:
return 37
elif Pclass == 2:
return 29
else:
return 24
else:
return Age | Titanic - Machine Learning from Disaster |
10,525,083 | train_data=train_data.iloc[:,202:]<split> | train_data['Age'] = train_data[['Age','Pclass']].apply(inpute,axis=1)
test_data['Age'] = test_data[['Age','Pclass']].apply(inpute,axis=1 ) | Titanic - Machine Learning from Disaster |
10,525,083 | test_data=test_data.iloc[:,201:]<normalization> | train_data.drop('Cabin',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
10,525,083 | pipeline = Pipeline([('StanderScaler', StandardScaler())])
train_data = pipeline.fit_transform(train_data)
test_data = pipeline.transform(test_data )<create_dataframe> | train_data.Age=train_data.Age.astype(int)
test_data.Age = test_data.Age.astype(int ) | Titanic - Machine Learning from Disaster |
10,525,083 | train_data = pd.DataFrame(data=train_data,columns=features[200:])
test_data = pd.DataFrame(data=test_data,columns=features[200:] )<split> | for dataset in combine:
dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0
dataset.loc[(dataset['Age'] > 16)&(dataset['Age'] <= 32), 'Age'] = 1
dataset.loc[(dataset['Age'] > 32)&(dataset['Age'] <= 48), 'Age'] = 2
dataset.loc[(dataset['Age'] > 48)&(dataset['Age'] <= 64), 'Age'] = 3
dataset.loc[ dataset['Age'] > 64, 'Age'] = ... | Titanic - Machine Learning from Disaster |
10,525,083 | <compute_test_metric><EOS> | y = train_data["Survived"]
features = ["Pclass", "Sex", "Age", "Parch",'SibSp']
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=0)
model.fit(X, y)
predictions = model.predict(X_test)
acc_random_forest =... | Titanic - Machine Learning from Disaster |
8,143,656 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<import_modules> | train, test = read_data_()
train, test = get_title_feature_(train, test)
train, test = get_surname_(train, test)
train, test = get_first_names_(train, test)
train, test = get_married_feature_(train, test)
train, test = get_family_counts_(train, test)
train, test = extract_ticket_number_(train, test)
train, test =... | Titanic - Machine Learning from Disaster |
8,143,656 | import lightgbm as lgbm<train_model> | X, X_submit, y = get_X_y_(train, test)
X, X_submit = encode_categories_(X, X_submit, y)
X, X_submit = impute_missing_(X, X_submit)
X, X_submit = get_decomposition_features_(X, X_submit ) | Titanic - Machine Learning from Disaster |
8,143,656 | def lightGBM(train,target,test, n_folds):
params = {
'boosting_type':'gbdt',
'boost': 'gbdt',
'objective':'binary',
'learning_rate':0.008,
'metric':'auc',
'max_depth':2,
'num_leaves':13,
"bagging_fraction" : 0.4,
"feature_fraction" : 1.0,
"min_child_samples":80,
"bagging_freq" : 5,
"bagging_seed" : 2020,
"verbosity" : ... | environ["HYPEROPT_FMIN_SEED"] = "0"
estimator = RandomForestClassifier(n_jobs=-1, random_state=0, class_weight="balanced")
def fn(params):
for p in ["n_estimators", "max_depth", "min_samples_split"]:
params[p] = int(params[p])
params.update({"min_samples_leaf": params["min_samples_split"] - 1})
estimator.set_params(... | Titanic - Machine Learning from Disaster |
8,143,656 | prediction, model, eval_result = lightGBM(train_data,Target, test_data,5 )<find_best_params> | for p in ["n_estimators", "max_depth", "min_samples_split"]:
best[p] = int(best[p])
best.update({"min_samples_leaf": best["min_samples_split"] - 1})
best["criterion"] = ["gini", "entropy"][best["criterion"]]
print(best ) | Titanic - Machine Learning from Disaster |
8,143,656 | model.best_score<save_to_csv> | n_estimators = 5
estimator.set_params(**best)
y_submit = zeros(( X_submit.shape[0],))
for r in range(n_estimators):
estimator.set_params(random_state=r + 1)
estimator.fit(X, y)
y_submit += estimator.predict(X_submit)
y_submit =(y_submit / n_estimators)> 0.5 | Titanic - Machine Learning from Disaster |
8,143,656 | <load_from_csv><EOS> | DataFrame(data={"PassengerId": test.index, "Survived": y_submit.astype(int)} ).to_csv(
"submission.csv", index=False
) | Titanic - Machine Learning from Disaster |
6,492,454 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | %matplotlib inline
warnings.filterwarnings("ignore")
print('Versions:')
print(' python', platform.python_version())
n =('numpy', 'pandas', 'sklearn', 'matplotlib', 'seaborn')
nn =(np, pd, sklearn, mpl, sns)
for a, b in zip(n, nn):
print(' --', str(a), b.__version__ ) | Titanic - Machine Learning from Disaster |
6,492,454 | def augment(x,y,t=2):
xs,xn = [],[]
for i in range(t):
mask = y>0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
np.random.shuffle(ids)
x1[:,c] = x1[ids][:,c]
xs.append(x1)
for i in range(t//2):
mask = y==0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
... | pd.set_option('colheader_justify', 'left')
pd.set_option('precision', 0)
pd.options.display.float_format = '{:,.2f}'.format
pd.set_option('display.max_colwidth', -1 ) | Titanic - Machine Learning from Disaster |
6,492,454 | lgb_params = {
"objective" : "binary",
"metric" : "auc",
"boosting": 'gbdt',
"max_depth" : -1,
"num_leaves" : 13,
"learning_rate" : 0.01,
"bagging_freq": 5,
"bagging_fraction" : 0.4,
"feature_fraction" : 0.05,
"min_data_in_leaf": 80,
"min_sum_heassian_in_leaf": 10,
"tree_learner": "serial",
"boost_from_average": "false... | sns.set_style('whitegrid', { 'axes.axisbelow': True, 'axes.edgecolor': 'black', 'axes.facecolor': 'white',
'axes.grid': True, 'axes.labelcolor': 'black', 'axes.spines.bottom': True, 'axes.spines.left': True,
'axes.spines.right': False, 'axes.spines.top': False, 'figure.facecolor': 'white',
'grid.color': 'grey', 'grid.l... | Titanic - Machine Learning from Disaster |
6,492,454 | skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=random_state)
oof = df_train[['ID_code', 'target']]
oof['predict'] = 0
predictions = df_test[['ID_code']]
val_aucs = []
feature_importance_df = pd.DataFrame()<prepare_x_and_y> | from sklearn import svm, tree, linear_model, neighbors, naive_bayes, ensemble, discriminant_analysis, gaussian_process
from sklearn import feature_selection, model_selection, metrics
from sklearn.preprocessing import OneHotEncoder, LabelEncoder
from xgboost import XGBClassifier | Titanic - Machine Learning from Disaster |
6,492,454 | features = [col for col in df_train.columns if col not in ['target', 'ID_code']]
X_test = df_test[features].values<split> | train_raw = pd.read_csv('.. /input/titanic/train.csv')
test_raw = pd.read_csv('.. /input/titanic/test.csv')
len(train_raw)+ len(test_raw ) | Titanic - Machine Learning from Disaster |
6,492,454 | for fold,(trn_idx, val_idx)in enumerate(skf.split(df_train, df_train['target'])) :
X_train, y_train = df_train.iloc[trn_idx][features], df_train.iloc[trn_idx]['target']
X_valid, y_valid = df_train.iloc[val_idx][features], df_train.iloc[val_idx]['target']
N = 5
p_valid,yp = 0,0
for i in range(N):
X_t, y_t = augment(X_tr... | df = pd.concat(objs=[train_raw, test_raw], axis=0)
df.shape | Titanic - Machine Learning from Disaster |
6,492,454 | mean_auc = np.mean(val_aucs)
std_auc = np.std(val_aucs)
all_auc = roc_auc_score(oof['target'], oof['predict'])
print("Mean auc: %.9f, std: %.9f.All auc: %.9f." %(mean_auc, std_auc, all_auc))<save_to_csv> | Titanic - Machine Learning from Disaster | |
6,492,454 | predictions['target'] = np.mean(predictions[[col for col in predictions.columns if col not in ['ID_code', 'target']]].values, axis=1)
predictions.to_csv('lgb_all_predictions.csv', index=None)
sub_df = pd.DataFrame({"ID_code":df_test["ID_code"].values})
sub_df["target"] = predictions['target']
sub_df.to_csv("lgb_subm... | col1 = test_raw['PassengerId']
df.drop(['PassengerId', 'Cabin'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
6,492,454 | import pandas as pd
from tqdm import tqdm<load_from_csv> | df['Age'] = df['Age'].fillna(df['Age'].median())
df['Fare'] = df['Fare'].fillna(df['Fare'].mean())
df['Embarked'] = df['Embarked'].fillna('S')
df.isnull().sum().to_frame().T | Titanic - Machine Learning from Disaster |
6,492,454 | train = pd.read_csv('.. /input/ames-housing-dataset/AmesHousing.csv')
train.drop(['PID'], axis=1, inplace=True)
origin = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/train.csv')
train.columns = origin.columns
test = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/test.csv')
... | df['Fsize'] = df['Parch'] + df['SibSp'] + 1 | Titanic - Machine Learning from Disaster |
6,492,454 | missing = test.isnull().sum()
missing = missing[missing>0]
train.drop(missing.index, axis=1, inplace=True)
train.drop(['Electrical'], axis=1, inplace=True)
test.dropna(axis=1, inplace=True)
test.drop(['Electrical'], axis=1, inplace=True )<feature_engineering> | df['Surname'], df['Name'] = zip(*df['Name'].apply(lambda x: x.split(',')))
df['Title'], df['Name'] = zip(*df['Name'].apply(lambda x: x.split('.')))
titles =(df['Title'].value_counts() < 10)
df['Title'] = df['Title'].apply(lambda x: ' Misc' if titles.loc[x] == True else x)
df['Title'].value_counts().to_frame().T | Titanic - Machine Learning from Disaster |
6,492,454 | l_test = tqdm(range(0, len(test)) , desc='Matching')
for i in l_test:
for j in range(0, len(train)) :
for k in range(1, len(test.columns)) :
if test.iloc[i,k] == train.iloc[j,k]:
continue
else:
break
else:
submission.iloc[i, 1] = train.iloc[j, -1]
break
l_test.close()<save_to_csv> | df['Tname'] = df['Ticket']
df['Tset']=0
for t in df['Tname'].unique() :
if df['Surname'].loc[(df['Tname']==t)].nunique() != 1:
df['Tset'].loc[(df['Tname']==t)] = 'mixed'
else:
df['Tset'].loc[(df['Tname']==t)] = 'monotonic'
for t in df['Tname'].unique() :
if df['Surname'].loc[(df['Tname']==t)].nunique() != 1:
df['Tset']... | Titanic - Machine Learning from Disaster |
6,492,454 | submission.to_csv('submission.csv', index=False )<save_to_csv> | for t in df['Ticket'].unique() :
df['Ticket'].loc[(df['Ticket']==t)] = len(df.loc[(df['Ticket']==t)])
df['Price'] = df['Fare'] / df['Ticket']
df.rename(columns={'Ticket':'Tgroup'}, inplace=True ) | Titanic - Machine Learning from Disaster |
6,492,454 | submission.to_csv('submission.csv', index=False )<load_from_csv> | df.drop(['Parch', 'SibSp', 'Name', 'Surname', 'Tname', 'Fare'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
6,492,454 | train = pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/train.csv")
test = pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/test.csv")
data = pd.concat([train, test], ignore_index=True )<sort_values> | label = LabelEncoder()
cols = df.dtypes[df.dtypes == 'object'].index.tolist()
for col in cols:
df[col] = label.fit_transform(df[col] ) | Titanic - Machine Learning from Disaster |
6,492,454 | percent_null = data.isnull().sum() /len(data)*100
percent_null = percent_null[percent_null>0]
print(percent_null.sort_values() )<count_missing_values> | df['Price'] = pd.qcut(df['Price'], 4)
df['Age'] = pd.cut(df['Age'].astype(int), 5 ) | Titanic - Machine Learning from Disaster |
6,492,454 | def null_cols(dataframe):
for col in dataframe.columns:
null_count = dataframe[col].isnull().sum()
if null_count > 0:
percent_null = null_count/len(dataframe[col])*100
print(f"{col} percent null: {round(percent_null,3)}" )<count_missing_values> | df['Age'] = label.fit_transform(df['Age'])
df['Price'] = label.fit_transform(df['Price'] ) | Titanic - Machine Learning from Disaster |
6,492,454 | null_cols(num_data )<feature_engineering> | a = len(train_raw)
train = df[:a]
test = df[a:] | Titanic - Machine Learning from Disaster |
6,492,454 | data.LotFrontage.fillna(np.mean(data.LotFrontage), inplace=True)
data.MasVnrArea.fillna(np.mean(data.MasVnrArea), inplace=True)
data.BsmtFinSF1.fillna(np.mean(data.BsmtFinSF1), inplace=True)
data.BsmtFinSF2.fillna(np.mean(data.BsmtFinSF2), inplace=True)
data.BsmtUnfSF.fillna(np.mean(data.BsmtUnfSF), inplace=True)
... | test.drop(['Survived'], axis=1, inplace=True)
test_raw.shape[0] == test.shape[0] | Titanic - Machine Learning from Disaster |
6,492,454 | encoder = OneHotEncoder()
temp = pd.DataFrame(encoder.fit_transform(data[['MSSubClass']] ).toarray() , columns=['MS20','MS30','MS40','MS45','MS50','MS60','MS70','MS75','MS80','MS85','MS90','MS120','MS150','MS160','MS180','MS190'])
data = data.join(temp)
data.drop('MSSubClass', 1, inplace=True)
temp = pd.DataFrame(en... | X = train.drop(['Survived'], axis=1 ).columns.to_list()
y = ['Survived'] | Titanic - Machine Learning from Disaster |
6,492,454 | data['LotShape'].replace({"IR3": 1, 'IR2': 2, 'IR1': 3, 'Reg': 4}, inplace=True)
data['Utilities'] = data['Utilities'].fillna('AllPub')
data['Utilities'].replace({'NoSeWa': 1, 'AllPub': 2}, inplace=True)
data['BldgType'].replace({"Twnhs": 1, 'TwnhsE': 2, 'Duplex': 3, '2fmCon': 4, '1Fam': 5}, inplace=True)
data['Ext... | MLA = [
ensemble.AdaBoostClassifier() , ensemble.BaggingClassifier() , ensemble.ExtraTreesClassifier() ,
ensemble.GradientBoostingClassifier() , ensemble.RandomForestClassifier() ,
gaussian_process.GaussianProcessClassifier() ,
linear_model.LogisticRegressionCV() , linear_model.PassiveAggressiveClassifier() ,
linear_mo... | Titanic - Machine Learning from Disaster |
6,492,454 | data['MSZoning'] = data['MSZoning'].fillna('RL')
temp = pd.DataFrame(encoder.fit_transform(data[['MSZoning']] ).toarray() , columns=['RLZone', 'RMZone', 'CZone', 'FVZone', 'RHZone'])
data = data.join(temp)
temp = pd.DataFrame(encoder.fit_transform(data[['Street']] ).toarray() , columns=['Pave','Grvl'])
data = data.... | cv_split = model_selection.ShuffleSplit(n_splits = 10, test_size =.3, train_size =.6, random_state = 0)
mla = pd.DataFrame(columns=['Name','TestScore','ScoreTime','FitTime','Parameters'])
prediction = train[y]
i = 0
for alg in MLA:
name = alg.__class__.__name__
mla.loc[i, 'Name'] = name
mla.loc[i, 'Parameters'] = str... | Titanic - Machine Learning from Disaster |
6,492,454 | data['TotalBaths'] = data['FullBath'] + 0.5 * data['HalfBath'] + data['BsmtFullBath'] + 0.5 * data['BsmtHalfBath']
data['TotalSF'] = data['1stFlrSF'] + data['2ndFlrSF'] + data['TotalBsmtSF']
data['TotalPorchSF'] = data['OpenPorchSF'] + data['EnclosedPorch'] + data['3SsnPorch'] + data['ScreenPorch']
data['BsmtFinType'] ... | param_grid = {'criterion': ['gini', 'entropy'],
'max_depth': [2,4,6,8,10,None],
'random_state': [0]}
tune_model = model_selection.GridSearchCV(tree.DecisionTreeClassifier() , param_grid=param_grid, scoring='roc_auc', cv=cv_split)
tune_model.fit(train[X], train[y])
print('Parameters: ', tune_model.best_params_ ) | Titanic - Machine Learning from Disaster |
6,492,454 | feature_cols = []
for col in data.columns:
feature_cols.append(col)
feature_cols.remove('Id' )<data_type_conversions> | clf = tree.DecisionTreeClassifier()
results = model_selection.cross_validate(clf, train[X], train[y], cv=cv_split)
clf.fit(train[X], train[y])
results['test_score'].mean() *100
fs = feature_selection.RFECV(clf, step=1, scoring='accuracy', cv=cv_split)
fs.fit(train[X], train[y])
X = train[X].columns.values[fs.get_su... | Titanic - Machine Learning from Disaster |
6,492,454 | test_index = data[data['SalePrice'].isnull() ].index.tolist()
test_index<prepare_x_and_y> | tuned = model_selection.GridSearchCV(tree.DecisionTreeClassifier() , param_grid=param_grid, scoring = 'roc_auc', cv=cv_split)
tuned.fit(train[X], train[y])
param_grid = tuned.best_params_
param_grid | Titanic - Machine Learning from Disaster |
6,492,454 | train_data = data[:1460]
test_data = data[1460:].drop(['SalePrice'], 1)
x = train_data.drop(['SalePrice'], 1)
y = np.log1p(train_data['SalePrice'])
<import_modules> | clf = ensemble.GradientBoostingClassifier()
results = model_selection.cross_validate(clf, train[X], train[y], cv=cv_split)
clf.fit(train[X], train[y])
results['test_score'].mean() *100 | Titanic - Machine Learning from Disaster |
6,492,454 | from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, AdaBoostRegressor, BaggingRegressor
from sklearn.linear_model import Ridge, RidgeCV, ElasticNet, ElasticNetCV
from sklearn.kernel_ridge import KernelRidge
from xgboost import XGBRegressor
from lightgbm import LGBMRegressor
from sklearn.svm i... | test['Survived'] = clf.predict(test[X] ) | Titanic - Machine Learning from Disaster |
6,492,454 | <train_on_grid><EOS> | submit = pd.DataFrame({ 'PassengerId' : col1, 'Survived': test['Survived'] } ).set_index('PassengerId')
submit['Survived'] = submit['Survived'].astype('int')
submit.to_csv('submission.csv' ) | Titanic - Machine Learning from Disaster |
6,188,326 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_on_grid> | !pip install -U pandas-profiling==2.9.0 | Titanic - Machine Learning from Disaster |
6,188,326 |
<train_on_grid> | import numpy as np
import pandas as pd
import pandas_profiling as pp
from pandas_profiling import ProfileReport | Titanic - Machine Learning from Disaster |
6,188,326 |
<train_on_grid> | pp.__version__ | Titanic - Machine Learning from Disaster |
6,188,326 |
<save_to_csv> | traindf = pd.read_csv('.. /input/titanic/train.csv' ).set_index('PassengerId')
testdf = pd.read_csv('.. /input/titanic/test.csv' ).set_index('PassengerId' ) | Titanic - Machine Learning from Disaster |
6,188,326 | clf = LGBMRegressor().fit(x,y)
pred = np.expm1(clf.predict(test_data))
pred = pd.DataFrame({"id": test.Id, "SalePrice": pred})
pred.to_csv('sample_submission.csv',index=False )<set_options> | df = pd.concat([traindf, testdf], axis=0, sort=False)
df['Title'] = df.Name.str.split(',' ).str[1].str.split('.' ).str[0].str.strip()
df['IsWomanOrBoy'] =(( df.Title == 'Master')|(df.Sex == 'female'))
df['LastName'] = df.Name.str.split(',' ).str[0]
family = df.groupby(df.LastName ).Survived
df['WomanOrBoyCount'] = fam... | Titanic - Machine Learning from Disaster |
6,188,326 | pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', None)
warnings.filterwarnings("ignore" )<load_from_csv> | train_x, test_x = df.loc[traindf.index], df.loc[testdf.index]
test_x = test_x.drop('Survived', axis=1 ) | Titanic - Machine Learning from Disaster |
6,188,326 | data = pd.read_csv(".. /input/house-prices-advanced-regression-techniques/train.csv")
print(data.shape)
data.head()<drop_column> | %%time
profile = ProfileReport(train_x, title='Pandas Profiling Report for training dataset', minimal=True)
profile.to_file(output_file="train_short_profile.html" ) | Titanic - Machine Learning from Disaster |
6,188,326 | data_explore = data.copy()
data_explore = data_explore.drop(columns="Id", axis=1 )<count_missing_values> | test_x = pd.concat([test_x.WomanOrBoySurvived.fillna(0), test_x.Alone, \
test_x.Sex.replace({'male': 0, 'female': 1})], axis=1)
pd.DataFrame({'Survived':(((test_x.WomanOrBoySurvived <= 0.2381)&(test_x.Sex > 0.5)&(test_x.Alone > 0.5)) | \
(( test_x.WomanOrBoySurvived > 0.2381)& \
~(( test_x.WomanOrBoySurvived > 0.55)&... | Titanic - Machine Learning from Disaster |
4,667,493 | nulls = data_explore.isna().sum()
nulls[nulls>0]<data_type_conversions> | test=pd.read_csv(".. /input/test.csv")
test.head() | Titanic - Machine Learning from Disaster |
4,667,493 | na_cols = ["Alley", "BsmtQual", "BsmtCond", "BsmtExposure", "BsmtFinType1", "BsmtFinType2", "GarageType", "GarageFinish", "GarageCond", "GarageQual"]
data_explore[na_cols] = data_explore[na_cols].fillna("NA" )<count_values> | gender_submission=pd.read_csv(".. /input/gender_submission.csv")
gender_submission.head() | Titanic - Machine Learning from Disaster |
4,667,493 | data_explore["Alley"].value_counts()<choose_model_class> | df.isnull().sum() | Titanic - Machine Learning from Disaster |
4,667,493 | num_imputer = SimpleImputer(strategy="mean")
cat_imputer = SimpleImputer(strategy="most_frequent" )<categorify> | df[(df['Fare'].isnull())|(df['Embarked'].isnull())] | Titanic - Machine Learning from Disaster |
4,667,493 | num_nans = ['LotFrontage', 'MasVnrArea', 'GarageYrBlt']
cat_nans = ['MasVnrType', 'Electrical', 'FireplaceQu']
data_explore[num_nans] = num_imputer.fit_transform(data[num_nans])
data_explore[cat_nans] = cat_imputer.fit_transform(data[cat_nans] )<count_missing_values> | cabin_df.groupby('PassengerCount' ).count() | Titanic - Machine Learning from Disaster |
4,667,493 | nulls = data_explore.isna().sum()
nan_cols = nulls[nulls>0].index
nan_cols<data_type_conversions> | cabin_df['CabinOccupancy']=np.where(cabin_df['PassengerCount']==1,1,'')
cabin_df['CabinOccupancy']=np.where(cabin_df['PassengerCount']==2,2,cabin_df['CabinOccupancy'])
cabin_df['CabinOccupancy']=np.where(cabin_df['PassengerCount']==3,3,cabin_df['CabinOccupancy'])
cabin_df['CabinOccupancy']=np.where(cabin_df['Passeng... | Titanic - Machine Learning from Disaster |
4,667,493 | data_explore['MSSubClass'] = data_explore['MSSubClass'].astype(str)
cat_attrs = []
num_attrs = []
columns = list(data_explore.columns)
for col in columns:
if data_explore[col].dtype=='O':
cat_attrs.append(col)
else:
num_attrs.append(col )<define_variables> | df=pd.merge(df,cabin_df[['Cabin','CabinOccupancy']],how='left',on='Cabin')
df.head() | Titanic - Machine Learning from Disaster |
4,667,493 | Q1 = data_explore.quantile(0.25)
Q3 = data_explore.quantile(0.75)
IQR = Q3 - Q1
outliers =(( data_explore <(Q1 - 1.5 * IQR)) |(data_explore >(Q3 + 1.5 * IQR)) ).sum()
outliers[outliers>0]<sort_values> | block=df['Cabin'].str.split('([A-Za-z]+ )(\d+)', expand=True)
block['block']=np.where(block[1].isnull() ,block[3],block[1])
block['block']=np.where(block['block'].isnull() ,block[5],block['block'])
block['block']=np.where(block['block'].isnull() ,block[7],block['block'])
block['block']=np.where(block['block'].isnul... | Titanic - Machine Learning from Disaster |
4,667,493 | corr_matrix['SalePrice'].sort_values(ascending=False )<count_values> | df=pd.merge(df,block,how='outer',left_index=True,right_index=True)
df=df.drop([0,1,2,3,4,5,6,7,8,9,10,11,12], axis=1)
df.head() | Titanic - Machine Learning from Disaster |
4,667,493 | data_explore['GarageCars'].value_counts()<prepare_x_and_y> | titles=df['Name'].str.split(',',expand=True)[1].str.split('.',expand=True)
titles.rename(columns={0: 'Titles'}, inplace=True)
titles=titles.drop(columns=[1,2])
titles.head() | Titanic - Machine Learning from Disaster |
4,667,493 | X = data.drop(columns=['SalePrice'], axis=1)
y = data['SalePrice'].copy()<split> | df=pd.merge(df,titles,how='outer',left_index=True,right_index=True)
df.head() | Titanic - Machine Learning from Disaster |
4,667,493 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
y_log_train = np.log(y_train)
y_log_test = np.log(y_test )<drop_column> | nonull_df=df[(df['Age'].notnull())&(df['Age'].notnull())&(df['Embarked'].notnull())&(df['block'].notnull())&(df['CabinOccupancy'].notnull())]
nonull_df.head() | Titanic - Machine Learning from Disaster |
4,667,493 | na_cols = ["Alley", "BsmtQual", "BsmtCond", "BsmtExposure", "BsmtFinType1", "BsmtFinType2", "GarageType", "GarageFinish", "GarageCond", "GarageQual", "PoolQC", "Fence", "MiscFeature"]
cat_attrs = [cat for cat in cat_attrs if not cat in na_cols]
num_attrs.remove('SalePrice' )<import_modules> | nonull_df.count() ['PassengerId'] | Titanic - Machine Learning from Disaster |
4,667,493 | from sklearn.impute import SimpleImputer, KNNImputer
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PowerTransformer, OneHotEncoder<categorify> | cat_feats=['Embarked','Sex','Titles','block','Pclass']
nonull_df_train = pd.get_dummies(nonull_df,columns=cat_feats,drop_first=False)
nonull_df_train=nonull_df_train[['Age','Fare','Parch','Pclass_1','Pclass_2','Pclass_3','SibSp','Embarked_S','Sex_male','Titles_ Mr']]
nonull_df_train.head()
| Titanic - Machine Learning from Disaster |
4,667,493 | num_pipeline = Pipeline([('imputer', SimpleImputer(strategy="mean")) ,
('transformer', PowerTransformer(method='yeo-johnson', standardize=True)) ])
cat_pipeline_1 = Pipeline([('cat_na_fill', SimpleImputer(strategy="constant", fill_value='NA')) ,
('encoder', OneHotEncoder(handle_unknown='ignore')) ])
cat_pipeline_2 ... | X_nonull_df_train = nonull_df_train.drop('Fare',axis=1)
y_nonull_df_train = nonull_df_train['Fare'] | 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.