kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,159,619 | 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> | n_model = KNeighborsClassifier(n_neighbors = 14)
n_model.fit(X_train, Y_train)
predictions_knn = n_model.predict(X_test)
knn_Ac = accuracy_score(predictions_knn, Y_test)* 100
print(knn_Ac ) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train['hacker_pt'][df_train['longestKill'] >= 1000] += 1
df_test['hacker_pt'][df_train['longestKill'] >= 1000] += 1<sort_values> | knn_acc = knn_data[14]
print("KNN accuracy: {}".format(knn_acc)) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train.sort_values('hacker_pt', ascending=False ).head()<feature_engineering> | model_naive = GaussianNB()
model_naive.fit(X_train, Y_train)
prediction_naive = model_naive.predict(X_test ) | Titanic - Machine Learning from Disaster |
11,159,619 | kills = df_train[['assists','winPlacePerc','kills']]
kills['kills_assists'] =(kills['kills'] + kills['assists'])
kills.corr()<drop_column> | gaussian_acc = accuracy_score(prediction_naive, Y_test)* 100
print("Gaussian Acc: {}".format(gaussian_acc)) | Titanic - Machine Learning from Disaster |
11,159,619 | 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']
del df_train['assists']
del df_test['assists']
del kills<set_options> | from sklearn.tree import DecisionTreeClassifier | Titanic - Machine Learning from Disaster |
11,159,619 | df_train = reduce_mem_usage(df_train)
df_test = reduce_mem_usage(df_test)
gc.collect()<drop_column> | tree_data = {}
for i in range(2,40):
tree_model = DecisionTreeClassifier(criterion='gini',
min_samples_split=i,
max_features='auto',
min_samples_leaf=1)
tree_model.fit(X_train, Y_train)
tree_predict = tree_model.predict(X_test)
tree_data[i]=accuracy_score(tree_predict, Y_test)
| Titanic - Machine Learning from Disaster |
11,159,619 | del missing_data
del percent
del total
gc.collect()<groupby> | tree_val = max(tree_data, key=tree_data.get)
print(tree_val ) | Titanic - Machine Learning from Disaster |
11,159,619 | 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> | tree_model = DecisionTreeClassifier(criterion='gini',
min_samples_split=12,
max_features='auto',
min_samples_leaf=12 ) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train_mean = df_train.groupby(['matchId','groupId'] ).mean().reset_index()
df_test_mean = df_test.groupby(['matchId','groupId'] ).mean().reset_index()<groupby> | tree_model.fit(X_train, Y_train)
tree_predict = tree_model.predict(X_test)
tree_acc = accuracy_score(tree_predict, Y_test)
print("Tree accuarcy: {}".format(tree_acc)) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train_match_mean = df_train.groupby(['matchId'] ).mean().reset_index()
df_test_match_mean = df_test.groupby(['matchId'] ).mean().reset_index()<merge> | model_ada = AdaBoostClassifier(n_estimators=1000, learning_rate=0.1)
model_ada.fit(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train = pd.merge(df_train, df_train_mean, suffixes=["", "_mean"], how='left', on=['matchId', 'groupId'])
df_test = pd.merge(df_test, df_test_mean, suffixes=["", "_mean"], how='left', on=['matchId', 'groupId'])
del df_train_mean
del df_test_mean<merge> | prediction_add = model_ada.predict(X_test)
ada_accuracy = accuracy_score(prediction_add, Y_test)* 100
print('ada accuarcy: {}'.format(ada_accuracy)) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train = pd.merge(df_train, df_train_match_mean, suffixes=["", "_match_mean"], how='left', on=['matchId'])
df_test = pd.merge(df_test, df_test_match_mean, suffixes=["", "_match_mean"], how='left', on=['matchId'])
del df_train_match_mean
del df_test_match_mean<merge> | model_linear_d= LinearDiscriminantAnalysis()
model_linear_d.fit(X_train,Y_train)
prediction_lda=model_linear_d.predict(X_test)
LDA_Accuracy = accuracy_score(prediction_lda, Y_test)
print("Accuracy LDA: {}".format(LDA_Accuracy)) | Titanic - Machine Learning from Disaster |
11,159,619 | df_train = pd.merge(df_train, df_train_size, how='left', on=['matchId', 'groupId'])
df_test = pd.merge(df_test, df_test_size, how='left', on=['matchId', 'groupId'])
del df_train_size
del df_test_size<set_options> | models = {
'LinearDiscriminant': [LDA_Accuracy, prediction_lda],
'ADA': [ada_accuracy, prediction_add],
'DecisionTreeClassifier':[tree_acc,tree_predict],
'GaussianNB': [gaussian_acc,prediction_naive],
'LinearSVC':[SVC_acc,predictions_svc],
'RandomForestClassifier':[Random_Forest_Acc,predictions_random],
'LogisticRegres... | Titanic - Machine Learning from Disaster |
11,159,619 | gc.collect()
df_train = reduce_mem_usage(df_train)
df_test = reduce_mem_usage(df_test)
gc.collect()<set_options> | models_acc = {
'LinearDiscriminant': LDA_Accuracy,
'ADA': ada_accuracy,
'DecisionTreeClassifier':tree_acc,
'GaussianNB': gaussian_acc,
'LinearSVC':SVC_acc,
'RandomForestClassifier':Random_Forest_Acc,
'LogisticRegression':Linear_Reg_acc} | Titanic - Machine Learning from Disaster |
11,159,619 | warnings.filterwarnings("ignore")
color = sns.color_palette()
<drop_column> | max_acc = max(models_acc, key=models_acc.get)
print("MAx accuracy is : {}".format(max_acc))
print(models_acc[max_acc] ) | Titanic - Machine Learning from Disaster |
11,159,619 | 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> | pred_test = svc_model.predict(testdf)
pred_test | Titanic - Machine Learning from Disaster |
11,159,619 | x_train = df_train[train_columns]
x_test = df_test[train_columns]
y_train = df_train["winPlacePerc"].astype('float' )<categorify> | submission = pd.DataFrame({
"PassengerId": test_dir["PassengerId"],
"Survived": pred_test} ) | Titanic - Machine Learning from Disaster |
11,159,619 | <merge><EOS> | submission.to_csv("submission.csv",index=False ) | Titanic - Machine Learning from Disaster |
10,376,325 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<drop_column> | init_notebook_mode(connected=True ) | Titanic - Machine Learning from Disaster |
10,376,325 | del x_train['matchType']
del x_test['matchType']<set_options> | %matplotlib inline | Titanic - Machine Learning from Disaster |
10,376,325 | del df_train; del df_test
gc.collect()<split> | df_train = pd.read_csv('.. /input/titanic/train.csv')
df_test = pd.read_csv('.. /input/titanic/test.csv')
df_sub = pd.read_csv('.. /input/titanic/gender_submission.csv' ) | Titanic - Machine Learning from Disaster |
10,376,325 | 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_... | df_train.dtypes.value_counts() | Titanic - Machine Learning from Disaster |
10,376,325 | print('Done' )<save_to_csv> | df_test.dtypes.value_counts() | Titanic - Machine Learning from Disaster |
10,376,325 | test_pred = pd.DataFrame({"Id":test_idx})
test_pred["winPlacePerc"] = sub_preds
test_pred.columns = ["Id", "winPlacePerc"]
test_pred.to_csv("lgb_base_model.csv", index=False )<train_model> | df_train["Survived"].value_counts() | Titanic - Machine Learning from Disaster |
10,376,325 | print('Done' )<save_to_csv> | missing_rate_train =(df_train.isna().sum() /df_train.shape[0] ).sort_values()
nb_missing = df_train.isna().sum().sort_values()
print(f'{"Variable" :-<40} {"missing_rate_train":-<30} {"Number of missing values":-<30}')
for n in range(len(missing_rate_train)) :
print(f'{missing_rate_train.index[n] :-<30} {missing_rate_t... | Titanic - Machine Learning from Disaster |
10,376,325 | sub = pd.read_csv('.. /input/submission2/submission.csv')
sub.to_csv('practice1.csv',index=False )<save_to_csv> | missing_rate_test =(df_test.isna().sum() /df_test.shape[0] ).sort_values()
nb_missing = df_test.isna().sum().sort_values()
print(f'{"Variable" :-<30} {"missing_rate_train":-<30} {"Number of missing values":-<30}')
for n in range(len(missing_rate_test)) :
print(f'{missing_rate_test.index[n] :-<30} {missing_rate_test[n]... | Titanic - Machine Learning from Disaster |
10,376,325 | sub = pd.read_csv('.. /input/pleasetry1/sub1.csv')
sub.to_csv('sub1.csv',index=False )<import_modules> | def TransfromAge(df_aux):
GroupAge = ['inf-10', '10-18', '18-35', '35-65', 'sup-65']
cond1 =(df_aux["Age"].isnull())&(df_aux["title"]=="Master")
df_aux.loc[cond1, 'Age'] = calcul_median(df_aux,"Master")
cond2 =(df_aux["Age"].isnull())&(df_aux["title"]=="Miss")
df_aux.loc[cond2, 'Age'] = calcul_median(df_aux,"Miss")
... | Titanic - Machine Learning from Disaster |
10,376,325 | import numpy as np
import pandas as pd<save_to_csv> | df_test[df_test["Fare"].isnull() ] | Titanic - Machine Learning from Disaster |
10,376,325 | sub = pd.read_csv('.. /input/pleasetry1/sub1.csv')
sub.to_csv('sub1.csv',index=False )<import_modules> | def TransfromFare(df_aux):
df_aux.loc[(df_aux["Fare"].isnull())&(df_aux["Pclass"]==3), 'Fare'] = df_aux[df_aux["Pclass"]==3].Fare.dropna().median()
bins = [-1,8,14,20,60,100,600]
GroupFare = ['0-8£','8-14£','14-20£','20-60£','60-100£','100-515£']
df_aux['GroupFare'] = pd.cut(df_aux['Fare'], bins, labels=GroupFare)
ret... | Titanic - Machine Learning from Disaster |
10,376,325 | import numpy as np
import pandas as pd
<save_to_csv> | def TransfromCabin(df_aux):
df_aux.loc[(df_aux["Cabin"].isnull()), 'HasOrNotCabinNumber'] = "Has Not Cabin Number"
df_aux.loc[(df_aux["Cabin"].notnull()), 'HasOrNotCabinNumber'] = "Has Cabin Number"
return df_aux.drop(columns=["Cabin","Ticket"] ) | Titanic - Machine Learning from Disaster |
10,376,325 | sub = pd.read_csv('.. /input/pleasetry2/sub2.csv')
sub.to_csv('sub2.csv',index=False )<import_modules> | df_train[df_train["Embarked"].isnull() ] | Titanic - Machine Learning from Disaster |
10,376,325 | import numpy as np
import pandas as pd<save_to_csv> | def TransfromEmbarked(df_aux):
df_aux.loc[(df_aux["Embarked"].isnull())&(df_aux["Pclass"]==1), 'Embarked'] = "S"
return df_aux | Titanic - Machine Learning from Disaster |
10,376,325 | sub = pd.read_csv('.. /input/pleasetry3/sub3.csv')
sub.to_csv('sub3.csv',index=False )<import_modules> | def TransfromFamiliy(df_aux):
df_aux["familiySize"] = df_aux["SibSp"] + df_aux["Parch"] + 1
AloneTravel =(df_aux['SibSp'] == 0)&(df_aux['Parch'] == 0)
CoupleTravel =(df_aux['SibSp'] == 0)&(df_aux['Parch'] == 1)
siblingsTravel =(df_aux['SibSp'] == 1)&(df_aux['Parch'] == 0)
SmallFamilly =(df_aux['familiySize'] <= 3)&(... | Titanic - Machine Learning from Disaster |
10,376,325 | import numpy as np
import pandas as pd<save_to_csv> | dfTrain = TransfromTitle(df_train)
dfTrain = TransfromAge(dfTrain)
dfTrain = TransfromFare(dfTrain)
dfTrain = TransfromCabin(dfTrain)
dfTrain = TransfromEmbarked(dfTrain)
dfTrain = TransfromFamiliy(dfTrain ) | Titanic - Machine Learning from Disaster |
10,376,325 | sub = pd.read_csv('.. /input/pleasetry4/sub3.csv')
sub.to_csv('sub4.csv',index=False )<import_modules> | dfTrain = dfTrain[['familiySize','SibSp','Parch','title','GroupAge','GroupFare','HasOrNotCabinNumber',
'Sex','Embarked','Pclass','familiy','Survived']] | Titanic - Machine Learning from Disaster |
10,376,325 | import numpy as np
import pandas as pd<save_to_csv> | dfTest = TransfromTitle(df_test)
dfTest = TransfromAge(dfTest)
dfTest = TransfromFare(dfTest)
dfTest = TransfromCabin(dfTest)
dfTest = TransfromEmbarked(dfTest)
dfTest = TransfromFamiliy(dfTest ) | Titanic - Machine Learning from Disaster |
10,376,325 | sub = pd.read_csv('.. /input/pleasetry5/sub5.csv')
sub.to_csv('sub5.csv',index=False )<import_modules> | dfTest = dfTest[['familiySize','SibSp','Parch','title','GroupAge','GroupFare','HasOrNotCabinNumber',
'Sex','Embarked','Pclass','familiy']] | Titanic - Machine Learning from Disaster |
10,376,325 | import numpy as np
import pandas as pd<save_to_csv> | from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.impute import KNNImputer
from sklearn.preprocessing import MinMaxScaler, StandardScaler, Robus... | Titanic - Machine Learning from Disaster |
10,376,325 | sub = pd.read_csv('.. /input/pleasetry6/sub5.csv')
sub.to_csv('sub5.csv',index=False )<import_modules> | X_train = dfTrain.drop(columns = ['Survived'] ).values
y = dfTrain.Survived.values
X_test = dfTest.values | Titanic - Machine Learning from Disaster |
10,376,325 | import numpy as np
import pandas as pd<save_to_csv> | for i in range(len(X_train)) :
X_train[i,9] = str(X_train[i,9])
X_train[:,0:3] = StandardScaler().fit_transform(X_train[:,0:3])
onehotencoder_1 = OneHotEncoder()
u1 = onehotencoder_1.fit_transform(X_train[:,3:] ).toarray()
X_train2 = np.concatenate(( X_train[:,0:3], u1), axis=1)
X_train2.shape | Titanic - Machine Learning from Disaster |
10,376,325 | sub = pd.read_csv('.. /input/lastTry1/sub6.csv')
sub.to_csv('sub6.csv',index=False )<save_to_csv> | StandardScaler().fit_transform(X_test[:,0:3] ).shape
X_test[:,0:3].shape | Titanic - Machine Learning from Disaster |
10,376,325 | sub = pd.read_csv('.. /input/lasttry1/sub6.csv')
sub.to_csv('sub6.csv',index=False )<save_to_csv> | for i in range(len(X_test)) :
X_test[i,9] = str(X_test[i,9])
X_test[:,0:3] = StandardScaler().fit_transform(X_test[:,0:3])
onehotencoder_2 = OneHotEncoder()
u2 = onehotencoder_2.fit_transform(X_test[:,3:] ).toarray()
X_test2 = np.concatenate(( X_test[:,0:3], u2), axis=1)
X_test2.shape | Titanic - Machine Learning from Disaster |
10,376,325 | sub = pd.read_csv('.. /input/lasttry1/sub6_avg.csv')
sub.to_csv('sub6_avg.csv',index=False )<load_from_csv> | from sklearn.pipeline import make_pipeline
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble.gradient_boosting import GradientBoostingClassifier
from sklearn.feature_selection import SelectKBest
from sklearn.model_selection import StratifiedKFold
from sklearn.model_selection import GridSearchCV
... | Titanic - Machine Learning from Disaster |
10,376,325 | inittime = dt.datetime.now()
print("Capturing train database...")
df_train = pd.read_csv(".. /input/train_V2.csv")
print("Train Database captured in ", dt.datetime.now() - inittime, " secs")
df_train= reduce_mem_usage(df_train)
inittime = dt.datetime.now()
print("Capturing Test database...")
df_test = pd.read_csv(... | logreg = LogisticRegression()
Gauss = GaussianNB()
rf = RandomForestClassifier()
gboost = GradientBoostingClassifier()
DTC = DecisionTreeClassifier()
RF = RandomForestClassifier(n_estimators=200)
SVectorMachine = SVC()
xgb = xgb.XGBClassifier(max_depth=3, n_estimators=10, learning_rate=0.01)
models = [logreg,Gauss, g... | Titanic - Machine Learning from Disaster |
10,376,325 | df_train.loc[df_train['winPlacePerc'].isna() ==True, 'winPlacePerc']= 0.5<count_values> | def compute_score(clf, X, y, scoring='accuracy'):
xval = cross_val_score(clf, X, y, cv = 10, scoring=scoring)
return np.mean(xval ) | Titanic - Machine Learning from Disaster |
10,376,325 | df_train['matchType'].value_counts()<feature_engineering> | for model in models:
print('Cross-validation of : {0}'.format(model.__class__))
score = compute_score(clf=model, X=X_train2, y=y, scoring='accuracy')
print('CV score = {0}'.format(score))
print('----->>>>>>' ) | Titanic - Machine Learning from Disaster |
10,376,325 | df_test['winPlacePerc']= 0.0
df_train['Type']= 'Train'
df_test['Type']= 'Test'
print(df_train.shape, df_test.shape )<concatenate> | X = np.asarray(X_train2 ).astype(np.float32)
Y = np.asarray(y ).astype(np.float32 ) | Titanic - Machine Learning from Disaster |
10,376,325 | df= pd.concat([df_train, df_test], ignore_index=True)
del df_train
print(df.shape )<drop_column> | classifier = Sequential()
classifier.add(Dense(units = 35,activation = "relu",kernel_initializer="uniform",input_dim=33))
classifier.add(Dropout(rate=0.1))
classifier.add(Dense(units = 20,activation = "relu",kernel_initializer="uniform"))
classifier.add(Dense(units = 15,activation = "relu",kernel_initializer="uniform")... | Titanic - Machine Learning from Disaster |
10,376,325 | df= reduce_mem_usage(df )<merge> | result = []
Y_pred = classifier.predict(np.asarray(X_test2 ).astype(np.float32))
Y_pred =(Y_pred>0.55)
for i in range(len(Y_pred)) :
if Y_pred[i][0] == True :
result.append(1)
else :
result.append(0)
PassengerId = df_test["PassengerId"]
SurvivedResult = pd.DataFrame({'Survived': result})
results = pd.concat([Passen... | Titanic - Machine Learning from Disaster |
9,097,067 | def min_by_team(df,df_Group, features):
print("Working on Min by Team features...")
inittime = dt.datetime.now()
agg = df_Group[features].min()
print("Features : Min Created in ", dt.datetime.now() - inittime)
return df.merge(agg, suffixes=['', '_min'], how='left', on=['matchId', 'groupId'])
def max_by_team(df,df_Gr... | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
test_data = pd.read_csv("/kaggle/input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
9,097,067 | Y_Column = 'winPlacePerc'
ColumnList = ['assists', 'boosts', 'damageDealt', 'DBNOs',
'headshotKills', 'heals', 'killPlace', 'killPoints', 'kills',
'killStreaks', 'longestKill', 'maxPlace', 'numGroups', 'revives',
'rideDistance', 'roadKills', 'swimDistance', 'teamKills',
'vehicleDestroys', 'walkDistance', 'weaponsAcquir... | params = {
'axes.labelsize': "large",
'xtick.labelsize': 'medium',
'legend.fontsize': 'medium',
'legend.loc': "best",
}
plot.rcParams.update(params)
train_data['Died'] = 1 - train_data['Survived'] | Titanic - Machine Learning from Disaster |
9,097,067 | import lightgbm as lgb
from sklearn.metrics import mean_absolute_error<train_model> | title_mapping = {"Mrs": 4, "Miss": 3, "Mr": 0, "Noble": 2,"Crew": 1}
train_data['Title Map'] = train_data['Titles'].map(title_mapping)
test_data['Title Map'] = test_data['Titles'].map(title_mapping ) | Titanic - Machine Learning from Disaster |
9,097,067 | %%time
starttime = dt.datetime.now()
d_train1 = lgb.Dataset(X_Train, label=Y_Train.values)
params = {}
params['learning_rate'] = 0.09
params['boosting_type'] = 'gbdt'
params['objective'] = 'regression'
params['metric'] = 'mae'
params['sub_feature'] = 0.8
params['num_leaves'] = 1000
params['min_data'] = 1
params['max_d... | train_data["Fare"] = train_data["Fare"].fillna(train_data["Fare"].median())
test_data["Fare"] = test_data["Fare"].fillna(test_data["Fare"].median() ) | Titanic - Machine Learning from Disaster |
9,097,067 | del X_Train
X_test = X_test.reset_index()
X_test["winPlacePerc"] = y_pred
X_test = X_test[['Id',"winPlacePerc"]]
df_test = df_test[['Id','groupId']]
df_test= df_test.merge(X_test, on = ['Id'])
del X_test
df_test["winPlacePerc"]= df_test["winPlacePerc"].clip(lower = 0.0, upper= 1.0)
print(df_test.head() )<save_to_csv> | train_data['FareGroup'] = pd.cut(train_data['Fare'],3)
print(train_data[['FareGroup', 'Survived']].groupby('FareGroup', as_index=False ).mean().sort_values('Survived', ascending=False)) | Titanic - Machine Learning from Disaster |
9,097,067 | df_test[['Id',"winPlacePerc"]].to_csv("submission.csv", index=False )<load_from_csv> | def group_fare(fare):
if fare <= 170: return 0
if fare > 170 and fare <= 340: return 1
if fare > 340: return 2
for i, row in train_data.iterrows() :
train_data.at[i,'Fare Group'] = group_fare(row["Fare"])
for i, row in test_data.iterrows() :
test_data.at[i,'Fare Group'] = group_fare(row["Fare"] ) | Titanic - Machine Learning from Disaster |
9,097,067 | print('-' * 80)
print('train')
train = import_data('.. /input/train.csv')
print('-' * 80)
print('test')
test = import_data('.. /input/test.csv')
print('-' * 80)
print('sample_submission')
submission = import_data('.. /input/sample_submission.csv' )<count_missing_values> | def calc_age(df, cl, sx, tl):
a = df.groupby(["Pclass", "Sex", "Titles"])["Age"].median()
return a[cl][sx][tl]
age_train = train_data.copy()
age_train.drop('PassengerId', axis=1, inplace=True)
age_train.drop('Survived',axis=1, inplace=True)
age_test = test_data.copy()
age_test.drop('PassengerId', axis=1, inplace=True... | Titanic - Machine Learning from Disaster |
9,097,067 | train.isnull().sum()<count_missing_values> | train_data['AgeGroup'] = pd.cut(train_data['Age'],5)
print(train_data[['AgeGroup', 'Survived']].groupby('AgeGroup', as_index=False ).mean().sort_values('Survived', ascending=False)) | Titanic - Machine Learning from Disaster |
9,097,067 | train.isnull().sum()<prepare_x_and_y> | train_data["Family"] = train_data["SibSp"] + train_data["Parch"]
test_data["Family"] = test_data["SibSp"] + test_data["Parch"] | Titanic - Machine Learning from Disaster |
9,097,067 | y = train['winPlacePerc']
columns_todrop = ['winPlacePerc']
train_sel = train.drop(columns_todrop,axis=1 )<groupby> | train_data["Embarked"] = train_data["Embarked"].fillna('S' ) | Titanic - Machine Learning from Disaster |
9,097,067 | train_mean = train_sel.groupby(['matchId','groupId'] ).mean()
test_mean = test.groupby(['matchId','groupId'] ).mean()
train_median = train_sel.groupby(['matchId','groupId'] ).median()
test_median = test.groupby(['matchId','groupId'] ).median()
train_rank = train_mean.groupby('matchId' ).rank(pct=True)
test_rank = test... | print(train_data[['Embarked', 'Survived']].groupby('Embarked', as_index=False ).mean().sort_values('Survived', ascending=False)) | Titanic - Machine Learning from Disaster |
9,097,067 | train_new = pd.merge(train_sel,train_mean,suffixes=['',"_mean"],how="left",on=['matchId','groupId'])
test_new = pd.merge(test,test_mean,suffixes=['',"_mean"],how="left",on=['matchId','groupId'])
train_new = pd.merge(train_new,train_rank,suffixes=['',"_rank"],how="left",on=['matchId','groupId'])
test_new = pd.merge(t... | def embarked_rate(embarked_port):
if embarked_port == 'C': return 2
if embarked_port == 'Q': return 1
if embarked_port == 'S': return 0
for i, row in train_data.iterrows() :
train_data.at[i,'Emb Rate'] = embarked_rate(row["Embarked"])
for i, row in test_data.iterrows() :
test_data.at[i,'Emb Rate'] = embarked_rate(row[... | Titanic - Machine Learning from Disaster |
9,097,067 | selected_columns=[]
for each in train_new.columns:
if "_" in each:
selected_columns.append(each)
train_selected = train_new[selected_columns]
test_selected = test_new[selected_columns]
train_selected['matchId'] = train['matchId']
test_selected['matchId'] = test['matchId']<drop_column> | sex_mapping = {"male": 0, "female": 1}
train_data['Sex Map'] = train_data['Sex'].map(sex_mapping)
test_data['Sex Map'] = test_data['Sex'].map(sex_mapping ) | Titanic - Machine Learning from Disaster |
9,097,067 | cols_toDrop = ['Id_rank','Id_mean','Id_median','vehicleDestroys_mean','vehicleDestroys_median','vehicleDestroys_mean']
train_selected.drop(cols_toDrop,axis=1,inplace=True)
test_selected.drop(cols_toDrop,axis=1,inplace=True )<prepare_x_and_y> | cols_to_drop = ["SibSp", "Parch", "Name", "Age", "Fare", "Embarked", "Cabin", "Ticket", "Sex", "Titles"]
new_train = train_data.drop(cols_to_drop, axis=1)
new_test = test_data.drop(cols_to_drop, axis=1)
y = train_data["Survived"]
features = ["Pclass", "Sex Map", "Family", "Title Map", "Age Group", "Fare Group", "Emb ... | Titanic - Machine Learning from Disaster |
9,097,067 | train_selected['winPlacePerc'] = y
matchId = train_selected['matchId'].unique()
matchIdTrain = np.random.choice(matchId, int(0.80*len(matchId)))
df_train2 = df_train[train_selected['matchId'].isin(matchIdTrain)]
df_test = df_train[~train_selected['matchId'].isin(matchIdTrain)]
y_train = df_train2['winPlacePerc']
X_tra... | model1 = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=1)
model1.fit(X, y)
y1_test = model1.predict(X_test)
model2 = XGBClassifier(max_depth=3, n_estimators=1000, learning_rate=0.05)
model2.fit(X, y)
y2_test = model2.predict(X_test)
model3 = SVC(random_state=1)
model3.fit(X,y)
y3_test = mod... | Titanic - Machine Learning from Disaster |
9,097,067 | scaler = MinMaxScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
model = LinearRegression()
regr = make_pipeline(model)
model.fit(X_train,y_train)
<predict_on_test> | model1_preds = cross_val_predict(model1, X, y, cv=10)
model1_acc = accuracy_score(y, model1_preds)
model2_preds = cross_val_predict(model2, X, y, cv=10)
model2_acc = accuracy_score(y, model2_preds)
model3_preds = cross_val_predict(model3, X, y, cv=10)
model3_acc = accuracy_score(y, model3_preds)
model4_preds = cr... | Titanic - Machine Learning from Disaster |
9,097,067 | <predict_on_test><EOS> | output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': y2_test})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
9,034,271 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_to_csv> | %matplotlib inline
InteractiveShell.ast_node_interactivity = "all"
logging.getLogger('tensorflow' ).setLevel(logging.ERROR)
tf.compat.v1.set_random_seed(0 ) | Titanic - Machine Learning from Disaster |
9,034,271 | finalPred_series = pd.Series(final_pred)
submission = pd.concat([test['Id'],finalPred_series],axis=1)
columns=['Id','winPlacePerc']
submission.columns = columns
print(submission)
submission.to_csv('submission.csv', index=False )<import_modules> | train = pd.read_csv(r'.. /input/titanic/train.csv')
test = pd.read_csv(r'.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
9,034,271 | import plotly.express as px
import plotly.graph_objects as go
import plotly.figure_factory as ff
from plotly.subplots import make_subplots
import matplotlib.pyplot as plt
from pandas_profiling import ProfileReport
import seaborn as sns
from sklearn import metrics
from scipy import stats
from copy import deepcopy
from s... | def calculate_error_types(prediction_array, true_array):
type1_errors = pd.Series(( true_array==0)&(true_array!=prediction_array))
type2_errors = pd.Series(( true_array==1)&(true_array!=prediction_array))
num_type1 = len(type1_errors.loc[type1_errors==True])
num_type2 = len(type2_errors.loc[type2_errors==True])
pct_t... | Titanic - Machine Learning from Disaster |
9,034,271 | train_df = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/train.csv')
test_df = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/test.csv')
sub_df = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/sample_submission.csv')
train_df.head()<prepare_x_and_y> | def write_model_results(name_str, accuracy, crossvalscores, predictions, y_test, accumulate=False):
num_type1, pct_type1, num_type2, pct_type2, pct_errors = calculate_error_types(predictions, y_test)
tot_errors = num_type1+num_type2
crossvalscore = crossvalscores.mean()
crossval_std = crossvalscores.std()
global model... | Titanic - Machine Learning from Disaster |
9,034,271 | feature_cols = train_df.drop(['id', 'target'], axis=1 ).columns
x = train_df[feature_cols]
y = train_df['target']
print(x.shape, y.shape )<concatenate> | def create_voted_predictions(model_predictions, survived_tilt=0):
voted_predictions = sum(model_predictions)
num_models = len(model_predictions)
cutoff = int(np.ceil(( num_models+1)/2)) - survived_tilt
voted_predictions[voted_predictions<cutoff] = 0
voted_predictions[voted_predictions>=cutoff] = 1
return voted_predic... | Titanic - Machine Learning from Disaster |
9,034,271 | train_indexs = train_df.index
test_indexs = test_df.index
df = pd.concat(objs=[train_df, test_df], axis=0 ).reset_index(drop=True)
df = df.drop('id', axis=1)
len(train_indexs), len(test_indexs )<sort_values> | def get_ticket_survival_arrays(test_indexes=np.array(['none'])) :
if test_indexes[0]=='none':
train_df = train_copy.loc[:, ['Ticket','Survived','Name']]
test_df = test.loc[:, ['Ticket','Name']]
else:
train_df = train_copy.loc[~test_indexes, ['Ticket','Survived','Name']]
test_df = train_copy.loc[test_indexes, ['Ticket',... | Titanic - Machine Learning from Disaster |
9,034,271 | def fix_skew(features):
numerical_columns = features.select_dtypes(include=['int64','float64'] ).columns
skewed_features = features[numerical_columns].apply(lambda x: stats.skew(x)).sort_values(ascending=False)
high_skew = skewed_features[abs(skewed_features)> 0.5]
skewed_features = high_skew.index
for column in ske... | def drop_column_feature_importances(X_train, y_train, random_state = 0):
feature_importances = pd.DataFrame(index=train.loc[:,train.columns!='Survived'].columns)
for model in [adaboost, logitmodel, randomforest]:
model_clone = clone(model)
model_clone.random_state = random_state
train_with_dummies=pd.get_dummies(X_tr... | Titanic - Machine Learning from Disaster |
9,034,271 | param_grid = {
'n_estimators': [5, 10, 15, 20],
'max_depth': [2, 5, 7, 9]
}
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=42)
clf = XGBRegressor(random_state = 42)
clf.fit(x_train, y_train )<compute_test_metric> | def cross_validate_entire_process(k=10, ticket_survival_feature=False):
rows = len(X_full)
cv_indexes = np.linspace(rows//k, rows-(rows//k), k-1 ).astype('int')
cv_indexes = np.append(cv_indexes, rows)
start_idx = 0
end_idx = 0
for index in cv_indexes:
end_idx = index
test_indexes = np.isin(np.arange(len(X_full)) , ... | Titanic - Machine Learning from Disaster |
9,034,271 | predictions = clf.predict(x_test)
errors = abs(predictions - y_test)
print('Mean Absolute Error:', round(np.mean(errors), 2), 'degrees.')
<split> | train.head(3)
summary = [[train[column].dtype, train[column].unique().size, train[column].isna().sum() ] for column in list(train)]
summary_df = pd.DataFrame(summary, index=list(train), columns=['data_type','unique_values','nan_values'])
summary_df['memory_usage'] = train.memory_usage(deep=True)
def highlight(df):
f... | Titanic - Machine Learning from Disaster |
9,034,271 | def objective(trial,data=x,target=y):
train_x, test_x, train_y, test_y = train_test_split(data, target, test_size=0.15,random_state=42)
param = {
'tree_method':'gpu_hist',
'lambda': trial.suggest_loguniform(
'lambda', 1e-3, 10.0
),
'alpha': trial.suggest_loguniform(
'alpha', 1e-3, 10.0
),
'colsample_bytree': trial... | train['HadCabin'] = train['Cabin'].notna().replace({False:0,True:1})
train['HadAge'] = train['Age'].notna().replace({False:0,True:1})
train['HadEmbarked'] = train['Embarked'].notna().replace({False:0,True:1} ) | Titanic - Machine Learning from Disaster |
9,034,271 | study = optuna.create_study(direction='minimize')
study.optimize(objective, n_trials=25)
print('Number of finished trials:', len(study.trials))
print('Best trial:', study.best_trial.params )<find_best_params> | train['CabinLetter'] = train['CabinLetter_Fillna'] | Titanic - Machine Learning from Disaster |
9,034,271 | study.best_params<train_model> | train_ages = train.loc[:,['Title','Age']] | Titanic - Machine Learning from Disaster |
9,034,271 | best_params = study.best_params
best_params['tree_method'] = 'gpu_hist'
best_params['random_state'] = 42
clf = XGBRegressor(**(best_params))
clf.fit(x, y )<predict_on_test> | Titanic - Machine Learning from Disaster | |
9,034,271 | preds = pd.Series(clf.predict(test_df.drop('id', axis=1)) , name='target')
preds = pd.concat([test_df['id'], preds], axis=1 )<save_to_csv> | train['Age_Fillna'] = train['Age']
for title in train['Title'].unique() :
nans = train.loc[(train['Title']==title)&(train['Age'].isna())]
non_nan_sample = train.loc[train['Title']==title,'Age'].dropna().sample(n=len(nans), \
replace=False, \
random_state=0 ).values
train.loc[nans.index,'Age_Fillna'] = non_nan_sample | Titanic - Machine Learning from Disaster |
9,034,271 | preds.to_csv("submission.csv", index=False )<set_options> | train['Age']=train['Age_Fillna'] | Titanic - Machine Learning from Disaster |
9,034,271 | pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 100)
%matplotlib inline
sys.version_info<load_from_csv> | train['TicketStub']=train['Ticket'].str.extract(r'([A-Za-z///.]+)',expand=False)
train['TicketStub']=train['TicketStub'].fillna('numeric:'+ train['Ticket'].str.len().astype('str'))
train['TicketStub']=train['TicketStub'].str.replace('.','' ).str.upper() | Titanic - Machine Learning from Disaster |
9,034,271 | items = pd.read_csv('.. /input/competitive-data-science-predict-future-sales/items.csv')
shops = pd.read_csv('.. /input/competitive-data-science-predict-future-sales/shops.csv')
cats = pd.read_csv('.. /input/competitive-data-science-predict-future-sales/item_categories.csv')
train = pd.read_csv('.. /input/competitiv... | train['FamilySize'] = train['SibSp'].add(train['Parch'])+1
train['FamilySize_Alone'] = train.loc[train['FamilySize']==1,'FamilySize']
train['FamilySize_SmallFamily'] = train.loc[(train['FamilySize']>1)&(train['FamilySize']<=4),'FamilySize']
train['FamilySize_LgFamily'] = train.loc[(train['FamilySize']>4),'FamilySize']
... | Titanic - Machine Learning from Disaster |
9,034,271 | print('train size, item in train, shop in train', train.shape[0], train.item_id.nunique() , train.shop_id.nunique())
print('train size, item in train, shop in train', test.shape[0], test.item_id.nunique() ,test.shop_id.nunique())
print('new items:', len(list(set(test.item_id)- set(test.item_id ).intersection(set(trai... | train_copy = train.copy() | Titanic - Machine Learning from Disaster |
9,034,271 | train.isnull().sum()<count_missing_values> | train_survival, test_survival = get_ticket_survival_arrays()
train.loc[:,'PctLived'] = train_survival | Titanic - Machine Learning from Disaster |
9,034,271 | train.isnull().sum()<feature_engineering> | train_copy = train.copy()
use_columns = ['Pclass','Sex','Title','CabinLetter','Age','TicketStub','FamilySize_Code','Fare','Embarked','Survived','PctLived']
drop_columns = set(train.columns)- set(use_columns)
train.drop(drop_columns, axis=1,inplace=True)
train.columns | Titanic - Machine Learning from Disaster |
9,034,271 | median = train[(train.shop_id==32)&(train.item_id==2973)&(train.date_block_num==4)&(train.item_price>0)].item_price.median()
train.loc[train.item_price<0, 'item_price'] = median<feature_engineering> | non_convertible_columns = \
train.columns[(train.dtypes == 'float64')|(train.dtypes == 'category')|(train.columns=='Survived')]
convertible_columns = set(train.columns)- set(non_convertible_columns)
for column in convertible_columns:
train[column] = pd.Categorical(train[column] ) | Titanic - Machine Learning from Disaster |
9,034,271 | train.loc[train.shop_id == 0, 'shop_id'] = 57
test.loc[test.shop_id == 0, 'shop_id'] = 57
train.loc[train.shop_id == 1, 'shop_id'] = 58
test.loc[test.shop_id == 1, 'shop_id'] = 58
train.loc[train.shop_id == 10, 'shop_id'] = 11
test.loc[test.shop_id == 10, 'shop_id'] = 11<categorify> | train_with_dummies=pd.get_dummies(train,drop_first=True)
train_with_dummies.head(1 ) | Titanic - Machine Learning from Disaster |
9,034,271 | shops.loc[shops.shop_name == 'Сергиев Посад ТЦ "7Я"', 'shop_name'] = 'СергиевПосад ТЦ "7Я"'
shops['city'] = shops['shop_name'].str.split(' ' ).map(lambda x: x[0])
shops.loc[shops.city == '!Якутск', 'city'] = 'Якутск'
shops['city_code'] = LabelEncoder().fit_transform(shops['city'])
shops = shops[['shop_id','city_code'... | X_full = np.array(train_with_dummies.loc[:,(train_with_dummies.columns !='Survived')])
y_full = np.array(train_with_dummies.loc[:,(train_with_dummies.columns=='Survived')].iloc[:,0] ) | Titanic - Machine Learning from Disaster |
9,034,271 | ts = time.time()
matrix = []
cols = ['date_block_num','shop_id','item_id']
for i in range(34):
sales = train[train.date_block_num==i]
matrix.append(np.array(list(product([i], sales.shop_id.unique() , sales.item_id.unique())) , dtype='int16'))
matrix = pd.DataFrame(np.vstack(matrix), columns=cols)
matrix['date_block_nu... | X_train, X_test, y_train, y_test = train_test_split(X_full, y_full, test_size=.25, random_state=0 ) | Titanic - Machine Learning from Disaster |
9,034,271 | train['revenue'] = train['item_price'] * train['item_cnt_day']<merge> | split_scaler = preprocessing.StandardScaler().fit(X_train)
X_train_standardized = split_scaler.transform(X_train)
X_test_standardized = split_scaler.transform(X_test ) | Titanic - Machine Learning from Disaster |
9,034,271 | group = train.groupby(['date_block_num','shop_id','item_id'] ).agg({'item_cnt_day': ['sum']})
group.columns = ['item_cnt_month']
group.reset_index(inplace=True)
matrix = pd.merge(matrix, group, on=cols, how='left')
matrix['item_cnt_month'] =(matrix['item_cnt_month']
.fillna(0)
.clip(0,20)
.astype(np.float32))
<dat... | if 'model_results' in globals() :
del(model_results ) | Titanic - Machine Learning from Disaster |
9,034,271 | test['date_block_num'] = 34
test['date_block_num'] = test['date_block_num'].astype(np.int8)
test['shop_id'] = test['shop_id'].astype(np.int8)
test['item_id'] = test['item_id'].astype(np.int16 )<concatenate> | def make_logit_model(X_train, y_train):
logitmodel = LogisticRegression(random_state=0,max_iter=500)
gridsearch = GridSearchCV(logitmodel,param_grid={'C':np.logspace(-3,2,6), 'solver':['lbfgs','sag'],\
'tol':np.logspace(-3,1,5)}, cv=10,return_train_score=True,iid=True)\
.fit(X_train, y_train)
logitmodel = gridsearch... | Titanic - Machine Learning from Disaster |
9,034,271 | matrix = pd.concat([matrix, test], ignore_index=True, sort=False, keys=cols)
matrix.fillna(0, inplace=True)
<data_type_conversions> | logitmodel, gridsearch = make_logit_model(X_train_standardized, y_train)
pd.DataFrame(gridsearch.cv_results_)\
.loc[:,['params','mean_test_score','mean_train_score','rank_test_score']]\
.sort_values(by='rank_test_score' ).head(3)
print('Setting logitmodel to {}'.format(gridsearch.best_params_)) | Titanic - Machine Learning from Disaster |
9,034,271 | matrix = pd.merge(matrix, shops, on=['shop_id'], how='left')
matrix = pd.merge(matrix, items, on=['item_id'], how='left')
matrix = pd.merge(matrix, cats, on=['item_category_id'], how='left')
matrix['city_code'] = matrix['city_code'].astype(np.int8)
matrix['item_category_id'] = matrix['item_category_id'].astype(np.i... | logit_predictions = logitmodel.predict(X_test_standardized)
probas_index_class1 = np.where(logitmodel.classes_==1)[0][0]
logit_probas = logitmodel.predict_proba(X_test_standardized)[:,probas_index_class1]
logit_accuracy = logitmodel.score(X_test_standardized, y_test)
logit_crossvalscores = cross_val_score(logitmodel,... | Titanic - Machine Learning from Disaster |
9,034,271 | def lag_feature(df, lags, col):
tmp = df[['date_block_num','shop_id','item_id',col]]
for i in lags:
shifted = tmp.copy()
shifted.columns = ['date_block_num','shop_id','item_id', col+'_lag_'+str(i)]
shifted['date_block_num'] += i
df = pd.merge(df, shifted, on=['date_block_num','shop_id','item_id'], how='left')
return d... | write_model_results('LogisticRegression', logit_accuracy, logit_crossvalscores, logit_predictions, y_test ) | Titanic - Machine Learning from Disaster |
9,034,271 | matrix = lag_feature(matrix, [1,2,3,6,12], 'item_cnt_month' )<merge> | def make_adaboost_model(X_train, y_train):
adaboost = AdaBoostClassifier(n_estimators=50,learning_rate=1,random_state=0)
gridsearch = GridSearchCV(adaboost,param_grid={'n_estimators':[10,60,200], 'learning_rate':np.linspace (.01,1,5), \
'random_state':[0]}, cv=10,return_train_score=True,iid=True)\
.fit(X_train, y_tra... | Titanic - Machine Learning from Disaster |
9,034,271 | def add_group_stats(matrix_, groupby_feats, target, enc_feat, last_periods):
if not 'date_block_num' in groupby_feats:
print('date_block_num must in groupby_feats')
return matrix_
group = matrix_.groupby(groupby_feats)[target].sum().reset_index()
max_lags = np.max(last_periods)
for i in range(1,max_lags+1):
shifted =... | adaboost, gridsearch = make_adaboost_model(X_train_standardized, y_train)
pd.DataFrame(gridsearch.cv_results_)\
.loc[:,['params','mean_test_score','mean_train_score','rank_test_score']]\
.sort_values(by='rank_test_score' ).head(3)
print('Setting adaboost to {}'.format(gridsearch.best_params_)) | Titanic - Machine Learning from Disaster |
9,034,271 | ts = time.time()
matrix = add_group_stats(matrix, ['date_block_num', 'item_id'], 'item_cnt_month', 'item', [6,12])
matrix = add_group_stats(matrix, ['date_block_num', 'shop_id'], 'item_cnt_month', 'shop', [6,12])
matrix = add_group_stats(matrix, ['date_block_num', 'item_category_id'], 'item_cnt_month', 'category', [1... | adaboost_index_class1 = np.where(adaboost.classes_==1)[0][0]
adaboost_predictions = adaboost.predict(X_test_standardized)
adaboost_probas = adaboost.predict_proba(X_test_standardized)[:,probas_index_class1]
adaboost_accuracy = adaboost.score(X_test_standardized,y_test)
adaboost_crossvalscores = cross_val_score(adaboo... | Titanic - Machine Learning from Disaster |
9,034,271 | def target_encoding(matrix_, groupby_feats, target, enc_feat, lags):
print('target encoding for',groupby_feats)
group = matrix_.groupby(groupby_feats ).agg({target:'mean'})
group.columns = [enc_feat]
group.reset_index(inplace=True)
matrix = matrix_.merge(group, on=groupby_feats, how='left')
matrix[enc_feat] = matri... | write_model_results('AdaBoost', adaboost_accuracy, adaboost_crossvalscores, adaboost_predictions, y_test ) | 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.