kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,602,777 | print(os.listdir())
model = Ensemble(text.vocab.vectors, padding_idx=text.vocab.stoi[text.pad_token], batch_size=batch_size ).cuda()
model.load_state_dict(torch.load('checkpoint.pt'))<init_hyperparams> | for dataset in all_data:
dataset['Embarked'] = dataset['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int)
train.head()
| Titanic - Machine Learning from Disaster |
14,602,777 | print('Threshold:',search_result['threshold'])
submission_list = list(torchtext.data.BucketIterator(dataset=submission_x,
batch_size=batch_size,
sort=False,
train=False))
pred = []
with torch.no_grad() :
for submission_batch in submission_list:
model.eval()
x = submission_batch.text.cuda()
pred += torch.sigmoid(model(... | train = train.drop(['Fare'], axis=1)
test = test.drop(['Fare'], axis=1)
all_data = [train,test]
train.head() | Titanic - Machine Learning from Disaster |
14,602,777 | list_train = [filepath for filepath in list_paths if "train/" in filepath]
shuffle(list_train)
list_test = [filepath for filepath in list_paths if "test/" in filepath]
list_train = list_train
list_test = list_test
index = [os.path.basename(filepath)for filepath in list_test]<define_variables> | for dataset in all_data:
dataset['Title'] = dataset.Name.str.extract('([A-Za-z]+)\.', expand=False)
pd.crosstab(train['Title'], train['Sex'])
| Titanic - Machine Learning from Disaster |
14,602,777 | list_classes = list(set([os.path.dirname(filepath ).split(os.sep)[-1] for filepath in list_paths if "train" in filepath]))<define_variables> | for dataset in all_data:
dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col',\
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
dataset['Title'] = dataset['... | Titanic - Machine Learning from Disaster |
14,602,777 | list_classes = ['Sony-NEX-7',
'Motorola-X',
'HTC-1-M7',
'Samsung-Galaxy-Note3',
'Motorola-Droid-Maxx',
'iPhone-4s',
'iPhone-6',
'LG-Nexus-5x',
'Samsung-Galaxy-S4',
'Motorola-Nexus-6']<categorify> | title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in all_data:
dataset['Title'] = dataset['Title'].map(title_mapping)
dataset['Title'] = dataset['Title'].fillna(0)
train.head()
| Titanic - Machine Learning from Disaster |
14,602,777 | def get_class_from_path(filepath):
return os.path.dirname(filepath ).split(os.sep)[-1]
def read_and_resize(filepath):
im_array = np.array(Image.open(( filepath)) , dtype="uint8")
pil_im = Image.fromarray(im_array)
new_array = np.array(pil_im.resize(( 256, 256)))
return new_array/255
def label_transform(labels):
labe... | train = train.drop(['Name', 'PassengerId'], axis=1)
test = test.drop(['Name'], axis=1)
all_data = [train, test]
| Titanic - Machine Learning from Disaster |
14,602,777 | X_train = np.array([read_and_resize(filepath)for filepath in list_train])
X_test = np.array([read_and_resize(filepath)for filepath in list_test] )<categorify> | X_train = train.drop("Survived", axis=1)
Y_train = train["Survived"]
X_test = test.drop("PassengerId", axis=1 ).copy()
| Titanic - Machine Learning from Disaster |
14,602,777 | labels = [get_class_from_path(filepath)for filepath in list_train]
y, label_index = label_transform(labels)
y = np.array(y )<choose_model_class> | random_forest= RandomForestClassifier(n_estimators=100,
max_features='auto',
criterion='entropy',
max_depth=10)
random_forest.fit(X_train, Y_train)
Y_prediction = random_forest.predict(X_test)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train)* 100, 2)
print(round... | Titanic - Machine Learning from Disaster |
14,602,777 | input_shape =(256, 256, 3)
nclass = len(label_index)
def get_model() :
nclass = len(label_index)
inp = Input(shape=input_shape)
norm_inp = BatchNormalization()(inp)
img_1 = Convolution2D(16, kernel_size=3, activation=activations.relu, padding="same" )(norm_inp)
img_1 = Convolution2D(16, kernel_size=3, activation=... | clf = GradientBoostingClassifier(n_estimators=100, learning_rate=1.0,
max_depth=1, random_state=0 ).fit(X_train, Y_train)
y_prediction= clf.predict(X_test)
clf.score(X_train, Y_train)
acc_clf = round(clf.score(X_train, Y_train)* 100, 2)
print(round(acc_clf,2,), "%")
| Titanic - Machine Learning from Disaster |
14,602,777 | model = get_model()
file_path="weights.best.hdf5"
checkpoint = ModelCheckpoint(file_path, monitor='val_acc', verbose=1, save_best_only=True, mode='max')
early = EarlyStopping(monitor="val_acc", mode="max", patience=1)
callbacks_list = [checkpoint, early]
history = model.fit(X_train, y, validation_split=0.1, epochs=3,... | model = LGBMClassifier().fit(X_train, Y_train)
y_predict= model.predict(X_test)
model.score(X_train, Y_train)
acc_model = round(model.score(X_train, Y_train)* 100, 2)
print(round(acc_model,2,), "%")
| Titanic - Machine Learning from Disaster |
14,602,777 | predicts = model.predict(X_test)
predicts = np.argmax(predicts, axis=1)
predicts = [label_index[p] for p in predicts]
<save_to_csv> | logreg = LogisticRegression()
logreg.fit(X_train, Y_train)
Y_pred = logreg.predict(X_test)
acc_log = round(logreg.score(X_train, Y_train)* 100, 2)
print(round(acc_log,2,), "%")
| Titanic - Machine Learning from Disaster |
14,602,777 | df = pd.DataFrame(columns=['fname', 'camera'])
df['fname'] = index
df['camera'] = predicts
df.to_csv("sub.csv", index=False )<set_options> | decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
Y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train)* 100, 2)
print(round(acc_decision_tree,2,), "%")
| Titanic - Machine Learning from Disaster |
14,602,777 | warnings.filterwarnings("ignore")
pd.set_option("display.max_columns", 500)
pd.set_option("display.max_rows", 500)
register_matplotlib_converters()
sns.set()<set_options> | params_xgb = {'colsample_bylevel': 0.7, 'learning_rate': 0.03, 'max_depth': 3,
'n_estimators': 400, 'reg_lambda': 15, 'subsample': 0.5}
xgb = XGBClassifier(**params_xgb)
y_preds = xgb.fit(X_train, Y_train ).predict(X_test)
acc_xgb = round(xgb.score(X_train, Y_train)* 100, 2)
print(round(acc_xgb,2,), "%")
| Titanic - Machine Learning from Disaster |
14,602,777 | def on_kaggle() :
return "KAGGLE_KERNEL_RUN_TYPE" in os.environ<install_modules> | results = pd.DataFrame({
'Model': ['LGBMClassifier', 'Logistic Regression',
'Random Forest', 'Boosting',
'Decision Tree','xgb'],
'Score': [ acc_model,acc_log,
acc_random_forest, acc_clf,
acc_decision_tree,acc_xgb]})
result_df = results.sort_values(by='Score', ascending=False)
result_df = result_df.set_index('Score')
... | Titanic - Machine Learning from Disaster |
14,602,777 | if on_kaggle() :
os.system("pip install --quiet mlflow_extend" )<categorify> | rf = RandomForestClassifier(n_estimators=100)
scores = cross_val_score(rf, X_train, Y_train, cv=10, scoring = "accuracy")
print("Scores:", scores)
print("Mean:", scores.mean())
print("Standard Deviation:", scores.std())
| Titanic - Machine Learning from Disaster |
14,602,777 | def reduce_mem_usage(df, verbose=False):
start_mem = df.memory_usage().sum() / 1024 ** 2
int_columns = df.select_dtypes(include=["int"] ).columns
float_columns = df.select_dtypes(include=["float"] ).columns
for col in int_columns:
df[col] = pd.to_numeric(df[col], downcast="integer")
for col in float_columns:
df[col] =... | params_xgb = {'colsample_bylevel': 0.7, 'learning_rate': 0.03, 'max_depth': 3,
'n_estimators': 400, 'reg_lambda': 15, 'subsample': 0.5}
xgb = XGBClassifier(**params_xgb)
y_preds = xgb.fit(X_train, Y_train ).predict(X_test)
print("Score: ",xgb.score, 4*100, "%")
| Titanic - Machine Learning from Disaster |
14,602,777 | def read_data() :
INPUT_DIR = "/kaggle/input" if on_kaggle() else "input"
INPUT_DIR = f"{INPUT_DIR}/m5-forecasting-accuracy"
print("Reading files...")
calendar = pd.read_csv(f"{INPUT_DIR}/calendar.csv" ).pipe(reduce_mem_usage)
prices = pd.read_csv(f"{INPUT_DIR}/sell_prices.csv" ).pipe(reduce_mem_usage)
sales = pd.re... | submission = pd.DataFrame({
"PassengerId": test['PassengerId'],
"Survived": y_preds
})
submission.to_csv('submission.csv', index=False)
| Titanic - Machine Learning from Disaster |
8,950,656 | sales, prices, calendar, submission = read_data()
NUM_ITEMS = sales.shape[0]
DAYS_PRED = submission.shape[1] - 1<categorify> | plt.style.use('seaborn-whitegrid' ) | Titanic - Machine Learning from Disaster |
8,950,656 | def encode_categorical(df, cols):
for col in cols:
le = LabelEncoder()
not_null = df[col][df[col].notnull() ]
df[col] = pd.Series(le.fit_transform(not_null), index=not_null.index)
return df
calendar = encode_categorical(
calendar, ["event_name_1", "event_type_1", "event_name_2", "event_type_2"]
).pipe(reduce_mem_usag... | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.info()
| Titanic - Machine Learning from Disaster |
8,950,656 | def extract_num(ser):
return ser.str.extract(r"(\d+)" ).astype(np.int16)
def reshape_sales(sales, submission, d_thresh=0, verbose=True):
id_columns = ["id", "item_id", "dept_id", "cat_id", "store_id", "state_id"]
product = sales[id_columns]
sales = sales.melt(id_vars=id_columns, var_name="d", value_name="demand",)
sa... | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.info() | Titanic - Machine Learning from Disaster |
8,950,656 | def add_demand_features(df):
for diff in [0, 1, 2]:
shift = DAYS_PRED + diff
df[f"shift_t{shift}"] = df.groupby(["id"])["demand"].transform(
lambda x: x.shift(shift)
)
for window in [7, 30, 60, 90, 180]:
df[f"rolling_std_t{window}"] = df.groupby(["id"])["demand"].transform(
lambda x: x.shift(DAYS_PRED ).rolling(wind... | train_data[train_data['Fare'] > 500] | Titanic - Machine Learning from Disaster |
8,950,656 | class CustomTimeSeriesSplitter:
def __init__(self, n_splits=5, train_days=80, test_days=20, day_col="d"):
self.n_splits = n_splits
self.train_days = train_days
self.test_days = test_days
self.day_col = day_col
def split(self, X, y=None, groups=None):
SEC_IN_DAY = 3600 * 24
sec =(X[self.day_col] - X[self.day_col].iloc[0... | test_data[test_data['Fare'] > 500] | Titanic - Machine Learning from Disaster |
8,950,656 | def show_cv_days(cv, X, dt_col, day_col):
for ii,(tr, tt)in enumerate(cv.split(X)) :
print(f"----- Fold:({ii + 1} / {cv.n_splits})-----")
tr_start = X.iloc[tr][dt_col].min()
tr_end = X.iloc[tr][dt_col].max()
tr_days = X.iloc[tr][day_col].max() - X.iloc[tr][day_col].min() + 1
tt_start = X.iloc[tt][dt_col].min()
tt_end ... | train_data["Fare"].replace({ 512.3292 : 7.25}, inplace=True)
test_data["Fare"].replace({ 512.3292 : 7.25}, inplace=True ) | Titanic - Machine Learning from Disaster |
8,950,656 | features = [
"item_id",
"dept_id",
"cat_id",
"store_id",
"state_id",
"event_name_1",
"event_type_1",
"event_name_2",
"event_type_2",
"snap_CA",
"snap_TX",
"snap_WI",
"sell_price",
"shift_t28",
"shift_t29",
"shift_t30",
"rolling_std_t7",
"rolling_std_t30",
"rolling_std_t60",
"rolling_std_t90",
"rolling_std_t180",
"rolli... | train_data = train_data[(train_data.PassengerId != 259)&(train_data.PassengerId != 680)&(train_data.PassengerId != 738)] | Titanic - Machine Learning from Disaster |
8,950,656 | def train_lgb(bst_params, fit_params, X, y, cv, drop_when_train=None):
models = []
if drop_when_train is None:
drop_when_train = []
for idx_fold,(idx_trn, idx_val)in enumerate(cv.split(X, y)) :
print(f"
----- Fold:({idx_fold + 1} / {cv.get_n_splits() })-----
")
X_trn, X_val = X.iloc[idx_trn], X.iloc[idx_val]
y_trn, y_... | train_data.isna().sum()
| Titanic - Machine Learning from Disaster |
8,950,656 | bst_params = {
"boosting_type": "gbdt",
"metric": "rmse",
"objective": "regression",
"n_jobs": -1,
"seed": 42,
"learning_rate": 0.1,
"bagging_fraction": 0.75,
"bagging_freq": 10,
"colsample_bytree": 0.75,
}
fit_params = {
"num_boost_round": 100_000,
"early_stopping_rounds": 50,
"verbose_eval": 100,
}
models = train_lgb... | test_data.isna().sum() | Titanic - Machine Learning from Disaster |
8,950,656 | def rmse(y_true, y_pred):
return np.sqrt(mean_squared_error(y_true, y_pred))<features_selection> | train_data['Age'] = train_data['Age'].replace(np.nan, 29)
test_data['Age'] = test_data['Age'].replace(np.nan, 30 ) | Titanic - Machine Learning from Disaster |
8,950,656 | imp_type = "gain"
importances = np.zeros(X_test.shape[1])
preds = np.zeros(X_test.shape[0])
for model in models:
preds += model.predict(X_test)
importances += model.feature_importance(imp_type)
preds = preds / cv.get_n_splits()
importances = importances / cv.get_n_splits()<save_to_csv> | train_data = train_data.drop(['Cabin'], axis=1)
test_data = test_data.drop(['Cabin'], axis=1 ) | Titanic - Machine Learning from Disaster |
8,950,656 | def make_submission(test, submission):
preds = test[["id", "date", "demand"]]
preds = preds.pivot(index="id", columns="date", values="demand" ).reset_index()
preds.columns = ["id"] + ["F" + str(d + 1)for d in range(DAYS_PRED)]
vals = submission[["id"]].merge(preds, how="inner", on="id")
evals = submission[submission["... | train_data['Embarked'] = train_data['Embarked'].replace(np.nan, 'Q')
test_data['Fare'] = test_data['Fare'].replace(np.nan, 36.0 ) | Titanic - Machine Learning from Disaster |
8,950,656 | make_submission(id_date.assign(demand=preds), submission )<import_modules> | train_data.isna().sum() | Titanic - Machine Learning from Disaster |
8,950,656 | import os
import sys
import time
import numpy as np
import pandas as pd
import seaborn as sns
from math import sqrt
from sklearn import metrics
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error<load_from_csv> | test_data.isna().sum() | Titanic - Machine Learning from Disaster |
8,950,656 | df1 = pd.read_csv(".. /input/elo-blending/3.695.csv")
df2 = pd.read_csv(".. /input/elo-blending/3.696.csv")
df3 = pd.read_csv(".. /input/submit/submit.csv")
df4 = pd.read_csv(".. /input/combined/combining_submission.csv" )<load_from_csv> | train_data['Title'] = train_data.Name.apply(lambda name: name.split(',')[1].split('.')[0].strip())
train_data.Title.value_counts() | Titanic - Machine Learning from Disaster |
8,950,656 | df_base0 = pd.read_csv('.. /input/elo-blending/3.695.csv', names=["card_id","target0"], skiprows=[0],header=None)
df_base1 = pd.read_csv('.. /input/elo-blending/3.696.csv', names=["card_id","target1"], skiprows=[0],header=None)
df_base2 = pd.read_csv('.. /input/elo-blending/3.6999.csv', names=["card_id","target2"], s... | test_data['Title'] = test_data.Name.apply(lambda name: name.split(',')[1].split('.')[0].strip())
test_data.Title.value_counts() | Titanic - Machine Learning from Disaster |
8,950,656 | df_base = pd.merge(df_base0,df_base1,how='inner',on='card_id')
df_base = pd.merge(df_base,df_base2,how='inner',on='card_id')
df_base = pd.merge(df_base,df_base3,how='inner',on='card_id')
df_base = pd.merge(df_base,df_base4,how='inner',on='card_id')
df_base = pd.merge(df_base,df_base5,how='inner',on='card_id')
df_b... | normalized_titles = {
"Capt": "Officer",
"Col": "Officer",
"Major": "Officer",
"Jonkheer": "Royal",
"Don": "Royal",
"Sir" : "Royal",
"Dr": "Officer",
"Rev": "Officer",
"the Countess":"Royal",
"Dona": "Royal",
"Mme": "Mrs",
"Mlle": "Miss",
"Ms": "Mrs",
"Mr" : "Mr",
"Mrs" : "Mrs",
"Miss" : "Miss",
"Master" : "Master",
"L... | Titanic - Machine Learning from Disaster |
8,950,656 | M = np.zeros([df_base.iloc[:,1:].shape[1],df_base.iloc[:,1:].shape[1]])
for i in np.arange(M.shape[1]):
for j in np.arange(M.shape[1]):
M[i,j] = sqrt(metrics.mean_squared_error(df_base.iloc[:,i+1], df_base.iloc[:,j+1]))<load_from_csv> | test_data.Title.value_counts() | Titanic - Machine Learning from Disaster |
8,950,656 | df_base0 = pd.read_csv('.. /input/elo-blending/3.695.csv', names=["card_id","target0"], skiprows=[0],header=None)
df_base1 = pd.read_csv('.. /input/elo-blending/3.696.csv', names=["card_id","target1"], skiprows=[0],header=None)
df_base10 = pd.read_csv('.. /input/elo-blending/Blending.csv', names=["card_id","target10"... | train_data.Title.value_counts() | Titanic - Machine Learning from Disaster |
8,950,656 | M = np.zeros([df_base.iloc[:,1:].shape[1],df_base.iloc[:,1:].shape[1]])
for i in np.arange(M.shape[1]):
for j in np.arange(M.shape[1]):
M[i,j] = sqrt(metrics.mean_squared_error(df_base.iloc[:,i+1], df_base.iloc[:,j+1]))<feature_engineering> | le = LabelEncoder()
train_data["Sex"] = le.fit_transform(train_data["Sex"].values)
test_data["Sex"] = le.fit_transform(test_data["Sex"].values ) | Titanic - Machine Learning from Disaster |
8,950,656 | df_base['target'] = df_base_median
df_base['target4'] = df4['target']<count_values> | train_data = train_data.drop(['Ticket'], axis=1)
test_data = test_data.drop(['Ticket'], axis=1 ) | Titanic - Machine Learning from Disaster |
8,950,656 | df_final = np.zeros(len(df_base))
a=-10*np.log2(10)
thresh = -14
for i in range(len(df3)-1):
if df3['target'][i]< thresh:
df_final[i]=a
else:
df_final[i]=df_base['target'][i]
pd.Series(df_final ).value_counts().head(1 )<feature_engineering> | train_data["Embarked"].value_counts() | Titanic - Machine Learning from Disaster |
8,950,656 | for i in range(len(df_final)-1):
if df_final[i] > magic:
df_final[i] = df_final[i] - abs(np.median(df_final)) /8 +0.001<save_to_csv> | train_data["Embarked"] = le.fit_transform(train_data["Embarked"].values)
test_data["Embarked"] = le.fit_transform(test_data["Embarked"].values ) | Titanic - Machine Learning from Disaster |
8,950,656 | df_finall=pd.DataFrame(df_base['card_id'])
df_finall['target'] = df_final
df_finall[['card_id','target']].to_csv("good_output.csv",index=False )<import_modules> | train_data["Name"] = le.fit_transform(train_data["Name"].values)
test_data["Name"] = le.fit_transform(test_data["Name"].values ) | Titanic - Machine Learning from Disaster |
8,950,656 | warnings.simplefilter(action='ignore', category=FutureWarning)
plt.style.use('seaborn')
sns.set(font_scale=1 )<load_from_csv> | from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from xgboost import XGBClassifier
import lightgbm as gbm
from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold, cross_val_score
from ... | Titanic - Machine Learning from Disaster |
8,950,656 | df_train = pd.read_csv('.. /input/vsb-power-line-fault-detection/metadata_train.csv')
df_train = df_train.set_index(['id_measurement', 'phase'])
X = np.load(".. /input/folk-base-neural-network-using-lstm/X.npy")
y = np.load(".. /input/folk-base-neural-network-using-lstm/y.npy")
features = np.load(".. /input/folk-ba... | features = ["Pclass","Sex","Age","SibSp","Fare"]
X = train_data[features]
y = train_data['Survived']
X_train,X_test, y_train,y_test = train_test_split(X,y,test_size=0.15)
sc_X = MinMaxScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.transform(X_test ) | Titanic - Machine Learning from Disaster |
8,950,656 | def augment(x,y,t=2):
xs,xn = [],[]
for i in range(t):
mask = y>0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
np.random.shuffle(ids)
x1[:,c] = x1[ids][:,c]
xs.append(x1)
for i in range(t//2):
mask = y==0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
... | pipelineone = Pipeline([('RandomForest', RandomForestClassifier())])
param_grid = {'RandomForest__max_features': ['auto'],
'RandomForest__min_samples_leaf': [1, 2, 4],
'RandomForest__min_samples_split': [2,3,4],
'RandomForest__n_estimators': [100,200,300]}
model = GridSearchCV(pipelineone, param_grid, cv =None)
model... | Titanic - Machine Learning from Disaster |
8,950,656 | %%time
X, y = augment(X,y)
print(X.shape, y.shape )<load_pretrained> | pipelinetwo = Pipeline([('logisticregression', LogisticRegression(max_iter=100)) ])
param_grid = {'logisticregression__penalty' : ['l2'],
'logisticregression__C' : [0.001, 0.01, 0.1, 1, 10, 100, 1000],
'logisticregression__solver' : ['liblinear']}
model = GridSearchCV(pipelinetwo, param_grid, cv =None)
model.fit(X_tr... | Titanic - Machine Learning from Disaster |
8,950,656 | features = np.load('.. /input/vsb-aug-features/aug_features.npy')
features.shape<set_options> | xg = XGBClassifier()
xg.fit(X_train, y_train)
y_pred = xg.predict(X_test)
XGB = accuracy_score(y_test, y_pred)
print(XGB ) | Titanic - Machine Learning from Disaster |
8,950,656 | class Attention(Layer):
def __init__(self, step_dim,
W_regularizer=None, b_regularizer=None,
W_constraint=None, b_constraint=None,
bias=True, **kwargs):
self.supports_masking = True
self.init = initializers.get('glorot_uniform')
self.W_regularizer = regularizers.get(W_regularizer)
self.b_regularizer = regularizers.ge... | KN = KNeighborsClassifier(n_neighbors=3)
KN.fit(X_train, y_train)
y_pred = KN.predict(X_test)
knn = accuracy_score(y_test, y_pred)
print(knn ) | Titanic - Machine Learning from Disaster |
8,950,656 | def matthews_correlation(y_true, y_pred):
y_pred_pos = K.round(K.clip(y_pred, 0, 1))
y_pred_neg = 1 - y_pred_pos
y_pos = K.round(K.clip(y_true, 0, 1))
y_neg = 1 - y_pos
tp = K.sum(y_pos * y_pred_pos)
tn = K.sum(y_neg * y_pred_neg)
fp = K.sum(y_neg * y_pred_pos)
fn = K.sum(y_pos * y_pred_neg)
numerator =(tp * tn -... | svc = SVC()
svc.fit(X_train, y_train)
y_pred = svc.predict(X_test)
SVC = accuracy_score(y_test, y_pred)
print(SVC ) | Titanic - Machine Learning from Disaster |
8,950,656 | def threshold_search(y_true, y_proba):
best_threshold = 0
best_score = 0
for threshold in tqdm([i * 0.01 for i in range(100)]):
score = K.eval(matthews_correlation(y_true.astype(np.float64),(y_proba > threshold ).astype(np.float64)))
if score > best_score:
best_threshold = threshold
best_score = score
search_result = ... | lsvc = LinearSVC(random_state=0)
lsvc.fit(X_train, y_train)
y_pred = lsvc.predict(X_test)
LSVC = accuracy_score(y_test, y_pred)
print(LSVC ) | Titanic - Machine Learning from Disaster |
8,950,656 | def model_lstm(input_shape, feat_shape):
inp = Input(shape=(input_shape[1], input_shape[2],))
feat = Input(shape=(feat_shape[1],))
bi_lstm_1 = Bidirectional(CuDNNLSTM(128, return_sequences=True), merge_mode='concat' )(inp)
bi_lstm_2 = Bidirectional(CuDNNGRU(64, return_sequences=True), merge_mode='concat' )(bi_lstm_1)
... | finalleaderboard = {
"Random Forest": forest,
"logistic regression": logistic,
"XGB": XGB,
"KNeighborsClassifier": knn,
"SVC": SVC,
"Linear SVC": LSVC
}
finalleaderboard = pd.DataFrame.from_dict(finalleaderboard, orient='index', columns=['Accuracy'])
print(finalleaderboard ) | Titanic - Machine Learning from Disaster |
8,950,656 | N_SPLITS = 5
splits = list(StratifiedKFold(n_splits=N_SPLITS, shuffle=True, random_state=2019 ).split(X, y))
preds_val = []
y_val = []
for idx,(train_idx, val_idx)in enumerate(splits):
K.clear_session()
print("Beginning fold {}".format(idx+1))
train_X, train_feat, train_y, val_X, val_feat, val_y = X[train_idx], feature... | output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': y_pred_sub})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
8,950,656 | def matthews_correlation(y_true, y_pred):
y_pred = tf.convert_to_tensor(y_pred, np.float64)
y_true = tf.convert_to_tensor(y_true, np.float64)
y_pred_pos = K.round(K.clip(y_pred, 0, 1))
y_pred_neg = 1 - y_pred_pos
y_pos = K.round(K.clip(y_true, 0, 1))
y_neg = 1 - y_pos
tp = K.sum(y_pos * y_pred_pos)
tn = K.sum(y_ne... | print(np.count_nonzero(y_pred))
| Titanic - Machine Learning from Disaster |
14,635,724 | optimal_values = threshold_search(y_val, preds_val)
best_threshold = optimal_values['threshold']
best_score = optimal_values['matthews_correlation']<load_from_csv> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
14,635,724 | meta_test = pd.read_csv('.. /input/vsb-power-line-fault-detection/metadata_test.csv')
X_test_input = np.load(".. /input/folk-base-neural-network-using-lstm/X_test.npy")
features_test = np.load(".. /input/folk-base-neural-network-using-lstm/features_test.npy")
submission = pd.read_csv('.. /input/vsb-power-line-fault-... | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
14,635,724 | preds_test = []
for i in range(N_SPLITS):
model.load_weights('weights_{}.h5'.format(i))
pred = model.predict([X_test_input, features_test], batch_size=300, verbose=1)
pred_3 = []
for pred_scalar in pred:
for i in range(3):
pred_3.append(pred_scalar)
preds_test.append(pred_3)
<compute_test_metric> | women = train_data.loc[train_data.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
print("% of women who survived:", rate_women ) | Titanic - Machine Learning from Disaster |
14,635,724 | optimal_values = threshold_search(y_val, preds_val)
best_threshold = optimal_values['threshold']
best_score = optimal_values['matthews_correlation']
<data_type_conversions> | men = train_data.loc[train_data.Sex == 'male']["Survived"]
rate_men = sum(men)/len(men)
print("% of men who survived:", rate_men ) | Titanic - Machine Learning from Disaster |
14,635,724 | preds_test =(np.squeeze(np.mean(preds_test, axis=0)) > best_threshold ).astype(np.int)
preds_test.shape<save_to_csv> | train_data["Age"] = train_data["Age"].fillna(train_data["Age"].median())
train_data["Embarked"] = train_data["Embarked"].fillna('S')
train_data.loc[train_data["Embarked"] == "S", "Embarked"] = 0
train_data.loc[train_data["Embarked"] == "C", "Embarked"] = 1
train_data.loc[train_data["Embarked"] == "Q", "Embarked"] = 2... | Titanic - Machine Learning from Disaster |
14,635,724 | submission['target'] = preds_test
submission.to_csv('submission.csv', index=False)
submission.head()<load_from_csv> | test_data["Age"] = test_data["Age"].fillna(test_data["Age"].median())
test_data["Fare"] = test_data["Fare"].fillna(test_data["Fare"].median())
test_data.loc[test_data["Embarked"] == "S", "Embarked"] = 0
test_data.loc[test_data["Embarked"] == "C", "Embarked"] = 1
test_data.loc[test_data["Embarked"] == "Q", "Embarked"]... | Titanic - Machine Learning from Disaster |
14,635,724 | v_raw_train = pq.read_pandas('.. /input/vsb-power-line-fault-detection/train.parquet' ).to_pandas().values
meta_train = np.loadtxt('.. /input/vsb-power-line-fault-detection/metadata_train.csv', skiprows=1, delimiter=',')
y_train = meta_train[:, 3].astype(bool)
print(v_raw_train.shape )<define_search_space> | y = train_data["Survived"]
features = ["Pclass", "Sex", 'Age',"SibSp", "Parch",'Embarked']
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
RF1 = RandomForestClassifier(n_estimators=700, max_depth=7, max_features=5 , n_jobs=-1)
adaboost = AdaBoostClassifier(RF1,n_estimators=10)
... | Titanic - Machine Learning from Disaster |
14,635,724 | def compute_spectra(v_raw, *, m = 1000):
percentile =(100, 99, 95, 0, 1, 5)
n = v_raw.shape[1]
length = v_raw.shape[0] // m
n_spectra = len(percentile)
mean_signal = np.zeros(( n, length), dtype='float32')
percentile_spectra = np.zeros(( n, length, n_spectra), dtype='float32')
print('computing spectra...', flush=... | scores = model_selection.cross_val_score(adaboost, X, y, cv=10)
print('The scores mean is :',scores.mean())
print('The Best Score:',scores.max())
predictions = adaboost.predict(X_test ) | Titanic - Machine Learning from Disaster |
14,635,724 | <normalization><EOS> | output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
14,525,173 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | pd.options.mode.chained_assignment = None
| Titanic - Machine Learning from Disaster |
14,525,173 | knowledge_data = pd.read_csv('.. /input/vsb-knowledge-0744/sub_ens_v16.csv' )<load_from_csv> | test_data = pd.read_csv('.. /input/titanic/test.csv')
train_data = pd.read_csv('.. /input/titanic/train.csv')
comb = [train_data, test_data] | Titanic - Machine Learning from Disaster |
14,525,173 | if 'v_raw_train' in globals() :
del v_raw_train
id_test = np.loadtxt('.. /input/vsb-power-line-fault-detection/metadata_test.csv', skiprows=1, delimiter=',')[:, 0].astype(int)
n_test = len(id_test)
X_tests = []
n_subset = 4
nread = 0
for i_subset in range(n_subset):
ibegin = 8712 + 3*int(n_test // 3 *(i_subset/n_subs... | for ds in comb:
age_avg = ds['Age'].mean()
age_std = ds['Age'].std()
age_nan = ds['Age'].isnull().sum()
age_rand_list = np.random.randint(age_avg - age_std, age_avg + age_std, size=age_nan)
ds['Age'][np.isnan(ds['Age'])] = age_rand_list
ds['Age'] = ds['Age'].astype(int ) | Titanic - Machine Learning from Disaster |
14,525,173 | len_train=len(X_all3)
y_list=knowledge_data['target'].values
y_test=[]
for j in range(0,len(y_list),3):
y_test.append(y_list[j])
y_test=np.asarray(y_test)
del knowledge_data
print(X_all3.shape,y_all3.shape)
print(X_test.shape,y_test.shape)
X_all3=np.concatenate([X_all3,X_test])
y_all3=np.concatenate([y_all3,y_tes... | emb_mode = comb[0]['Embarked'].mode().at[0]
comb[0]['Embarked'] = comb[0]['Embarked'].fillna(emb_mode ) | Titanic - Machine Learning from Disaster |
14,525,173 | n_splits = 5
models = []
scores = np.zeros(n_splits)
print('Training...')
print('MCC training & cv')
seeds=[0,42,1204,2019]
for seed in seeds:
splits = list(sklearn.model_selection.StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=seed ).split(X_all3, y_all3))
for i,(idx_train, idx_cv)in enumerate(splits... | fare = float(comb[1]['Fare'].mode())
comb[1]['Fare'] = comb[1]['Fare'].fillna(fare ) | Titanic - Machine Learning from Disaster |
14,525,173 |
<predict_on_test> | for ds in comb:
ds['Cabin_Null'] = ds['Cabin'].isnull().astype(int)
pd.crosstab(comb[0]['Cabin_Null'], comb[0]['Survived'] ) | Titanic - Machine Learning from Disaster |
14,525,173 | y_test_probas = np.empty(( X_test.shape[0], n_splits*len(seeds)))
for i, model in enumerate(models):
y_test_probas[:, i] = model.predict_proba(X_test)[:, 1]
y_test_proba = np.mean(y_test_probas, axis=1)
y_submit = np.repeat(y_test_proba > 0.25, 3)
print('Positive fraction %d/%d = %.3f' %(
np.sum(y_submit), len(y_su... | comb[0][['Cabin_Null', 'Survived']].groupby(['Cabin_Null'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | assert(len(id_test)== len(y_submit))
n = len(id_test)
with open('submission.csv', 'w')as f:
f.write('signal_id,target
')
for i in range(n):
f.write('%d,%d
' %(id_test[i], int(y_submit[i])))
print('submission.csv written' )<import_modules> | for daset in comb:
daset['TickType'] = 0
tic_let = daset['Ticket'].str.extract(r'(^\S+)')
daset['TickType'] = tic_let
daset['TickType'] = daset['TickType'].fillna('Other')
comb[0]['TickType'].unique() | Titanic - Machine Learning from Disaster |
14,525,173 | import os
import pandas as pd
import numpy as np
import pyarrow.parquet as pq
from keras.layers import *
from keras.callbacks import *
from keras.initializers import *
from keras import optimizers
from keras import backend as K
from keras.models import Model
import tensorflow as tf
from sklearn.model_selection import S... | for dataset in comb:
for letter in "ACFPSW":
let_regex = r"^(" + letter + ".*)"
l_tic = dataset.TickType.str.extract(let_regex ).dropna(axis=0 ).reset_index(drop=True)
tic_l_list = list(l_tic[0].unique())
dataset['TickType'].replace(tic_l_list, letter, inplace=True)
pd.crosstab(comb[0].TickType, comb[0].Survived ) | Titanic - Machine Learning from Disaster |
14,525,173 | sample_size = 800000<load_from_csv> | for ds in comb:
ds['TickType'] = ds['TickType'].replace('F', 'Other')
comb[0][['TickType', 'Survived']].groupby(['TickType'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | df_train = pd.read_csv('.. /input/metadata_train.csv')
df_train = df_train.set_index(['id_measurement', 'phase'])
df_train.head()<normalization> | for ds in comb:
ds['RelatAboard'] = ds['SibSp'] + ds['Parch']
comb[0][['RelatAboard', 'Survived']].groupby(['RelatAboard'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | max_num = 127
min_num = -128
def min_max_transf(ts, min_data, max_data, range_needed=(-1,1)) :
if min_data < 0:
ts_std =(ts + abs(min_data)) /(max_data + abs(min_data))
else:
ts_std =(ts - min_data)/(max_data - min_data)
if range_needed[0] < 0:
return ts_std *(range_needed[1] + abs(range_needed[0])) + range_needed[0]
... | for ds in comb:
ds['OTTmembers'] = 2
ds.loc[ds['RelatAboard'] == 0, 'OTTmembers'] = 0
ds.loc[(ds['RelatAboard'] == 1)|(ds['RelatAboard'] == 2), 'OTTmembers'] = 1
ds.loc[ds['RelatAboard'] == 3, 'OTTmembers'] = 3
comb[0][['OTTmembers', 'Survived']].groupby(['OTTmembers'], as_index=False ).mean().sort_values(by='Survived'... | Titanic - Machine Learning from Disaster |
14,525,173 | def transform_ts(ts, n_dim=160, min_max=(-1,1)) :
ts_std = min_max_transf(ts, min_data=min_num, max_data=max_num)
bucket_size = int(sample_size / n_dim)
new_ts = []
for i in range(0, sample_size, bucket_size):
ts_range = ts_std[i:i + bucket_size]
mean = ts_range.mean()
std = ts_range.std()
std_top = mean + std
std_bo... | for ds in comb:
ds['Rank'] = 0
rank = ds['Name'].str.extract(r'(\w+\.) ')
ds['Rank'] = rank
ranks = set(comb[0]['Rank'].values)
print(ranks ) | Titanic - Machine Learning from Disaster |
14,525,173 | def prep_data(start, end):
praq_train = pq.read_pandas('.. /input/train.parquet', columns=[str(i)for i in range(start, end)] ).to_pandas()
X = []
y = []
for id_measurement in tqdm(df_train.index.levels[0].unique() [int(start/3):int(end/3)]):
X_signal = []
for phase in [0,1,2]:
signal_id, target = df_train.loc[id_measur... | ot_list = ['Capt.', 'Col.', 'Countess.', 'Don.', 'Dr.', 'Jonkheer.', 'Rev.', 'Sir.', 'Major.']
miss_list = ['Lady.', 'Mlle.', 'Mme.', 'Ms.']
for dataset in comb:
dataset['Rank'].replace(ot_list, 'Other', inplace=True)
dataset['Rank'].replace(miss_list, 'Miss.', inplace=True)
comb[0][['Rank', 'Survived']].groupby(['Ra... | Titanic - Machine Learning from Disaster |
14,525,173 | X = []
y = []
def load_all() :
total_size = len(df_train)
for ini, end in [(0, int(total_size/2)) ,(int(total_size/2), total_size)]:
X_temp, y_temp = prep_data(ini, end)
X.append(X_temp)
y.append(y_temp)
load_all()
X = np.concatenate(X)
y = np.concatenate(y )<compute_test_metric> | comb[0]['AgeGroup'] = pd.cut(comb[0]['Age'], 5)
comb[0][['AgeGroup', 'Survived']].groupby(['AgeGroup'], as_index=False ).mean().sort_values(by='AgeGroup', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | def matthews_correlation(y_true, y_pred):
y_pred = tf.convert_to_tensor(y_pred, np.float32)
y_true = tf.convert_to_tensor(y_true, np.float32)
y_pred_pos = K.round(K.clip(y_pred, 0, 1))
y_pred_neg = 1 - y_pred_pos
y_pos = K.round(K.clip(y_true, 0, 1))
y_neg = 1 - y_pos
tp = K.sum(y_pos * y_pred_pos)
tn = K.sum(y_neg ... | for ds in comb:
ds.loc[ds['Age'] < 16, 'Age'] = 0
ds.loc[(ds['Age'] >= 16)&(ds['Age'] < 48), 'Age'] = 1
ds.loc[(ds['Age'] >= 48)&(ds['Age'] < 64), 'Age'] = 2
ds.loc[ds['Age'] >= 64, 'Age'] = 3
ds['Age'] = ds['Age'].astype(int)
comb[0][['Age', 'Survived']].groupby(['Age'], as_index=False ).mean().sort_values(by='Surviv... | Titanic - Machine Learning from Disaster |
14,525,173 | class Attention(Layer):
def __init__(self, step_dim,
W_regularizer=None, b_regularizer=None,
W_constraint=None, b_constraint=None,
bias=True, **kwargs):
self.supports_masking = True
self.init = initializers.get('glorot_uniform')
self.W_regularizer = regularizers.get(W_regularizer)
self.b_regularizer = regularizers.ge... | for ds in comb:
ds.loc[ds['Fare'] <= 10.5, 'Fare'] = 0
ds.loc[(ds['Fare'] > 10.5)&(ds['Fare'] <= 39.688), 'Fare'] = 1
ds.loc[ds['Fare'] > 39.688, 'Fare'] = 2
ds['Fare'] = ds['Fare'].astype(int)
comb[0][['Fare', 'Survived']].groupby(['Fare'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | def squash(x, axis=-1):
s_squared_norm = K.sum(K.square(x), axis, keepdims=True)
scale = K.sqrt(s_squared_norm + K.epsilon())
return x / scale
class Capsule(Layer):
def __init__(self, num_capsule, dim_capsule, routings=3, kernel_size=(9, 1), share_weights=True,
activation='default', **kwargs):
super(Capsule, self )._... | s_dict = {'male': 0, 'female': 1}
for ds in comb:
ds['Sex'] = ds['Sex'].map(s_dict)
ds['Embarked'] = ds['Embarked'].astype('category' ).cat.codes
ds['TickType'] = ds['TickType'].astype('category' ).cat.codes
ds['Rank'] = ds['Rank'].astype('category' ).cat.codes | Titanic - Machine Learning from Disaster |
14,525,173 | def model_lstm(input_shape):
inp = Input(shape=(input_shape[1], input_shape[2],))
x = Bidirectional(CuDNNLSTM(128, return_sequences=True,
kernel_initializer=glorot_normal(seed=1029),
recurrent_initializer=orthogonal(gain=1.0, seed=1029)) )(inp)
x = Bidirectional(CuDNNLSTM(128, return_sequences=True,
kernel_initializer... | drop_col_test = ['Cabin', 'Name', 'Parch', 'SibSp', 'RelatAboard', 'Ticket']
drop_col_train = drop_col_test.copy()
drop_col_train.extend(['FareGroup', 'AgeGroup', 'PassengerId'])
comb[0] = comb[0].drop(columns=drop_col_train)
comb[1] = comb[1].drop(columns=drop_col_test ) | Titanic - Machine Learning from Disaster |
14,525,173 | N_SPLITS = 5
splits = list(StratifiedKFold(n_splits=N_SPLITS, shuffle=True, random_state=1029 ).split(X, y))
preds_val = []
y_val = []
best_scores = []
for idx,(train_idx, val_idx)in enumerate(splits):
K.clear_session()
print("Beginning fold {}".format(idx+1))
train_X, train_y, val_X, val_y = X[train_idx], y[train_idx]... | train = comb[0]
test = comb[1] | Titanic - Machine Learning from Disaster |
14,525,173 | preds_val = np.concatenate(preds_val)[...,0]
y_val = np.concatenate(y_val)
print(preds_val.shape, y_val.shape )<compute_test_metric> | train[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | def threshold_search(y_true, y_proba):
best_threshold = 0
best_score = 0
for threshold in tqdm([i * 0.01 for i in range(100)]):
score = K.eval(matthews_correlation(y_true.astype(np.float64),(y_proba > threshold ).astype(np.float64)))
if score > best_score:
best_threshold = threshold
best_score = score
search_result = ... | train[['Sex', 'Survived']].groupby(['Sex'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | best_threshold = threshold_search(y_val, preds_val)['threshold']
print(best_threshold )<load_from_csv> | train[['Age', 'Survived']].groupby(['Age'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | meta_test = pd.read_csv('.. /input/metadata_test.csv')
meta_test = meta_test.set_index(['signal_id'])
meta_test.head()<define_variables> | train[['Fare', 'Survived']].groupby(['Fare'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | %%time
first_sig = meta_test.index[0]
n_parts = 10
max_line = len(meta_test)
part_size = int(max_line / n_parts)
last_part = max_line % n_parts
start_end = [[x, x+part_size] for x in range(first_sig, max_line + first_sig, part_size)]
start_end = start_end[:-1] + [[start_end[-1][0], start_end[-1][0] + last_part]]
X_te... | train[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | submission = pd.read_csv('.. /input/sample_submission.csv' )<concatenate> | train[['Cabin_Null', 'Survived']].groupby(['Cabin_Null'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | X_test_input = np.asarray([np.concatenate([X_test[i][3],X_test[i+1][3], X_test[i+2][3]], axis=1)for i in range(0,len(X_test), 3)])
X_test_input.shape<predict_on_test> | train[['TickType', 'Survived']].groupby(['TickType'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | preds_test = []
for i in range(N_SPLITS):
model.load_weights('weights_{}.h5'.format(i))
pred = model.predict(X_test_input, batch_size=300, verbose=1)
pred_3 = []
for pred_scalar in pred:
for i in range(3):
pred_3.append(pred_scalar)
preds_test.append(pred_3 )<data_type_conversions> | train[['OTTmembers', 'Survived']].groupby(['OTTmembers'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | preds_test =(np.squeeze(np.mean(preds_test, axis=0)) > best_threshold ).astype(np.int)
preds_test.shape<save_to_csv> | train[['Rank', 'Survived']].groupby(['Rank'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,525,173 | submission['target'] = preds_test
submission.to_csv('submission.csv', index=False)
submission.head(10 )<count_values> | y_list = list(train['Survived'])
y = pd.Series(y_list, name='Survived')
X = train.drop(columns='Survived')
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2 ) | Titanic - Machine Learning from Disaster |
14,525,173 | submission.target.value_counts().sort_index()<import_modules> | random_forest = RandomForestClassifier(bootstrap=True, n_estimators=700, criterion='entropy')
random_forest.fit(X_train, y_train)
print("Accuracy on train data: ", random_forest.score(X_train, y_train))
print("Accuracy on test data: ", random_forest.score(X_test, y_test)) | Titanic - Machine Learning from Disaster |
14,525,173 | import pandas as pd
import pyarrow.parquet as pq
import os
import numpy as np
from keras.layers import *
from keras.models import *
from tqdm import tqdm
from sklearn.model_selection import train_test_split
from keras import backend as K
from keras import optimizers
from sklearn.model_selection import GridSearchCV, Str... | params={'n_neighbors' : range(1, 20), 'leaf_size' : range(1, 50)}
knn_grid = GridSearchCV(KNeighborsClassifier() , params, scoring='roc_auc')
knn_grid.fit(X_train, y_train)
print("Accuracy on train data: ", knn_grid.score(X_train, y_train))
print("Accuracy on test data: ", knn_grid.score(X_test, y_test)) | Titanic - Machine Learning from Disaster |
14,525,173 | N_SPLITS = 5
sample_size = 800000<compute_test_metric> | params2 = {'alpha' : [0.00001, 0.0001, 0.001, 0.01, 1, 10, 100, 1000], 'normalize' : [True, False], 'random_state' : [0, 50, 100, 150, 200]}
r_grid = GridSearchCV(RidgeClassifier() , params2, scoring='roc_auc')
r_grid.fit(X_train, y_train)
print("Accuracy on train data: ", r_grid.score(X_train, y_train))
print("Accur... | Titanic - Machine Learning from Disaster |
14,525,173 | def matthews_correlation(y_true, y_pred):
y_pred_pos = K.round(K.clip(y_pred, 0, 1))
y_pred_neg = 1 - y_pred_pos
y_pos = K.round(K.clip(y_true, 0, 1))
y_neg = 1 - y_pos
tp = K.sum(y_pos * y_pred_pos)
tn = K.sum(y_neg * y_pred_neg)
fp = K.sum(y_neg * y_pred_pos)
fn = K.sum(y_pos * y_pred_neg)
numerator =(tp * tn -... | svm_classifier = svm.SVC(kernel="poly", C=3, degree=6)
svm_classifier.fit(X_train, y_train)
print("Accuracy on train data: ", svm_classifier.score(X_train, y_train))
print("Accuracy on test data: ", svm_classifier.score(X_test, y_test)) | Titanic - Machine Learning from Disaster |
14,525,173 | class Attention(Layer):
def __init__(self, step_dim,
W_regularizer=None, b_regularizer=None,
W_constraint=None, b_constraint=None,
bias=True, **kwargs):
self.supports_masking = True
self.init = initializers.get('glorot_uniform')
self.W_regularizer = regularizers.get(W_regularizer)
self.b_regularizer = regularizers.ge... | gbm = xgb.XGBClassifier(
learning_rate = 0.02,
use_label_encoder=False,
n_estimators= 2000,
max_depth= 4,
min_child_weight= 2,
gamma=0.9,
subsample=0.8,
colsample_bytree=0.8,
objective= 'binary:logistic',
nthread= -1,
eval_metric = 'error',
scale_pos_weight=1 ).fit(X_train, y_train)
print("Accuracy on train data: ", ... | Titanic - Machine Learning from Disaster |
14,525,173 | df_train = pd.read_csv('.. /input/metadata_train.csv')
df_train = df_train.set_index(['id_measurement', 'phase'])
df_train.head()<define_variables> | Y_train_full = train['Survived']
X_train_full = train.drop(columns='Survived')
X_test_full = test.drop(columns='PassengerId')
X_train_full.shape, X_test_full.shape, Y_train_full.shape | Titanic - Machine Learning from Disaster |
14,525,173 | max_num = 127
min_num = -128<categorify> | model = svm.SVC(kernel="poly", C=2)
model.fit(X_train_full, Y_train_full)
print("Accuracy on train data: ", model.score(X_train_full, Y_train_full)) | Titanic - Machine Learning from Disaster |
14,525,173 | def min_max_transf(ts, min_data, max_data, range_needed=(-1,1)) :
if min_data < 0:
ts_std =(ts + abs(min_data)) /(max_data + abs(min_data))
else:
ts_std =(ts - min_data)/(max_data - min_data)
if range_needed[0] < 0:
return ts_std *(range_needed[1] + abs(range_needed[0])) + range_needed[0]
else:
return ts_std *(range_n... | y_test_predicted = model.predict(X_test_full)
y_test_predicted | Titanic - Machine Learning from Disaster |
14,525,173 | def transform_ts(ts, n_dim=160, min_max=(-1,1)) :
ts_std = min_max_transf(ts, min_data=min_num, max_data=max_num)
bucket_size = int(sample_size / n_dim)
new_ts = []
for i in range(0, sample_size, bucket_size):
ts_range = ts_std[i:i + bucket_size]
mean = ts_range.mean()
std = ts_range.std()
std_top = mean + std
std_bo... | sub = pd.DataFrame({
"PassengerId": comb[1]['PassengerId'],
"Survived": y_test_predicted
})
sub.to_csv('submission.csv', index = False ) | 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.