kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,697,036 | df['size'] = df['question_text'].str.len()
print(mean(df['size']))
print(median(df['size']))
print(stdev(df['size']))
print(amax(df['size']))
print(amin(df['size']))<define_variables> | print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))
for feature in zip(features, model.feature_importances_):
print(feature)
| Titanic - Machine Learning from Disaster |
9,697,036 | punct_mapping = {"‘": "'", "₹": "e", "´": "'", "°": "", "€": "eur","$": "usd", "™": "tm", "√": " sqrt ", "×": "x", "²": "2", "—": "-", "–": "-", "’": "'", "_": "-", "`": "'", '“': '"', '”': '"', '“': '"', "£": "e", '∞': 'infinity', 'θ': 'theta', '÷': '/', 'α': 'alpha', '•': '.', 'à': 'a', '−': '-', 'β': 'beta', '∅': ''... | predictions = model.predict(X_test_r ) | Titanic - Machine Learning from Disaster |
9,697,036 | <feature_engineering><EOS> | output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Se guardó el csv")
| Titanic - Machine Learning from Disaster |
8,264,973 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Titanic - Machine Learning from Disaster |
8,264,973 |
<define_variables> | train_init_df=pd.read_csv('/kaggle/input/titanic/train.csv')
train_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | mispell_dict = {'colour': 'color', 'centre': 'center', 'favourite': 'favorite', 'travelling': 'traveling', 'counselling': 'counseling', 'theatre': 'theater', 'cancelled': 'canceled', 'labour': 'labor', 'organisation': 'organization', 'wwii': 'world war 2', 'citicise': 'criticize', 'youtu ': 'youtube ', 'Qoura': 'Quora'... | test_init_df=pd.read_csv('/kaggle/input/titanic/test.csv')
test_PassengerId = test_init_df["PassengerId"]
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | def correct_spelling(x, dic):
for word in dic.keys() :
x = x.replace(word, dic[word])
return x<feature_engineering> | train_init_df.isnull().sum() | Titanic - Machine Learning from Disaster |
8,264,973 | df['question_text'] = df['question_text'].apply(lambda x: correct_spelling(x, mispell_dict))<feature_engineering> | train_init_df=train_init_df.drop(['Cabin','PassengerId'],axis=1 ) | Titanic - Machine Learning from Disaster |
8,264,973 | df['size'] = df['question_text'].str.len()
print(mean(df['size']))
print(median(df['size']))
print(stdev(df['size']))
print(amax(df['size']))
print(amin(df['size']))
df = df.drop(['size'],axis=1 )<prepare_x_and_y> | train_init_df[["Pclass","Survived"]].groupby(["Pclass"], as_index = False ).mean().sort_values(by = "Survived", ascending = False ) | Titanic - Machine Learning from Disaster |
8,264,973 | total_set_qid = df['qid'].values
total_set_X = df["question_text"].fillna("_na_" ).values
total_set_y = df['target'].values<string_transform> | train_init_df[["Sex","Survived"]].groupby(["Sex"], as_index = False ).mean().sort_values(by = "Survived", ascending = False ) | Titanic - Machine Learning from Disaster |
8,264,973 | tokenizer = Tokenizer(num_words=None, filters='')
tokenizer.fit_on_texts(list(total_set_X))
total_set_X = tokenizer.texts_to_sequences(total_set_X )<string_transform> | train_init_df[["SibSp","Survived"]].groupby(["SibSp"], as_index = False ).mean().sort_values(by = "Survived", ascending = False ) | Titanic - Machine Learning from Disaster |
8,264,973 | total_set_X = pad_sequences(total_set_X, maxlen=question_length)
<create_dataframe> | train_init_df[["Parch","Survived"]].groupby(["Parch"], as_index = False ).mean().sort_values(by = "Survived", ascending = False ) | Titanic - Machine Learning from Disaster |
8,264,973 | df = pd.concat([pd.DataFrame(total_set_qid),pd.DataFrame(total_set_X), pd.DataFrame(total_set_y)], axis=1, keys=["qid", "question_text", "target"] )<categorify> | train_init_df[["Embarked","Survived"]].groupby(["Embarked"], as_index = False ).mean().sort_values(by = "Survived", ascending = False ) | Titanic - Machine Learning from Disaster |
8,264,973 | def embedding_matrix_creator(embeddings_index):
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_std = all_embs.mean() , all_embs.std()
embed_size = all_embs.shape[1]
word_index = tokenizer.word_index
nb_words = len(word_index)
embedding_matrix = np.random.normal(emb_mean, emb_std,(nb_words+1, embed_size))... | def checkNameSalutations(name):
salutation = re.findall(r'(\w{2,})\.',name)
return salutation[0] | Titanic - Machine Learning from Disaster |
8,264,973 | emb_matrix = embedding_matrix_creator(my_embedding_matrix )<drop_column> | train_init_df['Salutation']=train_init_df['Name'].apply(checkNameSalutations)
train_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 |
<set_options> | train_init_df[["Salutation","Survived"]].groupby(["Salutation"], as_index = False ).mean().sort_values(by = "Survived", ascending = False ) | Titanic - Machine Learning from Disaster |
8,264,973 |
<split> | def binaryGender(val):
if val=='male':
return 0
elif val=='female':
return 1 | Titanic - Machine Learning from Disaster |
8,264,973 | train_df, val_df = train_test_split(df[df.target[0]!=-1], test_size=0.1)
train_X = np.array(train_df["question_text"])
train_y = np.array(train_df["target"])
val_X = np.array(val_df["question_text"])
val_y = np.array(val_df["target"] )<drop_column> | train_init_df['Sex']= train_init_df['Sex'].apply(binaryGender)
train_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | test_df = df[df.target[0]==-1]
test_X=np.array(test_df["question_text"])
<compute_test_metric> | train_init_df[["Sex","Survived"]].groupby(["Sex"], as_index = False ).mean().sort_values(by = "Survived", ascending = False ) | Titanic - Machine Learning from Disaster |
8,264,973 | def f1(y_true, y_pred):
def recall(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
recall = true_positives /(possible_positives + K.epsilon())
return recall
def precision(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y... | def checkAplphabetInTicket(ticket):
alpha=re.findall(r'(\w{1,}\D)',ticket)
if len(alpha)!=0:
return 1
else:
return 0 | Titanic - Machine Learning from Disaster |
8,264,973 | 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... | train_init_df['Alpha_ticket']= train_init_df['Ticket'].apply(checkAplphabetInTicket)
train_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | def make_old_model(embedding_matrix, embed_size=300, loss='binary_crossentropy'):
inp = Input(shape=(question_length,))
x = Embedding(embedding_matrix.shape[0], embed_size, weights=[embedding_matrix], trainable=False )(inp)
x = Bidirectional(CuDNNGRU(128, return_sequences=True))(x)
x = Bidirectional(CuDNNGRU(64, retu... | train_init_df['Alpha_ticket'].value_counts() | Titanic - Machine Learning from Disaster |
8,264,973 | def model_lstm_gru_atten(embedding_matrix, embed_size=300, loss='binary_crossentropy'):
inp = Input(shape=(question_length,))
x = Embedding(embedding_matrix.shape[0], embed_size, weights=[embedding_matrix], trainable=False )(inp)
x = SpatialDropout1D(0.1,seed=seed_nb )(x)
x = Bidirectional(CuDNNLSTM(64, kernel_initia... | train_init_df[["Alpha_ticket","Survived"]].groupby(["Alpha_ticket"], as_index = False ).mean().sort_values(by = "Survived", ascending = False ) | Titanic - Machine Learning from Disaster |
8,264,973 | checkpoints = ModelCheckpoint('weights.hdf5', monitor="val_f1", mode="max", verbose=True, save_best_only=True)
reduce_lr = ReduceLROnPlateau(monitor='val_f1', factor=0.1, patience=2, verbose=1, min_lr=0.000001 )<compute_test_metric> | train_init_df["Salutation"] = train_init_df["Salutation"].replace(["Lady","Countess","Capt","Col","Don","Dr","Major","Rev","Sir","Jonkheer","Dona"],"other")
train_init_df["Salutation"] = [0 if i == "Master" else 1 if i == "Miss" or i == "Ms" or i == "Mlle" or i == "Mrs" else 2 if i == "Mr" else 3 for i in train_init_d... | Titanic - Machine Learning from Disaster |
8,264,973 | def tweak_threshold(pred, truth):
thresholds = []
scores = []
print("Threshold: Valor")
for thresh in np.arange(0.01, 1.01, 0.01):
thresh = np.round(thresh, 2)
thresholds.append(thresh)
score = f1_score(truth,(pred>thresh ).astype(int))
print(thresh, ": ", score)
scores.append(score)
return np.max(scores), thresho... | train_init_df.drop(labels= ["Name"], axis = 1, inplace = True)
| Titanic - Machine Learning from Disaster |
8,264,973 | df_X = df[df.target[0]!=-1]["question_text"]
df_y = df[df.target[0]!=-1]["target"]
train_meta = np.zeros(df_y.shape)
test_meta = np.zeros(test_X.shape[0])
my_splits = list(StratifiedKFold(n_splits=K_FOLDS,
shuffle=True,
random_state=DATA_SPLIT_SEED ).split(df_X, df_y))
for idx,(train_idx, valid_idx)in enumerate(my_sp... | train_init_df.drop(labels= ["Ticket"], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
8,264,973 | score_val, best_thresh = tweak_threshold(train_meta, df_y)
print("=====================================")
print(f"Scored {round(score_val, 4)} for threshold {best_thresh} with untreated texts on validation data" )<save_to_csv> | train_init_df.isnull().sum() | Titanic - Machine Learning from Disaster |
8,264,973 | y_te =(np.array(test_meta)> best_thresh ).astype(np.int)
qid = test_df["qid"].values
submit_df = pd.concat([pd.DataFrame(qid, columns=['qid']),pd.DataFrame(y_te, columns=['prediction'])], axis = 1)
submit_df.to_csv("submission_cesc.csv", index=False )<set_options> | train_init_df["Embarked"] = train_init_df["Embarked"].fillna("C")
train_init_df[train_init_df["Embarked"].isnull() ] | Titanic - Machine Learning from Disaster |
8,264,973 | %matplotlib inline
pd.set_option('max_colwidth',400)
warnings.filterwarnings("ignore", message="F-score is ill-defined and being set to 0.0 due to no predicted samples.")
<set_options> | index_nan_age = list(train_init_df["Age"][train_init_df["Age"].isnull() ].index)
for i in index_nan_age:
age_pred = train_init_df["Age"][(( train_init_df["SibSp"] == train_init_df.iloc[i]["SibSp"])&(train_init_df["Parch"] == train_init_df.iloc[i]["Parch"])&(train_init_df["Pclass"] == train_init_df.iloc[i]["Pclass"])) ... | Titanic - Machine Learning from Disaster |
8,264,973 | def seed_torch(seed=1029):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True<load_from_csv> | train_init_df = pd.get_dummies(train_init_df,columns = ["Embarked"])
train_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
sub = pd.read_csv('.. /input/sample_submission.csv' )<define_variables> | train_init_df = pd.get_dummies(train_init_df,columns = ["Salutation"])
train_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | sin = len(train[train["target"] == 0])
insin = len(train[train["target"] == 1])
tot = sin + insin
print("Train sincere text total {}".format(sin))
print("Train insincere text total {}".format(insin))
print("Sincere percentage = {0:.2f}".format(sin*100/tot))
print("Sincere percentage = {0:.2f}".format(insin*100/tot))<... | train_init_df = pd.get_dummies(train_init_df,columns = ["Pclass"])
train_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | print('Average word length of questions in train is {0:.0f}.'.format(np.mean(train['question_text'].apply(lambda x: len(x.split())))))
print('Average word length of questions in test is {0:.0f}.'.format(np.mean(test['question_text'].apply(lambda x: len(x.split())))) )<string_transform> | train_init_df = pd.get_dummies(train_init_df,columns = ["Alpha_ticket"])
train_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | print('Max word length of questions in train is {0:.0f}.'.format(np.max(train['question_text'].apply(lambda x: len(x.split())))))
print('Max word length of questions in test is {0:.0f}.'.format(np.max(test['question_text'].apply(lambda x: len(x.split())))) )<compute_test_metric> | train_init_df["Sex"] = train_init_df["Sex"].astype("category")
train_init_df = pd.get_dummies(train_init_df, columns = ["Sex"])
train_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | print('Average character length of questions in train is {0:.0f}.'.format(np.mean(train['question_text'].apply(lambda x: len(x)))))
print('Average character length of questions in test is {0:.0f}.'.format(np.mean(test['question_text'].apply(lambda x: len(x)))) )<define_variables> | train_init_df["Fsize"] = train_init_df["SibSp"] + train_init_df["Parch"] + 1
train_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | train_init_df["family_size"] = [1 if i < 5 else 0 for i in train_init_df["Fsize"]]
train_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | max_features = 120000
tk = Tokenizer(lower = True, filters='', num_words=max_features)
full_text = list(train['question_text'].values)+ list(test['question_text'].values)
tk.fit_on_texts(full_text )<string_transform> | train_init_df = pd.get_dummies(train_init_df, columns= ["family_size"])
train_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | train_tokenized = tk.texts_to_sequences(train['question_text'].fillna('_
test_tokenized = tk.texts_to_sequences(test['question_text'].fillna('_<categorify> | test_df = train_init_df.copy(deep=True)
test_df.drop(labels = ["Survived"],axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
8,264,973 | max_len = 72
maxlen = 72
X_train = pad_sequences(train_tokenized, maxlen = max_len)
X_test = pad_sequences(test_tokenized, maxlen = max_len )<prepare_x_and_y> | train = train_init_df.copy(deep=True)
X_train = train.drop(labels = "Survived", axis = 1)
y_train = train["Survived"]
X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size = 0.33, random_state = 42)
print("X_train",len(X_train))
print("X_test",len(X_test))
print("y_train",len(y_train))
prin... | Titanic - Machine Learning from Disaster |
8,264,973 | y_train = train['target'].values<compute_test_metric> | logreg = LogisticRegression()
logreg.fit(X_train, y_train)
acc_log_train = round(logreg.score(X_train, y_train)*100,2)
acc_log_test = round(logreg.score(X_test, y_test)*100,2)
print("Training Accuracy: % {}".format(acc_log_train))
print("Testing Accuracy: % {}".format(acc_log_test)) | Titanic - Machine Learning from Disaster |
8,264,973 | def sigmoid(x):
return 1 /(1 + np.exp(-x))<split> | random_state = 42
classifier = [DecisionTreeClassifier(random_state = random_state),
SVC(random_state = random_state),
RandomForestClassifier(random_state = random_state),
LogisticRegression(random_state = random_state),
KNeighborsClassifier() ]
dt_param_grid = {"min_samples_split" : range(10,500,20),
"max_depth": rang... | Titanic - Machine Learning from Disaster |
8,264,973 | splits = list(StratifiedKFold(n_splits=4, shuffle=True, random_state=10 ).split(X_train, y_train))<statistical_test> | cv_result = []
best_estimators = []
for i in range(len(classifier)) :
clf = GridSearchCV(classifier[i], param_grid=classifier_param[i], cv = StratifiedKFold(n_splits = 10), scoring = "accuracy", n_jobs = -1,verbose = 1)
clf.fit(X_train,y_train)
cv_result.append(clf.best_score_)
best_estimators.append(clf.best_estima... | Titanic - Machine Learning from Disaster |
8,264,973 | embed_size = 300
embedding_path = ".. /input/embeddings/glove.840B.300d/glove.840B.300d.txt"
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embedding_index = dict(get_coefs(*o.split(" ")) for o in open(embedding_path, encoding='utf-8', errors='ignore'))
emb_mean,emb_std = -0.005838499, 0.48782... | votingC = VotingClassifier(estimators = [("dt",best_estimators[0]),
("rfc",best_estimators[2]),
("lr",best_estimators[3])],
voting = "soft", n_jobs = -1)
votingC = votingC.fit(X_train, y_train)
print(accuracy_score(votingC.predict(X_test),y_test)) | Titanic - Machine Learning from Disaster |
8,264,973 | embedding_path = ".. /input/embeddings/paragram_300_sl999/paragram_300_sl999.txt"
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embedding_index = dict(get_coefs(*o.split(" ")) for o in open(embedding_path, encoding='utf-8', errors='ignore')if len(o)>100)
emb_mean,emb_std = -0.0053247833, 0.4... | test_init_df.drop(['Cabin'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,264,973 | embedding_matrix = np.mean([embedding_matrix, embedding_matrix1], axis=0)
del embedding_matrix1<normalization> | test_final_sub=test_init_df['PassengerId'] | Titanic - Machine Learning from Disaster |
8,264,973 | class Attention(nn.Module):
def __init__(self, feature_dim, step_dim, bias=True, **kwargs):
super(Attention, self ).__init__(**kwargs)
self.supports_masking = True
self.bias = bias
self.feature_dim = feature_dim
self.step_dim = step_dim
self.features_dim = 0
weight = torch.zeros(feature_dim, 1)
nn.init.xavier_uniform... | test_init_df['Salutation']=test_init_df['Name'].apply(checkNameSalutations)
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | m = NeuralNet()
print(m )<train_model> | test_init_df["Salutation"] = test_init_df["Salutation"].replace(["Lady","Countess","Capt","Col","Don","Dr","Major","Rev","Sir","Jonkheer","Dona"],"other")
test_init_df["Salutation"] = [0 if i == "Master" else 1 if i == "Miss" or i == "Ms" or i == "Mlle" or i == "Mrs" else 2 if i == "Mr" else 3 for i in test_init_df["S... | Titanic - Machine Learning from Disaster |
8,264,973 | def train_model(model, x_train, y_train, x_val, y_val, validate=True):
optimizer = torch.optim.Adam(model.parameters())
train = torch.utils.data.TensorDataset(x_train, y_train)
valid = torch.utils.data.TensorDataset(x_val, y_val)
train_loader = torch.utils.data.DataLoader(train, batch_size=batch_size, shuffle=True)
... | test_init_df.isnull().sum() | Titanic - Machine Learning from Disaster |
8,264,973 | x_test_cuda = torch.tensor(X_test, dtype=torch.long ).cuda()
test = torch.utils.data.TensorDataset(x_test_cuda)
batch_size = 512
test_loader = torch.utils.data.DataLoader(test, batch_size=batch_size, shuffle=False )<compute_train_metric> | test_init_df.drop(['Name'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
8,264,973 | seed=1029
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)], disable=True):
score = f1_score(y_true=y_true, y_pred=y_proba > threshold)
if score > best_score:
best_threshold = threshold
best_score = score
search_result = {'threshold': best_thr... | test_init_df['Sex']= test_init_df['Sex'].apply(binaryGender)
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | train_preds = np.zeros(len(train))
test_preds = np.zeros(( len(test), len(splits)))
n_epochs = 5
for i,(train_idx, valid_idx)in enumerate(splits):
x_train_fold = torch.tensor(X_train[train_idx], dtype=torch.long ).cuda()
y_train_fold = torch.tensor(y_train[train_idx, np.newaxis], dtype=torch.float32 ).cuda()
x_val_fol... | test_init_df['Alpha_ticket']= test_init_df['Ticket'].apply(checkAplphabetInTicket)
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | search_result = threshold_search(y_train, train_preds)
print(search_result)
sub['prediction'] = test_preds.mean(1)> search_result['threshold']
sub.to_csv("submission.csv", index=False )<import_modules> | test_init_df['Alpha_ticket'].value_counts() | Titanic - Machine Learning from Disaster |
8,264,973 | pd.set_option("display.max_colwidth", 200)
sns.set_style('darkgrid')
pd.options.display.float_format = '{:,.3f}'.format<load_from_csv> | test_init_df.drop(labels= ["Ticket"], axis = 1, inplace = True)
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | %%time
train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
print(train.shape, test.shape )<drop_column> | index_nan_age = list(test_init_df["Age"][test_init_df["Age"].isnull() ].index)
for i in index_nan_age:
age_pred = test_init_df["Age"][(( test_init_df["SibSp"] == test_init_df.iloc[i]["SibSp"])&(test_init_df["Parch"] == test_init_df.iloc[i]["Parch"])&(test_init_df["Pclass"] == test_init_df.iloc[i]["Pclass"])) ].median(... | Titanic - Machine Learning from Disaster |
8,264,973 | train = reduce_mem_usage(train)
test = reduce_mem_usage(test )<normalization> | test_init_df[test_init_df["Fare"].isnull() ] | Titanic - Machine Learning from Disaster |
8,264,973 | punct_mapping = {"‘": "'", "₹": "e", "´": "'", "°": "", "€": "e", "™": "tm", "√": " sqrt ", "×": "x", "²": "2", "—": "-", "–": "-", "’": "'", "_": "-", "`": "'", '“': '"', '”': '"', '“': '"', "£": "e", '∞': 'infinity', 'θ': 'theta', '÷': '/', 'α': 'alpha', '•': '.', 'à': 'a', '−': '-', 'β': 'beta', '∅': '', '³': '3', '... | test_init_df["Fare"] = test_init_df["Fare"].fillna(np.mean(test_init_df[test_init_df["Pclass"] == 3]["Fare"])) | Titanic - Machine Learning from Disaster |
8,264,973 | text_to_word_sequence(train['question_text'].values[0] )<prepare_x_and_y> | test_init_df[test_init_df["Fare"].isnull() ] | Titanic - Machine Learning from Disaster |
8,264,973 | X_train = train.drop(['qid','target'], axis=1)
Y_train = train['target']
X_test = test.drop(['qid'], axis=1)
del train, test
print(X_train.shape, X_test.shape )<load_pretrained> | test_init_df = pd.get_dummies(test_init_df,columns = ["Embarked"])
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | TARGET_COLUMN = 'target'
TEXT_COLUMN = 'question_text'
MAX_NUM_WORDS = 300000
TOKENIZER_FILTER = '\r\t
'
tokenizer = Tokenizer(num_words=MAX_NUM_WORDS, filters=TOKENIZER_FILTER)
tokenizer.fit_on_texts(list(X_train[TEXT_COLUMN])+ list(X_test[TEXT_COLUMN]))<sort_values> | test_init_df = pd.get_dummies(test_init_df,columns = ["Salutation"])
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | tokenizer_tx = Tokenizer(num_words=MAX_NUM_WORDS, filters=TOKENIZER_FILTER)
tokenizer_tx.fit_on_texts(list(X_train.loc[Y_train == 1, TEXT_COLUMN]))
counter = sorted(dict(tokenizer_tx.word_docs ).items() , key=lambda x:x[1], reverse=True)
wordcount_tx = pd.Series([x[1] for x in counter], [x[0] for x in counter])
word... | test_init_df = pd.get_dummies(test_init_df,columns = ["Pclass"])
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | wordcount = pd.concat([wordcount_tx['all'], wordcount] ).to_frame().reset_index()
wordcount.drop_duplicates(keep='first', inplace=True)
wordcount = wordcount.set_index('index')[0]
del counter, wordcount_tx, wordcount_stats<define_variables> | test_init_df = pd.get_dummies(test_init_df,columns = ["Alpha_ticket"])
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | VOCAB_SIZE = 50000
print('covered until', wordcount[VOCAB_SIZE], 'times word' )<define_variables> | test_init_df["Sex"] = test_init_df["Sex"].astype("category")
test_init_df = pd.get_dummies(test_init_df, columns = ["Sex"])
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | %%time
EMBEDDINGS_DIMENSION = 300
EMBEDDING_FILE = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
def get_coefs(word, *arr):
return word, np.asarray(arr, dtype='float32')
def load_embeddings(path):
with open(path)as f:
return dict(get_coefs(*line.strip().split(' ')) for line in f)
def build_matrix(path):
... | test_init_df["Fsize"] = test_init_df["SibSp"] + test_init_df["Parch"] + 1
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | words_count = len(unknown_words_glove)
print('n unknown words(glove):', words_count, ', {:.3%} of all words'.format(words_count / n_words))
print('unknown words(glove):', unknown_words_glove )<string_transform> | test_init_df["family_size"] = [1 if i < 5 else 0 for i in test_init_df["Fsize"]]
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | MAX_SEQUENCE_LENGTH = 128
def word_index(word):
try:
return word2index[word]
except KeyError:
return VOCAB_SIZE
def pad_text(texts, tokenizer):
matrix = [list(map(word_index, text_to_word_sequence(t, filters=TOKENIZER_FILTER)))for t in texts]
return pad_sequences(matrix, maxlen=MAX_SEQUENCE_LENGTH)
train_text = pad_te... | test_init_df = pd.get_dummies(test_init_df, columns= ["family_size"])
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | del(X_train, X_test)
gc.collect()
print(pd.DataFrame([[val for val in dir() ], [sys.getsizeof(eval(val)) for val in dir() ]],
index=['name','size'] ).T.sort_values('size', ascending=False ).reset_index(drop=True)[:10] )<compute_train_metric> | test_init_df.drop(['PassengerId'],axis=1,inplace=True)
test_init_df.head() | Titanic - Machine Learning from Disaster |
8,264,973 | class F1Callback(Callback):
def __init__(self):
self.f1s = []
def on_epoch_end(self, epoch, logs):
eps = np.finfo(np.float32 ).eps
recall = logs["val_true_positives"] /(logs["val_possible_positives"] + eps)
precision = logs["val_true_positives"] /(logs["val_predicted_positives"] + eps)
f1 = 2*precision*recall /(preci... | test_survived = pd.Series(votingC.predict(test_init_df), name = "Survived" ).astype(int)
results = pd.concat([test_PassengerId, test_survived],axis = 1)
results.to_csv("titanic.csv", index = False ) | Titanic - Machine Learning from Disaster |
12,482,554 | 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... | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
12,482,554 | def build_model(lr=0.0, lr_d=0.0, units=64, spatial_dr=0.0,
dense_units=0, dr=0.1, conv_size=32, epochs=20):
file_path = "best_model.hdf5"
check_point = ModelCheckpoint(file_path, monitor="val_loss", verbose=1, save_best_only=True, mode="min")
early_stop = EarlyStopping(monitor="val_loss", mode="min", patience=3)
seq... | full_data['Fare']=full_data['Fare'].map(lambda x: np.log(x)if x>0 else 0 ) | Titanic - Machine Learning from Disaster |
12,482,554 | model = build_model(lr=1e-3, lr_d=1e-7, units=64, spatial_dr=0.2, dense_units=64, dr=0.1, conv_size=64, epochs=10)
pred = model.predict(test_text, batch_size=1024 )<compute_train_metric> | full_data['Cabin'] = full_data['Cabin'].fillna('Unkown')
full_data['Cabin'].head() | Titanic - Machine Learning from Disaster |
12,482,554 | def threshold_search(y_true, y_proba):
best_threshold = 0
best_score = 0
for threshold in [i * 0.01 for i in range(100)]:
score = f1_score(y_true=y_true, y_pred=y_proba > threshold)
if score > best_score:
best_threshold = threshold
best_score = score
search_result = {'threshold': best_threshold, 'f1': best_score}
retu... | full_data[full_data['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
12,482,554 | pred =(pred[:,0] > 0.5 ).astype(np.int)
submission = pd.read_csv('.. /input/sample_submission.csv', index_col='qid')
submission['prediction'] = pred
submission.reset_index(drop=False, inplace=True)
submission.to_csv('submission.csv', index=False)
submission.head()<count_values> | full_data['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
12,482,554 | pd.Series(pred ).value_counts().to_frame().T / len(pred )<import_modules> | full_data['Embarked']=full_data['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
12,482,554 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import preprocessing
from xgboost import XGBRegressor
from sklearn.tree import DecisionTreeClassifier<import_modules> | full_data[full_data['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
12,482,554 | from fastai import *
from fastai.tabular import *
from fastai.callbacks import *<define_variables> | full_data['Fare'] = full_data['Fare'].fillna(full_data[(full_data['Pclass']==3)&(full_data['Embarked']=='S')&(full_data['Cabin']=='U')]['Fare'].mean() ) | Titanic - Machine Learning from Disaster |
12,482,554 | path1 = "/kaggle/input/covid19-global-forecasting-week-4"
path2 = "/kaggle/input/covid19-demographic-predictors"
path3 = "/kaggle/input/covid19-country-data-wk3-release"
path4 = "/kaggle/input/countryinfo"<load_from_csv> | full_data['Title']=full_data['Name'].map(lambda x:x.split(',')[1].split('.')[0].strip())
full_data['Title'].value_counts() | Titanic - Machine Learning from Disaster |
12,482,554 | train_df = pd.read_csv(f"{path1}/train.csv", parse_dates=['Date'])
test_df = pd.read_csv(f"{path1}/test.csv", parse_dates=['Date'] )<feature_engineering> | TitleDict={}
TitleDict['Mr']='Mr'
TitleDict['Mlle']='Miss'
TitleDict['Miss']='Miss'
TitleDict['Master']='Master'
TitleDict['Jonkheer']='Master'
TitleDict['Mme']='Mrs'
TitleDict['Ms']='Mrs'
TitleDict['Mrs']='Mrs'
TitleDict['Don']='Royalty'
TitleDict['Sir']='Royalty'
TitleDict['the Countess']='Royalty'
TitleDict['Dona']=... | Titanic - Machine Learning from Disaster |
12,482,554 | add_datepart(train_df, 'Date', drop=False )<feature_engineering> | TickCountDict = {}
TickCountDict = full_data['Ticket'].value_counts()
TickCountDict.head() | Titanic - Machine Learning from Disaster |
12,482,554 | add_datepart(test_df, 'Date', drop=False )<drop_column> | full_data['TickGroup'] = full_data['Ticket'].map(TickCountDict)
full_data['TickGroup'].head() | Titanic - Machine Learning from Disaster |
12,482,554 | missed = "NA"
def State(state, country):
if state == missed: return country
return state<load_from_csv> | AgePre = full_data[['Age','Parch','Pclass','SibSp','Title','familySize','TickGroup']]
AgePre = pd.get_dummies(AgePre)
ParAge = pd.get_dummies(AgePre['Parch'],prefix='Parch')
SibAge = pd.get_dummies(AgePre['SibSp'],prefix='SibSp')
PclAge = pd.get_dummies(AgePre['Pclass'],prefix='Pclass')
AgeCorrDf = pd.DataFrame()
A... | Titanic - Machine Learning from Disaster |
12,482,554 | metadata_df = pd.read_csv(f"{path3}/Data Join - RELEASE.csv", thousands=',' )<load_from_csv> | AgePre = pd.concat([AgePre,ParAge,SibAge,PclAge],axis=1)
AgePre.head() | Titanic - Machine Learning from Disaster |
12,482,554 | country_df = pd.read_csv(f"{path4}/covid19countryinfo.csv",thousands=",", parse_dates=['quarantine', 'schools', 'publicplace', 'gathering', 'nonessential'] )<load_from_csv> | Age_train = AgePre[AgePre['Age'].notnull() ]
Age_test = AgePre[AgePre['Age'].isnull() ]
AgeKnown_X = Age_train.drop(['Age'],axis=1)
AgeKnown_Y = Age_train['Age'] | Titanic - Machine Learning from Disaster |
12,482,554 | testinfo = pd.read_csv(f'{path4}/covid19tests.csv', thousands="," )<drop_column> | Age_X_test = Age_test.drop(['Age'],axis=1 ) | Titanic - Machine Learning from Disaster |
12,482,554 | country_df.rename(columns={'region': 'Province_State', 'country': 'Country_Region'}, inplace=True)
testinfo.rename(columns={'region': 'Province_State', 'country': 'Country_Region'}, inplace=True)
testinfo = testinfo.drop(['alpha3code', 'alpha2code', 'date'], axis=1 )<define_variables> | rfr=RandomForestRegressor(random_state=None,n_estimators=500,n_jobs=-1)
rfr.fit(AgeKnown_X,AgeKnown_Y)
print(rfr.score(AgeKnown_X,AgeKnown_Y)) | Titanic - Machine Learning from Disaster |
12,482,554 | group_cols = ['Country_Region', 'Province_State']<groupby> | AgeUnKnown_Y = rfr.predict(Age_X_test)
full_data.loc[full_data['Age'].isnull() ,['Age']] = AgeUnKnown_Y
full_data.info() | Titanic - Machine Learning from Disaster |
12,482,554 | group = train_df[train_df["Fatalities"] > 1].groupby(group_cols)
res_df =(group.Fatalities.last() / group.ConfirmedCases.last() ).reset_index()
fatalities = res_df.rename(columns={0 : 'FatalityRate'} )<groupby> | fullSel = fullSel.drop(['Family','SibSp','TickGroup','Parch'],axis=1)
fullSel = pd.get_dummies(fullSel)
PclassDf = pd.get_dummies(full_data['Pclass'],prefix='Pclass')
TickGroupDf = pd.get_dummies(full_data['TickGroup'],prefix='TickGroup')
familySizeDf = pd.get_dummies(full_data['familySize'],prefix='familySize')
f... | Titanic - Machine Learning from Disaster |
12,482,554 | group = train_df[train_df['ConfirmedCases'] >= 1].groupby(group_cols)
first_confirmed = group.Dayofyear.first().reset_index().rename(columns={'Dayofyear': "First_Confirmed"} )<groupby> | kfold = StratifiedKFold(n_splits=10)
experData = fullSel[fullSel['Survived'].notnull() ]
preData = fullSel[fullSel['Survived'].isnull() ]
experData_X = experData.drop('Survived',axis=1)
experData_y = experData['Survived']
preData_X = preData.drop('Survived',axis=1)
modelLR = LogisticRegression()
LR_param_grid = {'C'... | Titanic - Machine Learning from Disaster |
12,482,554 | group = train_df[train_df['ConfirmedCases'] >= 50].groupby(group_cols)
first_50= group.Dayofyear.first().reset_index().rename(columns={'Dayofyear': "First_50"} )<groupby> | print("Accuracy: ", modelgsLR.best_score_ ) | Titanic - Machine Learning from Disaster |
12,482,554 | group = train_df[train_df['ConfirmedCases'] >= 100].groupby(group_cols)
first_hundred = group.Dayofyear.first().reset_index().rename(columns={'Dayofyear': "First_Hundred"} )<merge> | 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]
}
modelgsGBC = GridSearchCV(GBC,param_grid = gb_param_grid, cv=kfold,
scoring="accuracy", n_jobs= ... | Titanic - Machine Learning from Disaster |
12,482,554 | <merge><EOS> | GBCpreData_y=modelgsGBC.predict(preData_X)
GBCpreData_y=GBCpreData_y.astype(int)
GBCpreResultDf=pd.DataFrame()
GBCpreResultDf['PassengerId']=full_data['PassengerId'][full_data['Survived'].isnull() ]
GBCpreResultDf['Survived']=GBCpreData_y
GBCpreResultDf
GBCpreResultDf.to_csv('submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
12,072,456 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<merge> | warnings.filterwarnings('ignore')
RS=81 | Titanic - Machine Learning from Disaster |
12,072,456 | test_df = pd.merge(test_df, metadata_df, how='left')
test_df = pd.merge(test_df, country_df, how='left')
test_df = pd.merge(test_df, testinfo, how='left', left_on=group_cols, right_on=group_cols)
test_df = pd.merge(test_df, fatalities, how='left')
test_df = pd.merge(test_df, first_confirmed, how='left')
test_df = ... | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
12,072,456 | for df in [train_df, test_df]:
df['Province_State'].fillna(missed, inplace=True)
df['Province_State'] = df.loc[:, ['Province_State', 'Country_Region']].apply(lambda x : State(x['Province_State'], x['Country_Region']), axis=1)
df.loc[:, 'Date'] = df.Date.dt.strftime("%m%d")
df["Date"] = df["Date"].astype(int )<catego... | data=pd.concat([train, test], sort = True ).reset_index(drop=True)
data.info() | Titanic - Machine Learning from Disaster |
12,072,456 | le = preprocessing.LabelEncoder()
for df in [train_df, test_df]:
df['Country_Region'] = le.fit_transform(df['Country_Region'])
df['Province_State'] = le.fit_transform(df['Province_State'] )<prepare_x_and_y> | def replace_titles(x):
title=x['Title']
if title in ['Don', 'Major', 'Capt', 'Jonkheer', 'Rev', 'Col', 'Sir']:
return 'Mr'
elif title in ['Countess', 'Mme', 'Lady', 'Dona']:
return 'Mrs'
elif title in ['Mlle', 'Ms']:
return 'Miss'
elif title =='Dr':
if x['Sex']=='Male':
return 'Mr'
else:
return 'Mrs'
else:
return title... | Titanic - Machine Learning from Disaster |
12,072,456 | sub = pd.DataFrame({'ForecastId': [], 'ConfirmedCases': [], 'Fatalities': []})
features = ['Country_Region', 'Province_State', 'Date']
for country in range(len(countries)) :
country_train = train_df.loc[train_df['Country_Region'] == countries[country]]
country_test = test_df.loc[test_df['Country_Region'] == countries[... | data['Age']=data.groupby(['Title', 'Pclass'])['Age'].apply(lambda x: x.fillna(x.median()))
data['Fare'].fillna(data['Fare'].median() , inplace=True ) | Titanic - Machine Learning from Disaster |
12,072,456 | sub.ForecastId = sub.ForecastId.astype('int')
sub.to_csv('submission.csv', index=False )<import_modules> | data['Family_Size']=data['SibSp']+data['Parch']
data['Alone']=[1 if x==0 else 0 for x in data['SibSp']+data['Parch']] | Titanic - Machine Learning from Disaster |
12,072,456 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import sys
import os
import time
from tqdm import tqdm
from tqdm.keras import TqdmCallback
from datetime import timedelta
from copy import deepcopy
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
i... | data['Surname'] =data.Name.str.extract(r'([A-Za-z]+),', expand=False)
df=data[data.duplicated(['Ticket','Surname'], keep=False)]
dfg=df.groupby(['Ticket','Surname'])[['Survived']].max().fillna(0.5)
data=pd.merge(data, dfg.rename(columns={'Survived':'FamSurvived'}), how='left', on=['Ticket','Surname'])
data['FamSurvi... | Titanic - Machine Learning from Disaster |
12,072,456 | train_path = '.. /input/covid19-global-forecasting-week-4/train.csv'
test_path = '.. /input/covid19-global-forecasting-week-4/test.csv'
sub_path = '.. /input/covid19-global-forecasting-week-4/submission.csv'<load_from_csv> | data['Age_T']=PowerTransformer().fit_transform(data[['Age']])
data['Fare_T']=PowerTransformer().fit_transform(data[['Fare']] ) | Titanic - Machine Learning from Disaster |
12,072,456 | df = pd.read_csv('.. /input/covid19-global-forecasting-week-4/train.csv')
df.tail()<load_from_csv> | data = pd.get_dummies(data, columns=['Title'], drop_first=True ) | Titanic - Machine Learning from Disaster |
12,072,456 | def load_csv(path):
df = pd.read_csv(path)
df.fillna('None', inplace=True)
return df<categorify> | train = data[:len(train)]
test = data[len(train):].drop(['Survived'],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.