kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
2,064,952 | kappa_metrics = Metrics()
history = model.fit_generator(
data_generator,
steps_per_epoch=x_train.shape[0] / BATCH_SIZE,
epochs=15,
validation_data=(x_val, y_val)
)<predict_on_test> | salutation = [i.split(",")[1].split(".")[0].strip() for i in combdata["Name"]]
combdata["Title"] = pd.Series(salutation)
combdata["Title"].value_counts() | Titanic - Machine Learning from Disaster |
2,064,952 | y_test = model.predict(x_test)
y_test<filter> | combdata['Title'] = combdata['Title'].replace('Mlle', 'Miss')
combdata['Title'] = combdata['Title'].replace(['Mme','Lady','Ms'], 'Mrs')
combdata.Title.loc[(combdata.Title != 'Master')&(combdata.Title != 'Mr')&
(combdata.Title != 'Miss')&(combdata.Title != 'Mrs')] = 'Others'
combdata["Title"].value_counts() | Titanic - Machine Learning from Disaster |
2,064,952 | y_test = y_test > 0.37757874193797547
y_test<data_type_conversions> | combdata[['Title', 'Survived']].groupby(['Title'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
2,064,952 | y_test.astype(int ).sum(axis=1 )<data_type_conversions> | combdata = pd.get_dummies(combdata, columns = ["Title"] ) | Titanic - Machine Learning from Disaster |
2,064,952 | y_test.astype(int ).sum(axis=1)- 1<data_type_conversions> | combdata["Fare"].isnull().sum()
combdata["Fare"] = combdata["Fare"].fillna(combdata["Fare"].median())
| Titanic - Machine Learning from Disaster |
2,064,952 | y_test = y_test.astype(int ).sum(axis=1)- 1
y_test<save_to_csv> | combdata['Fare-bin'] = pd.qcut(combdata.Fare,5,labels=[1,2,3,4,5] ).astype(int)
combdata[['Fare-bin', 'Survived']].groupby(['Fare-bin'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
2,064,952 | test_df['diagnosis'] = y_test
test_df.to_csv('submission.csv',index=False )<set_options> | Titanic - Machine Learning from Disaster | |
2,064,952 | warnings.filterwarnings("ignore")
gc.enable()
print(os.listdir(".. /input"))
<load_from_csv> | combdata_temp = combdata[['Age','Title_Master','Title_Miss','Title_Mr','Title_Mrs','Title_Others','Fare-bin','SibSp']]
X = combdata_temp.dropna().drop('Age', axis=1)
Y = combdata['Age'].dropna()
holdout = combdata_temp.loc[np.isnan(combdata.Age)].drop('Age', axis=1)
regressor = RandomForestRegressor(n_estimators = 30... | Titanic - Machine Learning from Disaster |
2,064,952 | def feature_engineering(is_train=True,debug=True):
if is_train:
print("processing train.csv")
if debug == True:
df = pd.read_csv('.. /input/train_V2.csv', nrows=10000)
else:
df = pd.read_csv('.. /input/train_V2.csv')
df = df[df['maxPlace'] > 1]
else:
print("processing test.csv")
df = pd.read_csv('.. /input/test_V2.... | bins = [ 0, 4, 12, 18, 30, 50, 65, 100]
age_index =(1,2,3,4,5,6,7)
combdata['Age-bin'] = pd.cut(combdata.Age, bins, labels=age_index ).astype(int)
combdata[['Age-bin', 'Survived']].groupby(['Age-bin'],as_index=False ).mean() | Titanic - Machine Learning from Disaster |
2,064,952 | x_train, y_train = feature_engineering(True,False)
x_test, _ = feature_engineering(False,True )<drop_column> | combdata["Sex"] = combdata["Sex"].map({"male": 0, "female":1})
| Titanic - Machine Learning from Disaster |
2,064,952 | x_train = reduce_mem_usage(x_train)
x_test = reduce_mem_usage(x_test )<load_from_csv> | combdata["Fsize"] = combdata["SibSp"] + combdata["Parch"] + 1
combdata[['Fsize', 'Survived']].groupby(['Fsize'], as_index=False ).mean()
| Titanic - Machine Learning from Disaster |
2,064,952 | def post_rst(pred_test):
df_sub = pd.read_csv(".. /input/sample_submission_V2.csv")
df_test = pd.read_csv(".. /input/test_V2.csv")
df_sub['winPlacePerc'] = pred_test
df_sub = df_sub.merge(df_test[["Id", "matchId", "groupId", "maxPlace", "numGroups"]], on="Id", how="left")
df_sub_group = df_sub.groupby(["matchId", "g... | combdata = combdata.drop(labels='SibSp', axis=1 ) | Titanic - Machine Learning from Disaster |
2,064,952 | def nn_model(input_shape=x_train.shape[1], hidden_size=64):
model = Sequential()
model.add(Dense(hidden_size, input_dim=input_shape, kernel_initializer='normal'))
model.add(LeakyReLU(0.1))
model.add(Dense(hidden_size, kernel_initializer='normal'))
model.add(LeakyReLU(0.1))
model.add(Dense(hidden_size, kernel_initialize... | combdata = combdata.drop(labels='Parch', axis=1 ) | Titanic - Machine Learning from Disaster |
2,064,952 | def train_val_split(x_train, y_train):
train_index = round(int(x_train.shape[0]*0.8))
dev_X = x_train[:train_index]
val_X = x_train[train_index:]
dev_y = y_train[:train_index]
val_y = y_train[train_index:]
del x_train, y_train
gc.collect() ;
return dev_X, val_X, dev_y, val_y<split> | combdata.Ticket = combdata.Ticket.map(lambda x: x[0])
combdata[['Ticket', 'Survived']].groupby(['Ticket'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
2,064,952 | dev_X, val_X, dev_y, val_y = train_val_split(x_train, y_train)
def run_lgb(train_X, train_y, val_X, val_y, x_test):
params = {"objective" : "regression", "metric" : "mae", 'n_estimators':5000, 'early_stopping_rounds':200,
"num_leaves" : 150, "learning_rate" : 0.05, "bagging_fraction" : 0.5,
"bagging_seed" : 0, "num_th... | combdata['Ticket'].value_counts() | Titanic - Machine Learning from Disaster |
2,064,952 | np.random.seed(42)
std_scaler = StandardScaler().fit(x_train)
x_train = std_scaler.transform(x_train)
x_test = std_scaler.transform(x_test)
mlp_model = nn_model(x_train.shape[1], hidden_size=64)
mlp_model.fit(x_train, y_train, batch_size=128, epochs=8, verbose=1, validation_split=0.1, shuffle=True)
pred_test_mlp ... | combdata['Ticket'] = combdata['Ticket'].replace(['A','W','F','L','5','6','7','8','9'], '4')
combdata[['Ticket', 'Survived']].groupby(['Ticket'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
2,064,952 | del x_train, y_train, x_test
gc.collect()<define_variables> | combdata = pd.get_dummies(combdata, columns = ["Ticket"], prefix="T" ) | Titanic - Machine Learning from Disaster |
2,064,952 | pred_test =(pred_test_mlp + pred_test_lgb)/ 2.0<import_modules> | combdata["Cabin"] = pd.Series([i[0] if not pd.isnull(i)else 'U' for i in combdata['Cabin'] ] ) | Titanic - Machine Learning from Disaster |
2,064,952 | import numpy as np
import pandas as pd
import os
<set_options> | combdata = combdata.drop(labels='Cabin', axis=1 ) | Titanic - Machine Learning from Disaster |
2,064,952 | mpl.rcParams['font.sans-serif'] = ['FangSong']
mpl.rcParams['axes.unicode_minus'] = False
%matplotlib inline
sns.set_style('darkgrid')
sns.set_palette('bone')
warnings.filterwarnings('ignore')
gc.enable()
INPUT_DIR = ".. /input/"<data_type_conversions> | combdata = combdata.drop(labels='Embarked', axis=1 ) | Titanic - Machine Learning from Disaster |
2,064,952 | def fillInf(df, val):
numcols = df.select_dtypes(include='number' ).columns
cols = numcols[numcols != 'winPlacePerc']
df[df == np.Inf] = np.NaN
df[df == np.NINF] = np.NaN
for c in cols: df[c].fillna(val, inplace=True )<load_from_csv> | combdata =combdata.drop(labels=['Age', 'Fare', 'Name'],axis = 1 ) | Titanic - Machine Learning from Disaster |
2,064,952 | def feature_engineering(is_train=True):
if is_train:
print("processing train.csv")
df = pd.read_csv(INPUT_DIR + 'train_V2.csv')
df = df[df['maxPlace'] > 1]
else:
print("processing test.csv")
df = pd.read_csv(INPUT_DIR + 'test_V2.csv')
df.dropna(inplace=True)
df['totalDistance'] = df['rideDistance'] + df["walkDista... | from sklearn.svm import SVC
from collections import Counter
from sklearn.tree import DecisionTreeClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.discriminant_analysis import LinearDiscriminant... | Titanic - Machine Learning from Disaster |
2,064,952 | x_train, y, feature_names = feature_engineering(True)
scaler = MinMaxScaler(feature_range=(-1, 1), copy=False ).fit(x_train)
scaler.transform(x_train )<normalization> | train = combdata.loc[combdata['source']=="train"]
test = combdata.loc[combdata['source']=="test"]
test.drop(labels=["Survived"],axis = 1,inplace=True)
train.drop(labels=["source"],axis = 1,inplace=True)
test.drop(labels=["source"],axis = 1,inplace=True)
test.shape | Titanic - Machine Learning from Disaster |
2,064,952 | x_prediction, _, _ = feature_engineering(False)
scaler = MinMaxScaler(feature_range=(-1, 1), copy=False ).fit(x_prediction)
scaler.transform(x_prediction )<split> | train["Survived"] = train["Survived"].astype(int)
Y_train = train["Survived"]
X_train = train.drop(labels = ["Survived"],axis = 1)
X_train.shape | Titanic - Machine Learning from Disaster |
2,064,952 | X_train,X_test, y_train, y_test =train_test_split(x_train,y,test_size=0.3, random_state=0 )<train_model> | kfold = StratifiedKFold(n_splits=10 ) | Titanic - Machine Learning from Disaster |
2,064,952 | %%time
linreg = LinearRegression()
linreg.fit(X_train, y_train)
print(linreg.intercept_)
print(linreg.coef_ )<compute_test_metric> | random_state = 2
classifiers = []
classifiers.append(KNeighborsClassifier())
classifiers.append(LinearDiscriminantAnalysis())
classifiers.append(SVC(random_state=random_state))
classifiers.append(MLPClassifier(random_state=random_state))
classifiers.append(ExtraTreesClassifier(random_state=random_state))
classifiers.... | Titanic - Machine Learning from Disaster |
2,064,952 |
<compute_test_metric> | DTC = DecisionTreeClassifier()
adaDTC = AdaBoostClassifier(DTC, random_state=7)
ada_param_grid = {"base_estimator__criterion" : ["gini", "entropy"],
"base_estimator__splitter" : ["best", "random"],
"algorithm" : ["SAMME","SAMME.R"],
"n_estimators" :[1,2],
"learning_rate": [0.0001, 0.001, 0.01, 0.1, 0.2, 0.3,1.5]}
gsad... | Titanic - Machine Learning from Disaster |
2,064,952 |
<predict_on_test> | ExtC = ExtraTreesClassifier()
ex_param_grid = {"max_depth": [None],
"max_features": [1, 3, 10],
"min_samples_split": [2, 3, 10],
"min_samples_leaf": [1, 3, 10],
"bootstrap": [False],
"n_estimators" :[100,300],
"criterion": ["gini"]}
gsExtC = GridSearchCV(ExtC,param_grid = ex_param_grid, cv=kfold, scoring="accuracy", n_... | Titanic - Machine Learning from Disaster |
2,064,952 | %%time
result = linreg.predict(x_prediction )<load_from_csv> | RFC = RandomForestClassifier()
rf_param_grid = {"max_depth": [None],
"max_features": [1, 3, 10],
"min_samples_split": [2, 3, 10],
"min_samples_leaf": [1, 3, 10],
"bootstrap": [False],
"n_estimators" :[100,300],
"criterion": ["gini"]}
gsRFC = GridSearchCV(RFC,param_grid = rf_param_grid, cv=kfold, scoring="accuracy", n_j... | Titanic - Machine Learning from Disaster |
2,064,952 | %%time
test_data = pd.read_csv(INPUT_DIR+'test_V2.csv')
print("fix winPlacePerc")
for i in range(len(test_data)) :
winPlacePerc = result[i]
maxPlace = int(test_data.iloc[i]['maxPlace'])
if maxPlace == 0:
winPlacePerc = 0.0
elif maxPlace == 1:
winPlacePerc = 1.0
else:
gap = 1.0 /(maxPlace - 1)
winPlacePerc = round(w... | GBC = GradientBoostingClassifier()
gb_param_grid = {'loss' : ["deviance"],
'n_estimators' : [100,200,300],
'learning_rate': [0.1, 0.05, 0.01],
'max_depth': [4, 8],
'min_samples_leaf': [100,150],
'max_features': [0.3, 0.1]
}
gsGBC = GridSearchCV(GBC,param_grid = gb_param_grid, cv=kfold, scoring="accuracy", n_jobs= 4, ve... | Titanic - Machine Learning from Disaster |
2,064,952 | f3=open(INPUT_DIR+'sample_submission_V2.csv')
submit=pd.read_csv(f3)
sample_result = pd.DataFrame(result,columns = ['winPlacePerc'])
submit['winPlacePerc'] = sample_result
submit.to_csv(r'sample_submission_lineregression.csv', index=False)
del f3,result,submit
gc.collect()<train_model> | SVMC = SVC(probability=True)
svc_param_grid = {'kernel': ['rbf'],
'gamma': [ 0.001, 0.01, 0.1, 1],
'C': [1, 10, 50, 100,200,300, 1000]}
gsSVMC = GridSearchCV(SVMC,param_grid = svc_param_grid, cv=kfold, scoring="accuracy", n_jobs= 4, verbose = 1)
gsSVMC.fit(X_train,Y_train)
SVMC_best = gsSVMC.best_estimator_
gsSVMC.b... | Titanic - Machine Learning from Disaster |
2,064,952 | %%time
model_lasso = Lasso(alpha=0.001)
model_lasso.fit(X_train, y_train)
print(model_lasso.intercept_)
print(model_lasso.coef_ )<predict_on_test> | votingC = VotingClassifier(estimators=[('rfc', RFC_best),('extc', ExtC_best),
('svc', SVMC_best),('adac',ada_best),('gbc',GBC_best)], voting='soft', n_jobs=4)
votingC = votingC.fit(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
2,064,952 | %%time
predicted_lasso = model_lasso.predict(x_prediction )<load_from_csv> | test_Survived = pd.Series(votingC.predict(test), name="Survived")
results = pd.concat([IDtest,test_Survived],axis=1)
results.to_csv("Final Submission File.csv",index=False ) | Titanic - Machine Learning from Disaster |
10,345,958 | %%time
test_data = pd.read_csv(INPUT_DIR+'test_V2.csv')
print("fix winPlacePerc")
for i in range(len(test_data)) :
winPlacePerc = predicted_lasso[i]
maxPlace = int(test_data.iloc[i]['maxPlace'])
if maxPlace == 0:
winPlacePerc = 0.0
elif maxPlace == 1:
winPlacePerc = 1.0
else:
gap = 1.0 /(maxPlace - 1)
winPlacePerc ... | import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.preprocessing import LabelEncoder
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cro... | Titanic - Machine Learning from Disaster |
10,345,958 | f4=open(INPUT_DIR+'sample_submission_V2.csv')
submit_lasso=pd.read_csv(f4)
sample_result_lasso = pd.DataFrame(predicted_lasso,columns = ['winPlacePerc'])
submit_lasso['winPlacePerc'] = sample_result_lasso
submit_lasso.to_csv(r'sample_submission_lasso.csv', index=False)
del f4,submit_lasso,sample_result_lasso
gc.col... | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
10,345,958 | %%time
model_ridge = Ridge(alpha=0.5994842503189409)
model_ridge.fit(X_train, y_train)
print(model_ridge.intercept_)
print(model_ridge.coef_ )<predict_on_test> | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
10,345,958 | %%time
predicted_ridge = model_ridge.predict(x_prediction )<load_from_csv> | train_df = pd.read_csv('/kaggle/input/titanic/train.csv')
test_df = pd.read_csv('/kaggle/input/titanic/test.csv')
print(train_df.shape)
print(test_df.shape)
train_df.head() | Titanic - Machine Learning from Disaster |
10,345,958 | %%time
test_data = pd.read_csv(INPUT_DIR+'test_V2.csv')
print("fix winPlacePerc")
for i in range(len(test_data)) :
winPlacePerc = predicted_ridge[i]
maxPlace = int(test_data.iloc[i]['maxPlace'])
if maxPlace == 0:
winPlacePerc = 0.0
elif maxPlace == 1:
winPlacePerc = 1.0
else:
gap = 1.0 /(maxPlace - 1)
winPlacePerc ... | train_df[['Pclass','Survived']].groupby('Pclass' ).mean().sort_values(by = 'Survived', ascending = False ) | Titanic - Machine Learning from Disaster |
10,345,958 | f5=open(INPUT_DIR+'sample_submission_V2.csv')
submit_ridge=pd.read_csv(f5)
sample_result_ridge = pd.DataFrame(predicted_ridge,columns = ['winPlacePerc'])
submit_ridge['winPlacePerc'] = sample_result_ridge
submit_ridge.to_csv(r'sample_submission_ridge.csv', index=False)
del f5,submit_ridge,sample_result_ridge
gc.col... | train_df[['Sex','Survived']].groupby('Sex' ).mean().sort_values(by = 'Survived', ascending = False ) | Titanic - Machine Learning from Disaster |
10,345,958 | %%time
model_elasticnet = ElasticNet(alpha=1.6152516038498196e-06, copy_X=True, fit_intercept=True, l1_ratio=0.5,
max_iter=1000, normalize=False, positive=False, precompute=False,
random_state=0, selection='cyclic', tol=0.0001, warm_start=False)
model_elasticnet.fit(X_train, y_train)
print(model_elasticnet.intercept_... | train_df[['SibSp','Survived']].groupby('SibSp' ).mean().sort_values(by = 'Survived', ascending = False ) | Titanic - Machine Learning from Disaster |
10,345,958 | %%time
predicted_elasticNet = model_elasticnet.predict(x_prediction )<load_from_csv> | train_df[['Parch','Survived']].groupby('Parch' ).mean().sort_values(by = 'Survived', ascending = False ) | Titanic - Machine Learning from Disaster |
10,345,958 | %%time
test_data = pd.read_csv(INPUT_DIR+'test_V2.csv')
print("fix winPlacePerc")
for i in range(len(test_data)) :
winPlacePerc = predicted_elasticNet[i]
maxPlace = int(test_data.iloc[i]['maxPlace'])
if maxPlace == 0:
winPlacePerc = 0.0
elif maxPlace == 1:
winPlacePerc = 1.0
else:
gap = 1.0 /(maxPlace - 1)
winPlace... | labelencoder = LabelEncoder()
train_df['Sex'] = labelencoder.fit_transform(train_df['Sex'])
test_df['Sex'] = labelencoder.fit_transform(test_df['Sex'])
test_df.head() | Titanic - Machine Learning from Disaster |
10,345,958 | f6=open(INPUT_DIR+'sample_submission_V2.csv')
submit_elasticNet=pd.read_csv(f6)
sample_result_elasticNet = pd.DataFrame(predicted_elasticNet,columns = ['winPlacePerc'])
submit_elasticNet['winPlacePerc'] = sample_result_elasticNet
submit_elasticNet.to_csv(r'sample_submission_elasticNet.csv', index=False)
del f6,subm... | train_df['Family size'] = train_df['SibSp'] + train_df['Parch'] + 1
test_df['Family size'] = test_df['SibSp'] + test_df['Parch'] + 1
train_df[['Family size','Survived']].groupby('Family size' ).mean().sort_values(by = 'Survived', ascending = False ) | Titanic - Machine Learning from Disaster |
10,345,958 | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Lasso
from catboost import CatBoostRegressor
from sklearn.metrics import mean_absolute_error
from sklearn.preprocessing import StandardScaler,MinMaxScaler<load_fro... | train_df['Fam_type'] = pd.cut(train_df['Family size'], [0,1,4,7,11], labels=['Solo', 'Small', 'Big', 'Very big'])
test_df['Fam_type'] = pd.cut(test_df['Family size'], [0,1,4,7,11], labels=['Solo', 'Small', 'Big', 'Very big'] ) | Titanic - Machine Learning from Disaster |
10,345,958 | train=pd.read_csv('.. /input/train_V2.csv')
test=pd.read_csv('.. /input/test_V2.csv')
ID=test['Id']<count_missing_values> | combine = [train_df, test_df]
for dataset in combine:
dataset['Title'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False)
pd.crosstab(train_df['Title'], train_df['Sex'] ) | Titanic - Machine Learning from Disaster |
10,345,958 | train.isna().sum()<correct_missing_values> | for dataset in combine:
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
dataset['Title'] = dataset['Title'].replace('Mme', 'Mrs')
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Don', 'Sir', 'Jonkheer', 'Dona'],'Royalty')
dataset... | Titanic - Machine Learning from Disaster |
10,345,958 | train=train.dropna(axis=0 )<prepare_x_and_y> | y = train_df['Survived']
features = ['Pclass','Sex','Fam_type','Fare','Age Bin','Embarked']
X = train_df[features]
X.head() | Titanic - Machine Learning from Disaster |
10,345,958 | y_train=train['winPlacePerc']
train=train.drop(['winPlacePerc'],axis=1 )<categorify> | numerical_col = ['Fare']
categorical_col = ['Pclass','Sex','Fam_type','Age Bin','Embarked']
num_trans = SimpleImputer(strategy = 'median')
cat_trans = Pipeline(steps = [
('imputer',SimpleImputer(strategy = 'most_frequent')) ,
('onehot',OneHotEncoder())
])
preprocessor = ColumnTransformer(
transformers = [
('num'... | Titanic - Machine Learning from Disaster |
10,345,958 | train["playersInMatch"] = train.groupby("matchId")["Id"].transform("count")
train["playersInGroup"] = train.groupby("groupId")["Id"].transform("count")
test["playersInMatch"] = test.groupby("matchId")["Id"].transform("count")
test["playersInGroup"] = test.groupby("groupId")["Id"].transform("count" )<categorify> | numerical_col = ['Fare']
categorical_col = ['Pclass','Sex','Fam_type','Age Bin','Embarked']
num_trans = SimpleImputer(strategy = 'median')
cat_trans = Pipeline(steps = [
('imputer',SimpleImputer(strategy = 'most_frequent')) ,
('onehot',OneHotEncoder())
])
preprocessor = ColumnTransformer(
transformers = [
('num'... | Titanic - Machine Learning from Disaster |
10,345,958 | <categorify><EOS> | predictions = titanic_pipeline.predict(X_test)
output = pd.DataFrame({'PassengerId': test_df.PassengerId, 'Survived': predictions})
output.to_csv('my_submission2.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
12,392,871 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | import pandas as pd
import numpy as np
from sklearn.model_selection import cross_validate
from sklearn.gaussian_process.kernels import RBF, WhiteKernel, ConstantKernel, RationalQuadratic, DotProduct,Matern
from sklearn.gaussian_process import GaussianProcessClassifier
| Titanic - Machine Learning from Disaster |
12,392,871 | train['LastMan'] = train.groupby('groupId')['matchDuration'].transform('max')
test['LastMan'] = test.groupby('groupId')['matchDuration'].transform('max' )<feature_engineering> | train_df = pd.read_csv('.. /input/titanic/train.csv')
test_df = pd.read_csv('.. /input/titanic/test.csv')
for test_set,df in enumerate([train_df, test_df]):
df['Title'] = df.Name.str.extract('([A-Za-z]+)\.', expand=False)
df['Title'] = df['Title'].replace(['Lady', 'Countess','Capt', 'Col',
'Don', 'Dr', 'Major', 'Rev... | Titanic - Machine Learning from Disaster |
12,392,871 | train['Survival'] = train['LastMan'] - train['FirstMan']
test['Survival'] = test['LastMan'] - test['FirstMan']<feature_engineering> | ls = np.ones(( dx,))
kernels = [ConstantKernel() * RBF(ls)+ WhiteKernel() ,
ConstantKernel() * Matern(ls)+ WhiteKernel() ,
]
best_score = 0
for kernel in kernels:
classifier = GaussianProcessClassifier(kernel=kernel,n_restarts_optimizer=5)
classifier.fit(X_train, y_train)
result = cross_validate(classifier,X_train, y... | Titanic - Machine Learning from Disaster |
12,392,871 | train['Position'] = train['killPlace'] /(train['maxPlace'] + 1e-9)
test['Position'] = test['killPlace'] /(test['maxPlace'] + 1e-9 )<drop_column> | predictions = best_classifier.predict(X_test ).astype(int)
output = pd.DataFrame({'PassengerId': test_df.PassengerId,
'Survived': predictions})
print(best_classifier.kernel)
print(output)
output.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
10,757,188 | train.drop(["matchId","groupId",'Id','killPoints', 'maxPlace', 'winPoints','vehicleDestroys'],axis=1,inplace=True)
test.drop(["matchId","groupId",'Id','killPoints', 'maxPlace', 'winPoints','vehicleDestroys'],axis=1,inplace=True )<feature_engineering> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head(5 ) | Titanic - Machine Learning from Disaster |
10,757,188 | train['headshotrate'] = train['kills'] /(train['headshotKills'] + 1e-9)
test['headshotrate'] = test['kills'] /(test['headshotKills'] + 1e-9)
train['killStreakrate'] = train['killStreaks'] /(train['kills'] + 1e-9)
test['killStreakrate'] = test['killStreaks'] /(test['kills'] + 1e-9 )<feature_engineering> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head(5 ) | Titanic - Machine Learning from Disaster |
10,757,188 | train['TotalDamage'] = train['damageDealt'] + train['teamKills']*100
test['TotalDamage'] = test['damageDealt'] + test['teamKills']*100<feature_engineering> | data_dict = {}
data_dict['train data'] = train_data
data_dict['test data'] = test_data;
| Titanic - Machine Learning from Disaster |
10,757,188 | train['Noob']=(train['matchDuration'] < train['matchDuration'].mean())
test['Noob']=(test['matchDuration'] < train['matchDuration'].mean() )<feature_engineering> | compare_features(train_data, 'Pclass','Age' ) | Titanic - Machine Learning from Disaster |
10,757,188 | train['Sniper']=(train['longestKill']>=250)
test['Sniper']=(test['longestKill']>=250 )<feature_engineering> | compare_features(train_data, 'SibSp', 'Survived' ) | Titanic - Machine Learning from Disaster |
10,757,188 | train['ProAim']=(train['headshotKills']/(train['kills']+1e-9))
test['ProAim']=(test['headshotKills']/(test['kills']+1e-9))<feature_engineering> | compare_features(train_data, 'Parch', 'Survived' ) | Titanic - Machine Learning from Disaster |
10,757,188 | train['distance'] =(train['rideDistance']+train['swimDistance']+train['walkDistance'])
test['distance'] =(test['rideDistance']+test['swimDistance']+test['walkDistance'])
train['distance'] = np.log1p(train['distance'])
test['distance'] = np.log1p(test['distance'] )<define_variables> | compare_features(train_data, 'Embarked', 'Survived' ) | Titanic - Machine Learning from Disaster |
10,757,188 | set1=set(i for i in train[(train['kills']>40)&(train['heals']==0)].index.tolist())
set2=set(i for i in train[(train['distance']==0)&(train['kills']>20)].index.tolist())
set3=set(i for i in train[(train['damageDealt']>4000)&(train['heals']<2)].index.tolist())
set4=set(i for i in train[(train['rideDistance']>25000)].i... | train_data.groupby(['Embarked'] ).mean().drop(['PassengerId', 'SibSp', 'Parch'], axis=1 ) | Titanic - Machine Learning from Disaster |
10,757,188 | train=train.drop(list(sets))
y_train=y_train.drop(list(sets))
<feature_engineering> | def concat_data(data_1, data_2):
return pd.concat([data_1, data_2], sort=False ).reset_index(drop=True)
def divide_data(all_data):
return all_data.loc[:890], all_data.loc[891:].drop(['Survived'], axis=1)
data_all = concat_data(train_data, test_data)
data_fs = [train_data, test_data] | Titanic - Machine Learning from Disaster |
10,757,188 | fpp=['crashfpp','duo-fpp','flare-fpp','normal-duo-fpp','normal-solo-fpp','normal-squad-fpp','solo-fpp','squad-fpp']
train["fpp"] = np.where(train["matchType"].isin(fpp),1,0)
test["fpp"] = np.where(test["matchType"].isin(fpp),1,0 )<define_variables> | miss_data_dict = {}
for key, dataset in data_dict.items() :
miss_abs = dataset.isnull().sum()
miss_rel = miss_abs / dataset.isnull().count()
col_abs = '{}: missing values(absolut)'.format(key)
col_rel = '{}: missing values(relative in %)'.format(key)
if key == 'test data':
miss_data_dict[key] = pd.concat([miss_abs.so... | Titanic - Machine Learning from Disaster |
10,757,188 | change={'crashfpp':'crash',
'crashtpp':'crash',
'duo':'duo',
'duo-fpp':'duo',
'flarefpp':'flare',
'flaretpp':'flare',
'normal-duo':'duo',
'normal-duo-fpp':'duo',
'normal-solo':'solo',
'normal-solo-fpp':'solo',
'normal-squad':'squad',
'normal-squad-fpp':'squad',
'solo-fpp':'solo',
'squad-fpp':'squad',
'solo':'solo',
'sq... | msno.matrix(test_data,figsize=(9,2),width_ratios=(10,1))
miss_data_dict['test data'].head() | Titanic - Machine Learning from Disaster |
10,757,188 | modes={'crash':1,
'duo':2,
'flare':3,
'solo':4,
'squad':5
}
train['matchType']=train['matchType'].map(modes)
test['matchType']=test['matchType'].map(modes )<categorify> | data_all.groupby(['Pclass', 'Sex'])['Age'].mean() | Titanic - Machine Learning from Disaster |
10,757,188 | d1=pd.get_dummies(train['matchType'])
train=train.drop(['matchType'],axis=1)
train=train.join(d1)
d2=pd.get_dummies(test['matchType'])
test=test.drop(['matchType'],axis=1)
test=test.join(d2)
<normalization> | index = data_all['Age'].index[data_all['Age'].apply(np.isnan)]
data_all.loc[index, ['Pclass', 'Sex', 'Age']] | Titanic - Machine Learning from Disaster |
10,757,188 | scaler = MinMaxScaler()
scaler.fit(train)
train=scaler.transform(train)
test=scaler.transform(test )<create_dataframe> | data_all['Age'] = data_all.groupby(['Pclass', 'Sex'])['Age'].apply(lambda x: x.fillna(x.mean()))
train_data, test_data = divide_data(data_all)
data_dict['train data'] = train_data
data_dict['test data'] = test_data
data_all.loc[index, ['Pclass', 'Sex', 'Age']] | Titanic - Machine Learning from Disaster |
10,757,188 | df = pd.DataFrame(train)
df.isnull().sum()<split> | data_all.Cabin = data_all.Cabin.fillna('Unknown')
data_all['Deck'] = data_all['Cabin'].str[0] | Titanic - Machine Learning from Disaster |
10,757,188 | X_train,X_test,y_train,y_test= train_test_split(train,y_train,test_size=0.3 )<train_model> | data_all.groupby(['Pclass'] ).Deck.value_counts() | Titanic - Machine Learning from Disaster |
10,757,188 | lm = Lasso(alpha=1e-5)
lm.fit(X_train,y_train )<compute_test_metric> | data_all.groupby(['Deck'] ).mean().drop(['PassengerId', 'SibSp', 'Parch'], axis=1 ) | Titanic - Machine Learning from Disaster |
10,757,188 | train_mse =(mean_absolute_error(y_train,lm.predict(X_train)))
test_mse =(mean_absolute_error(y_test, lm.predict(X_test)))
train_mse,test_mse<predict_on_test> | deck_avg_fare = data_all.groupby(['Deck'] ).Fare.mean().drop('U')
deck_avg_fare | Titanic - Machine Learning from Disaster |
10,757,188 | y_train = y_train - lm.predict(X_train)
y_test = y_test - lm.predict(X_test )<define_variables> | indices_U = data_all[data_all['Deck'] == 'U'].index
for i in indices_U:
fare = data_all.iloc[i].Fare
nearest_avg_fare = min(deck_avg_fare, key=lambda x:abs(x-fare))
deck = deck_avg_fare[deck_avg_fare == nearest_avg_fare].index[0]
data_all['Deck'].iloc[i] = deck
train_data, test_data = divide_data(data_all)
data_dict['... | Titanic - Machine Learning from Disaster |
10,757,188 | train_pool = Pool(X_train, y_train)
test_pool = Pool(X_test, y_test )<choose_model_class> | data_all.loc[indices_U, ['Fare', 'Deck']] | Titanic - Machine Learning from Disaster |
10,757,188 | model = CatBoostRegressor(
iterations=5000,
depth=10,
learning_rate=0.1,
l2_leaf_reg= 2,
loss_function='RMSE',
eval_metric='MAE',
random_strength=0.1,
bootstrap_type='Bernoulli',
leaf_estimation_method='Gradient',
leaf_estimation_iterations=1,
boosting_type='Plain'
,task_type = "GPU"
,feature_border_type='GreedyLogSum... | def handle_missing_data(data, miss_abs):
for col in data:
miss_prop = data[col].isna().sum() /len(data)
if miss_prop < 0.5:
if data[col].dtype == "float64" and data[col].isnull().sum() > 0:
mean = data[col].mean()
data[col] = data[col].fillna(mean)
print("Filling {} missing values in {} with mean value {:.0f}.".forma... | Titanic - Machine Learning from Disaster |
10,757,188 | model.fit(train_pool, eval_set=test_pool )<compute_test_metric> | for key, dataset in data_dict.items() :
print('{} operations:'.format(key))
miss_abs = miss_data_dict[key]['{}: missing values(absolut)'.format(key)]
miss_rel = miss_data_dict[key]['{}: missing values(relative in %)'.format(key)]
data_dict[key] = handle_missing_data(dataset, miss_abs ) | Titanic - Machine Learning from Disaster |
10,757,188 | train_mse =(mean_absolute_error(y_train,lm.predict(X_train)+ model.predict(X_train)))
test_mse =(mean_absolute_error(y_test, lm.predict(X_test)+ model.predict(X_test)))
print('Train error= ',train_mse)
print('Test error= ',test_mse)
<save_to_csv> | def title_extract(data):
data['Title'] = data['Name'].str.split(',', expand=True)[1].str.split('.', expand=True)[0] | Titanic - Machine Learning from Disaster |
10,757,188 | subm = pd.read_csv('.. /input/sample_submission_V2.csv')
predictions = model.predict(test)+ lm.predict(test)
test = pd.read_csv('.. /input/test_V2.csv')
test['winPlacePerc'] = predictions
test['winPlacePerc'] = test.groupby('groupId')['winPlacePerc'].transform('median')
subm['winPlacePerc'] = test['winPlacePerc']
s... | for key, dataset in data_dict.items() :
title = title_extract(dataset)
data_all = concat_data(train_data, test_data)
data_all['Title'].value_counts() | Titanic - Machine Learning from Disaster |
10,757,188 | kernel_start_time = datetime.datetime.now()
train_path = '.. /input/train_V2.csv'
test_path = '.. /input/test_V2.csv'
print(os.listdir(".. /input"))
<data_type_conversions> | title_names =(data_all['Title'].value_counts() < 10)
for key, dataset in data_dict.items() :
dataset['Title'] = dataset['Title'].apply(lambda x: 'Misc' if title_names.loc[x] == True else x)
data_all = concat_data(train_data, test_data)
print(data_all['Title'].value_counts() ) | Titanic - Machine Learning from Disaster |
10,757,188 | data_types = {'Id':str,'groupId':str,'matchId':str,'assists':np.int8,'boosts':np.int8,'damageDealt':np.float16,'DBNOs':np.int8,
'headshotKills':np.int8,'heals':np.int8,'killPlace':np.int8,'killPoints':np.int16,'kills':np.int8,'killStreaks':np.int8,'longestKill':np.float16,
'matchDuration':np.int16,'matchType':str,'maxP... | for key, dataset in data_dict.items() :
dataset['Age'] = dataset['Age'].astype('int', copy=True)
age_labels = [1,2,3,4,5]
dataset['Age interval'] = pd.cut(data_all['Age'].astype('int'),5)
dataset['Age Code'] = pd.cut(data_all['Age'],5, labels=age_labels ).astype('int64')
data_all = concat_data(train_data, test_data)... | Titanic - Machine Learning from Disaster |
10,757,188 | zero_stdev_cols = ['median_match_roadKills', 'median_match_vehicleDestroys', 'median_match_road_kills_per_rideDistance', 'std_match_longestKill']
ulesess_stat_cols = ['median_match_revives','median_match_teamKills','median_match_swimDistance_norm',
'max_match_kill_streak_rate','max_group_roadKills','min_group_roadKills... | for key, dataset in data_dict.items() :
fare_labels = [1,2,3,4,5]
dataset['Fare interval'] = pd.qcut(data_all['Fare'], 5)
dataset['Fare Code'] = pd.qcut(data_all['Fare'], 5, labels=fare_labels ).astype('int64')
data_all = concat_data(train_data, test_data)
print('Number of cases per fare category in dataset(approx.e... | Titanic - Machine Learning from Disaster |
10,757,188 | def fix_missing_ranks(X, mean_ranks=None, rank_stds=None, rank_cols=['rankPoints', 'winPoints']):
if(mean_ranks is None)or(rank_stds is None):
mean_ranks = {}
rank_stds = {}
for rank_col in rank_cols:
mean_ranks[rank_col] = X.loc[X[rank_col] > 1, rank_col].mean()
rank_stds[rank_col] = X.loc[X[rank_col] > 1, rank_col].s... | for key, dataset in data_dict.items() :
dataset['Family Size'] = dataset ['SibSp'] + dataset['Parch'] + 1
data_all = concat_data(train_data, test_data ) | Titanic - Machine Learning from Disaster |
10,757,188 | def add_player_features(X):
X['headshot_rate'] = X['headshotKills'] /(X['kills'] + 0.00001)
X['kill_streak_rate'] = X['killStreaks'] /(X['kills'] + 0.00001)
X['kills_assists'] = X['kills'] + X['assists']
X['heals_boosts'] = X['heals'] + X['boosts']
X['total_distance'] = X['walkDistance'] + X['rideDistance'] + X['swim... | family_mapping =(lambda s: 1 if s == 1 else(2 if s == 2 else(3 if 3 <= s <= 4 else(4 if s >= 5 else 0))))
for key, dataset in data_dict.items() :
dataset['Family Size Code'] = dataset['Family Size'].map(family_mapping)
data_all = concat_data(train_data, test_data)
data_all['Family Size Code'].value_counts() | Titanic - Machine Learning from Disaster |
10,757,188 | def create_basic_group_info(X):
group_cols = ['matchId', 'groupId', 'matchDuration', 'matchType', 'maxPlace', 'numGroups', 'maxPlace_per_numGroups', 'winPlacePerc', 'killPlace']
if 'winPlacePerc' not in X.columns:
group_cols.remove('winPlacePerc')
pl_data_grouped = X[group_cols].groupby(['matchId', 'groupId'])
gr_dat... | for key, dataset in data_dict.items() :
dataset['Mother'] = np.where(( dataset.Title == 'Mrs')&(dataset.Parch >0),1,0)
data_all = concat_data(train_data, test_data ) | Titanic - Machine Learning from Disaster |
10,757,188 | def create_group_and_match_stats(data, gr_data):
group_stats_cols = ['assists','boosts','DBNOs','killPoints','longestKill','rankPoints', 'road_kills_per_rideDistance',
'kills_assists_norm_both', 'damageDealt_norm_both', 'DBNOs_norm', 'heals_boosts', 'assists_per_kill', 'killPlace_norm',
'revives','roadKills','teamKills... | for key, dataset in data_dict.items() :
dataset['Ticket Frequency'] = data_all.groupby('Ticket')['Ticket'].transform('count')
data_all = concat_data(train_data, test_data ) | Titanic - Machine Learning from Disaster |
10,757,188 | def remove_outliers(X):
outliers =(X['walkDistance'] > 10000)|(X['rideDistance'] > 15000)|(X['swimDistance'] > 1000)|(( X['kills'] > 0)&(X['total_distance'] == 0))
outliers = outliers |(X['kills'] > 30)|(X['longestKill'] > 800)|(X['weaponsAcquired'] > 40)
X = X.loc[~outliers]
outlier_data = X.loc[outliers]
return X, o... | X_train = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[ features])
X_test.head() | Titanic - Machine Learning from Disaster |
10,757,188 | class DataPipeline() :
def __init__(self, pipeline=None):
if pipeline is not None:
self.rank_means = pipeline.rank_means
self.rank_stds = pipeline.rank_stds
return
def fit_transform(self, data_path):
data = pd.read_csv(data_path)
for col_name, col_type in data_types.items() :
data[col_name] = data[col_name].astype(col... | y = train_data['Survived'] | Titanic - Machine Learning from Disaster |
10,757,188 | <data_type_conversions><EOS> | model = RandomForestClassifier(n_estimators=1800,
max_depth=8,
min_samples_split=6,
min_samples_leaf=6,
max_features='auto',
oob_score=True,
random_state=42,
n_jobs=-1,
verbose=1)
model.fit(X_train, y)
predictions = model.predict(X_test)
acc_random_forest = round(model.score(X_train, y)* 100, 2)
print(acc_random_fo... | Titanic - Machine Learning from Disaster |
10,257,425 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | %matplotlib inline
sns.set_style('whitegrid')
ExtraTreesClassifier, GradientBoostingClassifier, VotingClassifier)
LogisticRegression, PassiveAggressiveClassifier, RidgeClassifier)
data_raw = pd.read_csv('/kaggle/input/titanic/train.csv')
data_test = pd.read_csv('/kaggle/input/titanic/test.csv')
train = data_raw.co... | Titanic - Machine Learning from Disaster |
10,257,425 | def get_data_batch(batch_size, randomize=False):
if randomize:
curr_idx = np.random.permutation(train.shape[0])
else:
curr_idx = range(train.shape[0])
for batch_n in range(int(np.ceil(train.shape[0] / batch_size))):
batch_data = train.iloc[curr_idx[batch_n*batch_size:(batch_n+1)*batch_size]]
group_sizes = batch_data[... | for dataset in data_all:
dataset.drop(['Ticket', 'Cabin'], axis=1, inplace=True)
dataset['Fare'].fillna(dataset['Fare'].median() , inplace=True)
dataset['Embarked'].fillna(dataset['Embarked'].mode() [0], inplace=True)
for c in set(dataset['Pclass']):
for s in set(dataset['Sex']):
age_median = dataset[(dataset['Pclas... | Titanic - Machine Learning from Disaster |
10,257,425 | dropout_rate = [0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5]
def leaky_relu(z, name=None):
return tf.maximum(0.01*z, z, name=name)
tf.reset_default_graph()
dynamic_dropout = tf.placeholder_with_default(0.5, shape=(None), name='dynamic_dropout')
X = tf.placeholder(dtype=tf.float32, shape=[None, train.shape[1]-3], name='X')
y =... | train = train.dropna(axis=0, subset=['Survived'])
targ_col = 'Survived'
feature_cols = ['Pclass', 'FamilySize', 'IsAlone', 'Sex_Code', 'Embarked_Code',
'Title_Code', 'AgeBin_Code', 'FareBin_Code']
| Titanic - Machine Learning from Disaster |
10,257,425 | with tf.name_scope('loss')as scope:
diff_vector = tf.abs(tf.reshape(output, shape=[-1])- y)
sum_group_sizes = tf.reduce_sum(group_sizes)
loss_mse = tf.reduce_sum(tf.square(diff_vector)*group_sizes)/sum_group_sizes
loss_mae = tf.reduce_sum(diff_vector*group_sizes)/sum_group_sizes
clipped_diff_vector = tf.clip_by_value... | classifiers = [
KNeighborsClassifier(**{'n_jobs': -1, 'n_neighbors': 7}),
SVC(**{'C': 0.390625, 'kernel': 'poly', 'probability': True, 'random_state': 0}),
LinearSVC(**{'C': 25.0, 'dual': False, 'loss': 'squared_hinge', 'max_iter': 25000, 'penalty': 'l1', 'random_state': 0}),
DecisionTreeClassifier(**{'criterion': 'ent... | Titanic - Machine Learning from Disaster |
10,257,425 | gc.collect()
batch_size = 5000
n_epochs = 1000
max_epochs_wo_improvement = 50
max_epochs_wo_lr_change = 10
max_time = 2
loss_data = {'mse_train':[], 'mae_train':[], 'lr':[]}
start_time = datetime.datetime.now()
def get_dropout(initial_dropout, epoch):
return np.maximum(0, initial_dropout*(1 - epoch/200))
with tf.Sessio... | clf_scores = pd.DataFrame(columns=['Classifier', 'Test Score', 'Test Score 3*STD'])
clf_preds = pd.DataFrame(train[targ_col])
for i in range(len(classifiers)) :
clf = classifiers[i]
clf_name = clf.__class__.__name__
clf.fit(train[feature_cols], train[targ_col])
cv_results = cross_val_score(clf, train[feature_cols], ... | Titanic - Machine Learning from Disaster |
10,257,425 | group_cols = [col for col in train.columns if re.search(r'group', col)is not None]
group_cols = [col for col in group_cols if re.search(r'_rank', col)is None]
group_cols.remove('groupId')
other_cols = [col for col in train.columns if re.search(r'match|group', col)is None]
other_cols.remove('num_opponents')
other_cols... | def print_scores_info(model_name, scores):
mean = scores.mean() * 100
std_3 = scores.std() * 100 * 3
print(model_name, 'score mean: ', mean)
print(model_name, 'score 3 std range: ', mean - std_3, '—', mean + std_3 ) | Titanic - Machine Learning from Disaster |
10,257,425 | <define_search_space><EOS> | vote_classifiers = [
('knn', KNeighborsClassifier(**{'n_jobs': -1, 'n_neighbors': 7})) ,
('bag', BaggingClassifier(**{'max_samples': 0.1, 'n_estimators': 50, 'n_jobs': -1, 'random_state': 0})) ,
('gbc', GradientBoostingClassifier(**{'learning_rate': 0.3, 'max_depth': 2, 'min_samples_split': 2, 'n_estimators': 10, 'r... | Titanic - Machine Learning from Disaster |
2,403,150 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<drop_column> | pd.options.mode.chained_assignment = None
warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
2,403,150 | train_array = train.drop(columns=['matchId', 'groupId', 'winPlacePerc'] ).values<define_variables> | train = pd.read_csv('.. /input/train.csv', header=0)
test = pd.read_csv('.. /input/test.csv', header=0)
test.insert(1,'Survived',np.nan)
all = pd.concat([train, test] ) | Titanic - Machine Learning from Disaster |
2,403,150 | group_col_inds = [train.columns.drop(['matchId', 'groupId', 'winPlacePerc'] ).get_loc(col)for col in group_cols]
other_col_inds = [train.columns.drop(['matchId', 'groupId', 'winPlacePerc'] ).get_loc(col)for col in other_cols]
def get_comp_batch(inds, batch_size, omit_last=True):
rand_inds = np.random.permutation(inds.s... | all['Title'] = all.Name.str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
2,403,150 | dropout_rate = [0.0, 0.0, 0.0, 0.0, 0.1, 0.2, 0.2, 0.2]
layer_sizes = [100, 100, 60, 60, 60, 30, 30, 30]
tf.reset_default_graph()
def leaky_relu(z, name=None):
return tf.maximum(0.01*z, z, name=name)
X1 = tf.placeholder(dtype=tf.float32, shape=[None, len(group_cols)], name='X1')
X2 = tf.placeholder(dtype=tf.float32, ... | all.loc[all['Title'].isin(['Ms','Mlle']), 'Title'] = 'Miss'
all.loc[all['Title'].isin(['Mme','Lady','Dona','Countess']), 'Title'] = 'Mrs'
all.loc[all['Title'].isin(['Col','Major','Sir','Rev','Capt','Don','Jonkheer']), 'Title'] = 'Mr'
all.loc[(all['Title'] == 'Dr')&(all['Sex'] == 'male'),'Title'] = 'Mr'
all.loc[(all['Ti... | Titanic - Machine Learning from Disaster |
2,403,150 | with tf.name_scope('loss')as scope:
xentropy = tf.nn.sigmoid_cross_entropy_with_logits(labels=y_all,logits=tf.reshape(logits, [-1]),name='xentropy')
loss = tf.reduce_mean(xentropy)
with tf.name_scope('training')as scope:
lr_low = 0.00001
lr_high = 0.003
lr_high_2 = 0.0003
decay_rate = 15
lr = tf.Variable(lr_high, tra... | all['FamSize'] = all.apply(lambda s: 1+s['SibSp']+s['Parch'], axis = 1)
all['isAlone'] = all.apply(lambda s: 1 if s['FamSize'] == 1 else 0, axis = 1 ) | 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.