kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,562,196 | cols = ["numGroups","killPoints","winPoints","killStreaks","kills","longestKill"]<drop_column> | titanic.Ticket.value_counts()
| Titanic - Machine Learning from Disaster |
10,562,196 | for col in cols:
print(col, get_oob(X_train.drop(labels=col, axis=1)) )<define_variables> | titanic['TicketFreq']=titanic.groupby('Ticket')['Ticket'].transform('count')
| Titanic - Machine Learning from Disaster |
10,562,196 | cols = ["killPoints","longestKill"]<drop_column> | titanic['customizedFare']=titanic.Fare/(titanic.TicketFreq*titanic.Pclass ) | Titanic - Machine Learning from Disaster |
10,562,196 | get_oob(X_train.drop(labels=cols, axis=1))<save_model> | titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
10,562,196 | np.save(f'{PATH_TMP}features_keep.npy', np.array(X_train.columns))<load_pretrained> | titanic.loc[(titanic.Age.isnull())&(titanic.Title=='Master'),'Age']=int(4.0 ) | Titanic - Machine Learning from Disaster |
10,562,196 | features_keep = np.load(f'{PATH_TMP}features_keep.npy' )<train_model> | titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
10,562,196 | %%time
reset_rf_samples()
m = RandomForestRegressor(n_estimators=120, max_features=0.5, min_samples_leaf=3, n_jobs=-1)
m.fit(X_train, y_train)
print_score(m )<prepare_x_and_y> | titanic.loc[(titanic.Age.isnull())&(titanic.Sex=='female'),'Age']=int(27.0 ) | Titanic - Machine Learning from Disaster |
10,562,196 | df, y, _ = proc_df(df_raw, 'winPlacePerc', skip_flds=["Id","groupId","matchId"] )<create_dataframe> | titanic[titanic['Title']!='Master'][titanic['Sex']=='male'].Age.median() | Titanic - Machine Learning from Disaster |
10,562,196 | df = df[features_keep].copy()<create_dataframe> | titanic.loc[(titanic.Age.isnull())&(titanic.Sex=='male'),'Age']=int(30.0 ) | Titanic - Machine Learning from Disaster |
10,562,196 | df_test = df_test[features_keep].copy()<split> | titanic['Embarked'].fillna('S',inplace=True)
| Titanic - Machine Learning from Disaster |
10,562,196 | X_train, X_valid, y_train, y_valid = train_test_split(df, y, test_size=0.2)
print(X_train.shape, X_valid.shape, y_train.shape, y_valid.shape )<train_model> | titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
10,562,196 | %%time
reset_rf_samples()
m = RandomForestRegressor(n_estimators=120, max_features=0.5, min_samples_leaf=3, n_jobs=-1)
m.fit(X_train, y_train)
print_score(m )<save_to_csv> | titanic['Family']=titanic['SibSp']+titanic['Parch']+1
titanic=titanic.drop(['SibSp','Parch'],axis=1 ) | Titanic - Machine Learning from Disaster |
10,562,196 | submission = pd.DataFrame({"Id": ids, "winPlacePerc": preds})
submission.to_csv(f'{PATH_WORKING}submission.csv', index=False )<set_options> | def FamilyGroup(family):
a=''
if family<=1:
a='Solo'
elif family<=4:
a='Small'
else:
a='Large'
return a
titanic['FamilyGroup']=titanic['Family'].map(FamilyGroup)
titanic=titanic.drop(['Family'],axis=1 ) | Titanic - Machine Learning from Disaster |
10,562,196 | !pip install ultimate
gc.enable()
<define_variables> | titanic['Cabin']=titanic['Cabin'].notnull().astype(str ).str[0] | Titanic - Machine Learning from Disaster |
10,562,196 | INPUT_DIR = ".. /input/"<load_from_csv> | titanic['Cabin'].isnull().sum() | Titanic - Machine Learning from Disaster |
10,562,196 | def feature_engineering(is_train=True):
if is_train:
print("processing train_V2.csv")
df = pd.read_csv(INPUT_DIR + 'train_V2.csv')
df = df[df['maxPlace'] > 1]
else:
print("processing test_V2.csv")
df = pd.read_csv(INPUT_DIR + 'test_V2.csv')
state('totalDistance')
s = timer()
df['totalDistance'] = df['rideDistance'... | titanic.Cabin.isnull() | Titanic - Machine Learning from Disaster |
10,562,196 | %%time
x_train, y = feature_engineering(True)
scaler = preprocessing.MinMaxScaler(feature_range=(-1, 1), copy=False ).fit(x_train )<train_model> | titanic=titanic.drop(['Fare','PassengerId','TicketFreq','Title','Ticket','Surname'], axis=1)
| Titanic - Machine Learning from Disaster |
10,562,196 | print("x_train", x_train.shape, x_train.max() , x_train.min())
scaler.transform(x_train)
print("x_train", x_train.shape, x_train.max() , x_train.min() )<choose_model_class> | def AgeGroup(age):
a=''
if age<=15:
a='Child'
elif age<=30:
a='Young'
elif age<=50:
a='Adult'
else:
a='Old'
return a
titanic['AgeGroup']=titanic['Age'].map(AgeGroup)
titanic=titanic.drop(['Age'],axis=1 ) | Titanic - Machine Learning from Disaster |
10,562,196 | %%time
NN_model = Sequential()
NN_model.add(Dense(x_train.shape[1], input_dim = x_train.shape[1], activation='relu'))
NN_model.add(Dense(136, activation='relu'))
NN_model.add(Dense(136, activation='relu'))
NN_model.add(Dense(136, activation='relu'))
NN_model.add(Dense(136, activation='relu'))
NN_model.add(Dense(1, acti... | titanic_data=pd.get_dummies(titanic,columns=['Sex','Embarked','FamilyGroup','AgeGroup','Cabin'] ) | Titanic - Machine Learning from Disaster |
10,562,196 | %%time
NN_model.fit(x=x_train, y=y, batch_size=1000,
epochs=30, verbose=1, callbacks=callbacks_list,
validation_split=0.15, validation_data=None, shuffle=True,
class_weight=None, sample_weight=None, initial_epoch=0,
steps_per_epoch=None, validation_steps=None)
del x_train, y
gc.collect()<normalization> | titanic_data.loc[891:1308] | Titanic - Machine Learning from Disaster |
10,562,196 | x_test, _ = feature_engineering(False)
scaler.transform(x_test)
print("x_test", x_test.shape, x_test.max() , x_test.min())
np.clip(x_test, out=x_test, a_min=-1, a_max=1)
print("x_test", x_test.shape, x_test.max() , x_test.min() )<predict_on_test> | train_df = titanic_data.loc[0:890]
train_df['Survived'] = train_results
test_df = titanic_data.loc[891:1308] | Titanic - Machine Learning from Disaster |
10,562,196 | %%time
pred = NN_model.predict(x_test)
del x_test
gc.collect()<prepare_output> | X=train_df.drop(['Survived'],axis=1)
X.head()
y=train_df.Survived
y.head()
| Titanic - Machine Learning from Disaster |
10,562,196 | pred = pred.reshape(-1)
pred =(pred + 1)/ 2<load_from_csv> | Titanic - Machine Learning from Disaster | |
10,562,196 | df_test = pd.read_csv(INPUT_DIR + 'test_V2.csv' )<feature_engineering> | xgbr=XGBClassifier(n_estimators=2800,
min_child_weight=0.1,
learning_rate=0.002,
max_depth=2,
subsample=0.47,
colsample_bytree=0.35,
gamma=0.4,
reg_lambda=0.4,
random_state=42,
n_jobs=-1,)
xgbr.fit(X,y)
predicts=xgbr.predict(test_df)
| Titanic - Machine Learning from Disaster |
10,562,196 | <feature_engineering><EOS> | submission = pd.DataFrame({
"PassengerId": test_data["PassengerId"],
"Survived": predicts
})
submission.Survived = submission.Survived.round().astype("int")
submission.to_csv('titanic.csv', index=False)
print("Submitted Successfully")
| Titanic - Machine Learning from Disaster |
3,382,545 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_to_csv> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
| Titanic - Machine Learning from Disaster |
3,382,545 | submission = df_test[['Id', 'winPlacePerc']]
submission.to_csv('submission.csv', index=False )<load_from_csv> | train_data = pd.read_csv('.. /input/train.csv')
test_data = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
3,382,545 | train_data_df = pd.read_csv('.. /input/train_V2.csv')
test_data_df = pd.read_csv('.. /input/test_V2.csv' )<feature_engineering> | from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
3,382,545 | train_data_df.insert(loc=28, column='totalDistance', value=train_data_df['swimDistance'] + train_data_df['walkDistance'] + train_data_df['rideDistance'])
test_data_df.insert(loc=28, column='totalDistance', value=test_data_df['swimDistance'] + test_data_df['walkDistance'] + test_data_df['rideDistance'] )<categorify> | model = XGBClassifier() | Titanic - Machine Learning from Disaster |
3,382,545 | train_data_df = train_data_df.replace({'matchType' : {'crashfpp':0, 'crashtpp':1, 'duo':2, 'duo-fpp':3, 'flarefpp':4, 'flaretpp':5, 'normal-duo':6, 'normal-duo-fpp':7, 'normal-solo':8, 'normal-solo-fpp':9, 'normal-squad':10, 'normal-squad-fpp':11, 'solo':12, 'solo-fpp':13, 'squad':14, 'squad-fpp':15}})
test_data_df = ... | train_data["Sex"] = train_data["Sex"].fillna("NA")
train_data["Embarked"] = train_data["Embarked"].fillna("C")
test_data["Sex"] = test_data["Sex"].fillna("NA")
test_data["Embarked"] = test_data["Embarked"].fillna("C")
train_data[['Pclass', 'Age', 'SibSp', 'Fare']] = train_data[['Pclass', 'Age', 'SibSp', 'Fare']].fi... | Titanic - Machine Learning from Disaster |
3,382,545 | train_data_df = reduce_mem_usage(train_data_df)
test_data_df = reduce_mem_usage(test_data_df )<merge> | genders = {'male': 0, 'female': 1, 'NA': 2}
embarks = {'C': 0, 'Q': 1, 'S': 2,}
train_data['Sex'] = train_data['Sex'].apply(lambda x: genders[x])
train_data['Embarked'] = train_data['Embarked'].apply(lambda x: embarks[x])
test_data['Sex'] = test_data['Sex'].apply(lambda x: genders[x])
test_data['Embarked'] = test_da... | Titanic - Machine Learning from Disaster |
3,382,545 | groupedGroups = train_data_df.groupby(['matchId','groupId'])[columns]
print("Add group mean features")
group_features = groupedGroups.agg('mean')
group_rank_features = group_features.groupby(['matchId'])[columns].rank(pct=True ).reset_index()
features = pd.merge(group_features, group_rank_features, on=['matchId', 'gr... | X = train_data[['Pclass', 'Sex', 'Age', 'SibSp', 'Embarked', 'Fare']]
Y = train_data['Survived'] | Titanic - Machine Learning from Disaster |
3,382,545 | groupedMatches = train_data_df.groupby(['matchId'])[columns]
print("Add match mean features")
match_features = groupedMatches.agg('mean')[columns].reset_index()
features = pd.merge(features, match_features, on=['matchId'], how='right', suffixes=['', '_match_mean'])
print("Add match size features")
match_features = t... | sc = StandardScaler()
X = sc.fit_transform(X ) | Titanic - Machine Learning from Disaster |
3,382,545 | features = features.fillna(0.0 )<groupby> | trainX, testX, trainY, testY = train_test_split(X, Y, test_size=0.2, random_state=42 ) | Titanic - Machine Learning from Disaster |
3,382,545 | train_targets = train_data_df.groupby(['matchId', 'groupId'])['winPlacePerc'].agg('mean' ).reset_index() ['winPlacePerc']<prepare_output> | model.fit(trainX, trainY ) | Titanic - Machine Learning from Disaster |
3,382,545 | train_targets = train_targets.values<import_modules> | predict = model.predict(testX ) | Titanic - Machine Learning from Disaster |
3,382,545 | import sklearn<normalization> | from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
3,382,545 | train_features = features.drop(['matchId', 'groupId'], axis=1 ).values
scaler = MinMaxScaler(feature_range=(-1, 1)).fit(train_features)
train_features = scaler.transform(train_features )<correct_missing_values> | accuracy_score(predict, testY ) | Titanic - Machine Learning from Disaster |
3,382,545 | train_features = np.delete(train_features, 266069, 0)
train_targets = np.delete(train_targets, 266069, 0 )<import_modules> | from sklearn.ensemble import RandomForestClassifier | Titanic - Machine Learning from Disaster |
3,382,545 | import ultimate
from ultimate.mlp import MLP<train_model> | model_f = RandomForestClassifier() | Titanic - Machine Learning from Disaster |
3,382,545 | epoch_train = 15
model = MLP(layer_size=[train_features.shape[1], 32, 32, 32, 1], regularization=1, output_shrink=0.1, output_range=[0,1], loss_type="hardmse")
model.train(train_features, train_targets, iteration_log=20000, rate_init=0.08, rate_decay=0.8, epoch_train=epoch_train, epoch_decay=1 )<merge> | model_f.fit(trainX, trainY ) | Titanic - Machine Learning from Disaster |
3,382,545 | groupedGroups = test_data_df.groupby(['matchId','groupId'])[columns]
print("Add group mean features")
group_features = groupedGroups.agg('mean')
group_rank_features = group_features.groupby(['matchId'])[columns].rank(pct=True ).reset_index()
features = pd.merge(group_features, group_rank_features, on=['matchId', 'gro... | predict_f = model_f.predict(testX ) | Titanic - Machine Learning from Disaster |
3,382,545 | groupedMatches = test_data_df.groupby(['matchId'])[columns]
print("Add match mean features")
match_features = groupedMatches.agg('mean')[columns].reset_index()
features = pd.merge(features, match_features, on=['matchId'], how='right', suffixes=['', '_match_mean'])
print("Add match size features")
match_features = te... | accuracy_score(predict_f, testY ) | Titanic - Machine Learning from Disaster |
3,382,545 | test_features = features.drop(['matchId', 'groupId'], axis=1 ).values
test_features = scaler.transform(test_features )<predict_on_test> | from sklearn.svm import SVC | Titanic - Machine Learning from Disaster |
3,382,545 | predictions = model.predict(test_features )<groupby> | model_svm = SVC(gamma='scale', decision_function_shape='ovo' ) | Titanic - Machine Learning from Disaster |
3,382,545 | features['winPlacePercPred'] = predictions
group_preds = features.groupby(['matchId', 'groupId'])['winPlacePercPred'].agg('mean' ).groupby(['matchId'] ).rank(pct=True )<define_variables> | model_svm.fit(trainX, trainY ) | Titanic - Machine Learning from Disaster |
3,382,545 | dictionary = dict(zip(features['groupId'].values, group_preds.values))<prepare_output> | predict_svm = model_svm.predict(testX ) | Titanic - Machine Learning from Disaster |
3,382,545 | individual_preds = []
for i in test_data_df['groupId'].values:
individual_preds.append(dictionary[i])
test_data_df['winPlacePercPred'] = individual_preds<create_dataframe> | accuracy_score(predict_f, testY ) | Titanic - Machine Learning from Disaster |
3,382,545 | predictions = pd.DataFrame(np.transpose(np.array([test_data_df['Id'], test_data_df['winPlacePercPred']])))
predictions.columns = ['Id', 'winPlacePerc']<prepare_output> | from sklearn.neural_network import MLPClassifier | Titanic - Machine Learning from Disaster |
3,382,545 | maxPlaces = test_data_df['maxPlace'].values
new_predictions = predictions['winPlacePerc'].values
for i in range(0, len(test_data_df)) :
if maxPlaces[i] == 0:
new_predictions[i] = 0.0
if maxPlaces[i] == 1:
new_predictions[i] = 1.0
else:
gap = 1.0 /(maxPlaces[i] - 1.0)
new_predictions[i] = round(new_predictions[i]/gap)*... | model_nn = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(5, 2), random_state=1 ) | Titanic - Machine Learning from Disaster |
3,382,545 | predictions['winPlacePerc'] = new_predictions<save_to_csv> | model_nn.fit(trainX, trainY ) | Titanic - Machine Learning from Disaster |
3,382,545 | predictions.to_csv('PUBG_preds.csv', index=False )<define_variables> | predict_nn = model_nn.predict(testX ) | Titanic - Machine Learning from Disaster |
3,382,545 | def get_sample(df,n):
idxs = sorted(np.random.permutation(len(df)) [:n])
return df.iloc[idxs].copy()
def proc_df(df, y_fld, skip_flds=None, do_scale=False, na_dict=None,
preproc_fn=None, max_n_cat=None, subset=None, mapper=None):
if not skip_flds: skip_flds=[]
if subset: df = get_sample(df,subset)
df = df.copy()
... | accuracy_score(predict_nn, testY ) | Titanic - Machine Learning from Disaster |
3,382,545 | train = pd.read_csv(KAGGLE_DIR + 'train_V2.csv')
test = pd.read_csv(KAGGLE_DIR + 'test_V2.csv' )<train_model> | test_df = test_data[['Pclass', 'Sex', 'Age', 'SibSp', 'Embarked', 'Fare']]
test_df = sc.transform(test_df)
final_predictions = model_svm.predict(test_df ) | Titanic - Machine Learning from Disaster |
3,382,545 | <filter><EOS> | submission = pd.DataFrame({
"PassengerId": test_data["PassengerId"],
"Survived": final_predictions
})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,984,731 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<drop_column> | warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
11,984,731 | train.drop(2744604, inplace=True )<filter> | data = pd.read_csv(".. /input/titanic/train.csv")
print(data.shape)
data.head() | Titanic - Machine Learning from Disaster |
11,984,731 | train[train['winPlacePerc'].isnull() ]<feature_engineering> | data_explore = data.copy() | Titanic - Machine Learning from Disaster |
11,984,731 | train['killsNorm'] = train['kills']*(( 100-train['playersJoined'])/100 + 1)
train['damageDealtNorm'] = train['damageDealt']*(( 100-train['playersJoined'])/100 + 1)
train['maxPlaceNorm'] = train['maxPlace']*(( 100-train['playersJoined'])/100 + 1)
train['matchDurationNorm'] = train['matchDuration']*(( 100-train['playe... | data_explore = data_explore.drop(columns=['PassengerId', 'Name', 'Ticket', 'Cabin'], axis=1)
data_explore.shape | Titanic - Machine Learning from Disaster |
11,984,731 | train['healsandboosts'] = train['heals'] + train['boosts']
train[['heals', 'boosts', 'healsandboosts']].tail()<feature_engineering> | max_embarked = data_explore['Embarked'].value_counts().idxmax()
data_explore['Embarked'] = data_explore['Embarked'].fillna(max_embarked ) | Titanic - Machine Learning from Disaster |
11,984,731 | train['totalDistance'] = train['rideDistance'] + train['walkDistance'] + train['swimDistance']
train['killsWithoutMoving'] =(( train['kills'] > 0)&(train['totalDistance'] == 0))<feature_engineering> | data_explore['Family'] = data_explore['SibSp'] + data_explore['Parch']
data_explore['Family'].loc[data_explore['Family'] > 0] = "Yes"
data_explore['Family'].loc[data_explore['Family'] == 0] = "No" | Titanic - Machine Learning from Disaster |
11,984,731 | train['headshot_rate'] = train['headshotKills'] / train['kills']
train['headshot_rate'] = train['headshot_rate'].fillna(0 )<drop_column> | label_encoder = LabelEncoder()
data_explore["sex_enc"] = label_encoder.fit_transform(data_explore["Sex"])
print(label_encoder.classes_)
data_explore["embarked_enc"] = label_encoder.fit_transform(data_explore['Embarked'])
print(label_encoder.classes_)
data_explore["Family_enc"] = label_encoder.fit_transform(data_exp... | Titanic - Machine Learning from Disaster |
11,984,731 | train.drop(train[train['killsWithoutMoving'] == True].index, inplace=True )<filter> | def fill_with_mean(df, num_cols):
for col in num_cols:
total_null = df[col].isna().sum()
if total_null>0:
mean = df[col].mean()
std = df[col].std()
lower = mean - std
upper = mean + std
random_values = np.random.randint(lower, upper, total_null)
df[col][np.isnan(df[col])] = random_values.copy()
return df | Titanic - Machine Learning from Disaster |
11,984,731 | train[train['roadKills'] > 10]<drop_column> | data_explore = fill_with_mean(data_explore, ['Age'] ) | Titanic - Machine Learning from Disaster |
11,984,731 | train.drop(train[train['roadKills'] > 10].index, inplace=True )<drop_column> | data_explore_survived = data_explore[data_explore['Survived']==1]
data_explore_not_survived = data_explore[data_explore['Survived']==0] | Titanic - Machine Learning from Disaster |
11,984,731 | train.drop(train[train['kills'] > 30].index, inplace=True )<drop_column> | def get_person_type(passanger):
age, sex = passanger
return 'child' if age < 16 else sex
data_explore["Person"] = data_explore[["Age", "Sex"]].apply(get_person_type, axis=1)
data_explore_survived = data_explore[data_explore['Survived']==1]
data_explore_not_survived = data_explore[data_explore['Survived']==0]
data_expl... | Titanic - Machine Learning from Disaster |
11,984,731 | train.drop(train[train['longestKill'] >= 1000].index, inplace=True )<drop_column> | overall_age = dict(data_explore["Person"].value_counts())
overall_age = sorted(overall_age.items())
overall_age_values = [item[1] for item in overall_age]
overall_age_label = [item[0] for item in overall_age]
survived_age = dict(data_explore_survived["Person"].value_counts())
survived_age = sorted(survived_age.items... | Titanic - Machine Learning from Disaster |
11,984,731 | train.drop(train[train['walkDistance'] >= 10000].index, inplace=True )<drop_column> | overall_embarked = dict(data_explore["Embarked"].value_counts())
overall_embarked = sorted(overall_embarked.items())
overall_embarked_values = [item[1] for item in overall_embarked]
overall_embarked_labels = [item[0] for item in overall_embarked]
survived_embarked = dict(data_explore_survived["Embarked"].value_counts... | Titanic - Machine Learning from Disaster |
11,984,731 | train.drop(train[train['rideDistance'] >= 20000].index, inplace=True )<filter> | overall_pclass = dict(data_explore["Pclass"].value_counts())
overall_pclass = sorted(overall_pclass.items())
overall_pclass_labels = ["Upper Class", "Middle Class", "Lower Class"]
overall_pclass_values = [item[1] for item in overall_pclass]
survived_pclass = dict(data_explore_survived["Pclass"].value_counts())
survi... | Titanic - Machine Learning from Disaster |
11,984,731 | train[train['swimDistance'] >= 2000]<drop_column> | overall_family = dict(data_explore["Family"].value_counts())
overall_family = sorted(overall_family.items())
overall_family_labels = ["No", "Yes"]
overall_family_values = [item[1] for item in overall_family]
survived_family = dict(data_explore_survived["Family"].value_counts())
survived_family = sorted(survived_fami... | Titanic - Machine Learning from Disaster |
11,984,731 | train.drop(train[train['swimDistance'] >= 2000].index, inplace=True )<drop_column> | corr_matrix['Survived'].sort_values(ascending=False ) | Titanic - Machine Learning from Disaster |
11,984,731 | train.drop(train[train['weaponsAcquired'] >= 80].index, inplace=True )<drop_column> | from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.base import BaseEstimator, TransformerMixin | Titanic - Machine Learning from Disaster |
11,984,731 | train.drop(train[train['heals'] >= 40].index, inplace=True )<count_unique_values> | X = data.drop(columns=['Survived'], axis=1)
y = data['Survived'].copy()
X.shape, X.columns | Titanic - Machine Learning from Disaster |
11,984,731 | print('There are {} different Match types in the dataset.'.format(train['matchType'].nunique()))<categorify> | split = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
for train_index, test_index in split.split(X, y):
strat_train_set = data.iloc[train_index]
strat_test_set = data.iloc[test_index]
X_train = strat_train_set.drop('Survived', axis=1)
y_train = strat_train_set['Survived'].copy()
X_test = strat_te... | Titanic - Machine Learning from Disaster |
11,984,731 | train = pd.get_dummies(train, columns=['matchType'])
matchType_encoding = train.filter(regex='matchType')
matchType_encoding.head()<data_type_conversions> | def fill_with_mean(df, num_cols):
for col in num_cols:
total_null = df[col].isna().sum()
if total_null>0:
mean = df[col].mean()
std = df[col].std()
lower = mean - std
upper = mean + std
random_values = np.random.randint(lower, upper, total_null)
df[col][np.isnan(df[col])] = random_values.copy()
return df | Titanic - Machine Learning from Disaster |
11,984,731 | train['groupId'] = train['groupId'].astype('category')
train['matchId'] = train['matchId'].astype('category')
train['groupId_cat'] = train['groupId'].cat.codes
train['matchId_cat'] = train['matchId'].cat.codes
train.drop(columns=['groupId', 'matchId'], inplace=True)
train[['groupId_cat', 'matchId_cat']].head()<drop_... | class AddCustomAttribute(BaseEstimator, TransformerMixin):
def __init__(self):
self.cat_imp=None
self.cat_encoder=None
self.scaler=None
def fit(self, X, y=None):
return self
def transform(self, X):
try:
X = fill_with_mean(X, ['Age', 'SibSp', 'Parch'])
if self.cat_imp==None:
self.cat_imp = SimpleImputer(strategy="m... | Titanic - Machine Learning from Disaster |
11,984,731 | train.drop(columns = ['Id'], inplace=True )<prepare_x_and_y> | class FillWithMeanSD(BaseEstimator, TransformerMixin):
def __init__(self):
pass
def fit(self, X, y=None):
return self
def transform(self, X):
try:
num_cols = X.columns
for col in num_cols:
total_null_fare = X[col].isna().sum()
if total_null_fare>0:
mean = X[col].mean()
std = X[col].std()
lower = mean - std
upper = mean... | Titanic - Machine Learning from Disaster |
11,984,731 | df = df_sample.drop(columns = ['winPlacePerc'])
y = df_sample['winPlacePerc']<split> | cat_pipeline = Pipeline([('cat_imputer', SimpleImputer(strategy="most_frequent")) ,
('cat_encoder', OneHotEncoder())])
num_pipeline = Pipeline([('num_imputer', FillWithMeanSD()),
('scaler', StandardScaler())])
pre_process = ColumnTransformer([('drop_attrs', 'drop', ['PassengerId', 'Name', 'Ticket', 'Cabin']),
('nu... | Titanic - Machine Learning from Disaster |
11,984,731 | def split_vals(a, n : int):
return a[:n].copy() , a[n:].copy()
val_perc = 0.12
n_valid = int(val_perc * sample)
n_trn = len(df)-n_valid
raw_train, raw_valid = split_vals(df_sample, n_trn)
X_train, X_valid = split_vals(df, n_trn)
y_train, y_valid = split_vals(y, n_trn)
print('Sample train shape: ', X_train.shape,
'S... | feature_columns = ['Pclass', 'Fare', 'C', 'Q', 'S', 'Age', 'person_child', 'person_female', 'person_male',
'family_no', 'family_yes'] | Titanic - Machine Learning from Disaster |
11,984,731 | def print_score(m : RandomForestRegressor):
res = ['mae train: ', mean_absolute_error(m.predict(X_train), y_train),
'mae val: ', mean_absolute_error(m.predict(X_valid), y_valid)]
if hasattr(m, 'oob_score_'): res.append(m.oob_score_)
print(res )<train_model> | kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42 ) | Titanic - Machine Learning from Disaster |
11,984,731 | m1 = RandomForestRegressor(n_estimators=40, min_samples_leaf=3, max_features='sqrt',
n_jobs=-1)
m1.fit(X_train, y_train)
print_score(m1 )<compute_train_metric> | lgr_grid_parm=[{'solver':['liblinear', 'lbfgs'], 'C':list(np.linspace(0.01, 1, 15)) , 'penalty':['l1', 'l2'], 'class_weight':[None, 'balanced']}]
lgr_grid_search = GridSearchCV(LogisticRegression(random_state=42, n_jobs=-1),
lgr_grid_parm, cv=kf, scoring="accuracy", return_train_score=True, n_jobs=-1)
lgr_grid_search.... | Titanic - Machine Learning from Disaster |
11,984,731 | fi = rf_feat_importance(m1, df); fi[:10]<features_selection> | lgr_grid_search.best_params_, lgr_grid_search.best_score_ | Titanic - Machine Learning from Disaster |
11,984,731 | to_keep = fi[fi.imp>0.005].cols
print('Significant features: ', len(to_keep))
to_keep<split> | train_models = []
train_models.append(['Logistic Regression', lgr_grid_search.best_params_, lgr_grid_search.best_score_] ) | Titanic - Machine Learning from Disaster |
11,984,731 | df_keep = df[to_keep].copy()
X_train, X_valid = split_vals(df_keep, n_trn )<train_model> | best_lgr_clf = lgr_grid_search.best_estimator_
best_lgr_clf | Titanic - Machine Learning from Disaster |
11,984,731 | m2 = RandomForestRegressor(n_estimators=80, min_samples_leaf=3, max_features='sqrt',
n_jobs=-1)
m2.fit(X_train, y_train)
print_score(m2 )<split> | svc_grid_parm=[{'C':list(np.linspace(0.01, 1, 20)) , 'penalty':['l1', 'l2'], 'class_weight':[None, 'balanced']}]
svc_grid_search = GridSearchCV(LinearSVC(loss="hinge", random_state=42), svc_grid_parm, cv=kf, scoring="accuracy",
return_train_score=True, n_jobs=-1)
svc_grid_search.fit(X_train_transformed, y_train ) | Titanic - Machine Learning from Disaster |
11,984,731 | val_perc_full = 0.12
n_valid_full = int(val_perc_full * len(train))
n_trn_full = len(train)-n_valid_full
df_full = train.drop(columns = ['winPlacePerc'])
y = train['winPlacePerc']
df_full = df_full[to_keep]
X_train, X_valid = split_vals(df_full, n_trn_full)
y_train, y_valid = split_vals(y, n_trn_full)
print('Sample ... | svc_grid_search.best_params_, svc_grid_search.best_score_ | Titanic - Machine Learning from Disaster |
11,984,731 | m3 = RandomForestRegressor(n_estimators=70, min_samples_leaf=3, max_features=0.5,
n_jobs=-1)
m3.fit(X_train, y_train)
print_score(m3 )<feature_engineering> | best_svc_clf = svc_grid_search.best_estimator_
best_svc_clf | Titanic - Machine Learning from Disaster |
11,984,731 | test['headshot_rate'] = test['headshotKills'] / test['kills']
test['headshot_rate'] = test['headshot_rate'].fillna(0)
test['totalDistance'] = test['rideDistance'] + test['walkDistance'] + test['swimDistance']
test['playersJoined'] = test.groupby('matchId')['matchId'].transform('count')
test['killsNorm'] = test['kills... | rf_grid_parm=[{'n_estimators':[50, 100, 200, 300], 'max_depth':[6, 8, 16],
'class_weight':['balanced', 'balanced_subsample', None]}]
rf_grid_search = GridSearchCV(RandomForestClassifier(random_state=42, n_jobs=-1), rf_grid_parm, cv=kf,
scoring="accuracy", return_train_score=True, n_jobs=-1)
rf_grid_search.fit(X_train_... | Titanic - Machine Learning from Disaster |
11,984,731 | predictions = np.clip(a = m3.predict(test_pred), a_min = 0.0, a_max = 1.0)
pred_df = pd.DataFrame({'Id' : test['Id'], 'winPlacePerc' : predictions})
pred_df.to_csv("submission.csv", index=False )<load_from_csv> | rf_grid_search.best_params_, rf_grid_search.best_score_ | Titanic - Machine Learning from Disaster |
11,984,731 | train_data_df = pd.read_csv('.. /input/train.csv')
test_data_df = pd.read_csv('.. /input/test.csv' )<normalization> | best_rf_clf = rf_grid_search.best_estimator_
best_rf_clf | Titanic - Machine Learning from Disaster |
11,984,731 | train_data_df = reduce_mem_usage(train_data_df)
test_data_df = reduce_mem_usage(test_data_df )<groupby> | xgb_grid_parm=[{'n_estimators':[50, 100, 200], 'max_depth':[4, 8, 16, 24], 'subsample':[0.5, 0.75, 1.0],
'colsample_bytree':[0.5, 0.75, 1.0], 'gamma':[0, 0.25, 0.5, 0.75, 1.0]}]
xgb_grid_search = GridSearchCV(XGBClassifier(objective='binary:logistic', learning_rate=0.1, random_state=42,
n_jobs=-1), xgb_grid_parm, cv=kf... | Titanic - Machine Learning from Disaster |
11,984,731 | mean_match_features = train_data_df.groupby(['matchId'])[train_data_df.columns[3:-1]].agg('mean' ).reset_index().loc[:, 'assists':'winPoints']
size_match_features = pd.DataFrame(train_data_df.groupby(['matchId'])[train_data_df.columns[3]].agg('size' ).reset_index() [train_data_df.columns[3]])
size_match_features.colum... | xgb_grid_search.best_params_, xgb_grid_search.best_score_ | Titanic - Machine Learning from Disaster |
11,984,731 | mean_group_features = train_data_df.groupby(['matchId','groupId'])[train_data_df.columns[3:-1]].agg('mean' ).reset_index().loc[:, 'assists':'winPoints']
max_group_features = train_data_df.groupby(['matchId','groupId'])[train_data_df.columns[3:-1]].agg('max' ).reset_index().loc[:, 'assists':'winPoints']
min_group_featur... | best_xgb_clf = xgb_grid_search.best_estimator_
best_xgb_clf | Titanic - Machine Learning from Disaster |
11,984,731 | features_three = mean_group_features.join(max_group_features, lsuffix='_group_mean', rsuffix='_group_max')
features_four = min_group_features.join(size_group_features, lsuffix='_group_min', rsuffix='_group_size')
features_2 = features_three.join(features_four)
features_2['matchId'] = train_data_df.groupby(['matchId'... | named_estimators = [('logistic', best_lgr_clf),('linear_svc', best_svc_clf),
('forest', best_rf_clf),('xgb', best_xgb_clf)] | Titanic - Machine Learning from Disaster |
11,984,731 | features = pd.merge(features_2, features_1, on='matchId', how='right' )<drop_column> | stack_clf = StackingClassifier(estimators=named_estimators, cv=kf, passthrough=False, n_jobs=-1)
stack_clf.fit(X_train_transformed, y_train ) | Titanic - Machine Learning from Disaster |
11,984,731 | features = features.drop(['matchId'], axis=1)
features<groupby> | stack_acc = cross_val_score(stack_clf, X_train_transformed, y_train, scoring="accuracy", cv=kf, n_jobs=-1)
stack_acc = np.round(np.median(stack_acc), 4)
train_models.append(['Stacking Classifier', '', stack_acc] ) | Titanic - Machine Learning from Disaster |
11,984,731 | targets = train_data_df.groupby(['matchId', 'groupId'])['winPlacePerc'].agg('mean' ).reset_index() ['winPlacePerc']
targets<groupby> | voting_clf = VotingClassifier(estimators=named_estimators, n_jobs=-1)
voting_clf.fit(X_train_transformed, y_train ) | Titanic - Machine Learning from Disaster |
11,984,731 | train_data_df.groupby(['matchId', 'groupId'])['winPlacePerc'].agg('max' )<define_variables> | voting_acc = cross_val_score(voting_clf, X_train_transformed, y_train, scoring="accuracy", cv=kf, n_jobs=-1)
voting_acc = np.round(np.mean(voting_acc), 4)
train_models.append(['Voting Classifier', '', voting_acc] ) | Titanic - Machine Learning from Disaster |
11,984,731 | train_features = features.values[0:np.int32(0.8*len(features)) ]
train_targets = targets.values[0:np.int32(0.8*len(features)) ]
val_features = features.values[np.int32(0.8*len(features)) :len(features)]
val_targets = targets.values[np.int32(0.8*len(features)) :len(features)]<import_modules> | pd.set_option('display.max_colwidth', -1)
train_models_df = pd.DataFrame(train_models, columns=['Model', 'Best Paramas', 'Accuracy'])
train_models_df | Titanic - Machine Learning from Disaster |
11,984,731 | import sklearn<normalization> | results = dict()
best_models = [best_lgr_clf, best_svc_clf, best_rf_clf, best_xgb_clf, stack_clf, voting_clf]
model_names = []
model_accuracy = []
for model in best_models:
test_accuracy_scores = cross_val_score(model, X_test_transformed, y_test, scoring="accuracy", cv=kf, n_jobs=-1)
test_accuracy_scores = np.round(te... | 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.