kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
4,215,533 | binary_vars = [c for c in X.columns if 'bin_' in c]
nominal_vars = [c for c in X.columns if 'nom_' in c]
high_cardinality = [c for c in nominal_vars if len(X[c].unique())> 16]
low_cardinality = [c for c in nominal_vars if len(X[c].unique())<= 16]
ordinal_vars = [c for c in X.columns if 'ord_' in c]
time_vars = ['day', ... | ( 145+67)/(41+67+15+145 ) | Titanic - Machine Learning from Disaster |
4,215,533 | X['ord_5_1'] = X['ord_5'].apply(lambda x: x[0] if type(x)== str else np.nan)
X['ord_5_2'] = X['ord_5'].apply(lambda x: x[1] if type(x)== str else np.nan)
Xt['ord_5_1'] = Xt['ord_5'].apply(lambda x: x[0] if type(x)== str else np.nan)
Xt['ord_5_2'] = Xt['ord_5'].apply(lambda x: x[1] if type(x)== str else np.nan)
ordi... | gbk = GradientBoostingClassifier()
gbk.fit(X_train, y_train)
y_pred = gbk.predict(X_test)
acc_gbk = round(accuracy_score(y_pred, y_test)* 100, 2)
print(acc_gbk ) | Titanic - Machine Learning from Disaster |
4,215,533 | ordinals = {
'ord_1' : {
'Novice' : 0,
'Contributor' : 1,
'Expert' : 2,
'Master' : 3,
'Grandmaster' : 4
},
'ord_2' : {
'Freezing' : 0,
'Cold' : 1,
'Warm' : 2,
'Hot' : 3,
'Boiling Hot' : 4,
'Lava Hot' : 5
}
}
def return_order(X, Xt, var_name):
mode = X[var_name].mode() [0]
el = sorted(set(X[var_name].fillna(mode ).uniqu... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,215,533 | X_cat, Xt_cat = list() , list()
categorical_counts = dict()
for hc in binary_vars+nominal_vars+ordinal_vars+time_vars:
levels = set(X[hc].astype(str ).fillna("NAN" ).unique())|set(Xt[hc].astype(str ).fillna("NAN" ).unique())
levels = np.array(list(levels))
categorical_counts[hc] = len(levels)
le = LabelEncoder()
le.f... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
4,215,533 | <categorify><EOS> | predictions1 = gbk.predict(test)
sample_sub['Survived']= predictions1
sample_sub.to_csv("submit.csv", index=False)
sample_sub.head() | Titanic - Machine Learning from Disaster |
4,089,372 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<normalization> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns | Titanic - Machine Learning from Disaster |
4,089,372 | ssc = StandardScaler()
selection = freq_encoded + target_encoded + ordinal_vars + time_vars
X_ohe = ssc.fit_transform(X[selection].fillna(X[selection].median()))
Xt_ohe = ssc.transform(Xt[selection].fillna(X[selection].median()))<normalization> | df_train = pd.read_csv(".. /input/train.csv", sep=",")
df_test = pd.read_csv(".. /input/test.csv", sep=",")
df_train.head() | Titanic - Machine Learning from Disaster |
4,089,372 | def gelu(x):
return 0.5 * x *(1 + tf.tanh(tf.sqrt(2 / np.pi)*(x + 0.044715 * tf.pow(x, 3))))
get_custom_objects().update({'gelu': Activation(gelu)})
get_custom_objects().update({'leaky-relu': Activation(LeakyReLU(alpha=0.2)) } )<choose_model_class> | df_train[['Sex','Survived']].groupby(['Sex'],as_index=False ).mean().sort_values(by='Survived',ascending=False ).round(2 ) | Titanic - Machine Learning from Disaster |
4,089,372 | def tabular_dnn(numeric_variables, categorical_variables, categorical_counts,
feature_selection_dropout=0.2, categorical_dropout=0.1,
first_dense = 256, second_dense = 256, dense_dropout = 0.2,
activation_type=gelu):
numerical_inputs = Input(shape=(numeric_variables,))
numerical_normalization = BatchNormalization()(num... | df_train = df_train.drop(["PassengerId", "Name"], axis=1)
df_test = df_test.drop(["Name"], axis=1 ) | Titanic - Machine Learning from Disaster |
4,089,372 | def auroc(y_true, y_pred):
try:
return tf.py_function(roc_auc_score,(y_true, y_pred), tf.double)
except:
return tf.py_func(roc_auc_score,(y_true, y_pred), tf.double)
get_custom_objects().update({'auroc': auroc})
def mAP(y_true, y_pred):
try:
return tf.py_function(average_precision_score,(y_true, y_pred), tf.double)
... | df_train['Cabin'].isna().sum() | Titanic - Machine Learning from Disaster |
4,089,372 | SEED = 42
FOLDS = 20
MAX_EPOCHS = 100
BATCH_SIZE = 1024 * 4<choose_model_class> | df_train = df_train.drop(["Cabin"], axis=1)
df_test = df_test.drop(["Cabin"], axis=1 ) | Titanic - Machine Learning from Disaster |
4,089,372 | measure_to_monitor = 'val_auroc'
modality = 'max'
early_stopping = EarlyStopping(monitor=measure_to_monitor,
mode=modality,
patience=5,
verbose=0)
model_checkpoint = ModelCheckpoint('best.model',
monitor=measure_to_monitor,
mode=modality,
save_best_only=True,
verbose=0)
model_reduce_lr = ReduceLROnPlateau(monitor=mea... | df_train['Ticket'] = df_train['Ticket'].astype("category" ).cat.codes
df_train['Sex']= df_train['Sex'].astype("category" ).cat.codes
df_train['Embarked'] = df_train['Embarked'].astype("category" ).cat.codes
df_train['Age'] = round(df_train['Age'])
is_alone_train=[]
for x in df_train['SibSp']:
if(x==0):is_alone_train.a... | Titanic - Machine Learning from Disaster |
4,089,372 | model_params = {
"numeric_variables" : X_ohe.shape[1],
"categorical_variables" : categorical_counts.keys() ,
"categorical_counts" : categorical_counts,
"feature_selection_dropout" : 0.0,
"categorical_dropout" : 0.3,
"first_dense" : 512,
"second_dense" : 512,
"dense_dropout" : 0.3,
"activation_type" : 'relu'
}<choose_mo... | df_train['Age'].fillna(0,inplace=True)
df_train['Embarked'].fillna(df_train['Embarked'].mode() [0],inplace=True)
df_train['Fare'].fillna(0, inplace=True)
df_test['Age'].fillna(0,inplace=True)
df_test['Embarked'].fillna(df_test['Embarked'].mode() [0],inplace=True)
df_test['Fare'].fillna(0, inplace=True ) | Titanic - Machine Learning from Disaster |
4,089,372 | skf = StratifiedKFold(n_splits=FOLDS,
shuffle=True,
random_state=SEED)
roc_auc = list()
average_precision = list()
oof = np.zeros(len(X))
best_iteration = list()
cv_test_preds = np.zeros(len(Xt))
for fold,(train_idx, test_idx)in enumerate(skf.split(X, y)) :
model = compile_model(tabular_dnn(**model_params),
binary_cro... | y = df_train['Survived']
export = pd.DataFrame()
export['PassengerId'] = df_test['PassengerId']
df_test = df_test.drop(['PassengerId'], axis=1)
df_train = df_train.drop('Survived', axis=1)
X = df_train | Titanic - Machine Learning from Disaster |
4,089,372 | oof = pd.DataFrame({'id':id_train, 'dnn_oof': oof})
oof.to_csv("oof.csv", index=False)
submission = pd.read_csv("/kaggle/input/cat-in-the-dat-ii/sample_submission.csv")
submission.target = cv_test_preds
submission.to_csv("./dnn_cv_submission.csv", index=False )<compute_test_metric> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.18, random_state=0)
clf = RandomForestClassifier(n_estimators=50,
max_depth=6,
n_jobs = -1,
random_state=0)
clf.fit(X_train, y_train)
print("Teste: {}%".format(clf.score(X_test, y_test ).round(2)))
print("Train: {}%".format(clf.score(X_train, y_t... | Titanic - Machine Learning from Disaster |
4,089,372 | print("Average cv roc auc score %0.3f ± %0.3f" %(np.mean(roc_auc), np.std(roc_auc)))
print("Average cv roc average precision %0.3f ± %0.3f" %(np.mean(average_precision), np.std(average_precision)))
print("Roc auc score OOF %0.3f" % roc_auc_score(y_true=y, y_score=oof.dnn_oof))
print("Average precision OOF %0.3f" % av... | X_test = df_test
y_pred_test = clf.predict(X_test)
export['Survived'] = y_pred_test
export_csv = export.to_csv(r'titanic.csv', index = None, header=True ) | Titanic - Machine Learning from Disaster |
4,089,372 | <save_to_csv><EOS> | sc = StandardScaler()
X_scale = sc.fit_transform(X)
cv = KFold(n_splits = 6, shuffle = True)
result = cross_validate(clf,X_scale,y,cv=cv, return_train_score=False)
print("Cross validate median {}%".format(np.median(result['test_score'] ).round(2)*100))
print("Cross validate average {}%".format(np.average(result['tes... | Titanic - Machine Learning from Disaster |
11,321,331 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_to_csv> | seed_value=2509
os.environ['PYTHONHASHSEED']=str(seed_value)
np.random.seed(seed_value)
rn.seed(seed_value)
| Titanic - Machine Learning from Disaster |
11,321,331 | submission.target =(submission.target + pd.read_csv("./dnn_cv_submission.csv" ).target)/ 2
submission.to_csv("./blend_submission.csv", index=False )<load_from_csv> | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
11,321,331 | train = pd.read_csv('.. /input/cat-in-the-dat-ii/train.csv', index_col='id')
test = pd.read_csv('.. /input/cat-in-the-dat-ii/test.csv', index_col='id' )<prepare_output> | combo = [train, test]
for item in combo:
item['Sex'] = item['Sex'].map({'male': 1, 'female': 0} ).astype(int ) | Titanic - Machine Learning from Disaster |
11,321,331 | def summary(df):
summary = pd.DataFrame(df.dtypes, columns=['dtypes'])
summary = summary.reset_index()
summary['Name'] = summary['index']
summary = summary[['Name', 'dtypes']]
summary['Missing'] = df.isnull().sum().values
summary['Uniques'] = df.nunique().values
summary['First Value'] = df.loc[0].values
summary['Secon... | for item in combo:
item['FamilySize'] = item['SibSp'] + item['Parch']+1
| Titanic - Machine Learning from Disaster |
11,321,331 | train['missing_count'] = train.isnull().sum(axis=1)
test['missing_count'] = test.isnull().sum(axis=1 )<define_variables> | train[['FamilySize', 'Survived']].groupby(['FamilySize'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
11,321,331 | missing_number = -99999
missing_string = 'MISSING_STRING'<define_variables> | for item in combo:
item.loc[(item['FamilySize'] ==1), 'Fsize'] = 0
item.loc[(item['FamilySize'] ==2), 'Fsize'] = 1
item.loc[(item['FamilySize'] ==3), 'Fsize'] = 2
item.loc[(item['FamilySize'] ==4), 'Fsize'] = 3
item.loc[(item['FamilySize'] >4), 'Fsize'] = 4
item['Fsize']=item['Fsize'].astype(int ) | Titanic - Machine Learning from Disaster |
11,321,331 | numerical_features = [
'bin_0', 'bin_1', 'bin_2',
'ord_0',
'day', 'month'
]
string_features = [
'bin_3', 'bin_4',
'ord_1', 'ord_2', 'ord_3', 'ord_4', 'ord_5',
'nom_0', 'nom_1', 'nom_2', 'nom_3', 'nom_4', 'nom_5', 'nom_6', 'nom_7', 'nom_8', 'nom_9'
]<categorify> | for item in combo:
item['Title'] = item.Name.str.extract('([A-Za-z]+)\.', expand=False)
item = item.drop(['Name'], axis=1, inplace=True)
print("Titles in test dataset")
print(' ')
print(test.Title.unique())
print(' ')
print("Titles in train dataset")
print(' ')
print(train.Title.unique() ) | Titanic - Machine Learning from Disaster |
11,321,331 | def impute(train, test, columns, value):
for column in columns:
train[column] = train[column].fillna(value)
test[column] = test[column].fillna(value )<compute_test_metric> | for item in combo:
item['Title'] = item['Title'].replace(['Ms','Lady', 'Countess','Dona'],'Mrs')
item['Title'] = item['Title'].replace(['Mme','Mlle'], 'Miss')
item['Title'] = item['Title'].replace(['Major', 'Sir', 'Jonkheer', 'Dr','Col','Don', 'Capt','Rev'],'Mr' ) | Titanic - Machine Learning from Disaster |
11,321,331 | impute(train, test, numerical_features, missing_number)
impute(train, test, string_features, missing_string )<drop_column> | print(train.loc[(train.PassengerId== 797)] ) | Titanic - Machine Learning from Disaster |
11,321,331 | train['ord_5_1'] = train['ord_5'].str[0]
train['ord_5_2'] = train['ord_5'].str[1]
train.loc[train['ord_5'] == missing_string, 'ord_5_1'] = missing_string
train.loc[train['ord_5'] == missing_string, 'ord_5_2'] = missing_string
train = train.drop('ord_5', axis=1)
test['ord_5_1'] = test['ord_5'].str[0]
test['ord_5_2'] = ... | print("
print(train.Title.value_counts())
print("
print(test.Title.value_counts() ) | Titanic - Machine Learning from Disaster |
11,321,331 | simple_features = [
'missing_count'
]
oe_features = [
'bin_0', 'bin_1', 'bin_2', 'bin_3', 'bin_4',
'nom_0', 'nom_1', 'nom_2', 'nom_3', 'nom_4',
'ord_0', 'ord_1', 'ord_2', 'ord_3', 'ord_4', 'ord_5_1', 'ord_5_2',
'day', 'month'
]
ohe_features = oe_features
target_features = [
'nom_5', 'nom_6', 'nom_7', 'nom_8', 'nom_9'
]... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
11,321,331 | y_train = train['target'].copy()
x_train = train.drop('target', axis=1)
del train
x_test = test.copy()
del test<normalization> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
11,321,331 | scaler = StandardScaler()
simple_x_train = scaler.fit_transform(x_train[simple_features])
simple_x_test = scaler.transform(x_test[simple_features] )<categorify> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
11,321,331 | ohe = OneHotEncoder(dtype='uint16', handle_unknown="ignore")
ohe_x_train = ohe.fit_transform(x_train[ohe_features])
ohe_x_test = ohe.transform(x_test[ohe_features] )<categorify> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
11,321,331 | oe = OrdinalEncoder()
oe_x_train = oe.fit_transform(x_train[oe_features])
oe_x_test = oe.transform(x_test[oe_features] )<import_modules> | for item in combo:
item['Cabin'].fillna('N', inplace=True)
item['Cabin'] = item['Cabin'].map(lambda c: c[0] ) | Titanic - Machine Learning from Disaster |
11,321,331 | from category_encoders import TargetEncoder
from sklearn.model_selection import StratifiedKFold<categorify> | for item in combo:
item['Cabin'] = item['Cabin'].replace(['A', 'B','C',"D",'E','T'], 0)
item['Cabin'] = item['Cabin'].replace(['F','G'], 0)
item['Cabin'] = item['Cabin'].replace(['N'], 1 ) | Titanic - Machine Learning from Disaster |
11,321,331 | def transform(transformer, x_train, y_train, cv):
oof = pd.DataFrame(index=x_train.index, columns=x_train.columns)
for train_idx, valid_idx in cv.split(x_train, y_train):
x_train_train = x_train.loc[train_idx]
y_train_train = y_train.loc[train_idx]
x_train_valid = x_train.loc[valid_idx]
transformer.fit(x_train_train, ... | train[['Cabin','Survived']].groupby(['Cabin'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
11,321,331 | target = TargetEncoder(drop_invariant=True, smoothing=0.2)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
target_x_train = transform(target, x_train[target_features], y_train, cv ).astype('float')
target.fit(x_train[target_features], y_train)
target_x_test = target.transform(x_test[target_features]... | train['Embarked'] = train['Embarked'].fillna('S')
combo = [train, test]
for item in combo:
item['Embarked'] = item['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int ) | Titanic - Machine Learning from Disaster |
11,321,331 | x_train = scipy.sparse.hstack([ohe_x_train, simple_x_train, target_x_train] ).tocsr()
x_test = scipy.sparse.hstack([ohe_x_test, simple_x_test, target_x_test] ).tocsr()<train_model> | combo = [train, test]
for item in combo:
item['Age'] = item.groupby(['Pclass','Title'])['Age'].apply(lambda x: x.fillna(x.mean())) | Titanic - Machine Learning from Disaster |
11,321,331 | logit = LogisticRegression(C=0.54321, solver='lbfgs', max_iter=10000)
logit.fit(x_train, y_train)
y_pred_logit = logit.predict_proba(x_test)[:, 1]<concatenate> | test['Fare'].fillna(test['Fare'].median() , inplace = True ) | Titanic - Machine Learning from Disaster |
11,321,331 | x_train = np.concatenate(( oe_x_train, simple_x_train, target_x_train), axis=1)
x_test = np.concatenate(( oe_x_test, simple_x_test, target_x_test), axis=1 )<define_variables> | for item in combo:
item.loc[ item['Fare'] <= 7.55, 'Fare'] = 0
item.loc[(item['Fare'] > 7.55)&(item['Fare'] <= 10.5), 'Fare'] = 1
item.loc[(item['Fare'] > 10.5)&(item['Fare'] <= 14.454), 'Fare'] = 2
item.loc[(item['Fare'] > 14.454)&(item['Fare'] <= 21.67), 'Fare'] = 3
item.loc[(item['Fare'] > 21.67)&(item['Fare'] <= 77... | Titanic - Machine Learning from Disaster |
11,321,331 | categorial_part = oe_x_train.shape[1]<import_modules> | train[['Pclass','Survived']].groupby(['Pclass'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
11,321,331 | import tensorflow as tf<compute_test_metric> | train[['Fare','Survived']].groupby(['Fare'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
11,321,331 | def auc(y_true, y_pred):
def fallback_auc(y_true, y_pred):
try:
return roc_auc_score(y_true, y_pred)
except:
return 0.5
return tf.py_function(fallback_auc,(y_true, y_pred), tf.double )<choose_model_class> | for item in combo:
item = item.drop(['Ticket'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
11,321,331 | def make_model(data, categorial_part):
inputs = []
categorial_outputs = []
for idx in range(categorial_part):
n_unique = np.unique(data[:,idx] ).shape[0]
n_embeddings = int(min(np.ceil(n_unique / 2), 50))
inp = tf.keras.layers.Input(shape=(1,))
inputs.append(inp)
x = tf.keras.layers.Embedding(n_unique + 1, n_embedding... | train['Age2']=-1
test['Age2']=-1
combo=[train,test]
for item in combo:
item.loc[(item['Age'] <=4), 'Age2'] =0
item.loc[(item['Age']<=17)&(item['Age'] >4), 'Age2'] =1
item.loc[(item['Age'] >=18)&(item['Age'] <=32), 'Age2'] =2
item.loc[(item['Age'] >32)&(item['Age'] <=42), 'Age2']= 3
item.loc[(item['Age'] >42)&(item['Age... | Titanic - Machine Learning from Disaster |
11,321,331 | def make_inputs(data, categorial_part):
inputs = []
for idx in range(categorial_part):
inputs.append(data[:, idx])
inputs.append(data[:, categorial_part:])
return inputs<split> | train[['Survived','Age2']].groupby(['Age2'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
11,321,331 | n_splits = 50
trained_estimators = []
histories = []
scores = []
cv = KFold(n_splits=n_splits, random_state=42)
for train_idx, valid_idx in cv.split(x_train, y_train):
x_train_train = x_train[train_idx]
y_train_train = y_train[train_idx]
x_train_valid = x_train[valid_idx]
y_train_valid = y_train[valid_idx]
K.clear_ses... | pearson_coef1 , p_value1 =scipy.stats.pearsonr(train["Cabin"],train["Pclass"])
print("Cabin - Pclass", pearson_coef1," Correlation certainty =",p_value1 ) | Titanic - Machine Learning from Disaster |
11,321,331 | print('Mean score:', np.mean(scores))<predict_on_test> | for item in combo:
item = item.drop(['Sex'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
11,321,331 | y_pred = np.zeros(x_test.shape[0])
x_test_inputs = make_inputs(x_test, categorial_part)
for estimator in trained_estimators:
y_pred += estimator.predict(x_test_inputs ).reshape(-1)/ len(trained_estimators )<prepare_output> | for item in combo:
item.loc[(( item['Title']=='Miss')&(item['Age'] <=4)) , 'Title'] = 'child'
item.loc[(( item['Title']=='Master')&(item['Age'] <=4)) , 'Title'] = 'child'
item.loc[(( item['Title']=='Miss')&(item['Age'] <=17)) , 'Title'] = 'kid'
item.loc[(( item['Title']=='Master')&(item['Age'] <=17)) , 'Title'] = 'kid'... | Titanic - Machine Learning from Disaster |
11,321,331 | y_pred_keras = y_pred<compute_test_metric> | train[['Title', 'Survived']].groupby(['Title'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
11,321,331 | y_pred = np.add(y_pred_logit, y_pred_keras)/ 2<save_to_csv> | train['Title'] = train['Title'].map({ 'Mr': 0 ,'Miss':1, 'MrsNoCh':2 ,'MrsYesCh':3,'kid':4,'child':5} ).astype(int)
test['Title'] = test['Title'].map({'Mr': 0 ,'Miss':1, 'MrsNoCh':2 ,'MrsYesCh':3,'kid':4, 'child':5} ).astype(int ) | Titanic - Machine Learning from Disaster |
11,321,331 | submission = pd.read_csv('.. /input/cat-in-the-dat-ii/sample_submission.csv', index_col='id')
submission['target'] = y_pred
submission.to_csv('logit_keras.csv' )<install_modules> | for item in combo:
item = item.drop(['Age'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
11,321,331 | !pip install --no-warn-conflicts -q deepctr<import_modules> | X_train = train.drop(['Survived','PassengerId','FamilySize','FareBin'], axis=1)
col=(X_train.columns)
Y_train = train["Survived"]
X_test=test.drop(["PassengerId","FamilySize"], axis=1 ) | Titanic - Machine Learning from Disaster |
11,321,331 | warnings.simplefilter('ignore' )<load_from_csv> | scaler = StandardScaler()
scaler.fit_transform(X_train)
scaler.transform(X_test ) | Titanic - Machine Learning from Disaster |
11,321,331 | train = pd.read_csv('.. /input/cat-in-the-dat-ii/train.csv')
test = pd.read_csv('.. /input/cat-in-the-dat-ii/test.csv' )<feature_engineering> | test1 = SelectKBest(score_func= f_classif, k=4)
fit = test1.fit(X_train, Y_train)
set_printoptions(precision=3)
print(col)
print(' ',fit.scores_ ) | Titanic - Machine Learning from Disaster |
11,321,331 | test['target'] = -1
test.head()<concatenate> | model = ExtraTreesClassifier(n_estimators=10)
model.fit(X_train, Y_train)
print(col)
print('Feature importance')
print(model.feature_importances_ ) | Titanic - Machine Learning from Disaster |
11,321,331 | data = pd.concat([train, test] ).reset_index(drop=True )<feature_engineering> | rfe = RFE(estimator=DecisionTreeClassifier() , n_features_to_select=4)
fit = rfe.fit(X_train, Y_train)
print('Features : ',col)
print("Num Features: ",fit.n_features_)
print("Selected Features: ",fit.support_)
print("Feature Ranking: ",fit.ranking_ ) | Titanic - Machine Learning from Disaster |
11,321,331 | data['null'] = data.isna().sum(axis=1 )<feature_engineering> | X_train = pd.get_dummies(X_train, columns = ["Title"],prefix="N")
X_train = pd.get_dummies(X_train, columns = ["Fare"],prefix="F",drop_first=True)
X_test = pd.get_dummies(X_test, columns = ["Title"],prefix="N")
X_test = pd.get_dummies(X_test, columns = ["Fare"],prefix="F",drop_first=True)
Y_train = train["Survived"... | Titanic - Machine Learning from Disaster |
11,321,331 | sparse_features = [feat for feat in train.columns if feat not in ['id','target']]
data[sparse_features] = data[sparse_features].fillna('-1', )<categorify> | X_train.drop(["Embarked","Cabin",'Age2'], axis=1, inplace=True)
X_test.drop(["Embarked","Cabin",'Age2'], axis=1,inplace=True)
print("Training set X: ", X_train.shape, "Training set Y:",Y_train.shape, "Testing set X", X_test.shape ) | Titanic - Machine Learning from Disaster |
11,321,331 | for feat in sparse_features:
lbe = LabelEncoder()
data[feat] = lbe.fit_transform(data[feat].fillna('-1' ).astype(str ).values )<prepare_x_and_y> | from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier,AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
import lightgbm as lgb
from lightgbm import L... | Titanic - Machine Learning from Disaster |
11,321,331 | train = data[data.target != -1].reset_index(drop=True)
test = data[data.target == -1].reset_index(drop=True )<count_unique_values> | kfld = StratifiedKFold(n_splits=5, shuffle=True, random_state=2509)
GB_param = {"n_estimators":[100,150,250,500], "learning_rate": [0.001,0.01,0.05,0.1,0.2],
"min_samples_split":[3,10,31],"max_depth":[3,5,7], "max_features":[4,7,8,9,10,11,13],
"subsample":[0.8,1], "criterion": ["mae"]}
AdaB_param ={'n_estimators': [10... | Titanic - Machine Learning from Disaster |
11,321,331 | fixlen_feature_columns = [SparseFeat(feat, data[feat].nunique())for feat in sparse_features]
dnn_feature_columns = fixlen_feature_columns
linear_feature_columns = fixlen_feature_columns
feature_names = get_feature_names(linear_feature_columns + dnn_feature_columns )<compute_test_metric> | randomforest = RandomForestClassifier(criterion = 'gini',bootstrap= True, max_depth= 5, max_features=10, min_samples_split= 31, n_estimators=20,random_state=seed_value)
svc_model = SVC(C=0.5, cache_size=200,
decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf', max_iter=-1, probability=True, random_stat... | Titanic - Machine Learning from Disaster |
11,321,331 | def auc(y_true, y_pred):
def fallback_auc(y_true, y_pred):
try:
return roc_auc_score(y_true, y_pred)
except:
return 0.5
return tf.py_function(fallback_auc,(y_true, y_pred), tf.double )<compute_train_metric> | def evaluate_model(model):
seed=7
kfld = StratifiedKFold(n_splits=5,shuffle=True,random_state=seed)
scores = cross_val_score(model, X_train , Y_train, scoring='accuracy', cv=kfld, n_jobs=-1, error_score='raise')
return scores
clfs={'LightGBM':[modellt,78.707],'XGBoost':[xgb_model,99978.229],'GradientBoost':[gb,78.468... | Titanic - Machine Learning from Disaster |
11,321,331 | def focal_loss(gamma=2., alpha=.25):
def focal_loss_fixed(y_true, y_pred):
pt_1 = tf.where(tf.equal(y_true, 1), y_pred, tf.ones_like(y_pred))
pt_0 = tf.where(tf.equal(y_true, 0), y_pred, tf.zeros_like(y_pred))
return -K.mean(alpha * K.pow(1.- pt_1, gamma)* K.log(K.epsilon() +pt_1)) -K.mean(( 1-alpha)* K.pow(pt_0, gamma... | x_train, x_test, y_train, y_test = train_test_split(X_train, Y_train, test_size=0.2,shuffle=True ,random_state=123 ) | Titanic - Machine Learning from Disaster |
11,321,331 | def custom_gelu(x):
return 0.5 * x *(1 + tf.tanh(tf.sqrt(2 / np.pi)*(x + 0.044715 * tf.pow(x, 3))))
get_custom_objects().update({'custom_gelu': Activation(custom_gelu)} )<choose_model_class> | def evaluation(name,clf):
model=clf.fit(x_train,y_train)
y_prob = model.predict_proba(x_test)[:, 1]
prAuc = average_precision_score(y_test, y_prob)
y_pred = model.predict(x_test)
acc = balanced_accuracy_score(y_test, y_pred)
f1= f1_score(y_test, y_pred)
return prAuc,acc,f1
scores={}
for name, model in models_set.i... | Titanic - Machine Learning from Disaster |
11,321,331 | class WarmUpLearningRateScheduler(tf.keras.callbacks.Callback):
def __init__(self, warmup_batches, init_lr, verbose=0):
super(WarmUpLearningRateScheduler, self ).__init__()
self.warmup_batches = warmup_batches
self.init_lr = init_lr
self.verbose = verbose
self.batch_count = 0
self.learning_rates = []
def on_batch_e... | def create_clf(E,t):
if t=='Voting':
vclf=VotingClassifier(E, voting='hard')
else:
vclf=StackingClassifier(E, final_estimator= LogisticRegression())
return vclf
E1=[KNN1,NN1,SVM1,RF1,GR1]
E2=[KNN1,SVM1,RF1,GR1]
E3=[KNN1,SVM1,GR1]
E4=[KNN1,SVM1]
ensembles_set={'KNN-NN-SVM-RF-GR':[E1,'79.186','78.947'],'KNN-SVM-RF-GR':... | Titanic - Machine Learning from Disaster |
11,321,331 | <define_variables><EOS> | E=[KNN1,SVM1]
vot=VotingClassifier(E, voting='hard')
ensemble = vot.fit(X_train, Y_train)
y_vote = ensemble.predict(X_test)
submission = pd.DataFrame({
"PassengerId": test["PassengerId"],
"Survived": y_vote
})
submission.to_csv('Titanic.csv', index=False)
print("Your submission was successfully saved!")
| Titanic - Machine Learning from Disaster |
11,271,490 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<prepare_x_and_y> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
11,271,490 | oof_pred_deepfm = np.zeros(( len(train),))
y_pred_deepfm = np.zeros(( len(test),))
skf = StratifiedKFold(n_splits=N_Splits, shuffle=True, random_state=SEED)
for fold,(tr_ind, val_ind)in enumerate(skf.split(train, train[target])) :
X_train, X_val = train[sparse_features].iloc[tr_ind], train[sparse_features].iloc[val_in... | df_test = pd.read_csv('.. /input/titanic/test.csv')
df_train = pd.read_csv('.. /input/titanic/train.csv' ) | Titanic - Machine Learning from Disaster |
11,271,490 | print(f'OOF AUC : {round(roc_auc_score(train.target.values, oof_pred_deepfm), 5)}' )<save_to_csv> | df_train.drop(['Cabin','Fare','Parch','Ticket','Name'],axis=1,inplace = True ) | Titanic - Machine Learning from Disaster |
11,271,490 | test_idx = test.id.values
submission = pd.DataFrame.from_dict({
'id': test_idx,
'target': y_pred_deepfm
})
submission.to_csv('submission.csv', index=False)
print('Submission file saved!' )<save_model> | df_test.drop(['Cabin','Fare','Parch','Ticket','Name'],axis=1,inplace = True ) | Titanic - Machine Learning from Disaster |
11,271,490 | np.save('oof_pred_deepfm.npy',oof_pred_deepfm)
np.save('y_pred_deepfm.npy', y_pred_deepfm )<define_variables> | df_test.fillna(35,inplace=True ) | Titanic - Machine Learning from Disaster |
11,271,490 | path = Path('.. /input/cassava-leaf-disease-classification' )<load_from_csv> | df_train.fillna(35,inplace=True ) | Titanic - Machine Learning from Disaster |
11,271,490 | train_df = pd.read_csv(path/'train.csv')
train_df = train_df[~train_df['image_id'].isin(['1562043567.jpg', '3551135685.jpg', '2252529694.jpg'])]
train_df.head()<set_options> | embark = pd.get_dummies(df_train['Embarked'],drop_first=True)
sex = pd.get_dummies(df_train['Sex'],drop_first=True)
train = pd.concat([df_train.drop(['Embarked','Sex'],axis=1),sex,embark],axis=1 ) | Titanic - Machine Learning from Disaster |
11,271,490 | item_tfms = RandomResizedCrop(460, min_scale=0.75, ratio=(1.,1.))
batch_tfms = [*aug_transforms(size=384, max_warp=0), Normalize.from_stats(*imagenet_stats)]
bs=16<prepare_x_and_y> | embark = pd.get_dummies(df_test['Embarked'],drop_first=True)
sex = pd.get_dummies(df_test['Sex'],drop_first=True)
test = pd.concat([df_test.drop(['Embarked','Sex'],axis=1),sex,embark],axis=1 ) | Titanic - Machine Learning from Disaster |
11,271,490 | def get_x(r):
return path/'train_images'/r['image_id']
def get_y(r):
return r['label']<load_pretrained> | train = train.drop(['C','PassengerId'],axis=1)
test = test.drop(['PassengerId'],axis=1 ) | Titanic - Machine Learning from Disaster |
11,271,490 | pets = DataBlock(blocks=(ImageBlock, CategoryBlock),
get_x=get_x,
get_y=get_y,
splitter=RandomSplitter(0.2, seed=42),
item_tfms=item_tfms,
batch_tfms=batch_tfms)
dataloader = pets.dataloaders(train_df, bs=bs )<define_variables> | model = Sequential()
model.add(Dense(19,activation='relu'))
model.add(Dense(19,activation='relu'))
model.add(Dense(19,activation='relu'))
model.add(Dense(19,activation='relu'))
model.add(Dense(1))
model.compile(optimizer='rmsprop',loss='mse' ) | Titanic - Machine Learning from Disaster |
11,271,490 | dataloader.show_batch()<choose_model_class> | model.fit(train.drop(['Survived'],axis=1),train['Survived'],epochs=200 ) | Titanic - Machine Learning from Disaster |
11,271,490 | learn = cnn_learner(dataloader, resnet50,
loss_func = LabelSmoothingCrossEntropy() ,
cbs=[MixUp() ],
metrics=[error_rate,accuracy])
learn.fine_tune(8,freeze_epochs = 2,base_lr=1e-2 )<categorify> | pred = model.predict_classes(test ) | Titanic - Machine Learning from Disaster |
11,271,490 | learn = learn.to_native_fp32()<load_from_csv> | idpred = []
for i in range(len(pred)) :
idpred.append(pred[i][0] ) | Titanic - Machine Learning from Disaster |
11,271,490 | sample_df = pd.read_csv(path/'sample_submission.csv')
sample_df.head()<train_model> | submit = pd.concat([df_test['PassengerId'],p],axis=1 ) | Titanic - Machine Learning from Disaster |
11,271,490 | test_data_path = sample_df['image_id'].apply(lambda x: path/'test_images'/x)
tst_dl = learn.dls.test_dl(test_data_path)
predictions = learn.tta(dl = tst_dl, n=10)
<prepare_output> | submit.rename(columns={0:'Survived'},inplace = True ) | Titanic - Machine Learning from Disaster |
11,271,490 | <save_to_csv><EOS> | submit.to_csv('Submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
16,585,522 | <SOS> metric: MCAUC Kaggle data source: ranzcr-clip-catheter-and-line-position-challenge<define_variables> | %env SM_FRAMEWORK=tf.keras
!pip install.. /input/segmentation-models-keras/Keras_Applications-1.0.8-py3-none-any.whl --quiet
!pip install.. /input/segmentation-models-keras/image_classifiers-1.0.0-py3-none-any.whl --quiet
!pip install.. /input/segmentation-models-keras/efficientnet-1.0.0-py3-none-any.whl --quiet
!pip i... | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | path = '.. /input/'
comp = 'jigsaw-toxic-comment-classification-challenge/'
EMBEDDING_FILE=f'{path}fasttext-crawl-300d-2m/crawl-300d-2M.vec'
TRAIN_DATA_FILE=f'{path}{comp}train.csv'
TEST_DATA_FILE=f'{path}{comp}test.csv'<define_variables> | DEBUG = False | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | embed_size = 300
max_features = 20000
maxlen = 100<load_from_csv> | print(tf.__version__ ) | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | train = pd.read_csv(TRAIN_DATA_FILE)
test = pd.read_csv(TEST_DATA_FILE)
list_sentences_train = train["comment_text"].fillna("_na_" ).values
list_classes = ["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"]
y = train[list_classes].values
list_sentences_test = test["comment_text"].fillna("_na_" )... | data_dir = '.. /input/ranzcr-clip-catheter-line-classification'
model_dir = '.. /input/ranzcr-1st-place-solution-by-tf-models'
seg_image_size = 1024
cls_image_size = 512
batch_size = 16 | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | tokenizer = Tokenizer(num_words=max_features)
tokenizer.fit_on_texts(list(list_sentences_train))
list_tokenized_train = tokenizer.texts_to_sequences(list_sentences_train)
list_tokenized_test = tokenizer.texts_to_sequences(list_sentences_test)
X_t = pad_sequences(list_tokenized_train, maxlen=maxlen)
X_te = pad_seque... | df_sub = pd.read_csv(os.path.join(data_dir, 'sample_submission.csv'))
| RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.strip().split())for o in open(EMBEDDING_FILE))<feature_engineering> | seg_model_names = [
'seg_model_V10_0.hdf5'
]
cls_model_names = [
'cls_model_V14_0.hdf5',
'cls_model_V15_1.hdf5',
'cls_model_V15_2.hdf5',
'cls_model_V16_3.hdf5',
'cls_model_V16_4.hdf5'
] | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | word_index = tokenizer.word_index
nb_words = min(max_features, len(word_index))
embedding_matrix = np.zeros(( nb_words, embed_size))
for word, i in word_index.items() :
if i >= max_features: continue
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None: embedding_matrix[i] = embedding_vector<c... | tfrec_path = data_dir + '/test_tfrecords/*.tfrec'
tfrec_file_names = sorted(tf.io.gfile.glob(tfrec_path))
tfrec_file_names = \
[ tfrec_file_names[0] ] if DEBUG else tfrec_file_names
tfrec_file_names | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | inp = Input(shape=(maxlen,))
x = Embedding(max_features, embed_size, weights=[embedding_matrix] )(inp)
x = Bidirectional(LSTM(300, return_sequences=True, dropout=0.1, recurrent_dropout=0.1))(x)
x = GlobalMaxPool1D()(x)
x = Dense(50, activation="relu" )(x)
x = Dropout(0.1 )(x)
x = Dense(6, activation="sigmoid" )(x)... | AUTOTUNE = tf.data.experimental.AUTOTUNE
def decode_image(image_data):
image = tf.image.decode_jpeg(image_data, channels=3)
return image
def read_tfrecord(example):
TFREC_FORMAT = {
'image': tf.io.FixedLenFeature([], tf.string),
'StudyInstanceUID': tf.io.FixedLenFeature([], tf.string),
}
example = tf.io.parse_single_e... | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | model.fit(X_t, y, batch_size=32, epochs=2, validation_split=0.1);<save_to_csv> | raw_test_ds = load_dataset(tfrec_file_names)
raw_test_ds | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | y_test = model.predict([X_te], batch_size=1024, verbose=1)
sample_submission = pd.read_csv(f'{path}{comp}sample_submission.csv')
sample_submission[list_classes] = y_test
sample_submission.to_csv('submission.csv', index=False )<import_modules> | study_inst_id_list = [
study_inst_id.numpy().decode('utf-8')for image, study_inst_id in raw_test_ds
]
print(study_inst_id_list[ :10 ])
print(study_inst_id_list[ -10: ] ) | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | print(tf.__version__)
tf.test.is_gpu_available(
cuda_only=False,
min_cuda_compute_capability=None
)<load_from_csv> | def drop_study_inst_id(image, study_inst_id):
return image
def preprocess_image(image):
image_seg = tf.image.resize(image,(seg_image_size, seg_image_size))
image_seg = image_seg / 255.0
image_cls = tf.image.resize(image,(cls_image_size, cls_image_size))
return(( image_seg, image_cls),)
def make_test_dataset() :
ds = l... | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | BATCH_SIZE = 512
LSTM_UNITS = 128
DENSE_HIDDEN_UNITS = 4 * LSTM_UNITS
EPOCHS = 4
MAX_LEN = 220
TEXT_COLUMN = 'comment_text'
list_classes = ["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"]
CHARS_TO_REMOVE = '!"
“”’'∞θ÷α•à−β∅³π‘₹´°£€\×™√²—'
submission = pd.read_csv(".. /input/jigsaw-toxic-comment... | test_ds = make_test_dataset()
test_ds | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | categories = ["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"]
data_folder = ".. /input/jigsaw-toxic-comment-classification-challenge/"
pretrained_folder = ".. /input/"
train_filepath = data_folder + "train.csv"
test_filepath = data_folder + "test.csv"
submission_path = data_folder + "submission... | def load_model(weight_file_name):
weight_file_path = os.path.join(model_dir, weight_file_name)
model = tf.keras.models.load_model(weight_file_path)
return model
def make_seg_masks(x):
fold_seg_masks = tf.stack(x, axis=0)
average_seg_masks = \
tf.math.reduce_mean(fold_seg_masks, axis=0)
return average_seg_masks
def ... | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | hyphens_filepath = ".. /input/cleaning-dictionaries/hyphens_dictionary.bin"
misspellings_filepath = ".. /input/cleaning-dictionaries/misspellings_all_dictionary.bin"
merged_filepath = ".. /input/cleaning-dictionaries/merged_all_dictionary.bin"
hyphens_dict = misspellings_dict = merged_dict = {}
with open(hyphens_filepa... | strategy = tf.distribute.get_strategy()
print("REPLICAS: ", strategy.num_replicas_in_sync ) | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | training_samples_count = 149571
validation_samples_count = 10000
length_threshold = 20000
word_count_threshold = 900
words_limit = 310000
valid_characters = " " + "@$" + "'!?-" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz".upper()
valid_characters_ext = valid_characters + "abcdefghijklmnopqrstuvwxyz".up... | df_sub['StudyInstanceUID'] = study_inst_id_list | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | cont_patterns = [
(r'(W|w)on't', r'will not'),
(r'(C|c)an't', r'can not'),
(r'(I|i)'m', r'i am'),
(r'(A|a)in't', r'is not'),
(r'(\w+)'ll', r'\g<1> will'),
(r'(\w+)n't', r'\g<1> not'),
(r'(\w+)'ve', r'\g<1> have'),
(r'(\w+)'s', r'\g<1> is'),
(r'(\w+)'re', r'\g<1> are'),
(r'(\w+)'d', r'\g<1> would'),
]
patterns... | target_cols = [
'ETT - Abnormal',
'ETT - Borderline',
'ETT - Normal',
'NGT - Abnormal',
'NGT - Borderline',
'NGT - Incompletely Imaged',
'NGT - Normal',
'CVC - Abnormal',
'CVC - Borderline',
'CVC - Normal',
'Swan Ganz Catheter Present'
] | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | nlp = spacy.load('en')
def normalize_comment(comment):
comment = unidecode(comment)
comment = comment[:length_threshold]
normalized_words = []
for w in astericks_words:
if w[0] in comment:
comment = comment.replace(w[0], w[1])
if w[0].upper() in comment:
comment = comment.replace(w[0].upper() , w[1].upper())
for wo... | df_subs = [df_sub.copy() for _ in range(PROBS.shape[0])]
for i, this_sub in enumerate(df_subs):
this_sub[target_cols] = PROBS[i]
this_sub[target_cols] = \
this_sub[target_cols].rank(pct=True ) | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | def read_data_files(train_filepath, test_filepath):
train = pd.read_csv(train_filepath)
labels = train[categories].values
test = pd.read_csv(test_filepath)
test_comments = test["comment_text"].fillna("_na_" ).values
np_normalize = np.vectorize(normalize_comment)
comments = train["comment_text"].fillna("_na_" ).value... | rank_values = \
[this_sub[target_cols].values for this_sub in df_subs]
df_sub[target_cols] = \
np.stack(rank_values, 0 ).mean(0 ) | RANZCR CLiP - Catheter and Line Position Challenge |
16,585,522 | <string_transform><EOS> | df_sub.to_csv('submission.csv', index=False)
!head submission.csv | RANZCR CLiP - Catheter and Line Position Challenge |
15,515,986 | <SOS> metric: MCAUC Kaggle data source: ranzcr-clip-catheter-and-line-position-challenge<load_pretrained> | batch_size = 1
image_size = 512
tta = True
submit = True
enet_type = ['resnet200d'] * 5
model_path = ['.. /input/resnet200d-baseline-benchmark-public/resnet200d_fold0_cv953.pth',
'.. /input/resnet200d-baseline-benchmark-public/resnet200d_fold1_cv955.pth',
'.. /input/resnet200d-baseline-benchmark-public/resnet200d_fold2... | RANZCR CLiP - Catheter and Line Position Challenge |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.