kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
5,707,809 | all = []
for k in range(input_ids_t.shape[0]):
a = np.argmax(preds_start[k,])
b = np.argmax(preds_end[k,])
if a>b:
st = test.loc[k,'text']
else:
text1 = " "+" ".join(test.loc[k,'text'].split())
enc = tokenizer.encode(text1)
st = tokenizer.decode(enc.ids[a-1:b])
all.append(st )<save_to_csv> | score_cv(XGBClassifier() ) | Titanic - Machine Learning from Disaster |
5,707,809 | test['selected_text'] = all
test[['textID','selected_text']].to_csv('submission.csv',index=False)
pd.set_option('max_colwidth', 60)
test.sample(25 )<set_options> | gradient = GradientBoostingClassifier()
gradient.fit(train, y_train ) | Titanic - Machine Learning from Disaster |
5,707,809 | %matplotlib inline
plt.style.use('seaborn-whitegrid')
warnings.filterwarnings('ignore' )<load_from_csv> | score_cv(GradientBoostingClassifier() ) | Titanic - Machine Learning from Disaster |
5,707,809 | test = pd.read_csv('.. /input/titanic/test.csv')
train = pd.read_csv('.. /input/titanic/train.csv' )<prepare_x_and_y> | params = {
"loss":["deviance"],
"learning_rate": [0.01, 0.05, 0.1, 0.15, 0.2],
"min_samples_split": np.linspace(0.1, 0.5, 4),
"min_samples_leaf": np.linspace(0.1, 0.5, 4),
"max_depth":[3,5,8],
"max_features":["auto","log2","sqrt"],
"criterion": ["friedman_mse", "mae"],
"subsample":[0.5, 0.618, 0.8, 0.85, 0.9, 0.95, 1.0... | Titanic - Machine Learning from Disaster |
5,707,809 | ntrain = train.shape[0]
ntest = test.shape[0]
y_train = train['Survived'].values
passId = test['PassengerId']
data = pd.concat(( train, test))
print("data size is: {}".format(data.shape))<count_values> | score_cv(gridsearch_gradient.best_estimator_ ) | Titanic - Machine Learning from Disaster |
5,707,809 | train['Survived'].value_counts()<count_missing_values> | pred = gridsearch_logistic.best_estimator_.predict(test)
sub = pd.DataFrame()
sub['PassengerID'] = test_ID
sub['Survived'] = pred
sub.to_csv('submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
5,421,572 | data.isnull().sum()
<count_values> | train_data = pd.read_csv(".. /input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
5,421,572 | data.Name.value_counts()<feature_engineering> | test_data = pd.read_csv('.. /input/titanic/test.csv')
test_data.head() | Titanic - Machine Learning from Disaster |
5,421,572 | temp = data.copy()
temp['Initial'] = 0
temp['Initial'] = data.Name.str.extract('([A-Za-z]+)\.')
<count_values> | print("Missing data counts in Training Data : ")
print(train_data.isnull().sum())
print("Missing data counts in Test Data : ")
print(test_data.isnull().sum())
| Titanic - Machine Learning from Disaster |
5,421,572 | temp['Initial'].value_counts()<groupby> | print("Percentage of data missing Training Data: ")
print(train_data.isnull().sum() /train_data.shape[0])
print("Percentage of data missing Test Data: ")
print(test_data.isnull().sum() /test_data.shape[0] ) | Titanic - Machine Learning from Disaster |
5,421,572 | def survpct(col):
return temp.groupby(col)['Survived'].mean()
survpct('Initial' )<filter> | columns_to_drop = []
columns_to_drop.append('Cabin' ) | Titanic - Machine Learning from Disaster |
5,421,572 | temp.loc[temp['Initial'] == 'Dona']<feature_engineering> | test_data[test_data['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
5,421,572 | temp.loc[temp['Initial'] == 'Dona', 'Initial'] = 'Mrs'<feature_engineering> | test_data[test_data['Ticket']=='3701'] | Titanic - Machine Learning from Disaster |
5,421,572 | temp = temp.reset_index(drop=True)
temp['Age'] = temp.groupby('Initial')['Age'].apply(lambda x: x.fillna(x.mean()))
temp[31:50]<categorify> | class_3_data = test_data[test_data['Pclass'] == 3]
class_3_S = class_3_data[class_3_data['Embarked'] == 'S']
class_3_S[class_3_S['Age']>40] | Titanic - Machine Learning from Disaster |
5,421,572 | temp['Initial'].replace(['Capt', 'Col', 'Countess', 'Don', 'Dona' , 'Dr', 'Jonkheer', 'Lady', 'Major', 'Master', 'Miss' ,'Mlle', 'Mme', 'Mr', 'Mrs', 'Ms', 'Rev', 'Sir'], ['Sacrificed', 'Respected', 'Nobles', 'Mr', 'Mrs', 'Respected', 'Mr', 'Nobles', 'Respected', 'Kids', 'Miss', 'Nobles', 'Nobles', 'Mr', 'Mrs', 'Nobles'... | test_data[test_data["Fare"].isnull() ] | Titanic - Machine Learning from Disaster |
5,421,572 | temp['Age_Range'] = pd.qcut(temp['Age'], 10)
survpct('Age_Range')
<feature_engineering> | test_data.iloc[152,-3]= 14 | Titanic - Machine Learning from Disaster |
5,421,572 | temp['Agroup'] = 0
temp.loc[temp['Age'] < 1.0, 'Agroup'] = 1
temp.loc[(temp['Age'] >= 1.0)&(temp['Age'] <= 3.0), 'Agroup'] = 2
temp.loc[(temp['Age'] > 3.0)&(temp['Age'] < 11.0), 'Agroup'] = 7
temp.loc[(temp['Age'] >= 11.0)&(temp['Age'] < 15.0), 'Agroup'] = 13
temp.loc[(temp['Age'] >= 15.0)&(temp['Age'] < 18.0), 'Agroup... | train_data[train_data['Age'].isnull() ] | Titanic - Machine Learning from Disaster |
5,421,572 | temp.loc[(temp['Sex'] == 'male'), 'Sex'] = 1
temp.loc[(temp['Sex'] == 'female'), 'Sex'] = 2
temp.loc[(temp['Age'] < 1), 'Sex'] = 3
survpct('Sex' )<feature_engineering> | def extract_titles(df):
pos = df.columns.get_loc('Name')
titles = set({})
for row in df.values:
title = row[pos].split(',')[1].split('.')[0] + '.'.strip()
titles.add(title)
return titles
| Titanic - Machine Learning from Disaster |
5,421,572 | temp.loc[(temp['SibSp'] == 0)&(temp['Parch'] == 0), 'Alone'] = 1
temp['Family'] = temp['Parch'] + temp['SibSp'] + 1
temp.head(n=10 )<drop_column> | def add_titles_to_df(df):
titles = extract_titles(df)
pos = df.columns.get_loc('Name')
title_list = []
for row in df.values:
for title in titles:
if title in row[pos]:
title_list.append(title)
break
df['Title'] = title_list
return df
| Titanic - Machine Learning from Disaster |
5,421,572 | bag('Parch', 'Survived', 'Survived per Parch', 'Parch Survived vs Not Survived' )<filter> | train_data = add_titles_to_df(train_data ) | Titanic - Machine Learning from Disaster |
5,421,572 | temp.loc[(temp.Embarked.isnull())]<filter> | test_data = add_titles_to_df(test_data ) | Titanic - Machine Learning from Disaster |
5,421,572 | temp.loc[(temp.Ticket == '113572')]<sort_values> | train_data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
5,421,572 | temp.sort_values(['Ticket'], ascending=True)[55:70]<feature_engineering> | test_data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
5,421,572 | temp.loc[(temp.Embarked.isnull()), 'Embarked'] = 'S'
temp.loc[(temp.Embarked.isnull())]<feature_engineering> | male_titles = [' Col.',' Major.',' Capt.',' Jonkheer.',' Don.',' Sir.']
female_titles = [' Lady.',' Mme.',' the Countess.',' Dona.',' Mlle.'] | Titanic - Machine Learning from Disaster |
5,421,572 | temp['Embarked'] = temp['Embarked'].factorize() [0]
temp[11:20]<feature_engineering> | def replace_uncommon_titles(df,new_title,title_list):
pos = df.columns.get_loc('Title')
for title in title_list:
for i in range(0,df.shape[0]):
if df.iloc[i,pos] == title:
print(title)
df.iloc[i,pos] = new_title
return df
train_data = replace_uncommon_titles(train_data,' Mr.',male_titles)
train_data = replace_uncomm... | Titanic - Machine Learning from Disaster |
5,421,572 | temp['Priority'] = 0
temp.loc[(temp['Initial'] == 6), 'Priority'] = 1
temp.loc[(temp['Pclass'] == 1)&(temp['Sex'] == 2), 'Priority'] = 2
temp.loc[(temp['Age'] < 1), 'Priority'] = 3
temp.loc[(temp['Pclass'] == 1)&(temp['Age'] <= 17), 'Priority'] = 4
temp.loc[(temp['Pclass'] == 2)&(temp['Age'] <= 17), 'Priority'] = 5<cou... | age_mean = train_data.groupby("Title" ).mean() ['Age'] | Titanic - Machine Learning from Disaster |
5,421,572 | temp.Priority.value_counts()<feature_engineering> | def fill_age_na(df,age_mean):
rows_with_age_missing = df[df['Age'].isnull() ]
pos = df.columns.get_loc("Age")
for title in age_mean.index:
passengerIds = rows_with_age_missing[rows_with_age_missing['Title'] == title]["PassengerId"]
for Id in passengerIds:
df.iloc[df[df['PassengerId'] == Id].index.values,pos] = age_mea... | Titanic - Machine Learning from Disaster |
5,421,572 | temp['F1'] = temp['Priority']
temp['F2'] = temp['Initial']
temp['F3'] = temp['NumName']
temp['F4'] = temp['Family']
temp['F5'] = temp['Embarked']
temp['F6'] = temp['Sex']
temp['F7'] = temp['Pclass']<categorify> | train_data = fill_age_na(train_data,age_mean)
test_data = fill_age_na(test_data,age_mean)
train_data[train_data['Age'].isnull() ] | Titanic - Machine Learning from Disaster |
5,421,572 | dfl = pd.DataFrame()
good_columns = ['F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7']
dfl[good_columns] = temp[good_columns]
dfh = dfl.copy()
dfl_enc = dfl.apply(LabelEncoder().fit_transform)
dfl_enc.head()<categorify> | test_data[test_data['Age'].isnull() ] | Titanic - Machine Learning from Disaster |
5,421,572 | one_hot_cols = dfh.columns.tolist()
dfh_enc = pd.get_dummies(dfh, columns=one_hot_cols)
dfh_enc.head()<split> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
5,421,572 | train = dfh_enc[:ntrain]
test = dfh_enc[ntrain:]<prepare_x_and_y> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
5,421,572 | X_test = test
X_train = train<normalization> | train_data['Embarked']= train_data['Embarked'].fillna(value='S',axis=0 ) | Titanic - Machine Learning from Disaster |
5,421,572 | scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test )<define_search_model> | columns_to_drop.extend(["Ticket"] ) | Titanic - Machine Learning from Disaster |
5,421,572 | ran = RandomForestClassifier(random_state=1)
knn = KNeighborsClassifier()
log = LogisticRegression()
xgb = XGBClassifier()
gbc = GradientBoostingClassifier()
svc = SVC(probability=True)
ext = ExtraTreesClassifier()
ada = AdaBoostClassifier()
gnb = GaussianNB()
gpc = GaussianProcessClassifier()
bag = BaggingClassifier... | def drop_columns(df,list_of_columns):
return df.drop(list_of_columns,axis=1)
| Titanic - Machine Learning from Disaster |
5,421,572 | results = pd.DataFrame(scores ).T
results['mean'] = results.mean(1)
result_df = results.sort_values(by='mean', ascending=False)
result_df.head(11 )<create_dataframe> | train_data = drop_columns(train_data,columns_to_drop)
test_data = drop_columns(test_data,columns_to_drop ) | Titanic - Machine Learning from Disaster |
5,421,572 | gbc_imp = pd.DataFrame({'Feature':train.columns, 'gbc importance':gbc.feature_importances_})
xgb_imp = pd.DataFrame({'Feature':train.columns, 'xgb importance':xgb.feature_importances_})
ran_imp = pd.DataFrame({'Feature':train.columns, 'ran importance':ran.feature_importances_})
ext_imp = pd.DataFrame({'Feature':trai... | labels = train_data['Survived']
train_data = train_data.drop('Survived',axis=1 ) | Titanic - Machine Learning from Disaster |
5,421,572 | mylist = list(importance1.index )<prepare_output> | cleaned_train_data = train_data
cleaned_test_data = test_data | Titanic - Machine Learning from Disaster |
5,421,572 | train1 = pd.DataFrame()
test1 = pd.DataFrame()
for i in mylist:
train1[i] = train[i]
test1[i] = test[i]
train1.head()<normalization> | categorical_columns = ['Pclass','Sex','Embarked','Title']
numerical_columns = ['Age','Fare','SibSp','Parch']
| Titanic - Machine Learning from Disaster |
5,421,572 | train = train1
test = test1
X_train = train
X_test = test
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test )<choose_model_class> | def preprocess_data(df):
scaler = StandardScaler()
numerical_data = df[numerical_columns]
categorical_data = df[categorical_columns]
std_data_numerical = scaler.fit_transform(numerical_data)
df_numerical = pd.DataFrame(std_data_numerical,columns=numerical_columns,index=df.index)
std_data_categorical = pd.get_dummies(... | Titanic - Machine Learning from Disaster |
5,421,572 | ran = RandomForestClassifier(random_state=1)
knn = KNeighborsClassifier()
log = LogisticRegression()
xgb = XGBClassifier(random_state=1)
gbc = GradientBoostingClassifier(random_state=1)
svc = SVC(probability=True)
ext = ExtraTreesClassifier(random_state=1)
ada = AdaBoostClassifier(random_state=1)
gnb = GaussianNB... | preprocessed_train_data = preprocess_data(cleaned_train_data ) | Titanic - Machine Learning from Disaster |
5,421,572 | results = pd.DataFrame(scores2 ).T
results['mean'] = results.mean(1)
result_df = results.sort_values(by='mean', ascending=False)
result_df.head(11 )<train_on_grid> | preprocessed_test_data = preprocess_data(cleaned_test_data ) | Titanic - Machine Learning from Disaster |
5,421,572 | Cs = [0.01, 0.1, 1, 5, 10, 15, 20, 50]
gammas = [0.001, 0.01, 0.1]
hyperparams = {'C': Cs, 'gamma': gammas}
gd = GridSearchCV(estimator=SVC(probability=True), param_grid=hyperparams, verbose=True, cv=5, scoring="accuracy", n_jobs=-1)
gd.fit(X_train, y_train)
print(gd.best_score_)
print(gd.best_params_ )<train_on_gri... | train_X, val_X, train_y, val_y = train_test_split(preprocessed_train_data,labels,random_state=1 ) | Titanic - Machine Learning from Disaster |
5,421,572 | learning_rate = [0.01, 0.05, 0.1, 0.2, 0.5]
n_estimators = [100, 1000, 2000]
max_depth = [3, 5, 10, 15]
hyperparams = {'learning_rate': learning_rate, 'n_estimators': n_estimators}
gd = GridSearchCV(estimator=GradientBoostingClassifier() , param_grid = hyperparams, verbose=True, cv=5, scoring="accuracy", n_jobs=-1)
gd... | estimators = [1, 2, 4, 8, 16, 32, 64, 100, 200]
for num in estimators:
model = RandomForestClassifier(n_estimators=num)
model.fit(train_X,train_y)
preds = model.predict(val_X)
print("Accuracy for {} estimators is {}".format(num,accuracy_score(val_y,preds,normalize=True)) ) | Titanic - Machine Learning from Disaster |
5,421,572 | penalty = ['l1', 'l2']
C = np.logspace(0, 4, 10)
hyperparams = {'penalty': penalty, 'C': C}
gd = GridSearchCV(estimator=LogisticRegression() , param_grid=hyperparams, verbose=True, cv=5, scoring="accuracy", n_jobs=-1)
gd.fit(X_train, y_train)
print(gd.best_score_)
print(gd.best_params_ )<train_on_grid> | n_est = [5,10,20,40,100,200]
for num in n_est:
xgb_model = xgb.XGBClassifier(n_estimators=num)
xgb_model.fit(train_X,train_y)
preds = xgb_model.predict(val_X)
print("Accuracy lr {} is {}".format(num,accuracy_score(val_y,preds,normalize=True)) ) | Titanic - Machine Learning from Disaster |
5,421,572 | learning_rate = [0.001, 0.005, 0.01, 0.05, 0.1, 0.2]
n_estimators = [10, 50, 100, 250, 500, 1000]
hyperparams = {'learning_rate': learning_rate, 'n_estimators': n_estimators}
gd = GridSearchCV(estimator = XGBClassifier() , param_grid=hyperparams, verbose=True, cv=5, scoring="accuracy", n_jobs=-1)
gd.fit(X_train, y_tra... | iters = [50,100,150,200,300,500]
for num in iters:
model = LogisticRegression(penalty='l2',max_iter=num,random_state=1,verbose=3)
model.fit(train_X,train_y)
preds = model.predict(val_X)
print("Accuracy for {} iterations is {}".format(num,accuracy_score(val_y,preds,normalize=True)) ) | Titanic - Machine Learning from Disaster |
5,421,572 | max_depth = [3, 4, 5, 6, 7, 8, 9, 10]
min_child_weight = [1, 2, 3, 4, 5, 6]
hyperparams = {'max_depth': max_depth, 'min_child_weight': min_child_weight}
gd = GridSearchCV(estimator=XGBClassifier(learning_rate=0.2, n_estimators=50),
param_grid=hyperparams, verbose=True, cv=5, scoring="accuracy", n_jobs=-1)
gd.fit(X_tra... | model = LogisticRegression(penalty='l2',solver='lbfgs',random_state=1)
model.fit(preprocessed_train_data,labels)
preds = model.predict(preprocessed_test_data ) | Titanic - Machine Learning from Disaster |
5,421,572 | gamma = [i*0.1 for i in range(0,5)]
hyperparams = {'gamma': gamma}
gd = GridSearchCV(estimator= XGBClassifier(learning_rate=0.2, n_estimators=50, max_depth=8, min_child_weight=2),
param_grid=hyperparams, verbose=True, cv=5, scoring="accuracy", n_jobs=-1)
gd.fit(X_train, y_train)
print(gd.best_score_)
print(gd.best_p... | output = pd.DataFrame({'PassengerId': test_data.PassengerId,
'Survived': preds})
output.to_csv('submission.csv', index=False)
output | Titanic - Machine Learning from Disaster |
5,421,572 | subsample = [0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1]
colsample_bytree = [0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1]
hyperparams = {'subsample': subsample, 'colsample_bytree': colsample_bytree}
gd = GridSearchCV(estimator=XGBClassifier(learning_rate=0.2, n_estimators=50, max_depth=8, min_child_weight=2, gamma... | %matplotlib inline | Titanic - Machine Learning from Disaster |
4,063,566 | reg_alpha = [1e-5, 1e-2, 0.1, 1, 100]
hyperparams = {'reg_alpha': reg_alpha}
gd = GridSearchCV(estimator=XGBClassifier(learning_rate=0.2, n_estimator=50, max_depth=8, min_child_weight=2, gamma=0, subsample=0.7, colsample_bytree=0.65),
param_grid=hyperparams, verbose=True, cv=5, scoring="accuracy", n_jobs=-1)
gd.fit(X_... | train=pd.read_csv(".. /input/train.csv")
test=pd.read_csv(".. /input/test.csv")
train_Id=train['PassengerId']
train=train.drop(['PassengerId'],axis=1)
test_Id=test['PassengerId']
test=test.drop(['PassengerId'],axis=1)
y=train['Survived']
| Titanic - Machine Learning from Disaster |
4,063,566 | n_restarts_optimizer = [0, 1, 2, 3]
max_iter_predict = [1, 2, 5, 10, 20, 35, 50, 100]
warm_start = [True, False]
hyperparams = {'n_restarts_optimizer': n_restarts_optimizer, 'max_iter_predict': max_iter_predict, 'warm_start': warm_start}
gd = GridSearchCV(estimator=GaussianProcessClassifier() , param_grid=hyperparams, ... | alldata=pd.concat([train,test])
| Titanic - Machine Learning from Disaster |
4,063,566 | n_estimators = [10, 100, 200, 500]
learning_rate = [0.001, 0.01, 0.1, 0.5, 1, 1.5, 2]
hyperparams = {'n_estimators': n_estimators, 'learning_rate': learning_rate}
gd = GridSearchCV(estimator=AdaBoostClassifier() , param_grid=hyperparams, verbose=True, cv=5, scoring="accuracy", n_jobs=-1)
gd.fit(X_train, y_train)
prin... | alldata.isna().sum() | Titanic - Machine Learning from Disaster |
4,063,566 | n_neighbors = [1, 2, 3, 4, 5]
algorithm = ['auto']
weights = ['uniform', 'distance']
leaf_size = [1, 2, 3, 4, 5, 10]
hyperparams = {'algorithm':algorithm, 'weights': weights, 'leaf_size': leaf_size, 'n_neighbors': n_neighbors}
gd=GridSearchCV(estimator=KNeighborsClassifier() , param_grid=hyperparams, verbose=True, cv=5... | alldata['Fare']=alldata['Fare'].fillna(alldata['Fare'].mode().values[0])
alldata['Age']=alldata['Age'].fillna(alldata['Age'].median())
alldata['Embarked']=alldata['Embarked'].fillna(alldata['Embarked'].mode().values[0])
| Titanic - Machine Learning from Disaster |
4,063,566 | n_estimators = [10, 50, 100, 200]
max_depth = [3, None]
max_features = [0.1, 0.2, 0.5, 0.8]
min_samples_split = [2, 6]
min_samples_leaf = [2, 6]
hyperparams = {'n_estimators': n_estimators, 'max_depth': max_depth, 'max_features': max_features,
'min_samples_split': min_samples_split, 'min_samples_leaf': min_samples_leaf... | alldata['Surename']=alldata.Name.apply(lambda x: x.split(',')[0])
alldata['Title']=alldata.Name.apply(lambda x: x.split(',')[1].split('.')[0])
alldata['SurrnameFreq']=alldata.Surename.apply(lambda x: alldata.groupby('Surename' ).count().Age[x])
alldata['Deck']=alldata.Cabin.apply(lambda x: str(x)[0])
alldata['Famil... | Titanic - Machine Learning from Disaster |
4,063,566 | n_estimators = [10, 25, 50, 75, 100]
max_depth = [3, None]
max_features = [0.1, 0.2, 0.5, 0.8]
min_samples_split = [2, 10]
min_samples_leaf = [2, 10]
hyperparams = {'n_estimators': n_estimators, 'max_depth': max_depth, 'max_features': max_features, 'min_samples_split': min_samples_split, 'min_samples_leaf': min_samples... | alldata.isna().sum() | Titanic - Machine Learning from Disaster |
4,063,566 | n_estimators = [10, 50, 75, 100, 200]
max_samples = [0.1, 0.2, 0.5, 0.8, 1.0]
max_features = [0.1, 0.2, 0.5, 0.8, 1.0]
hyperparams = {'n_estimators': n_estimators, 'max_samples': max_samples, 'max_features': max_features}
gd = GridSearchCV(estimator=BaggingClassifier() , param_grid=hyperparams, verbose=True, cv=5, scor... | alldata=pd.get_dummies(alldata)
alldata.info() | Titanic - Machine Learning from Disaster |
4,063,566 | ran = RandomForestClassifier(max_depth=None, max_features=0.1, min_samples_leaf=2, min_samples_split=6, n_estimators=100, random_state=1)
knn = KNeighborsClassifier(leaf_size=1, n_neighbors=5, weights='distance')
log = LogisticRegression(C=1.0, penalty='l2')
xgb = XGBClassifier(learning_rate=0.2, n_estimators=50, ma... | num_feat=alldata.dtypes[alldata.dtypes!="object"].index
scX = StandardScaler()
alldata[num_feat] = scX.fit_transform(alldata[num_feat].values)
| Titanic - Machine Learning from Disaster |
4,063,566 | grid_hard = VotingClassifier(estimators = [('Random Forest', ran),
('Logistic Regression', log),
('XGBoost', xgb),
('Gradient Boosting', gbc),
('Extra Trees', ext),
('AdaBoost', ada),
('Gaussian Process', gpc),
('SVC', svc),
('K Nearest Neighbor', knn),
('Bagging Classifier', bag)], voting='hard')
grid_hard_c... | from sklearn.model_selection import train_test_split,KFold,cross_val_score | Titanic - Machine Learning from Disaster |
4,063,566 | grid_soft = VotingClassifier(estimators = [('Random Forest', ran),
('Logistic Regression', log),
('XGBoost', xgb),
('Gradient Boosting', gbc),
('Extra Trees', ext),
('AdaBoost', ada),
('Gaussian Process', gpc),
('SVC', svc),
('K Nearest Neighbor', knn),
('Bagging Classifier', bag)], voting='soft')
grid_soft_c... | alldata=alldata.drop(['Survived'],axis=1)
train=alldata[:len(train)]
test=alldata[len(train):]
| Titanic - Machine Learning from Disaster |
4,063,566 | predictions = grid_hard.predict(X_test)
submission = pd.concat([pd.DataFrame(passId), pd.DataFrame(predictions)], axis='columns')
submission.columns = ["PassengerId", "Survived"]
submission.to_csv('titanic_submission1.csv', header=True, index=False )<save_to_csv> | kfolds = KFold(n_splits=5, shuffle=True,random_state=1)
def acc_cv(model):
acc= cross_val_score(model, train.values, y.values, scoring="accuracy", cv = kfolds.get_n_splits(train.values))
return acc | Titanic - Machine Learning from Disaster |
4,063,566 | predictions = grid_soft.predict(X_test)
submission = pd.concat([pd.DataFrame(passId), pd.DataFrame(predictions)], axis='columns')
submission.columns = ["PassengerId", "Survived"]
submission.to_csv('titanic_submission2.csv', header=True, index=False )<set_options> | X_train, X_test, y_train, y_test = train_test_split(train.values, y.values, test_size=0.4,random_state=100)
| Titanic - Machine Learning from Disaster |
4,063,566 | %matplotlib inline
<load_from_csv> | class StackNet(BaseEstimator, RegressorMixin, TransformerMixin):
def __init__(self, base_models,meta_final_model, meta_models1=None, meta_models2=None,add_prev_out=True, n_folds=10):
self.base_models = base_models
self.meta_models1 = meta_models1
self.meta_models2 = meta_models2
self.meta_final_model=meta_final_model
s... | Titanic - Machine Learning from Disaster |
4,063,566 | train_df = pd.read_csv(".. /input/titanic/train.csv")
test_df = pd.read_csv(".. /input/titanic/test.csv")
combine = [train_df, test_df]<count_missing_values> | lr=LogisticRegression(random_state=1)
xgbm=xgb.XGBClassifier(objective='binary:hinge',random_state=1)
lgbmm=lgb.LGBMClassifier(objective='huber',random_state=1)
gbc=GradientBoostingClassifier(random_state=1)
adc=AdaBoostClassifier(random_state=1)
rf=RandomForestClassifier(random_state=1,n_jobs=-1,n_estimators=100)... | Titanic - Machine Learning from Disaster |
4,063,566 | train_df.isnull().sum()<count_missing_values> | sn.fit(train.values,y.values)
submission = pd.read_csv('.. /input/gender_submission.csv')
submission['Survived'] = sn.predict(test.values)
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
3,846,140 | print('_'*40)
test_df.isnull().sum()<sort_values> | titanic = pd.read_csv(".. /input/train.csv")
titanic_t = pd.read_csv(".. /input/test.csv" ) | Titanic - Machine Learning from Disaster |
3,846,140 | train_df[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean().sort_values(by='Survived',
ascending=False )<sort_values> | titanic['Sex'].value_counts() | Titanic - Machine Learning from Disaster |
3,846,140 | train_df[["Sex", "Survived"]].groupby(['Sex'], as_index=False ).mean().sort_values(by='Survived',
ascending=False )<sort_values> | titanic = titanic.drop(['Cabin'], axis=1)
titanic_t = titanic_t.drop(['Cabin'], axis=1 ) | Titanic - Machine Learning from Disaster |
3,846,140 | train_df[["SibSp", "Survived"]].groupby(['SibSp'], as_index=False ).mean().sort_values(by='Survived',
ascending=False )<sort_values> | def impute_age(cols):
Age = cols[0]
Pclass = cols[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 |
3,846,140 | train_df[["Parch", "Survived"]].groupby(['Parch'], as_index=False ).mean().sort_values(by='Survived',
ascending=False )<feature_engineering> | titanic['Age'] = titanic[['Age','Pclass']].apply(impute_age,axis=1)
titanic_t['Age'] = titanic_t[['Age','Pclass']].apply(impute_age,axis=1)
titanic_t['Fare'] = titanic_t['Fare'].fillna(fare_mean ) | Titanic - Machine Learning from Disaster |
3,846,140 | for dataset in combine:
dataset['Title'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False)
pd.crosstab(train_df['Title'], train_df['Sex'] )<feature_engineering> | titanic['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
3,846,140 | for dataset in combine:
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
dataset['Title'] = dataset['Titl... | titanic['Embarked'] = titanic['Embarked'].fillna('S')
titanic_t['Embarked'] = titanic_t['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
3,846,140 | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in combine:
dataset['Title'] = dataset['Title'].map(title_mapping)
dataset['Title'] = dataset['Title'].fillna(0)
train_df.head()<drop_column> | titanic = titanic.drop(['PassengerId', 'Ticket'], axis=1)
titanic_t = titanic_t.drop(['PassengerId', 'Ticket'], axis=1 ) | Titanic - Machine Learning from Disaster |
3,846,140 | train_df = train_df.drop(['Name', 'PassengerId'], axis=1)
test_df = test_df.drop(['Name', 'PassengerId'], axis=1)
combine = [train_df, test_df]
train_df.shape, test_df.shape<data_type_conversions> | titanic['With_someone'] = titanic['SibSp'] | titanic['Parch']
titanic_t['With_someone'] = titanic_t['SibSp'] | titanic_t['Parch'] | Titanic - Machine Learning from Disaster |
3,846,140 | for dataset in combine:
dataset['Sex'] = dataset['Sex'].map({'female': 1, 'male': 0} ).astype(int)
train_df.head()<define_variables> | titanic['With_someone'] = titanic['With_someone'].apply(lambda x:1 if x >=1 else 0)
titanic_t['With_someone'] = titanic_t['With_someone'].apply(lambda x:1 if x >=1 else 0 ) | Titanic - Machine Learning from Disaster |
3,846,140 | guess_ages = np.zeros(( 2,3))
guess_ages<categorify> | titanic['Title'] = titanic['Name'].str.extract('([A-Za-z]+)\.', expand=False)
titanic_t['Title'] = titanic_t['Name'].str.extract('([A-Za-z]+)\.', expand=False)
titanic['Title'].value_counts() | Titanic - Machine Learning from Disaster |
3,846,140 | for dataset in combine:
for i in range(0, 2):
for j in range(0, 3):
guess_df = dataset[(dataset['Sex'] == i)&(dataset['Pclass'] == j+1)]['Age'].dropna()
age_guess = guess_df.median()
guess_ages[i,j] = int(age_guess/0.5 + 0.5)* 0.5
for i in range(0, 2):
for j in range(0, 3):
dataset.loc[(dataset.Age.isnull())&(dataset.S... | title_mapping = {"Mr": 0, "Miss": 1, "Mrs": 2,
"Master": 3, "Dr": 3, "Rev": 3, "Col": 3, "Major": 3, "Mlle": 3,"Countess": 3,
"Ms": 3, "Lady": 3, "Jonkheer": 3, "Don": 3, "Dona" : 3, "Mme": 3,"Capt": 3,"Sir": 3 }
titanic['Title'] = titanic['Title'].map(title_mapping)
titanic_t['Title'] = titanic_t['Title'].map(title_m... | Titanic - Machine Learning from Disaster |
3,846,140 | train_df['AgeBand'] = pd.cut(train_df['Age'], 5)
train_df[['AgeBand', 'Survived']].groupby(['AgeBand'], as_index=False ).mean().sort_values(by='AgeBand', ascending=True )<feature_engineering> | titanic = titanic.drop(['Name'], axis=1)
titanic_t = titanic_t.drop(['Name'], axis=1 ) | Titanic - Machine Learning from Disaster |
3,846,140 | 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['family members'] = titanic['SibSp'] + titanic['Parch'] + 1
titanic_t['family members'] = titanic_t['SibSp'] + titanic_t['Parch'] + 1 | Titanic - Machine Learning from Disaster |
3,846,140 | train_df = train_df.drop(['AgeBand'], axis=1)
combine = [train_df, test_df]
train_df.head()<sort_values> | titanic = pd.get_dummies(titanic, columns = ['Pclass', 'Sex', 'Embarked', 'Title'], drop_first = True)
titanic_t = pd.get_dummies(titanic_t, columns = ['Pclass', 'Sex', 'Embarked', 'Title'], drop_first = True ) | Titanic - Machine Learning from Disaster |
3,846,140 | for dataset in combine:
dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1
train_df[['FamilySize', 'Survived']].groupby(['FamilySize'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<feature_engineering> | titanic = titanic.drop(['SibSp', 'Parch', 'Age'], axis=1)
titanic_t = titanic_t.drop(['SibSp', 'Parch', 'Age'], axis=1 ) | Titanic - Machine Learning from Disaster |
3,846,140 | for dataset in combine:
dataset['IsAlone'] = 0
dataset.loc[dataset['FamilySize'] == 1, 'IsAlone'] = 1
train_df[['IsAlone', 'Survived']].groupby(['IsAlone'], as_index=False ).mean()<drop_column> | X = titanic.drop(['Survived'], axis=1)
y = titanic['Survived'] | Titanic - Machine Learning from Disaster |
3,846,140 | train_df = train_df.drop(['Parch', 'SibSp'], axis=1)
test_df = test_df.drop(['Parch', 'SibSp'], axis=1)
combine = [train_df, test_df]
train_df.head()<set_options> | X_t = titanic_t | Titanic - Machine Learning from Disaster |
3,846,140 | freq_port = train_df.Embarked.dropna().mode() [0]
print(freq_port )<sort_values> | X_scale = X[['Fare', 'family members']]
X_noscale = X.drop(['Fare', 'family members'], axis=1)
X_scale_t = X_t[['Fare', 'family members']]
X_noscale_t = X_t.drop(['Fare', 'family members'], axis=1 ) | Titanic - Machine Learning from Disaster |
3,846,140 | for dataset in combine:
dataset['Embarked'] = dataset['Embarked'].fillna(freq_port)
train_df[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False ).mean().sort_values(by='Survived', ascending=False )<data_type_conversions> | sc_X = MinMaxScaler()
X_scaled = sc_X.fit_transform(X_scale)
X_scaled_t = sc_X.fit_transform(X_scale_t ) | Titanic - Machine Learning from Disaster |
3,846,140 | for dataset in combine:
dataset['Embarked'] = dataset['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int)
train_df.head()<data_type_conversions> | X_scaled = pd.DataFrame(X_scaled, columns=['Fare', 'family members'])
X_scaled_t = pd.DataFrame(X_scaled_t, columns=['Fare', 'family members'] ) | Titanic - Machine Learning from Disaster |
3,846,140 | test_df['Fare'].fillna(test_df['Fare'].dropna().median() , inplace=True )<sort_values> | X = pd.concat([X_scaled, X_noscale], axis=1)
X_t = pd.concat([X_scaled_t, X_noscale_t], axis=1 ) | Titanic - Machine Learning from Disaster |
3,846,140 | train_df['FareBand'] = pd.qcut(train_df['Fare'], 4)
train_df[['FareBand', 'Survived']].groupby(['FareBand'], as_index=False ).mean().sort_values(by='FareBand', ascending=True )<data_type_conversions> | k_range = [4]
weight_options = ['uniform']
norm = [1]
algo = ['ball_tree'] | Titanic - Machine Learning from Disaster |
3,846,140 | for dataset in combine:
dataset.loc[ dataset['Fare'] <= 7.91, 'Fare'] = 0
dataset.loc[(dataset['Fare'] > 7.91)&(dataset['Fare'] <= 14.454), 'Fare'] = 1
dataset.loc[(dataset['Fare'] > 14.454)&(dataset['Fare'] <= 31), 'Fare'] = 2
dataset.loc[ dataset['Fare'] > 31, 'Fare'] = 3
dataset['Fare'] = dataset['Fare'].astype(int)... | param_grid = dict(n_neighbors = k_range, weights = weight_options, p = norm, algorithm = algo)
param_grid | Titanic - Machine Learning from Disaster |
3,846,140 | X_train = train_df.drop("Survived", axis=1)
y_train = train_df["Survived"]
print("X_train.shape" ,X_train.shape)
print("y_train.shape" ,y_train.shape)
X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size=0.2, random_state=111 )<compute_train_metric> | from sklearn.model_selection import GridSearchCV, RandomizedSearchCV | Titanic - Machine Learning from Disaster |
3,846,140 | logreg = LogisticRegression()
logreg.fit(X_train, y_train)
Y_pred_lr = logreg.predict(X_test)
Score_lr = accuracy_score(y_test,Y_pred_lr)
print(Score_lr )<compute_train_metric> | knn = KNeighborsClassifier() | Titanic - Machine Learning from Disaster |
3,846,140 | svc = SVC()
svc.fit(X_train, y_train)
Y_pred_svc = svc.predict(X_test)
Score_svc = accuracy_score(y_test,Y_pred_svc)
print(Score_svc )<compute_train_metric> | grid_knn = GridSearchCV(knn, param_grid, cv = 10, scoring='accuracy', return_train_score=False)
grid_knn.fit(X, y ) | Titanic - Machine Learning from Disaster |
3,846,140 | knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, y_train)
Y_pred_knn = knn.predict(X_test)
Score_knn = accuracy_score(y_test,Y_pred_knn)
print(Score_knn )<compute_train_metric> | grid_knn.best_params_ | Titanic - Machine Learning from Disaster |
3,846,140 | gaussian = GaussianNB()
gaussian.fit(X_train, y_train)
Y_pred_gnb = gaussian.predict(X_test)
Score_gnb = accuracy_score(y_test,Y_pred_gnb)
print(Score_gnb )<compute_train_metric> | grid_knn.best_score_ | Titanic - Machine Learning from Disaster |
3,846,140 | perceptron = Perceptron()
perceptron.fit(X_train, y_train)
Y_pred_per = perceptron.predict(X_test)
Score_per = accuracy_score(y_test,Y_pred_per)
print(Score_per )<compute_train_metric> | forest_clf = RandomForestClassifier() | Titanic - Machine Learning from Disaster |
3,846,140 | linear_svc = LinearSVC()
linear_svc.fit(X_train, y_train)
Y_pred_lsvc = linear_svc.predict(X_test)
Score_lsvc = accuracy_score(y_test,Y_pred_lsvc)
print(Score_lsvc )<compute_train_metric> | param_grid = dict(n_estimators = [10], criterion = ['gini'], max_depth = [135, 140, 145] ) | Titanic - Machine Learning from Disaster |
3,846,140 | sgd = SGDClassifier()
sgd.fit(X_train, y_train)
Y_pred_sgd = sgd.predict(X_test)
Score_sgd = accuracy_score(y_test,Y_pred_sgd)
print(Score_sgd )<compute_train_metric> | grid_forest = GridSearchCV(forest_clf, param_grid, cv = 10, scoring='accuracy', return_train_score=False)
grid_forest.fit(X, y ) | Titanic - Machine Learning from Disaster |
3,846,140 | decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, y_train)
Y_pred_dtr = decision_tree.predict(X_test)
Score_dtr = accuracy_score(y_test,Y_pred_dtr)
print(Score_dtr )<train_model> | grid_forest.best_params_ | Titanic - Machine Learning from Disaster |
3,846,140 | random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, y_train)
Y_pred_rf = random_forest.predict(X_test)
Score_rf = accuracy_score(y_test,Y_pred_rf)
print(Score_rf )<create_dataframe> | grid_forest.best_score_ | Titanic - Machine Learning from Disaster |
3,846,140 | models = pd.DataFrame({
'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression',
'Random Forest', 'Naive Bayes', 'Perceptron',
'Stochastic Gradient Decent', 'Linear SVC',
'Decision Tree'],
'Score': [Score_svc, Score_knn, Score_lr,
Score_rf, Score_gnb, Score_per,
Score_sgd, Score_lsvc, Score_dtr]})
models.sor... | clf = svm.SVC(probability = False ) | Titanic - Machine Learning from Disaster |
3,846,140 | Y_pred = linear_svc.predict(test_df )<save_to_csv> | param_grid = dict(C = [34], kernel = ['poly'], gamma = ['scale'], degree = [2])
param_grid | Titanic - Machine Learning from Disaster |
3,846,140 | submission = pd.read_csv('.. /input/titanic/gender_submission.csv')
submission['Survived'] = Y_pred
submission.to_csv('submission.csv', index=False )<load_from_csv> | grid_svm = GridSearchCV(clf, param_grid, cv = 10, scoring='accuracy', return_train_score=True)
grid_svm.fit(X, y)
| 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.