kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
2,692,970 | del X_train
X_test = pickle.load(open(MELS_TEST, 'rb'))
CUR_X_FILES, CUR_X = list(test_df.fname.values), X_test
test = ImageList.from_csv(WORK, Path('.. ')/CSV_SUBMISSION, folder='test')
learn = load_learner(WORK, test=test)
preds, _ = learn.get_preds(ds_type=DatasetType.Test )<save_to_csv> | randomforest = RandomForestClassifier()
randomforest.fit(x_train, y_train)
y_pred = randomforest.predict(x_cv)
acc_randomforest = round(accuracy_score(y_pred, y_cv)* 100, 2)
print(acc_randomforest ) | Titanic - Machine Learning from Disaster |
2,692,970 | test_df[learn.data.classes] = preds
test_df.to_csv('submission.csv', index=False)
test_df.head()<load_pretrained> | svc = SVC()
svc.fit(x_train, y_train)
y_pred = svc.predict(x_cv)
acc_svc = round(accuracy_score(y_pred, y_cv)* 100, 2)
print(acc_svc ) | Titanic - Machine Learning from Disaster |
2,692,970 | del X_test
X_train = pickle.load(open(MELS_TRN_CURATED, 'rb'))
CUR_X_FILES, CUR_X = list(df.fname.values), X_train
learn = cnn_learner(data, borrowed_model, pretrained=False, metrics=[f_score])
learn.load('fat2019_fastai_cnn2d_stage-2');<load_from_csv> | models = pd.DataFrame({
'Method': ['KNN', 'Logistic Regression',
'Random Forest', 'Support Vector Machine'],
'Score': [acc_knn, acc_logreg,
acc_randomforest, acc_svc]})
models.sort_values(by='Score', ascending=False ) | Titanic - Machine Learning from Disaster |
2,692,970 | CSV_TRN_CURATED = DATA/'train_curated.csv'
CSV_TRN_NOISY = PREPROCESSED/'trn_noisy_best50s.csv'
CSV_SUBMISSION = DATA/'sample_submission.csv'
MELS_TRN_CURATED = PREPROCESSED/'mels_train_curated.pkl'
MELS_TRN_NOISY = '.. /input/fat2019_prep_mels1/mels_trn_noisy_best50s.pkl'
MELS_TEST = PREPROCESSED/'mels_test.pkl'
trn_c... | svc = MLPClassifier()
svc.fit(x_train, y_train)
y_pred = svc.predict(x_cv)
acc_svc = round(accuracy_score(y_pred, y_cv)* 100, 2)
print(acc_svc)
| Titanic - Machine Learning from Disaster |
2,692,970 | list_model = [ models.vgg16_bn, models.vgg19_bn]
predicts = None
i = 0<train_on_grid> | svc = NearestCentroid()
svc.fit(x_train, y_train)
y_pred = svc.predict(x_cv)
acc_svc = round(accuracy_score(y_pred, y_cv)* 100, 2)
print(acc_svc)
| Titanic - Machine Learning from Disaster |
2,692,970 | print(list_model[i])
CUR_X_FILES, CUR_X = list(df.fname.values), X_train
f_score = partial(fbeta, thresh=0.2)
learn = cnn_learner(data, list_model[i], pretrained=False, metrics=[f_score])
learn.unfreeze()
learn.lr_find()
learn.fit_one_cycle(5, slice(1e-6, 1e-1))
learn.lr_find()
learn.fit_one_cycle(100, slice(1e-6, 1... | svc = SVC()
svc.fit(x_train, y_train)
y_pred = svc.predict(test.drop('PassengerId',axis=1))
print(y_pred ) | Titanic - Machine Learning from Disaster |
2,692,970 | print(list_model[i])
CUR_X_FILES, CUR_X = list(df.fname.values), X_train
f_score = partial(fbeta, thresh=0.2)
learn = cnn_learner(data, list_model[i], pretrained=False, metrics=[f_score])
learn.unfreeze()
learn.lr_find()
learn.fit_one_cycle(5, slice(1e-6, 1e-1))
learn.lr_find()
learn.fit_one_cycle(100, slice(1e-6, 1... | submission = pd.DataFrame({'PassengerId':test['PassengerId'],'Survived':y_pred})
submission.head(5 ) | Titanic - Machine Learning from Disaster |
2,692,970 | <save_to_csv><EOS> | filename = 'TPredictions.csv'
submission.to_csv(filename,index=False)
print('Saved file: ' + filename ) | Titanic - Machine Learning from Disaster |
816,910 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | %matplotlib inline
train = pd.read_csv('.. /input/train.csv', header = 0, dtype={'Age': np.float64})
test = pd.read_csv('.. /input/test.csv' , header = 0, dtype={'Age': np.float64})
full_data = [train, test]
print(train.info())
train.head() | Titanic - Machine Learning from Disaster |
816,910 | DATA = Path('.. /input')
CSV_TRN_CURATED = DATA/'train_curated.csv'
CSV_TRN_NOISY = DATA/'train_noisy.csv'
CSV_SUBMISSION = DATA/'sample_submission.csv'
TRN_CURATED = DATA/'train_curated'
TRN_NOISY = DATA/'train_noisy'
TEST = DATA/'test'
WORK = Path('work')
IMG_TRN_CURATED = WORK/'image/trn_curated'
IMG_TRN_NOISY = W... | print(train[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean())
print(train[['Pclass', 'Survived']].groupby(['Pclass'] ).mean() ) | Titanic - Machine Learning from Disaster |
816,910 | def read_audio(conf, pathname, trim_long_data):
y, sr = librosa.load(pathname, sr=conf.sampling_rate)
if 0 < len(y):
y, _ = librosa.effects.trim(y)
if len(y)> conf.samples:
if trim_long_data:
y = y[0:0+conf.samples]
else:
padding = conf.samples - len(y)
offset = padding // 2
y = np.pad(y,(offset, conf.samples - len(... | print(train[["Sex", "Survived"]].groupby(['Sex'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
816,910 | def mono_to_color(X, mean=None, std=None, norm_max=None, norm_min=None, eps=1e-6):
X = np.stack([X, X, X], axis=-1)
mean = mean or X.mean()
std = std or X.std()
Xstd =(X - mean)/(std + eps)
_min, _max = Xstd.min() , Xstd.max()
norm_max = norm_max or _max
norm_min = norm_min or _min
if(_max - _min)> eps:
V = Xstd
V[V ... | print(train[['SibSp', 'Survived']].groupby(['SibSp'], as_index=False ).mean())
print(train[['Parch', 'Survived']].groupby(['Parch'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
816,910 | def _one_sample_positive_class_precisions(scores, truth):
num_classes = scores.shape[0]
pos_class_indices = np.flatnonzero(truth > 0)
if not len(pos_class_indices):
return pos_class_indices, np.zeros(0)
retrieved_classes = np.argsort(scores)[::-1]
class_rankings = np.zeros(num_classes, dtype=np.int)
class_rankings... | for dataset in full_data:
dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1
print(train[['FamilySize', 'Survived']].groupby(['FamilySize'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
816,910 | data.show_batch(3 )<choose_model_class> | for dataset in full_data:
dataset['IsAlone'] = 0
dataset.loc[dataset['FamilySize'] == 1, 'IsAlone'] = 1
print(train[['IsAlone', 'Survived']].groupby(['IsAlone'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
816,910 | learn = cnn_learner(data, models.resnet18, pretrained=False, metrics=[lwlrap])
learn.unfreeze()
learn.lr_find() ; learn.recorder.plot()<train_model> | for dataset in full_data:
dataset['Embarked'] = dataset['Embarked'].fillna('S')
print(train[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
816,910 | learn.fit_one_cycle(5, 1e-1)
learn.fit_one_cycle(10, 1e-2 )<train_model> | for dataset in full_data:
dataset['Fare'] = dataset['Fare'].fillna(train['Fare'].median())
dataset['CategoricalFare'] = pd.qcut(dataset['Fare'], 4)
print(type(train['CategoricalFare'][0]))
print(train[['CategoricalFare', 'Survived']].groupby(['CategoricalFare'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
816,910 | learn.fit_one_cycle(20, 3e-3 )<train_model> | for dataset in full_data:
age_avg = dataset['Age'].mean()
age_std = dataset['Age'].std()
age_null_count = dataset['Age'].isnull().sum()
age_null_random_list = np.random.randint(age_avg - age_std, age_avg + age_std, size=age_null_count)
dataset['Age'][np.isnan(dataset['Age'])] = age_null_random_list
dataset['Age'] ... | Titanic - Machine Learning from Disaster |
816,910 | learn.fit_one_cycle(20, 1e-3 )<train_model> | def get_title(name):
title_search = re.search('([A-Za-z]+)\.', name)
if title_search:
return title_search.group(1)
return ""
for dataset in full_data:
dataset['Title'] = dataset['Name'].apply(get_title)
print(pd.crosstab(train['Title'], train['Sex'])) | Titanic - Machine Learning from Disaster |
816,910 | learn.fit_one_cycle(50, slice(1e-3, 3e-3))<train_model> | for dataset in full_data:
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[... | Titanic - Machine Learning from Disaster |
816,910 | learn.fit_one_cycle(10, slice(1e-4, 1e-3))<save_model> | for dataset in full_data:
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['F... | Titanic - Machine Learning from Disaster |
816,910 | learn.save('fat2019_fastai_cnn2d_stage-2')
learn.export()<load_from_csv> | train = pd.get_dummies(train,columns=['Sex','Title','Embarked','Fare','Age'])
test = pd.get_dummies(test,columns=['Sex','Title','Embarked','Fare','Age'] ) | Titanic - Machine Learning from Disaster |
816,910 | CUR_X_FILES, CUR_X = list(test_df.fname.values), X_test
test = ImageList.from_csv(WORK/'image', Path('.. /.. ')/CSV_SUBMISSION, folder='test')
learn = load_learner(WORK/'image', test=test)
preds, _ = learn.TTA(ds_type=DatasetType.Test )<save_to_csv> | drop_elements = ['PassengerId', 'Name', 'Ticket', 'Cabin', 'SibSp',\
'Parch', 'FamilySize']
train = train.drop(drop_elements, axis = 1)
train = train.drop(['CategoricalAge', 'CategoricalFare'], axis = 1)
test = test.drop(drop_elements, axis = 1)
test = test.drop(['CategoricalAge', 'CategoricalFare'], axis = 1)
prin... | Titanic - Machine Learning from Disaster |
816,910 | test_df[learn.data.classes] = preds
test_df.to_csv('submission.csv', index=False)
test_df.head()<choose_model_class> | train = train.values
test = test.values | Titanic - Machine Learning from Disaster |
816,910 | CUR_X_FILES, CUR_X = list(df.fname.values), X_train
learn = cnn_learner(data, models.resnet18, pretrained=False, metrics=[lwlrap])
learn.load('fat2019_fastai_cnn2d_stage-2');<load_from_csv> | import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import StratifiedShuffleSplit
from sklearn.metrics import accuracy_score, log_loss,f1_score
from xgboost import XGBClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import Decisio... | Titanic - Machine Learning from Disaster |
816,910 | train = pd.read_csv('.. /input/train.csv',
dtype={'is_booking':bool,'srch_destination_id':np.int32, 'hotel_cluster':np.int32},
usecols=['srch_destination_id','is_booking','hotel_cluster'],
chunksize=1000000)
aggs = []
print('-'*38)
for chunk in train:
agg = chunk.groupby(['srch_destination_id',
'hotel_cluster'])['is_... | classifiers = [
KNeighborsClassifier(n_neighbors=5,weights='distance',p=2,n_jobs=-1),
SVC(probability=True,random_state=666,tol=1e-6),
DecisionTreeClassifier(min_samples_split=10,random_state=666),
RandomForestClassifier(n_estimators=500,random_state=666,n_jobs=-1),
AdaBoostClassifier(n_estimators=500,random_state=666... | Titanic - Machine Learning from Disaster |
816,910 | def most_popular(group, n_max=5):
relevance = group['relevance'].values
hotel_cluster = group['hotel_cluster'].values
most_popular = hotel_cluster[np.argsort(relevance)[::-1]][:n_max]
return np.array_str(most_popular)[1:-1]<prepare_output> | clf1 = KNeighborsClassifier(n_neighbors=5,weights='distance',p=2,n_jobs=-1)
clf2 = SVC(probability=True,random_state=666,tol=1e-6)
clf3 = DecisionTreeClassifier(min_samples_split=10,random_state=666)
clf4 = RandomForestClassifier(n_estimators=500,random_state=666,n_jobs=-1)
clf5 = AdaBoostClassifier(n_estimators=50... | Titanic - Machine Learning from Disaster |
816,910 | most_pop = agg.groupby(['srch_destination_id'] ).apply(most_popular)
most_pop = pd.DataFrame(most_pop ).rename(columns={0:'hotel_cluster'})
most_pop.head()<load_from_csv> | final_file = pd.DataFrame({'PassengerId':full_data[1].PassengerId,'Survived':result.astype(int)})
final_file.to_csv('Titanic best working Classifier.csv',index=False ) | Titanic - Machine Learning from Disaster |
1,343,572 | test = pd.read_csv('.. /input/test.csv',
dtype={'srch_destination_id':np.int32},
usecols=['srch_destination_id'], )<merge> | train=pd.read_csv(".. /input/train.csv")
test=pd.read_csv(".. /input/test.csv" ) | Titanic - Machine Learning from Disaster |
1,343,572 | test = test.merge(most_pop, how='left',left_on='srch_destination_id',right_index=True)
test.head()<count_missing_values> | train.columns[train.isnull().any() ], test.columns[test.isnull().any() ] | Titanic - Machine Learning from Disaster |
1,343,572 | test.hotel_cluster.isnull().sum()<groupby> | total = train.isnull().sum().sort_values(ascending=False)
percent =(train.isnull().sum() /train.isnull().count() ).sort_values(ascending=False)
missing_data = pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
missing_data | Titanic - Machine Learning from Disaster |
1,343,572 | most_pop_all = agg.groupby('hotel_cluster')['relevance'].sum().nlargest(5 ).index
most_pop_all = np.array_str(most_pop_all)[1:-1]
most_pop_all<categorify> | total=test.isnull().sum().sort_values(ascending=False)
percent=(test.isnull().sum() /test.isnull().count() ).sort_values(ascending=False)
missing_data=pd.concat([total,percent],axis=1,keys=['Total','Percent'])
missing_data | Titanic - Machine Learning from Disaster |
1,343,572 | test.hotel_cluster.fillna(most_pop_all,inplace=True )<save_to_csv> | train=train.drop(['Ticket','Cabin'],axis=1)
test=test.drop(['Ticket','Cabin'],axis=1 ) | Titanic - Machine Learning from Disaster |
1,343,572 | test.hotel_cluster.to_csv('predicted_with_pandas.csv',header=True, index_label='id' )<load_from_csv> | 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['Title'... | Titanic - Machine Learning from Disaster |
1,343,572 | train = pd.read_csv('.. /input/train.csv',
dtype={'is_booking':bool,'srch_destination_id':np.int32, 'hotel_cluster':np.int32},
usecols=['srch_destination_id','is_booking','hotel_cluster'],
chunksize=1000000)
aggs = []
print('-'*38)
for chunk in train:
agg = chunk.groupby(['srch_destination_id',
'hotel_cluster'])['is_... | 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.head(6)
| Titanic - Machine Learning from Disaster |
1,343,572 | def most_popular(group, n_max=5):
relevance = group['relevance'].values
hotel_cluster = group['hotel_cluster'].values
most_popular = hotel_cluster[np.argsort(relevance)[::-1]][:n_max]
return np.array_str(most_popular)[1:-1]<prepare_output> | train['Age']=train['Age'].fillna(train['Age'].median(skipna=True))
test['Age']=test['Age'].fillna(test['Age'].median(skipna=True)) | Titanic - Machine Learning from Disaster |
1,343,572 | most_pop = agg.groupby(['srch_destination_id'] ).apply(most_popular)
most_pop = pd.DataFrame(most_pop ).rename(columns={0:'hotel_cluster'})
most_pop.head()<load_from_csv> | train['Age']=train['Age'].astype(int)
test['Age']=test['Age'].astype(int ) | Titanic - Machine Learning from Disaster |
1,343,572 | test = pd.read_csv('.. /input/test.csv',
dtype={'srch_destination_id':np.int32},
usecols=['srch_destination_id'], )<merge> | train['AgeBand']=pd.cut(train['Age'],5)
train[['AgeBand','Survived']].groupby(['AgeBand'],as_index=False ).mean().sort_values(by='AgeBand',ascending=True ) | Titanic - Machine Learning from Disaster |
1,343,572 | test = test.merge(most_pop, how='left',left_on='srch_destination_id',right_index=True)
test.head()<count_missing_values> | combine=[train,test]
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']=4
train.he... | Titanic - Machine Learning from Disaster |
1,343,572 | test.hotel_cluster.isnull().sum()<groupby> | train=train.drop(['AgeBand'],axis=1)
combine=[train,test] | Titanic - Machine Learning from Disaster |
1,343,572 | most_pop_all = agg.groupby('hotel_cluster')['relevance'].sum().nlargest(5 ).index
most_pop_all = np.array_str(most_pop_all)[1:-1]
most_pop_all<categorify> | for dataset in combine:
dataset['FamilySize']=dataset['SibSp']+dataset['Parch']+1
train[['FamilySize','Survived']].groupby(['FamilySize'],as_index=False ).mean().sort_values(by='Survived',ascending=False)
| Titanic - Machine Learning from Disaster |
1,343,572 | test.hotel_cluster.fillna(most_pop_all,inplace=True )<save_to_csv> | for dataset in combine:
dataset['IsAlone'] = 0
dataset.loc[dataset['FamilySize'] == 1, 'IsAlone'] = 1
train[['IsAlone', 'Survived']].groupby(['IsAlone'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
1,343,572 | test.hotel_cluster.to_csv('predicted_with_pandas.csv',header=True, index_label='id' )<set_options> | train = train.drop(['Parch', 'SibSp', 'FamilySize'], axis=1)
test = test.drop(['Parch', 'SibSp', 'FamilySize'], axis=1)
combine = [train, test]
train.head() | Titanic - Machine Learning from Disaster |
1,343,572 | warnings.filterwarnings('ignore')
pd.options.display.float_format = '{:.3f}'.format
%matplotlib inline
color = sns.color_palette()
py.init_notebook_mode(connected=True)
print(os.listdir(".. /input"))
<load_from_csv> | for dataset in combine:
dataset['Embarked'] = dataset['Embarked'].fillna(train['Embarked'].dropna().mode() [0])
train[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
1,343,572 | 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> | for dataset in combine:
dataset['Embarked'] = dataset['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int)
train.head() | Titanic - Machine Learning from Disaster |
1,343,572 | print('train : {}'.format(df_train.shape))
print('test : {}'.format(df_test.shape))<sort_values> | test['Fare'].fillna(test['Fare'].dropna().median() , inplace=True)
test.head() | Titanic - Machine Learning from Disaster |
1,343,572 | 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> | 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)... | Titanic - Machine Learning from Disaster |
1,343,572 | 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()<count_missing_values> | for dataset in combine:
dataset['Sex']=dataset['Sex'].map({'female':1,'male':0} ).astype(int)
train.head(10 ) | Titanic - Machine Learning from Disaster |
1,343,572 | df_train.dropna(axis=0, inplace=True)
df_train.isnull().sum()<feature_engineering> | train=train.drop(['Name','PassengerId'],axis=1)
test=test.drop(['Name'],axis=1 ) | Titanic - Machine Learning from Disaster |
1,343,572 | headshot = df_train[['kills', 'winPlacePerc', 'headshotKills']]
headshot['headshotrate'] = headshot['headshotKills'] / headshot['kills']
headshot.corr()<feature_engineering> | X_train=train.drop(['Survived'],axis=1)
Y_train=train.Survived
X_test=test.drop('PassengerId',axis=1 ).copy() | Titanic - Machine Learning from Disaster |
1,343,572 | df_train['headshotrate'] = df_train['headshotKills']/df_train['kills']
df_test['headshotrate'] = df_test['headshotKills']/df_test['kills']
del headshot<feature_engineering> | k_fold=KFold(len(Y_train),n_folds=10,shuffle=True,random_state=0 ) | Titanic - Machine Learning from Disaster |
1,343,572 | killStreak = df_train[['kills','winPlacePerc','killStreaks']]
killStreak['killStreakrate'] = killStreak['killStreaks']/killStreak['kills']
killStreak.corr()<feature_engineering> | from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC,LinearSVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import SGD... | Titanic - Machine Learning from Disaster |
1,343,572 | df_train['killStreakrate'] = -(df_train['killStreaks'] / df_train['kills'])
df_test['killStreakrate'] = -(df_test['killStreaks'] / df_test['kills'])
del killStreak<feature_engineering> | svc=SVC()
svc.fit(X_train, Y_train)
Y_pred = svc.predict(X_test)
acc_svc = round(svc.score(X_train, Y_train)* 100, 2)
acc_svc | Titanic - Machine Learning from Disaster |
1,343,572 | df_train['hacker_pt'] = 0
df_test['hacker_pt'] = 0<set_options> | knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)
Y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train)* 100, 2)
acc_knn | Titanic - Machine Learning from Disaster |
1,343,572 | pd.set_option('display.max_columns', 50 )<feature_engineering> | gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
Y_pred = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_train, Y_train)* 100, 2)
acc_gaussian | Titanic - Machine Learning from Disaster |
1,343,572 | 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> | linear_svc = LinearSVC()
linear_svc.fit(X_train, Y_train)
Y_pred = linear_svc.predict(X_test)
acc_linear_svc = round(linear_svc.score(X_train, Y_train)* 100, 2)
acc_linear_svc | Titanic - Machine Learning from Disaster |
1,343,572 | 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> | sgd = SGDClassifier()
sgd.fit(X_train, Y_train)
Y_pred = sgd.predict(X_test)
acc_sgd = round(sgd.score(X_train, Y_train)* 100, 2)
acc_sgd | Titanic - Machine Learning from Disaster |
1,343,572 | 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> | decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
Y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train)* 100, 2)
acc_decision_tree | Titanic - Machine Learning from Disaster |
1,343,572 | df_train['hacker_pt'][(df_train['kills'] > 10)&(df_train['weaponsAcquired'] >= 10)&(df_train['total_Distance'] == 0)] += 1
df_test['hacker_pt'][(df_test['kills'] > 10)&(df_test['weaponsAcquired'] >= 10)&(df_test['total_Distance'] == 0)] += 1<filter> | random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, Y_train)
Y_pred1 = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train)* 100, 2)
acc_random_forest | Titanic - Machine Learning from Disaster |
1,343,572 | df_train['hacker_pt'][df_train['longestKill'] >= 1000] += 1
df_test['hacker_pt'][df_train['longestKill'] >= 1000] += 1<feature_engineering> | models = pd.DataFrame({
'Model': ['Support Vector Machines', 'KNN','Random Forest', 'Naive Bayes','Stochastic Gradient Decent', 'Linear SVC','Decision Tree'],
'Score': [acc_svc, acc_knn,acc_random_forest, acc_gaussian, acc_sgd, acc_linear_svc, acc_decision_tree]})
models.sort_values(by='Score', ascending=False ) | Titanic - Machine Learning from Disaster |
1,343,572 | kills = df_train[['assists','winPlacePerc','kills']]
kills['kills_assists'] =(kills['kills'] + kills['assists'])
kills.corr()<drop_column> | submission=pd.read_csv('.. /input/gender_submission.csv' ) | Titanic - Machine Learning from Disaster |
1,343,572 | df_train['kills_assists'] = df_train['kills'] + df_train['assists']
df_test['kills_assists'] = df_test['kills'] + df_test['assists']
del kills<drop_column> | submission['Survived']= Y_pred1
submission['PassengerId']=test['PassengerId']
pd.DataFrame(submission,columns=['PassengerId','Survived'] ).to_csv('randomforest.csv',index=False)
| Titanic - Machine Learning from Disaster |
1,343,572 | df_train = reduce_mem_usage(df_train)
df_test = reduce_mem_usage(df_test)
gc.collect()<drop_column> | scoring = 'accuracy'
results = cross_val_score(random_forest, X_train, Y_train, cv=k_fold, n_jobs=1, scoring=scoring)
results | Titanic - Machine Learning from Disaster |
1,343,572 | del missing_data
del percent
del total
gc.collect()<groupby> | param_grid = {"n_estimators": [40,50,60],
"max_depth": [3, 5],
"min_samples_split": [5, 10],
"min_samples_leaf": [5, 6],
"max_leaf_nodes": [10, 15],
"min_weight_fraction_leaf": [0.1]}
param_grid | Titanic - Machine Learning from Disaster |
1,343,572 | df_train_size = df_train.groupby(['matchId','groupId'] ).size().reset_index(name='group_size')
df_test_size = df_test.groupby(['matchId','groupId'] ).size().reset_index(name='group_size' )<groupby> | grid_search = GridSearchCV(random_forest, param_grid=param_grid,scoring='accuracy',cv=k_fold,n_jobs=-1)
grid_search.fit(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
1,343,572 | df_train_mean = df_train.groupby(['matchId','groupId'] ).mean().reset_index()
df_test_mean = df_test.groupby(['matchId','groupId'] ).mean().reset_index()<groupby> | print(grid_search.best_score_)
print(grid_search.best_params_ ) | Titanic - Machine Learning from Disaster |
1,343,572 | <merge><EOS> | xgb=XGBClassifier(max_depth=5, n_estimators=900, learning_rate=1,gamma=0,min_child_weight=2, reg_alpha=0.1,subsample=0.8,cv=k_fold)
xgb.fit(X_train,Y_train)
Y_pred = xgb.predict(X_test)
acc_xgb = round(xgb.score(X_train, Y_train)* 100, 2)
acc_xgb | Titanic - Machine Learning from Disaster |
1,242,882 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<set_options> |
print(os.listdir(".. /input"))
warnings.filterwarnings('ignore')
| Titanic - Machine Learning from Disaster |
1,242,882 | df_train = reduce_mem_usage(df_train)
df_test = reduce_mem_usage(df_test)
gc.collect()<drop_column> |
try:
df_train = pd.read_csv(".. /input/train.csv")
df_test = pd.read_csv(".. /input/test.csv")
print('Files are loaded')
except:
print('Something went wrong.' ) | Titanic - Machine Learning from Disaster |
1,242,882 | train_columns = list(df_test.columns)
train_idx = df_train.Id
test_idx = df_test.Id
train_columns.remove("Id")
train_columns.remove("matchId")
train_columns.remove("groupId" )<prepare_x_and_y> | ship = df_train.append(df_test, ignore_index=True)
| Titanic - Machine Learning from Disaster |
1,242,882 | x_train = df_train[train_columns]
x_test = df_test[train_columns]
y_train = df_train["winPlacePerc"].astype('float' )<categorify> | df_train['Survived'].value_counts(normalize=True ) | Titanic - Machine Learning from Disaster |
1,242,882 | encoded_train = pd.get_dummies(x_train.matchType, prefix=x_train.matchType.name ,prefix_sep="_")
encoded_test = pd.get_dummies(x_test.matchType, prefix=x_test.matchType.name ,prefix_sep="_")
encoded_train.head()<merge> | print('"ship" columns with null values:
', ship.isnull().sum() ) | Titanic - Machine Learning from Disaster |
1,242,882 | x_train = x_train.merge(encoded_train, right_index=True, left_index=True)
x_test = x_test.merge(encoded_test, right_index=True, left_index=True )<drop_column> | try:
ship_orig = ship.copy()
print('Copies have been made')
except:
print('Something went wrong.' ) | Titanic - Machine Learning from Disaster |
1,242,882 | del x_train['matchType']
del x_test['matchType']<drop_column> | columns_to_drop = ['PassengerId', 'Ticket']
ship = ship.drop(columns_to_drop, axis=1)
print('The following columns have been dropped: ', columns_to_drop)
del columns_to_drop | Titanic - Machine Learning from Disaster |
1,242,882 | del df_train
del df_test
gc.collect()<split> | print('Missing Values in "ship" data: ', list(col for col in ship.columns if ship[col].isnull().any() == True)) | Titanic - Machine Learning from Disaster |
1,242,882 | folds = KFold(n_splits=3,random_state=6)
oof_preds = np.zeros(x_train.shape[0])
sub_preds = np.zeros(x_test.shape[0])
start = time.time()
valid_score = 0
importances = pd.DataFrame()
for n_fold,(trn_idx, val_idx)in enumerate(folds.split(x_train, y_train)) :
trn_x, trn_y = x_train.iloc[trn_idx], y_train[trn_idx]
val_... | ship['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
1,242,882 | print('Done' )<save_to_csv> | ship["Embarked"] = ship["Embarked"].fillna("S")
print('Embarked column blanks have been filled with the value "S"' ) | Titanic - Machine Learning from Disaster |
1,242,882 | test_pred = pd.DataFrame({"Id":test_idx})
test_pred["winPlacePerc"] = sub_preds
test_pred.columns = ["Id", "winPlacePerc"]
test_pred.to_csv("lgb_model_181204.csv", index=False )<set_options> | median_value = ship["Fare"].median()
print('The median value for the "Fare" column is: ', median_value)
ship["Fare"].fillna(median_value, inplace=True)
print('Fare column blanks have been filled with the median value of the column')
del median_value | Titanic - Machine Learning from Disaster |
1,242,882 | warnings.filterwarnings('ignore')
%matplotlib inline
py.init_notebook_mode(connected=True)
<load_from_csv> | print('Number of null values in Age column:', ship['Age'].isnull().sum())
print('The mean of the Age column: ', ship['Age'].mean() ) | Titanic - Machine Learning from Disaster |
1,242,882 | df_train = pd.read_csv('.. /input/train.csv')
df_test = pd.read_csv('.. /input/test.csv' )<filter> | imputer_tool = SimpleImputer()
ship_numeric = ship.select_dtypes(exclude=['object'])
cols_with_missing = ['Age']
for col in cols_with_missing:
ship_numeric.loc[:, col + '_was_missing'] = ship_numeric[col].isnull()
ship_numeric_imp = imputer_tool.fit_transform(ship_numeric.values)
ship_numeric = pd.DataFrame(ship_nume... | Titanic - Machine Learning from Disaster |
1,242,882 | df_train[df_train['groupId']==24]<filter> | ship_numeric.loc[lambda df: df.Age_was_missing == 1, :][:5] | Titanic - Machine Learning from Disaster |
1,242,882 | len(df_train[df_train['matchId']==0] )<count_values> | ship['Age'] = ship_numeric['Age'].copy()
print('Are there any null values?', ship['Age'].isnull().any())
ship['Age'] = ship_numeric['Age'].copy()
ship['Age_was_missing'] = ship_numeric['Age_was_missing'].copy()
del ship_numeric, ship_numeric_imp
print('Age data has been copied back to main dataset')
print('Age_was_mi... | Titanic - Machine Learning from Disaster |
1,242,882 | df_train['roadKills'].value_counts()<count_values> | print('NaN "Cabin" values in "ship" dataset: %s out of %s' %(ship['Cabin'].isnull().sum() , len(ship)) ) | Titanic - Machine Learning from Disaster |
1,242,882 | df_train['teamKills'].value_counts()<count_values> | cabin_notnull = df_train['Cabin'].loc[df_train['Cabin'].notnull() ].astype(str ).str[0]
cabin_notnull = pd.DataFrame([cabin_notnull, df_train['Survived'].loc[df_train['Cabin'].notnull() ]] ).T | Titanic - Machine Learning from Disaster |
1,242,882 | df_train['headshotKills'].value_counts()<count_values> | cabin_notnull['Cabin'].value_counts() | Titanic - Machine Learning from Disaster |
1,242,882 | df_train['vehicleDestroys'].value_counts()<feature_engineering> | ship.drop("Cabin", axis=1, inplace=True)
print('Cabin column has been dropped.' ) | Titanic - Machine Learning from Disaster |
1,242,882 | headshot = df_train[['kills','winPlacePerc','headshotKills']]
headshot['headshotrate'] = headshot['headshotKills']/headshot['kills']<feature_engineering> | embark_dummies_titanic = pd.get_dummies(ship['Embarked'])
embark_dummies_titanic.drop(['S'], axis=1, inplace=True)
ship = ship.join(embark_dummies_titanic)
ship.drop(['Embarked'], axis=1,inplace=True)
print('Embarked column has been dropped.C and Q columns have been added.' ) | Titanic - Machine Learning from Disaster |
1,242,882 | df_train['headshotrate'] = df_train['headshotKills']/df_train['kills']
df_test['headshotrate'] = df_test['headshotKills']/df_test['kills']<feature_engineering> | pclass_dummies_titanic = pd.get_dummies(ship['Pclass'])
pclass_dummies_titanic.columns = ['Class_1','Class_2','Class_3']
pclass_dummies_titanic.drop(['Class_3'], axis=1, inplace=True)
ship.drop(['Pclass'],axis=1,inplace=True)
ship = ship.join(pclass_dummies_titanic)
print('Pclass column has been changed.' ) | Titanic - Machine Learning from Disaster |
1,242,882 | killStreak = df_train[['kills','winPlacePerc','killStreaks']]
killStreak['killStreakrate'] = killStreak['killStreaks']/killStreak['kills']
killStreak.corr()<feature_engineering> | ship['Family'] = ship["Parch"] + ship["SibSp"]
ship['Family'].loc[ship['Family'] > 0] = 1
ship['Family'].loc[ship['Family'] == 0] = 0
ship = ship.drop(['SibSp','Parch'], axis=1)
print('SibSp and Parch columns have been dropped.Family column has been added.' ) | Titanic - Machine Learning from Disaster |
1,242,882 | del killStreak
df_train['killStreakrate'] = -(df_train['killStreaks']/df_train['kills'])
df_test['killStreakrate'] = -(df_test['killStreaks']/df_test['kills'])
del df_train['killStreaks']; del df_test['killStreaks']<feature_engineering> | def get_person(passenger):
age, sex = passenger
return 'child' if age < 18 else sex
ship['Person'] = ship[['Age','Sex']].apply(get_person, axis=1)
ship.drop(['Sex'],axis=1,inplace=True)
person_dummies_titanic = pd.get_dummies(ship['Person'])
person_dummies_titanic.columns = ['Child','Female','Male']
person_dummies_t... | Titanic - Machine Learning from Disaster |
1,242,882 | df_train['hacker_pt'] = 0
df_test['hacker_pt'] = 0<feature_engineering> | ship['Title'] = ship['Name'].str.split(", ", expand=True)[1].str.split(".", expand=True)[0]
print('Title column has been created with values')
ship.head() | Titanic - Machine Learning from Disaster |
1,242,882 | 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"]<feature_engineering> | ship['Title'].value_counts() | Titanic - Machine Learning from Disaster |
1,242,882 | 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> | ship.groupby('Title', sort=False)['Age'].agg(['mean', 'min', 'median', 'max', 'count'] ) | Titanic - Machine Learning from Disaster |
1,242,882 | df_train['hacker_pt'][(df_train['kills'] > 10)&(df_train['weaponsAcquired'] >= 10)&(df_train['total_Distance'] == 0)] += 1
df_test['hacker_pt'][(df_test['kills'] > 10)&(df_test['weaponsAcquired'] >= 10)&(df_test['total_Distance'] == 0)] += 1<drop_column> | ship['Title'].loc[ship['Title'] == 'the Countess'] = 'Mrs'
ship['Title'].loc[ship['Title'] == 'Ms'] = 'Mrs'
ship['Title'].loc[ship['Title'] == 'Lady'] = 'Mrs'
ship['Title'].loc[ship['Title'] == 'Dona'] = 'Mrs'
ship['Title'].loc[ship['Title'] == 'Mlle'] = 'Miss'
ship['Title'].loc[ship['Title'] == 'Mme'] = 'Miss'
print('... | Titanic - Machine Learning from Disaster |
1,242,882 | del healthitems<feature_engineering> | print(ship['Title'].value_counts())
stat_min = 10
title_names =(ship['Title'].value_counts() < stat_min)
ship['Title'] = ship['Title'].apply(lambda x: 'Misc' if title_names.loc[x] == True else x)
print(ship['Title'].value_counts())
print("-"*10)
print('Rare title names have been combined into a "Misc" option' ) | Titanic - Machine Learning from Disaster |
1,242,882 | kills = df_train[['assists','winPlacePerc','kills']]
kills['kills_assists'] =(kills['kills'] + kills['assists'])
kills.corr()<drop_column> | from sklearn.preprocessing import OneHotEncoder, LabelEncoder
from sklearn import feature_selection
from sklearn import model_selection
from sklearn import metrics | Titanic - Machine Learning from Disaster |
1,242,882 | del kills
df_train['kills_assists'] = df_train['kills'] + df_train['assists']
df_test['kills_assists'] = df_test['kills'] + df_test['assists']
del df_train['kills']; del df_test['kills']<drop_column> | label = LabelEncoder()
ship['Title_Code'] = label.fit_transform(ship['Title'])
print('Fit Transform function has been run.')
ship['Title_Code'].head() | Titanic - Machine Learning from Disaster |
1,242,882 | df_train = reduce_mem_usage(df_train)
df_test = reduce_mem_usage(df_test)
gc.collect()<groupby> | ship.drop(['Name'],axis=1,inplace=True)
print('Name column has been dropped.' ) | Titanic - Machine Learning from Disaster |
1,242,882 | df_train_size = df_train.groupby(['matchId','groupId'] ).size().reset_index(name='group_size')
df_test_size = df_test.groupby(['matchId','groupId'] ).size().reset_index(name='group_size')
df_train_mean = df_train.groupby(['matchId','groupId'] ).mean().reset_index()
df_test_mean = df_test.groupby(['matchId','groupId']... | title_data = {}
title_data['Mr - Survived'] = ship['Title_Code'].loc[(ship['Title_Code'] == 3)&(ship['Survived'] == 1)].count()
title_data['Mr - Deceased'] = ship['Title_Code'].loc[(ship['Title_Code'] == 3)&(ship['Survived'] == 0)].count()
title_data['Miss - Survived'] = ship['Title_Code'].loc[(ship['Title_Code'] == 2)... | Titanic - Machine Learning from Disaster |
1,242,882 | warnings.filterwarnings("ignore")
color = sns.color_palette()
<drop_column> | title_dummies_titanic = pd.get_dummies(ship['Title'])
title_dummies_titanic.drop(['Misc', 'Mr'], axis=1, inplace=True)
ship.drop(['Title', 'Title_Code'],axis=1,inplace=True)
ship = ship.join(title_dummies_titanic)
print('Title column has been dropped."Master", "Mrs", and "Miss" has been added.' ) | Titanic - Machine Learning from Disaster |
1,242,882 | train_columns = list(df_test.columns)
train_idx = df_train.Id
test_idx = df_test.Id
train_columns.remove("Id")
train_columns.remove("matchId")
train_columns.remove("groupId" )<prepare_x_and_y> | print('Number of people who survived with a Fare > 50: ',
len(ship['Survived'].loc[(ship['Fare'] > 50)&(ship['Survived'] == 1)]))
print('Number of people who died with a Fare > 50: ',
len(ship['Survived'].loc[(ship['Fare'] > 50)&(ship['Survived'] == 0)]))
| 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.