kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
1,067,710 | bs = 64
sz=256<categorify> | full.rename(columns={'Pclass':'TicketClass',
'SibSp':'Sibling_Spouse',
'Parch':'Parent_Children',
'Fare':'TicketFare'},
inplace=True ) | Titanic - Machine Learning from Disaster |
1,067,710 | tfms = get_transforms(do_flip=True, flip_vert=True, max_rotate=360, max_warp=0,
max_zoom=1.1, max_lighting=0.1, p_lighting=0.5)
src =(ImageList.from_df(df=df,path='./',cols='path')
.split_by_idx(val_idxs)
.label_from_df(cols='diagnosis', label_cls=FloatList)
)
data=(src.transform(tfms,size=sz,resize_method=ResizeMeth... | full[full.Name.isin(['Connolly, Miss.Kate','Kelly, Mr.James'])].sort_values(by='Name' ) | Titanic - Machine Learning from Disaster |
1,067,710 | def quadratic_kappa(y_hat, y):
return torch.tensor(cohen_kappa_score(torch.round(y_hat), y, weights='quadratic'),device='cuda:0' )<choose_model_class> | full.loc[:891,['TicketClass', 'Survived']]\
.groupby(['TicketClass'], as_index=False)\
.mean().sort_values(by='Survived',
ascending=False ) | Titanic - Machine Learning from Disaster |
1,067,710 | learn = cnn_learner(data, base_arch=models.resnet50, metrics = [quadratic_kappa], pretrained=False)
learn.load('resnet50' )<choose_model_class> | full.loc[:891,['Sex', 'Survived']]\
.groupby(['Sex'], as_index=False ).mean() \
.sort_values(by='Survived',
ascending=False ) | Titanic - Machine Learning from Disaster |
1,067,710 | learn_2 = cnn_learner(data, base_arch=models.resnet152, metrics = [quadratic_kappa], pretrained=False)
learn_2.load('resnet152' )<find_best_params> | full.loc[:891,['Embarked', 'Survived']]\
.groupby(['Embarked'], as_index=False ).mean() \
.sort_values(by='Survived',
ascending=False ) | Titanic - Machine Learning from Disaster |
1,067,710 | interp = ClassificationInterpretation.from_learner(learn)
losses,idxs = interp.top_losses()
len(data.valid_ds)==len(losses)==len(idxs )<import_modules> | full.drop(['Cabin','Ticket','PassengerId'],
axis=1,
inplace=True ) | Titanic - Machine Learning from Disaster |
1,067,710 | import numpy as np
import pandas as pd
import os
import scipy as sp
from functools import partial
from sklearn import metrics
from collections import Counter
import json<compute_test_metric> | full.drop(['Name'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
1,067,710 | class OptimizedRounder(object):
def __init__(self):
self.coef_ = 0
def _kappa_loss(self, coef, X, y):
X_p = np.copy(X)
for i, pred in enumerate(X_p):
if pred < coef[0]:
X_p[i] = 0
elif pred >= coef[0] and pred < coef[1]:
X_p[i] = 1
elif pred >= coef[1] and pred < coef[2]:
X_p[i] = 2
elif pred >= coef[2] and pred < coe... | full.isnull().sum() | Titanic - Machine Learning from Disaster |
1,067,710 | optR = OptimizedRounder()<load_from_csv> | full.loc[full['Embarked'].isnull() ,'Embarked'] = \
full['Embarked'].dropna().mode() [0] | Titanic - Machine Learning from Disaster |
1,067,710 | sample_df = pd.read_csv('.. /input/aptos2019-blindness-detection/sample_submission.csv')
sample_df.head()<define_variables> | full.loc[full['TicketFare'].isnull() ,'TicketFare'] = \
full['TicketFare'].dropna().mean() | Titanic - Machine Learning from Disaster |
1,067,710 | learn.data.add_test(ImageList.from_df(sample_df,'.. /input/aptos2019-blindness-detection',folder='test_images',suffix='.png'))<predict_on_test> | full.Age.isnull().sum() | Titanic - Machine Learning from Disaster |
1,067,710 | preds,y = learn.get_preds(ds_type=DatasetType.Test )<define_variables> | age_estimator = full[['Age','TicketClass','Sibling_Spouse']]\
.groupby(['TicketClass','Sibling_Spouse'] ).agg(['mean','std'])
age_nulls = full.loc[full.Age.isnull() ,:]
for idx,rec in age_nulls.iterrows() :
mean = age_estimator.loc[(rec['TicketClass'],rec['Sibling_Spouse']),('Age','mean')]
std = age_estimator.loc[(re... | Titanic - Machine Learning from Disaster |
1,067,710 | learn_2.data.add_test(ImageList.from_df(sample_df,'.. /input/aptos2019-blindness-detection',folder='test_images',suffix='.png'))<predict_on_test> | full.Age.isnull().sum() | Titanic - Machine Learning from Disaster |
1,067,710 | preds_2, y_2 = learn_2.get_preds(ds_type=DatasetType.Test )<predict_on_test> | quantile_label = ['Cheap','Regular','Premium']
full['TicketFare'] = pd.qcut(full['TicketFare'],
q=quantile_list,
labels=quantile_label)
full.TicketFare.value_counts().sort_values() | Titanic - Machine Learning from Disaster |
1,067,710 | preds_avg =(preds * 0.6 + preds_2 * 0.4)
test_predictions = optR.predict(preds_avg, coefficients )<data_type_conversions> | full['FamilySize'] = full['Sibling_Spouse'] + \
full['Parent_Children'] + \
1 | Titanic - Machine Learning from Disaster |
1,067,710 | sample_df.diagnosis = test_predictions.astype(int)
sample_df.head()<save_to_csv> | full.loc[full.FamilySize > 1, 'IsAlone'] = 0
full.loc[full.FamilySize <= 1, 'IsAlone'] = 1
full['IsAlone'] = full['IsAlone'].astype(int ) | Titanic - Machine Learning from Disaster |
1,067,710 | sample_df.to_csv('submission.csv',index=False )<count_values> | full.loc[:891,['FamilySize','Survived']]\
.groupby(['FamilySize'],as_index=False)\
.mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
1,067,710 | sample_df.diagnosis.value_counts()<import_modules> | full.loc[:891,['IsAlone','Survived']].groupby(['IsAlone'],as_index=False)\
.mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
1,067,710 | import gc
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
from keras.models import Sequential, load_model
from keras.layers import Dense, Dropout
from keras import optimizers
from sklearn.... | full.drop(['Sibling_Spouse','Parent_Children'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
1,067,710 | INPUT_DIR = ".. /input/"
LABEL = 'winPlacePerc'<load_from_csv> | for nom_feature in ['Sex','Embarked','Title']:
gle = LabelEncoder()
labels = gle.fit_transform(full[nom_feature])
report = {index: label for index,label in enumerate(gle.classes_)}
full[nom_feature] = labels
print(nom_feature,':',report,'
','-'*50 ) | Titanic - Machine Learning from Disaster |
1,067,710 | df_train = pd.read_csv(INPUT_DIR+'train_V2.csv' )<set_options> | age_ord_map = {'infant':0, 'kid':1, 'young':2, 'mid-age':3, 'old':4}
full.Age = full.Age.map(age_ord_map)
tf_ord_map = {'Cheap':0, 'Regular':1, 'Premium':2}
full.TicketFare = full.TicketFare.map(tf_ord_map ) | Titanic - Machine Learning from Disaster |
1,067,710 | df_train = reduce_mem_usage(df_train)
gc.collect()<count_missing_values> | list_category_features = ['TicketClass','Sex','Age','TicketFare','Embarked','Title']
dummy_features = pd.get_dummies(full[list_category_features], columns=list_category_features)
full.drop(list_category_features, axis=1,inplace=True)
full = pd.concat([full, dummy_features], axis=1)
full.sample(10 ) | Titanic - Machine Learning from Disaster |
1,067,710 | df_train.isnull().any()<correct_missing_values> | train_df_new = full.iloc[:891]
y = train_df_new['Survived']
X = train_df_new.drop(['Survived'], axis=1)
test_df_new = full.iloc[891:]
test_df_new = test_df_new.drop(['Survived'], axis=1)
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.3,
random_state=42)
print(X_train.shape, X_test.shape ) | Titanic - Machine Learning from Disaster |
1,067,710 | df_train = df_train.dropna()<filter> | logistic = LogisticRegression()
logistic.fit(X_train, y_train)
y_pred = logistic.predict(X_test)
print('Logistic Regression model score:',
np.round(logistic.score(X_test, y_test), 3)) | Titanic - Machine Learning from Disaster |
1,067,710 | df_train = df_train[df_train['maxPlace'] > 1]<drop_column> | def model_report(y_test, y_pred):
print('Confusion Matrix:
',
metrics.confusion_matrix(y_true=y_test,
y_pred=y_pred,
labels=[0, 1]))
print('{:-^30}'.format('|'))
print('{:15}{:.3f}'.format('Accuracy:',
metrics.accuracy_score(y_test,
y_pred)))
print('{:-^30}'.format('|'))
print('{:15}0:{:.3f}|1:{:.3f}'.format('Precisio... | Titanic - Machine Learning from Disaster |
1,067,710 | def FE(df,train=True):
LABEL = 'winPlacePerc'
if train:
df_y = df.groupby(['matchId','groupId'])[LABEL].agg('mean')
df = df.drop([LABEL],axis=1)
else:
df_ids = df[['Id','matchId','groupId']]
df = df.drop('Id',axis=1)
MATCH_FEATURE_part = ['numGroups','matchDuration','matchType','maxPlace']
GROUP_FEATURE = df.columns... | model = LogisticRegression()
model.fit(X_train, y_train)
predicted = model.predict(X_test)
report = classification_report(y_test, predicted, digits=3)
print(report ) | Titanic - Machine Learning from Disaster |
1,067,710 | X_train,y_train,lst_features = FE(df_train )<split> | kfold = model_selection.KFold(n_splits=10, random_state=0)
model = LogisticRegression()
scoring = 'accuracy'
results = model_selection.cross_val_score(model,
X,
y,
cv=kfold,
scoring=scoring)
print("Average Accuracy: {:.3f}".format(results.mean())) | Titanic - Machine Learning from Disaster |
1,067,710 |
<import_modules> | names = ["Nearest Neighbors",
"Linear SVM",
"RBF SVM",
"Gaussian Process",
"Decision Tree",
"Random Forest",
"Neural Net",
"AdaBoost",
"Naive Bayes",
"Logistic Regression"]
classifiers = [
KNeighborsClassifier(3),
SVC(kernel="linear", C=0.025),
SVC(gamma=2, C=1),
GaussianProcessClassifier(1.0 * RBF(1.0)) ,
DecisionTree... | Titanic - Machine Learning from Disaster |
1,067,710 |
<set_options> | for clf_name in sorted(names, key=lambda x:(results[x]['Score'])) :
print('{:19} :{:.3f}'.format(clf_name, results[clf_name]['Score'])) | Titanic - Machine Learning from Disaster |
1,067,710 | del df_train
gc.collect()<load_from_csv> | hyper_params={'max_depth':range(5,21,5),
'min_samples_split':range(2,9,2),
'min_samples_leaf':range(1,6,1),
'max_leaf_nodes':range(2,11,1)}
grid = GridSearchCV(RandomForestClassifier(random_state=1),
param_grid=hyper_params)
grid.fit(X,y)
print('Best Score: {:.4f}'.format(grid.best_score_))
print('Best Parameters set... | Titanic - Machine Learning from Disaster |
1,067,710 | df_test = pd.read_csv(INPUT_DIR+'test_V2.csv')
df_test = reduce_mem_usage(df_test)
gc.collect()<prepare_x_and_y> | ranfor_model = RandomForestClassifier(random_state=1,
max_depth=10,
max_leaf_nodes=10,
min_samples_leaf=2,
min_samples_split=2)
ranfor_model.fit(X,y)
y_pred = ranfor_model.predict(test_df_new ) | Titanic - Machine Learning from Disaster |
1,067,710 | <create_dataframe><EOS> | submission = pd.DataFrame({
"PassengerId": range(892,1310),
"Survived": y_pred
})
submission.to_csv('titanic.csv', index=False ) | Titanic - Machine Learning from Disaster |
412,422 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<init_hyperparams> | %matplotlib inline
warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
412,422 | params = {"objective" : "regression", "metric" : "mae", 'n_estimators':20000, 'early_stopping_rounds':100,
"num_leaves" : 25, "learning_rate" : 0.05, "bagging_fraction" : 0.9, "feature_fraction":0.7,
"bagging_seed" : 0, "num_threads" : 4
}<train_model> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
train.describe(include="all" ) | Titanic - Machine Learning from Disaster |
412,422 | for n_fold,(train_idx, vali_idx)in enumerate(folds.split(X_train, y_train)) :
X_train_fold, y_train_fold = X_train.iloc[train_idx], y_train[train_idx]
X_vali, y_vali = X_train.iloc[vali_idx], y_train[vali_idx]
train_data = lgb.Dataset(data=X_train_fold, label=y_train_fold)
valid_data = lgb.Dataset(data=X_vali, label=y... | print(pd.isnull(train ).sum() ) | Titanic - Machine Learning from Disaster |
412,422 | print('Full mae score %.6f' % mean_absolute_error(y_train, vali_pred))<save_model> | train = train.drop(['Cabin'], axis = 1)
test = test.drop(['Cabin'], axis = 1 ) | Titanic - Machine Learning from Disaster |
412,422 | lgb_model.save_model('lgb_model.txt' )<merge> | train = train.drop(['Ticket'], axis = 1)
test = test.drop(['Ticket'], axis = 1 ) | Titanic - Machine Learning from Disaster |
412,422 | pred = np.clip(pred, a_min=0, a_max=1)
df_pred = X_test_index.assign(winPlacePerc=pred)
result = pd.merge(df_test_ids, df_pred, how='left', on=['matchId', 'groupId'] )<save_to_csv> | train = train.fillna({"Embarked": "S"} ) | Titanic - Machine Learning from Disaster |
412,422 | submission = result[['Id', 'winPlacePerc']]
submission.to_csv('submission.csv', index=False )<create_dataframe> | for dataset in combine:
dataset['Title'] = dataset['Title'].replace(['Lady', 'Capt', 'Col',
'Don', 'Dr', 'Major', 'Rev', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace(['Countess', 'Lady', 'Sir'], 'Royal')
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
dataset['Title'] = datase... | Titanic - Machine Learning from Disaster |
412,422 | def get_null_observations(dataframe, column):
return dataframe[pd.isnull(dataframe[column])]
def delete_null_observations(dataframe, column):
fixed_df = dataframe.drop(get_null_observations(dataframe,column ).index)
return fixed_df
def get_missing_data_table(dataframe):
total = dataframe.isnull().sum()
percentage = da... | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Royal": 5, "Rare": 6}
for dataset in combine:
dataset['Title'] = dataset['Title'].map(title_mapping)
dataset['Title'] = dataset['Title'].fillna(0)
train.head() | Titanic - Machine Learning from Disaster |
412,422 | get_missing_data_table(df )<create_dataframe> | mr_age = train[train["Title"] == 1]["AgeGroup"].mode()
miss_age = train[train["Title"] == 2]["AgeGroup"].mode()
mrs_age = train[train["Title"] == 3]["AgeGroup"].mode()
master_age = train[train["Title"] == 4]["AgeGroup"].mode()
royal_age = train[train["Title"] == 5]["AgeGroup"].mode()
rare_age = train[train["Title"] == ... | Titanic - Machine Learning from Disaster |
412,422 | df = delete_null_observations(dataframe=df, column='winPlacePerc')
get_missing_data_table(df )<categorify> | age_mapping = {'Baby': 1, 'Child': 2, 'Teenager': 3, 'Student': 4, 'Young Adult': 5, 'Adult': 6, 'Senior': 7}
train['AgeGroup'] = train['AgeGroup'].map(age_mapping)
test['AgeGroup'] = test['AgeGroup'].map(age_mapping)
train.head()
train = train.drop(['Age'], axis = 1)
test = test.drop(['Age'], axis = 1 ) | Titanic - Machine Learning from Disaster |
412,422 | df_team_dict =(df.groupby('groupId', as_index = True)
.agg({'Id':'count', 'kills':'sum'})
.rename(columns={'Id':'teamSize', 'kills':'teamKills'})).to_dict()
teamKills = []
teamSize = []
for teamId in df['groupId']:
teamKills.append(df_team_dict['teamKills'][teamId])
teamSize.append(df_team_dict['teamSize'][teamId])
d... | train = train.drop(['Name'], axis = 1)
test = test.drop(['Name'], axis = 1 ) | Titanic - Machine Learning from Disaster |
412,422 | df_team =(df.groupby('groupId', as_index = False)
.agg({'Id':'count', 'matchId':lambda x: x.unique() [0], 'kills':'sum'})
.rename(columns={'Id':'teamSize', 'kills':'teamKills'})).reset_index()
df_match =(df_team.groupby('matchId', as_index = True)
.agg({'teamSize':'sum', 'teamKills':'sum'})
.rename(columns={'teamSize':... | sex_mapping = {"male": 0, "female": 1}
train['Sex'] = train['Sex'].map(sex_mapping)
test['Sex'] = test['Sex'].map(sex_mapping)
train.head() | Titanic - Machine Learning from Disaster |
412,422 | df.drop(['Id'], axis='columns', inplace=True)
df.drop(['groupId'], axis='columns', inplace=True)
df.drop(['matchId'], axis='columns', inplace=True)
df.head()<define_variables> | 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 |
412,422 | previous_record_size = df.shape[0]
h_spread = df['matchDuration'].quantile (.75)- df['matchDuration'].quantile (.25)
limit = df['matchDuration'].quantile (.25)- 2 * h_spread
df.drop(df[df['matchDuration'] < limit].index, inplace=True)
new_record_size = df.shape[0]
print('Total records deleted: {}({:.7%} of previous r... | predictors = train.drop(['Survived', 'PassengerId'], axis=1)
target = train["Survived"]
x_train, x_val, y_train, y_val = train_test_split(predictors, target, test_size = 0.22, random_state = 0 ) | Titanic - Machine Learning from Disaster |
412,422 | previous_record_size = df.shape[0]
df.drop(df.query('rideDistance == 0 and roadKills > 0' ).index, inplace=True)
new_record_size = df.shape[0]
print('Total records deleted: {}({:.7%} of previous record size)'.format(previous_record_size - new_record_size, 1 - new_record_size / previous_record_size))<categorify> | gaussian = GaussianNB()
gaussian.fit(x_train, y_train)
y_pred = gaussian.predict(x_val)
acc_gaussian = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_gaussian ) | Titanic - Machine Learning from Disaster |
412,422 | encoder = preprocessing.LabelEncoder()
df['matchType'] = encoder.fit_transform(df['matchType'])
df.head()<prepare_x_and_y> | logreg = LogisticRegression()
logreg.fit(x_train, y_train)
y_pred = logreg.predict(x_val)
acc_logreg = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_logreg ) | Titanic - Machine Learning from Disaster |
412,422 | y = df['winPlacePerc'].values
X = df.drop(['winPlacePerc'], axis='columns' ).values<split> | svc = SVC()
svc.fit(x_train, y_train)
y_pred = svc.predict(x_val)
acc_svc = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_svc ) | Titanic - Machine Learning from Disaster |
412,422 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)
lgb_train = lgb.Dataset(X_train, y_train, categorical_feature=[12])
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)
params = {
"objective" : "regression",
"metric" : "mae",
"n_estimators":15000,
"early_stopping_r... | linear_svc = LinearSVC()
linear_svc.fit(x_train, y_train)
y_pred = linear_svc.predict(x_val)
acc_linear_svc = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_linear_svc ) | Titanic - Machine Learning from Disaster |
412,422 | df_test = pd.read_csv('.. /input/test_V2.csv')
df_test['matchType'] = encoder.transform(df_test['matchType'])
df_test_team_dict =(df_test.groupby('groupId', as_index = True)
.agg({'Id':'count', 'kills':'sum'})
.rename(columns={'Id':'teamSize', 'kills':'teamKills'})).to_dict()
teamKills_test = []
teamSize_test = []
fo... | perceptron = Perceptron()
perceptron.fit(x_train, y_train)
y_pred = perceptron.predict(x_val)
acc_perceptron = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_perceptron ) | Titanic - Machine Learning from Disaster |
412,422 | def reduce_mem_usage_func(df):
start_mem = df.memory_usage().sum() / 1024**2
print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))
for col in df.columns:
col_type = df[col].dtype
if col_type != object:
c_min = df[col].min()
c_max = df[col].max()
if str(col_type)[:3] == 'int':
if c_min > np.iinfo(np.int8 )... | decisiontree = DecisionTreeClassifier()
decisiontree.fit(x_train, y_train)
y_pred = decisiontree.predict(x_val)
acc_decisiontree = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_decisiontree ) | Titanic - Machine Learning from Disaster |
412,422 | warnings.filterwarnings('ignore')
% matplotlib inline
<load_from_csv> | randomforest = RandomForestClassifier()
randomforest.fit(x_train, y_train)
y_pred = randomforest.predict(x_val)
acc_randomforest = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_randomforest ) | Titanic - Machine Learning from Disaster |
412,422 | data = read_fast(".. /input/train_V2.csv", sample = False)
data.head(10 )<load_from_csv> | knn = KNeighborsClassifier()
knn.fit(x_train, y_train)
y_pred = knn.predict(x_val)
acc_knn = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_knn ) | Titanic - Machine Learning from Disaster |
412,422 | test_data = read_fast(".. /input/test_V2.csv", sample = False )<filter> | sgd = SGDClassifier()
sgd.fit(x_train, y_train)
y_pred = sgd.predict(x_val)
acc_sgd = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_sgd ) | Titanic - Machine Learning from Disaster |
412,422 | data[data['winPlacePerc'].isnull() ]<feature_engineering> | gbk = GradientBoostingClassifier()
gbk.fit(x_train, y_train)
y_pred = gbk.predict(x_val)
acc_gbk = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_gbk ) | Titanic - Machine Learning from Disaster |
412,422 | data['headshotrate'] = data['headshotKills']/data['kills']
data['healthitems'] = data['heals'] + data['boosts']
data['totalDistance'] = data['rideDistance'] + data["walkDistance"] + data["swimDistance"]
data['killPlace_over_maxPlace'] = data['killPlace'] / data['maxPlace']
data['killsPerWalkDistance'] = data['kills'] /... | models = pd.DataFrame({
'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression',
'Random Forest', 'Naive Bayes', 'Perceptron', 'Linear SVC',
'Decision Tree', 'Stochastic Gradient Descent', 'Gradient Boosting Classifier'],
'Score': [acc_svc, acc_knn, acc_logreg,
acc_randomforest, acc_gaussian, acc_perceptron,a... | Titanic - Machine Learning from Disaster |
412,422 | test_data['headshotrate'] =test_data['headshotKills']/ test_data['kills']
test_data['healthitems'] = test_data['heals'] + test_data['boosts']
test_data['totalDistance'] = test_data['rideDistance'] + test_data["walkDistance"] + test_data["swimDistance"]
test_data['killPlace_over_maxPlace'] = test_data['killPlace'] / tes... | ids = test['PassengerId']
predictions = gbk.predict(test.drop('PassengerId', axis=1))
output = pd.DataFrame({ 'PassengerId' : ids, 'Survived': predictions })
output.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,159,619 | data['killsWithoutMoving'] =(( data['kills'] > 0)&(data['totalDistance'] == 0))
test_data['killsWithoutMoving'] =(( test_data['kills'] > 0)&(test_data['totalDistance'] == 0))<drop_column> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
| Titanic - Machine Learning from Disaster |
11,159,619 | data.drop(data[data['killsWithoutMoving'] == True].index, inplace=True)
data.drop(data[data['roadKills'] > 10].index, inplace=True)
data.drop(data[data['kills'] >= 40].index, inplace=True)
data.drop(data[data['longestKill'] >= 1000].index, inplace=True)
data.drop(data[data['heals'] >= 40].index, inplace=True )<cate... | train_dir = pd.read_csv('/kaggle/input/titanic/train.csv')
test_dir = pd.read_csv('/kaggle/input/titanic/test.csv')
print("Training data: {}".format(train_dir.shape))
print("Testing data: {}".format(test_dir.shape)) | Titanic - Machine Learning from Disaster |
11,159,619 | lbl = LabelEncoder()
lbl.fit(list(data['matchType'].values))
data['matchType'] = lbl.transform(list(data['matchType'].values))
lbl.fit(list(test_data['matchType'].values))
test_data['matchType'] = lbl.transform(list(test_data['matchType'].values))
<feature_engineering> | train_dir.isnull().any() | Titanic - Machine Learning from Disaster |
11,159,619 | cols = [col for col in data.columns if col not in ['Id','matchId','groupId']]
for i, t in data.loc[:, cols].dtypes.iteritems() :
if t == object:
data[i] = pd.factorize(data[i])[0]
cols = [col for col in test_data.columns if col not in ['Id','matchId','groupId']]
for i, t in test_data.loc[:, cols].dtypes.iteritems() :
i... | train_dir.isnull().sum() | Titanic - Machine Learning from Disaster |
11,159,619 | total = data.isnull().sum().sort_values(ascending = False)
percent =(data.isnull().sum() /data.isnull().count() ).sort_values(ascending = False)
missing_data = pd.concat([total,percent], axis = 1, keys = ['Total', 'Percent'])
missing_data.head(20 )<drop_column> | train_dir.isnull().sum() | Titanic - Machine Learning from Disaster |
11,159,619 | data.drop(2744604, inplace =True)
<correct_missing_values> | updated_train_dir = train_dir.drop(['Ticket', 'PassengerId', 'Name','Cabin'], axis = 1)
updated_train_dir.head(3 ) | Titanic - Machine Learning from Disaster |
11,159,619 | data= data.dropna()<drop_column> | updated_test_dir = test_dir.drop(['Ticket', 'PassengerId', 'Name','Cabin'], axis = 1)
updated_test_dir.head(3 ) | Titanic - Machine Learning from Disaster |
11,159,619 | data = data.drop(columns=['groupId','matchId'], axis = 1)
test_data = test_data.drop(columns=['groupId','matchId'], axis = 1 )<prepare_x_and_y> | Missing_age = 100 * updated_train_dir['Age'].isnull().sum() / updated_train_dir['Age'].shape[0]
print("Age missing value: {}".format(Missing_age)) | Titanic - Machine Learning from Disaster |
11,159,619 | y = data.winPlacePerc
X = data.drop(['winPlacePerc', 'Id'], axis=1 )<choose_model_class> | updated_train_dir['Age'].isnull().any() | Titanic - Machine Learning from Disaster |
11,159,619 | def identify_zero_importance_features(X, y, iterations = 2):
feature_importances = np.zeros(X.shape[1])
model = lgb.LGBMRegressor(objective='regression', boosting_type = 'goss',
n_estimators =10000, class_weight = 'balanced')
for i in range(iterations):
train_features, valid_features, train_y, valid_y = train_test_... | updated_test_dir['Age'].fillna(updated_test_dir['Age'].median() , inplace=True)
updated_test_dir['Age'].isnull().any() | Titanic - Machine Learning from Disaster |
11,159,619 | to_drop = feature_importances[feature_importances['importance'] <= pp]['feature']
X = X.drop(columns = to_drop )<split> | updated_train_dir.isnull().any() | Titanic - Machine Learning from Disaster |
11,159,619 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1 )<choose_model_class> | updated_train_dir['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
11,159,619 | gbm = LGBMRegressor(objective='regression',
num_leaves=40,
learning_rate=0.005,
n_estimators=20000,
max_bin=55,
bagging_fraction=0.7,
bagging_freq=9,
feature_fraction=0.7,
feature_fraction_seed=9,
bagging_seed=10,
min_data_in_leaf=7,
min_sum_hessian_in_leaf=5)
gbm.fit(X_train, y_train,
eval_set=[(X_test, y_test)],
eva... | Missing_embarked = 100 * updated_train_dir['Embarked'].isnull().sum() / updated_train_dir['Embarked'].shape[0]
print("Missing embakred info: {}".format(Missing_embarked)) | Titanic - Machine Learning from Disaster |
11,159,619 | feats = test_data.drop(['Id'], axis=1)
feats = feats[X_train.columns]
final_preds = gbm.predict(feats,num_iteration=gbm.best_iteration_ )<save_to_csv> | updated_train_dir['Embarked'].fillna('S', inplace=True)
updated_train_dir.isnull().any() | Titanic - Machine Learning from Disaster |
11,159,619 | submission = pd.DataFrame()
submission['Id'] = test_data.Id
submission['winPlacePerc'] = final_preds
submission.to_csv('submission1.csv', index=False )<feature_engineering> | updated_test_dir['Embarked'].value_counts()
| Titanic - Machine Learning from Disaster |
11,159,619 | submission[submission['winPlacePerc'] < 0] = 0
submission[submission['winPlacePerc'] >1] = 1
<set_options> | updated_test_dir["Embarked"].fillna(updated_test_dir['Embarked'].value_counts().idxmax() , inplace=True)
updated_test_dir.isnull().any() | Titanic - Machine Learning from Disaster |
11,159,619 |
gc.enable()
<load_from_csv> | total_survived_notsurvived = updated_train_dir['Survived'].shape[0]
num_survived = updated_train_dir[updated_train_dir['Survived'] == 1].shape[0]
not_survived = updated_train_dir[updated_train_dir['Survived'] == 0].shape[0]
print("Survived: {}".format(100 *(num_survived / total_survived_notsurvived)))
print("Not Survi... | Titanic - Machine Learning from Disaster |
11,159,619 | def feature_engineering(is_train=True):
if is_train:
print("processing train.csv")
df = pd.read_csv(".. /input/train_V2.csv")
df = df[df['maxPlace'] > 1]
else:
print("processing test.csv")
df = pd.read_csv(".. /input/test_V2.csv")
df['totalDistance'] = df['rideDistance'] + df["walkDistance"] + df["swimDistance"]
pr... | updated_test_dir['Age group']= updated_test_dir['Age'].apply(grouping_Age ) | Titanic - Machine Learning from Disaster |
11,159,619 | x_train, y, feature_names = feature_engineering(True )<split> | updated_train_dir['Age group'].value_counts() | Titanic - Machine Learning from Disaster |
11,159,619 | X_train, X_val, y_train, y_val = train_test_split(x_train, y, test_size=0.33, random_state=42)
<set_options> | gender = {
'male': 1,
'female':0
}
updated_train_dir['Sex'] = updated_train_dir['Sex'].apply(lambda x: gender.get(x))
updated_train_dir.drop(['Age'], axis=1, inplace=True)
| Titanic - Machine Learning from Disaster |
11,159,619 | warnings.filterwarnings("ignore")
color = sns.color_palette()
<predict_on_test> | updated_test_dir['Sex'] = updated_test_dir['Sex'].apply(lambda x: gender.get(x))
| Titanic - Machine Learning from Disaster |
11,159,619 | train_data=lgb.Dataset(X_train, label=y_train)
val_data= lgb.Dataset(X_val, label=y_val)
params = {
'num_leaves': 144,
'learning_rate': 0.1,
'n_estimators': 1500,
'max_depth':12,
'max_bin':55,
'bagging_fraction':0.8,
'bagging_freq':5,
'feature_fraction':0.9,
'verbose':50,
'early_stopping_rounds':100
}
params['metric'... | updated_test_dir.drop(['Age'], axis=1, inplace=True)
| Titanic - Machine Learning from Disaster |
11,159,619 | y_pred=light_reg.predict(X_val)
print(mean_absolute_error(y_val,y_pred))
del X_val
del y_val<prepare_x_and_y> | updated_train_dir.drop(['Fare'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
11,159,619 | x_test, y_test, feature_names = feature_engineering(False )<predict_on_test> | updated_test_dir.drop(['Fare'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
11,159,619 | y_test_pred=light_reg.predict(x_test )<save_to_csv> | traindf = pd.get_dummies(updated_train_dir, columns = ["Embarked","Age group", "Pclass"],
prefix=["Em_type", "Age_group", "Pclass_"] ) | Titanic - Machine Learning from Disaster |
11,159,619 | df=pd.read_csv(".. /input/test_V2.csv")
var=pd.DataFrame(columns=['Id','winPlacePerc'])
var['Id']= df['Id']
var['winPlacePerc'] = y_test_pred
submission = var[['Id', 'winPlacePerc']]
submission.to_csv('submission.csv', index=False )<set_options> | testdf = pd.get_dummies(updated_test_dir, columns = ["Embarked","Age group", "Pclass"],
prefix=["Em_type", "Age_group", "Pclass_"])
testdf.head(2)
| Titanic - Machine Learning from Disaster |
11,159,619 | warnings.filterwarnings('ignore')
%matplotlib inline
py.init_notebook_mode(connected=True)
print(os.listdir(".. /input"))
<load_from_csv> | train_y = traindf['Survived']
traindf.drop(['Survived'], axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train = reduce_mem_usage(pd.read_csv('.. /input/train_V2.csv'))
df_test = reduce_mem_usage(pd.read_csv('.. /input/test_V2.csv'))<train_model> | print("Training shape: {} and Testing shape: {}
\
Training Label:{}".format(traindf.shape,
testdf.shape,
train_y.shape)) | Titanic - Machine Learning from Disaster |
11,159,619 | print('train : {}'.format(df_train.shape))
print('test : {}'.format(df_test.shape))<sort_values> | from sklearn.model_selection import train_test_split
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix | Titanic - Machine Learning from Disaster |
11,159,619 | total = df_train.isnull().sum().sort_values(ascending=False)
percent =(df_train.isnull().sum() / df_train.isnull().count() ).sort_values(ascending=False)
missing_data = pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
missing_data.head()<sort_values> | X_train, X_test, Y_train, Y_test = train_test_split(traindf,
train_y,
test_size=0.3,
random_state=42)
X_train.shape, X_test.shape, Y_train.shape, Y_test.shape | Titanic - Machine Learning from Disaster |
11,159,619 | total = df_test.isnull().sum().sort_values(ascending=False)
percent =(df_test.isnull().sum() /df_test.isnull().count() ).sort_values(ascending=False)
missing_data = pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
missing_data.head()<correct_missing_values> | LogisticRegression = LogisticRegression(max_iter=10000)
LogisticRegression.fit(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train.dropna(axis=0, inplace=True )<compute_test_metric> | predictions = LogisticRegression.predict(X_test)
predictions | Titanic - Machine Learning from Disaster |
11,159,619 | cm = np.corrcoef(df_train[cols].values.T)
<feature_engineering> | Linear_Reg_acc = accuracy_score(predictions, Y_test)* 100 | Titanic - Machine Learning from Disaster |
11,159,619 | headshot = df_train[['kills', 'winPlacePerc', 'headshotKills']]
headshot['headshotrate'] = headshot['headshotKills'] / headshot['kills']
headshot.corr()<feature_engineering> | model_random = RandomForestClassifier(n_estimators = 700,
max_features='auto',
oob_score=True,
random_state=1,
n_jobs=1,
min_samples_leaf=1,
min_samples_split=10
) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train['headshotrate'] = df_train['headshotKills']/df_train['kills']
df_test['headshotrate'] = df_test['headshotKills']/df_test['kills']
del headshot<feature_engineering> | model_random.fit(X_train, Y_train)
predictions_random = model_random.predict(X_test ) | Titanic - Machine Learning from Disaster |
11,159,619 | killStreak = df_train[['kills','winPlacePerc','killStreaks']]
killStreak['killStreakrate'] = killStreak['killStreaks']/killStreak['kills']
killStreak.corr()<feature_engineering> | Random_Forest_Acc = accuracy_score(predictions_random, Y_test)* 100
print("Random FOrest acc: {}".format(Random_Forest_Acc)) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train['killStreakrate'] = -(df_train['killStreaks'] / df_train['kills'])
df_test['killStreakrate'] = -(df_test['killStreaks'] / df_test['kills'])
del killStreak<feature_engineering> | svc_model = SVC()
svc_model.fit(X_train, Y_train)
predictions_svc = svc_model.predict(X_test)
| Titanic - Machine Learning from Disaster |
11,159,619 | df_train['hacker_pt'] = 0
df_test['hacker_pt'] = 0<set_options> | SVC_acc = accuracy_score(predictions_svc, Y_test)* 100
print("SVC accuracy: {}".format(SVC_acc)) | Titanic - Machine Learning from Disaster |
11,159,619 | pd.set_option('display.max_columns', 50 )<feature_engineering> | n_model = KNeighborsClassifier(n_neighbors = 4)
n_model.fit(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train['total_Distance'] = df_train['rideDistance'] +df_train['walkDistance'] + df_train['swimDistance']
df_test['total_Distance'] = df_test['rideDistance'] + df_test['walkDistance'] + df_test['swimDistance']
df_train[(df_train['winPlacePerc'] == 1)&(df_train['total_Distance'] < 100)].head()<data_type_conversions> | predictions_knn = n_model.predict(X_test ) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train['headshotrate'] = df_train['headshotrate'].fillna(0)
df_train['killStreakrate'] = df_train['killStreakrate'].fillna(0)
df_test['headshotrate'] = df_test['headshotrate'].fillna(0)
df_test['killStreakrate'] = df_test['killStreakrate'].fillna(0)
<feature_engineering> | accuracy_score(predictions_knn, Y_test)* 100 | Titanic - Machine Learning from Disaster |
11,159,619 | df_train['hacker_pt'][(df_train['heals'] + df_train['boosts'] < 1)&(df_train['total_Distance'] < 100)&(df_train['kills'] > 20)] = 1
df_test['hacker_pt'][(df_test['heals'] + df_test['boosts'] < 1)&(df_test['total_Distance'] < 100)&(df_test['kills'] > 20)] = 1<filter> | knn_data = {}
for i in range(1,30):
model = KNeighborsClassifier(n_neighbors=i)
model.fit(X_train, Y_train)
prediction_data = model.predict(X_test)
knn_data[i] = accuracy_score(prediction_data, Y_test)* 100
| 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.