kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
521,447 | def compute_spearmanr(trues, preds):
rhos = []
for col_trues, col_pred in zip(trues.T, preds.T):
rhos.append(spearmanr(col_trues, col_pred + np.random.normal(0, 1e-7, col_pred.shape[0])).correlation)
return np.mean(rhos)
<choose_model_class> | grid.best_score_ | Titanic - Machine Learning from Disaster |
521,447 | def train_bert_model(input_units,output_units):
input_word_ids = tf.keras.layers.Input(( input_units,), dtype=tf.int32, name='input_word_ids')
input_masks = tf.keras.layers.Input(( input_units,), dtype=tf.int32, name='input_masks')
input_segments = tf.keras.layers.Input(( input_units,), dtype=tf.int32, name='input_se... | grid.best_params_ | Titanic - Machine Learning from Disaster |
521,447 |
<define_variables> | grid.score(X_test, y_test ) | Titanic - Machine Learning from Disaster |
521,447 | test_predictions = []
test_predictions.append(test_preds)
final_predictions = np.mean(test_predictions, axis=0)
final_predictions.shape<save_to_csv> | lg = grid.best_estimator_ | Titanic - Machine Learning from Disaster |
521,447 | submission.iloc[:,1:] = final_predictions
submission.to_csv('submission.csv', index=False)
submission.head()<load_from_csv> | lg.fit(train_set[features_], train_set[target] ) | Titanic - Machine Learning from Disaster |
521,447 |
<define_variables> | pred = lg.predict(test_set[features_] ) | Titanic - Machine Learning from Disaster |
521,447 | krig.seed_everything()<set_options> | df_pred = pd.concat([raw_test["PassengerId"], pd.Series(pred, name="Survived")], axis=1 ) | Titanic - Machine Learning from Disaster |
521,447 | pd.set_option('use_inf_as_na', True)
pd.set_option('display.max_columns', 999)
pd.set_option('display.max_rows', 999 )<define_variables> | df_pred['Survived'] = df_pred.Survived.astype(int)
df_pred.head() | Titanic - Machine Learning from Disaster |
521,447 | IS_KAGGLE = True
QUESTION_MODEL_NAME = 'question_bert_base_uncased_20200210_191831'
ANSWER_MODEL_NAME = 'answer_bert_base_uncased_20200210_202316'
MAX_SEQUENCE_LENGTH = 512
STRIDE = 50
WINDOW_LENGTH = 100
QUESTION_LABELS = [
'question_asker_intent_understanding', 'question_body_critical', 'question_conversational',
'qu... | df_pred.to_csv("out.csv", index=False ) | Titanic - Machine Learning from Disaster |
11,719,494 | corrs = pd.read_csv(f'{BASE_DIR}/{QUESTION_MODEL_NAME}/corrs.csv')
print(f'q mean(corr)={corrs["corr"].mean() :.4f}')
corrs.head(len(QUESTION_LABELS))<load_from_csv> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.impute import SimpleImputer
from sklear... | Titanic - Machine Learning from Disaster |
11,719,494 | corrs = pd.read_csv(f'{BASE_DIR}/{ANSWER_MODEL_NAME}/corrs.csv')
print(f'a mean(corr)={corrs["corr"].mean() :.4f}')
corrs.head(len(ANSWER_LABELS))<load_from_csv> | train=pd.read_csv('/kaggle/input/titanic/train.csv')
test=pd.read_csv('/kaggle/input/titanic/test.csv')
train.head() | Titanic - Machine Learning from Disaster |
11,719,494 | hist = pd.read_csv(f'{BASE_DIR}/{QUESTION_MODEL_NAME}/history.csv')
hist.head(len(hist))<load_from_csv> | test_id=test['PassengerId']
df=pd.concat([train,test],axis=0)
df.head()
print(df.info() ) | Titanic - Machine Learning from Disaster |
11,719,494 | hist = pd.read_csv(f'{BASE_DIR}/{ANSWER_MODEL_NAME}/history.csv')
hist.head(len(hist))<load_from_csv> | df=df.drop(['PassengerId','Cabin','Ticket'],axis=1)
df['Age'].fillna(df['Age'].median() ,inplace=True)
df['Fare'].fillna(df['Fare'].median() ,inplace=True)
df['Embarked'].fillna(df['Embarked'].mode() [0],inplace=True ) | Titanic - Machine Learning from Disaster |
11,719,494 | %%time
test = pd.read_csv('.. /input/google-quest-challenge/test.csv')
test.info()<load_pretrained> | df['Familysize']=df['SibSp']+df['Parch']
df['IsAlone']=1
df['IsAlone'].loc[df['Familysize']>=1]=0
df['FareBin']=pd.cut(df['Fare'],4)
df['AgeBin']=pd.cut(df['Age'].astype(int),5)
df['Title']=df['Name'].str.split(",",expand=True)[1].str.split('.',expand=True)[0]
min=10
title_names = df['Title'].value_counts() < min
df[... | Titanic - Machine Learning from Disaster |
11,719,494 | %%time
tokenizer = BertTokenizer.from_pretrained(f'{BASE_DIR}/{QUESTION_MODEL_NAME}')
ds = gqc.Dataset(key_column='qa_id')
ds.preprocess(test, tokenizer, first_seq_columns=QUESTION_FIRST_SEQUENCE,
second_seq_columns=QUESTION_SECOND_SEQUENCE,
max_sequence_length=MAX_SEQUENCE_LENGTH, window_length=WINDOW_LENGTH, stride... | label=LabelEncoder()
df['Sex_Code']=label.fit_transform(df['Sex'])
df['Embarked_Code']=label.fit_transform(df['Embarked'])
df['Title_Code']=label.fit_transform(df['Title'])
df['FareBin_Code']=label.fit_transform(df['FareBin'])
df['Age_Code']=label.fit_transform(df['AgeBin'])
df.head() | Titanic - Machine Learning from Disaster |
11,719,494 | %%time
y_pred = model.predict(x_test)
print(f'y_pred.shape={np.shape(y_pred)}' )<create_dataframe> | df=df.drop(['Name'],axis=1)
df=pd.get_dummies(df)
df.head() | Titanic - Machine Learning from Disaster |
11,719,494 | q = pd.DataFrame(y_pred, columns=QUESTION_LABELS)
q['qa_id'] = ds.df['qa_id'].values
q = q.groupby(['qa_id'], as_index=False)[QUESTION_LABELS].median()
q.info()<load_pretrained> | cX=ctrain.drop(['Survived'],axis=1)
cy=ctrain[['Survived']] | Titanic - Machine Learning from Disaster |
11,719,494 | %%time
tokenizer = BertTokenizer.from_pretrained(f'{BASE_DIR}/{ANSWER_MODEL_NAME}')
ds = gqc.Dataset(key_column='qa_id')
ds.preprocess(test, tokenizer, first_seq_columns=ANSWER_FIRST_SEQUENCE,
second_seq_columns=ANSWER_SECOND_SEQUENCE,
max_sequence_length=MAX_SEQUENCE_LENGTH, window_length=WINDOW_LENGTH, stride=STRID... | cX_train, cX_test, cy_train, cy_test = train_test_split(cX,cy,stratify=cy,test_size=0.2,random_state=1 ) | Titanic - Machine Learning from Disaster |
11,719,494 | %%time
y_pred = model.predict(x_test)
print(f'y_pred.shape={np.shape(y_pred)}' )<create_dataframe> | lcv=LassoCV()
lcv.fit(cX_train,cy_train)
lcv_mask=lcv.coef_!=0
print(sum(lcv_mask)) | Titanic - Machine Learning from Disaster |
11,719,494 | a = pd.DataFrame(y_pred, columns=ANSWER_LABELS)
a['qa_id'] = ds.df['qa_id'].values
a = a.groupby(['qa_id'], as_index=False)[ANSWER_LABELS].median()
a.info()<concatenate> | rfe_rf=RFE(estimator=RandomForestClassifier() ,n_features_to_select=12,verbose=1)
rfe_rf.fit(cX_train,cy_train)
rf_mask=rfe_rf.support_ | Titanic - Machine Learning from Disaster |
11,719,494 | qa = pd.concat([q, a], axis=1)
qa.head()<load_from_csv> | rfe_gb=RFE(estimator=GradientBoostingClassifier() ,n_features_to_select=12,verbose=1)
rfe_gb.fit(cX_train,cy_train)
gb_mask=rfe_gb.support_ | Titanic - Machine Learning from Disaster |
11,719,494 | sub = pd.read_csv('.. /input/google-quest-challenge/sample_submission.csv')
sub.iloc[:, 1:] = qa[QUESTION_LABELS + ANSWER_LABELS].values
gqc.check_submission(sub, shape=(476, 31), exclude={'qa_id'})
sub.head()<save_to_csv> | votes=np.sum([lcv_mask,rf_mask,gb_mask],axis=0)
print(votes)
mask=votes>1 | Titanic - Machine Learning from Disaster |
11,719,494 | sub.to_csv('submission.csv', index=False )<save_to_csv> | lr=LogisticRegression()
lr.fit(ccX_train,cy_train)
y_pred=lr.predict(ccX_test)
print(accuracy_score(cy_test,y_pred)) | Titanic - Machine Learning from Disaster |
11,719,494 | sub.to_csv('submission.csv', index=False )<install_modules> | steps=[('scaler',StandardScaler()),('lr',LogisticRegression())]
lr_pipe=Pipeline(steps)
lr_pipe.fit(ccX_train,cy_train)
y_pred=lr_pipe.predict(ccX_test)
print(accuracy_score(cy_test,y_pred)) | Titanic - Machine Learning from Disaster |
11,719,494 | !pip list<import_modules> | knn=KNeighborsClassifier(n_neighbors=9)
knn.fit(cX_train,cy_train)
y_pred=knn.predict(cX_test)
print(accuracy_score(cy_test,y_pred)) | Titanic - Machine Learning from Disaster |
11,719,494 |
pyLDAvis.enable_notebook()
warnings.filterwarnings('ignore' )<load_from_csv> | param={'knn__n_neighbors':np.arange(1,20)}
steps=[('scaler',StandardScaler()),('knn',KNeighborsClassifier())]
knn_pipe=Pipeline(steps)
grid_knn=GridSearchCV(estimator=knn_pipe,param_grid=param,cv=10,n_jobs=-1)
grid_knn.fit(ccX_train,cy_train)
y_pred=grid_knn.predict(ccX_test)
print(accuracy_score(cy_test,y_pred))
p... | Titanic - Machine Learning from Disaster |
11,719,494 | sample = pd.read_csv('/kaggle/input/google-quest-challenge/sample_submission.csv')
sample.head(3 )<load_from_csv> | param={'max_depth':np.arange(3,8),'min_samples_leaf':[0.04,0.06,0.08],'max_features':[0.2,0.4,0.6,0.8]}
dt=DecisionTreeClassifier(random_state=12)
grid_dt=GridSearchCV(estimator=dt,param_grid=param,cv=10,n_jobs=-1)
grid_dt.fit(ccX_train,cy_train)
y_pred=grid_dt.predict(ccX_test)
print(accuracy_score(cy_test,y_pred)... | Titanic - Machine Learning from Disaster |
11,719,494 | train = pd.read_csv('/kaggle/input/google-quest-challenge/train.csv')
train.head(3 )<load_from_csv> | param={'n_estimators':[200],'max_depth':np.arange(3,6),'min_samples_leaf':[0.04,0.06,0.08],'max_features':[0.2,0.4,0.6,0.8]}
rf=RandomForestClassifier(random_state=12)
grid_rf=GridSearchCV(estimator=rf,param_grid=param,cv=10,n_jobs=-1)
grid_rf.fit(ccX_train,cy_train)
y_pred=grid_rf.predict(ccX_test)
print(accuracy_... | Titanic - Machine Learning from Disaster |
11,719,494 | test = pd.read_csv('/kaggle/input/google-quest-challenge/test.csv')
test.head(3 )<define_variables> | xg_cl=xgb.XGBClassifier(objective='binary:logistic',n_estimators=4,seed=123)
xg_cl.fit(ccX_train,cy_train)
y_pred=xg_cl.predict(ccX_test)
print(accuracy_score(cy_test,y_pred)) | Titanic - Machine Learning from Disaster |
11,719,494 | targets = [
'question_asker_intent_understanding',
'question_body_critical',
'question_conversational',
'question_expect_short_answer',
'question_fact_seeking',
'question_has_commonly_accepted_answer',
'question_interestingness_others',
'question_interestingness_self',
'question_multi_intent',
'question_not_really_a_qu... | xg=xgb.XGBClassifier(objective='reg:logistic',seed=123)
params={'n_estimators':[100,200],'max_depth':np.arange(2,6),'alpha':[0.01,0.1,1,10]}
grid_xg=GridSearchCV(estimator=xg,param_grid=params,cv=10,n_jobs=-1)
grid_xg.fit(ccX_train,cy_train)
y_pred=grid_xg.predict(ccX_test)
print(accuracy_score(cy_test,y_pred))
pri... | Titanic - Machine Learning from Disaster |
11,719,494 | stopwords=stopwords.words('english')
train['que_stopwords']=train['question_body'].apply(lambda x : [x for x in x.split() if x in stopwords])
train['ans_stopwords']=train['answer'].apply(lambda x: [x for x in x.split() if x in stopwords] )<count_unique_values> | dt=DecisionTreeClassifier(max_depth=1,random_state=1)
ada=AdaBoostClassifier(base_estimator=dt,n_estimators=300,learning_rate=0.05)
ada.fit(ccX_train,cy_train)
y_pred=ada.predict(ccX_test)
print(accuracy_score(cy_test,y_pred)) | Titanic - Machine Learning from Disaster |
11,719,494 | def common_ngrams(col,common=10):
corpus=[]
for question in train[col].values:
words=[str(x[0]+' '+x[1])for x in ngrams(question.split() ,2)]
corpus.append(words)
flatten=[x for one in corpus for x in one]
counter=Counter(flatten)
most_common=counter.most_common(common)
string,value=zip(*(most_common))
return string... | grad=GradientBoostingClassifier(n_estimators=500,learning_rate=0.01)
grad.fit(ccX_train,cy_train)
y_pred=grad.predict(ccX_test)
print(accuracy_score(cy_test,y_pred)) | Titanic - Machine Learning from Disaster |
11,719,494 | np.set_printoptions(suppress=True )<load_from_csv> | svc=SVC(C=100,random_state=12)
svc.fit(ccX_train,cy_train)
y_pred=svc.predict(ccX_test)
print(accuracy_score(cy_test,y_pred)) | Titanic - Machine Learning from Disaster |
11,719,494 | PATH = '.. /input/google-quest-challenge/'
BERT_PATH = '.. /input/bert-base-from-tfhub/bert_en_uncased_L-12_H-768_A-12'
tokenizer = FullTokenizer(BERT_PATH+'/assets/vocab.txt', True)
MAX_SEQUENCE_LENGTH = 512
df_train = pd.read_csv(PATH+'train.csv')
df_test = pd.read_csv(PATH+'test.csv')
df_sub = pd.read_csv(PATH+'s... | lr=LogisticRegression(random_state=12)
knn=KNeighborsClassifier()
dt=DecisionTreeClassifier(random_state=12)
classifiers=[('Logistic',lr_pipe),
('knn',grid_knn),
('dt',grid_dt),
('gradient',grad),
('RF',grid_rf),
('Ada',ada),
('XGb',xg_cl),
('XgbGrid',grid_xg)]
vc=VotingClassifier(estimators=classifiers)
vc.f... | Titanic - Machine Learning from Disaster |
11,719,494 | def _get_masks(tokens, max_seq_length):
if len(tokens)>max_seq_length:
raise IndexError("Token length more than max seq length!")
return [1]*len(tokens)+ [0] *(max_seq_length - len(tokens))
def _get_segments(tokens, max_seq_length):
if len(tokens)>max_seq_length:
raise IndexError("Token length more than max seq le... | test_1=cctest
test_2=pd.DataFrame(test_1,columns=test_1.columns)
ans=vc.predict(test_2)
sub=pd.DataFrame({
'PassengerId':test_id.astype(int),
'Survived':ans.astype(int)
})
print(sub.head())
sub.to_csv('submissions.csv',index=False ) | Titanic - Machine Learning from Disaster |
9,428,263 | def compute_spearmanr(trues, preds):
rhos = []
for col_trues, col_pred in zip(trues.T, preds.T):
rhos.append(
spearmanr(col_trues, col_pred + np.random.normal(0, 1e-7, col_pred.shape[0])).correlation)
return np.nanmean(rhos)
class CustomCallback(tf.keras.callbacks.Callback):
def __init__(self, valid_data, test_data,... | from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
9,428,263 | test_inputs = compute_input_arrays(df_test, input_categories, tokenizer, MAX_SEQUENCE_LENGTH )<load_pretrained> | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
y = train.Survived
passengerid = test.PassengerId
titanic = train.append(test, ignore_index = True ) | Titanic - Machine Learning from Disaster |
9,428,263 | models = []
for i in range(1,4):
model_path = f'.. /input/bertuned-f{i}/bertuned_f{i}.h5'
model = bert_model()
model.load_weights(model_path)
models.append(model)
<load_pretrained> | train_index = len(train)
test_index = len(titanic)- len(test ) | Titanic - Machine Learning from Disaster |
9,428,263 | model_path = f'.. /input/bertf1e15/Full-0.h5'
model = bert_model()
model.load_weights(model_path)
models.append(model )<load_pretrained> | titanic['Title'] = titanic.Name.apply(lambda x: x.split(',')[1].split('.')[0].strip() ) | Titanic - Machine Learning from Disaster |
9,428,263 | for i in range(3,5):
model_path = f'.. /input/using-pretrained-kernel/using_pretrained_kernel/arj_bert-{0}.h5'
model = bert_model()
model.load_weights(model_path)
models.append(model )<load_pretrained> | titanic.Title.value_counts() | Titanic - Machine Learning from Disaster |
9,428,263 | for i in range(3-5):
model_path = f'.. /input/bert-pretrained-models/Pretrained_bert_models/bert-{0}.h5'
model = bert_model()
model.load_weights(model_path)
models.append(model )<load_pretrained> | normalized_title = {
'Mr':"Mr",
'Mrs': "Mrs",
'Ms': "Mrs",
'Mme':"Mrs",
'Mlle':"Miss",
'Miss':"Miss",
'Master':"Master",
'Dr':"Officer",
'Rev':"Officer",
'Col':"Officer",
'Capt':"Officer",
'Major':"Officer",
'Lady':"Royalty",
'Sir':"Royalty",
'the Countess':"Royalty",
'Dona':"Royalty",
'Don':"Royalty",
'Jonkheer':"Roya... | Titanic - Machine Learning from Disaster |
9,428,263 | for i in range(2):
model_path = f'.. /input/bertmodelpretrained/bert-{i}.h5'
model = bert_model()
model.load_weights(model_path)
models.append(model )<load_pretrained> | titanic.Title = titanic.Title.map(normalized_title ) | Titanic - Machine Learning from Disaster |
9,428,263 | for i in range(2,5):
model_path = f'.. /input/pretrained-bert/bert-{i}.h5'
model = bert_model()
model.load_weights(model_path)
models.append(model )<load_pretrained> | print(titanic.Title.value_counts() ) | Titanic - Machine Learning from Disaster |
9,428,263 | for i in range(3,6):
model_path = f'.. /input/bert-base-tf2-0-training/bert-{i}.h5'
model = bert_model()
model.load_weights(model_path)
models.append(model )<define_variables> | titanic.Age = grouped.Age.apply(lambda x: x.fillna(x.median()))
titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
9,428,263 | test_predictions = []<predict_on_test> | titanic.Fare = titanic.Fare.fillna(titanic.Fare.mean())
titanic.Cabin = titanic.Cabin.fillna('U')
most_Embarked = titanic.Embarked.value_counts().index[0]
titanic.Embarked = titanic.Embarked.fillna(most_Embarked ) | Titanic - Machine Learning from Disaster |
9,428,263 | for model in models:
test_predictions.append(model.predict(test_inputs, batch_size=8))<prepare_output> | titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
9,428,263 | final_predictions = np.mean(test_predictions, axis=0 )<load_pretrained> | titanic['FamilySize'] = titanic['SibSp'] + titanic['Parch'] + 1 | Titanic - Machine Learning from Disaster |
9,428,263 | n=df_test['url'].apply(lambda x:(( 'ell.stackexchange.com' in x)or('english.stackexchange.com' in x)) ).tolist()
spelling=[]
for x in n:
if x:
spelling.append(0.5)
else:
spelling.append(0.)
<save_to_csv> | titanic['Cabin'].value_counts() | Titanic - Machine Learning from Disaster |
9,428,263 | df_sub['question_type_spelling']=spelling
df_sub.iloc[:, 1:] = final_predictions
df_sub.to_csv('submission.csv', index=False )<set_options> | titanic.Cabin = titanic.Cabin.map(lambda x: x[0])
titanic.Cabin.head() | Titanic - Machine Learning from Disaster |
9,428,263 | def tqdm(it, *args, **kwargs):
return it
def seed_everything(seed=1234):
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
seed_everything()
np.set_printoptions(suppress=True)
print(tf.__ve... | titanic.Sex = titanic.Sex.map({"male":0,"female":1})
title_dummies = pd.get_dummies(titanic.Title , prefix = "Title")
cabin_dummies = pd.get_dummies(titanic.Cabin , prefix = "Cabin")
pclass_dummies = pd.get_dummies(titanic.Pclass , prefix ="Pclass")
embarked_dummies = pd.get_dummies(titanic.Embarked , prefix = "Emb... | Titanic - Machine Learning from Disaster |
9,428,263 | PATH = '.. /input/google-quest-challenge/'
BERT_PATH = '.. /input/bertpretrained/uncased_L-12_H-768_A-12/uncased_L-12_H-768_A-12/'
tokenizer = BertTokenizer.from_pretrained(BERT_PATH)
MAX_SEQUENCE_LENGTH = 512
df_train = pd.read_csv(PATH+'train.csv')
df_test = pd.read_csv(PATH+'test.csv')
sub = pd.read_csv(PATH+'sam... | titanic_dummies = pd.concat([titanic , title_dummies,cabin_dummies,
pclass_dummies,embarked_dummies],axis = 1 ) | Titanic - Machine Learning from Disaster |
9,428,263 | df_train.question_body = df_train.question_body.apply(html.unescape)
df_train.question_title = df_train.question_title.apply(html.unescape)
df_train.answer = df_train.answer.apply(html.unescape)
df_test.question_body = df_test.question_body.apply(html.unescape)
df_test.question_title = df_test.question_title.apply(... | titanic_dummies.drop(['Pclass', 'Title', 'Cabin', 'Embarked', 'Name', 'Ticket'],axis = 1,inplace = True ) | Titanic - Machine Learning from Disaster |
9,428,263 | def _preprocess_text(s: str)-> str:
return s
def _trim_input(question_tokens: List[str], answer_tokens: List[str], max_sequence_length: int, q_max_len: int, a_max_len: int)-> Tuple[List[str], List[str]]:
q_len = len(question_tokens)
a_len = len(answer_tokens)
if q_len + a_len + 3 > max_sequence_length:
if a_max_len <... | train_x = titanic_dummies[:train_index]
test_x = titanic_dummies[train_index:] | Titanic - Machine Learning from Disaster |
9,428,263 | def compute_input_arrays(df, question_only=False):
input_ids, input_token_type_ids, input_attention_masks = [], [], []
for title, body, answer in zip(df["question_title"].values, df["question_body"].values, df["answer"].values):
ids, type_ids, mask = _convert_to_transformer_inputs(title, body, answer, tokenizer, questi... | train_x.Survived = train_x.Survived.astype(int ) | Titanic - Machine Learning from Disaster |
9,428,263 | class Model(torch.nn.Module):
def __init__(self):
super().__init__()
config = BertConfig.from_json_file(BERT_PATH + "/bert_config.json")
config.output_hidden_states = True
self.bert = BertForPreTraining.from_pretrained(BERT_PATH + "/bert_model.ckpt.index", from_tf=True, config=config ).bert
self.cls_token_head = nn.Se... | X = train_x.drop('Survived', axis=1 ).values
y = train_x.Survived.values | Titanic - Machine Learning from Disaster |
9,428,263 | outputs = torch.tensor(compute_output_arrays(df_train), dtype=torch.float)
inputs = [torch.tensor(x, dtype=torch.long)for x in compute_input_arrays(df_train)]
question_only_inputs = [torch.tensor(x, dtype=torch.long)for x in compute_input_arrays(df_train, question_only=True)]
test_inputs = [torch.tensor(x, dtype=torch... | X_test = test_x.drop('Survived', axis=1 ).values | Titanic - Machine Learning from Disaster |
9,428,263 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device )<find_best_params> | label = train_x.Survived
train_X , val_X , train_Y , val_Y = train_test_split(train_x , label,test_size = 0.2,shuffle = True ) | Titanic - Machine Learning from Disaster |
9,428,263 | for n, _ in Model().named_parameters() :
print(n )<data_type_conversions> | dtrain_X = train_X.drop('Survived',axis = 1 ) | Titanic - Machine Learning from Disaster |
9,428,263 | LABEL_WEIGHTS = torch.tensor(1.0 / df_train[output_categories].std().values, dtype=torch.float32 ).to(device)
LABEL_WEIGHTS = LABEL_WEIGHTS / LABEL_WEIGHTS.sum() * 30
for name, weight in zip(output_categories, LABEL_WEIGHTS.cpu().numpy()):
print(name, "\t", weight )<define_search_space> | dval_X = val_X.drop('Survived',axis = 1 ) | Titanic - Machine Learning from Disaster |
9,428,263 | BEST_BINS = [400, 400, 15, 100, 400, 7, 1600, 100, 100, 400, 100, 9, 8, 50, 9, 8, 15, 400, 400, 5, 400, 400, 800, 50, 200, 1600, 20, 200, 1600, 1600]
def binning_output(preds, n_bins=BEST_BINS):
preds = preds.copy()
for i in range(preds.shape[-1]):
n = n_bins[i]
binned =(preds[:, i] * n ).astype(np.int32 ).astype(np.fl... | params = dict(
max_depth = [n for n in range(9,15)],
min_samples_split = [n for n in range(4, 11)],
min_samples_leaf = [n for n in range(2, 5)],
n_estimators = [n for n in range(10, 60, 10)],
) | Titanic - Machine Learning from Disaster |
9,428,263 | class Fold(object):
def __init__(self, n_splits=5, shuffle=True, random_state=71):
self.n_splits = n_splits
self.shuffle = shuffle
self.random_state = random_state
def get_groupkfold(self, train, group_name):
group = train[group_name]
unique_group = group.unique()
kf = KFold(
n_splits=self.n_splits,
shuffle=self.shuff... | model_forest = RandomForestClassifier() | Titanic - Machine Learning from Disaster |
9,428,263 | gkf = Fold(n_splits=3, shuffle=True, random_state=71)
fold_ids = gkf.get_groupkfold(df_train, group_name="url")
for train_idx, valid_idx in fold_ids:
print(( df_train.loc[train_idx, "question_type_spelling"] > 0 ).sum())
print(( df_train.loc[valid_idx, "question_type_spelling"] > 0 ).sum() )<create_dataframe> | forest_gs = GridSearchCV(param_grid=params,
estimator=model_forest,
cv=5)
forest_gs.fit(dtrain_X,train_Y ) | Titanic - Machine Learning from Disaster |
9,428,263 | histories = []
test_dataset = torch.utils.data.TensorDataset(*test_inputs)
q_test_dataset = torch.utils.data.TensorDataset(*test_question_only_inputs)
for fold,(train_idx, valid_idx)in enumerate(fold_ids):
gc.collect()
train_inputs = [inputs[i][train_idx] for i in range(3)]
q_train_inputs = [question_only_inputs[i][t... | forest_gs.best_score_ | Titanic - Machine Learning from Disaster |
9,428,263 | val_preds_list = []
n_epochs = len(histories[0][0])
for epoch in range(n_epochs):
val_preds_one_epoch = np.zeros([len(df_train), 30])
for fold,(train_idx, valid_idx)in enumerate(fold_ids):
val_pred = histories[fold][0][epoch]
val_preds_one_epoch[valid_idx, :] += val_pred
val_preds_list.append(val_preds_one_epoch )<de... | forest_gs.best_estimator_ | Titanic - Machine Learning from Disaster |
9,428,263 | oof_predictions = np.zeros(( n_epochs, len(df_train), len(output_categories)) , dtype=np.float32)
for j, name in enumerate(output_categories):
for epoch in range(n_epochs):
col = "{}_{}".format(epoch, name)
oof_predictions[epoch, :, j] = val_preds_list[epoch][:, j]
oof_predictions.shape<define_variables> | p = forest_gs.predict(dval_X)
print(mean_absolute_error(p,val_Y)) | Titanic - Machine Learning from Disaster |
9,428,263 | test_preds_list = []
for epoch in range(n_epochs):
test_preds_one_epoch = 0
for fold in range(len(fold_ids)) :
test_preds = histories[fold][1][epoch]
test_preds_one_epoch += test_preds
test_preds_one_epoch = test_preds_one_epoch / len(fold_ids)
test_preds_list.append(test_preds_one_epoch )<define_variables> | prediction_Random_forest = forest_gs.predict(X_test)
prediction_Random_forest | Titanic - Machine Learning from Disaster |
9,428,263 | <find_best_model_class><EOS> | output = pd.DataFrame({"PassengerId":passengerid , "Survived" : prediction_Random_forest})
output.to_csv("Submission5.csv",index = False ) | Titanic - Machine Learning from Disaster |
2,751,817 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<compute_test_metric> | %matplotlib inline
py.init_notebook_mode(connected=True)
@contextmanager
def timer(title):
t0 = time.time()
yield
print("{} - done in {:.0f}s".format(title, time.time() - t0))
warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
2,751,817 | def lgb_compute_spearmanr(preds, trues):
rhos = spearmanr(trues.get_label() , preds ).correlation
return "spearmanr", rhos, True
def compute_spearmanr_each_col(trues, preds, n_bins=None):
if n_bins:
preds = binning_output(preds, n_bins)
rhos = spearmanr(trues, preds ).correlation
return rhos<train_model> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Titanic - Machine Learning from Disaster |
2,751,817 | class LightGBM(Base_Model):
def fit(self, x_train, y_train, x_valid, y_valid, config):
d_train = lgb.Dataset(x_train, label=y_train)
d_valid = lgb.Dataset(x_valid, label=y_valid)
lgb_model_params = config["model"]["model_params"]
lgb_train_params = config["model"]["train_params"]
model = lgb.train(
params=lgb_model_... | train['Type'] = 'train'
test['Type'] = 'test'
data = train.append(test)
data.shape | Titanic - Machine Learning from Disaster |
2,751,817 | config = {
"model": {
"name": "lightgbm",
"model_params": {
"boosting_type": "gbdt",
"objective": "rmse",
"tree_learner": "serial",
"learning_rate": 0.1,
"max_depth": 1,
"seed": 71,
"bagging_seed": 71,
"feature_fraction_seed": 71,
"drop_seed": 71,
"verbose": -1
},
"train_params": {
"num_boost_round": 5000,
"early_stopp... | data['Title'] = data['Name']
for name_string in data['Name']:
data['Title'] = data['Name'].str.extract('([A-Za-z]+)\.', expand=True ) | Titanic - Machine Learning from Disaster |
2,751,817 | def compute_spearmanr(trues, preds, n_bins=None):
rhos = []
if n_bins:
preds = binning_output(preds, n_bins)
for col_trues, col_pred in zip(trues.T, preds.T):
if len(np.unique(col_pred)) == 1:
col_pred[np.random.randint(0, len(col_pred)- 1)] = col_pred.max() + 1
rhos.append(spearmanr(col_trues, col_pred ).correlation)... | mapping = {'Mlle': 'Miss',
'Ms': 'Miss',
'Mme': 'Mrs',
'Major': 'Other',
'Col': 'Other',
'Dr' : 'Other',
'Rev' : 'Other',
'Capt': 'Other',
'Jonkheer': 'Royal',
'Sir': 'Royal',
'Lady': 'Royal',
'Don': 'Royal',
'Countess': 'Royal',
'Dona': 'Royal'}
data.replace({'Title': mapping}, inplace=True)
titles = ['Miss', 'Mr', '... | Titanic - Machine Learning from Disaster |
2,751,817 | test_preds_fi = np.concatenate(test_preds_list, axis=1)
sub.iloc[:, 1:] = test_preds_fi
sub.to_csv('submission.csv', index=False )<install_modules> | for title in titles:
age_to_impute = data.groupby('Title')['Age'].median() [titles.index(title)]
data.loc[(data['Age'].isnull())&(data['Title'] == title), 'Age'] = age_to_impute | Titanic - Machine Learning from Disaster |
2,751,817 | !pip install.. /input/sacremoses/sacremoses-master/
!pip install.. /input/transformers/transformers-master/<define_variables> | data['Family_Size'] = data['Parch'] + data['SibSp'] + 1
data.loc[:,'FsizeD']='Alone'
data.loc[(data['Family_Size']>1),'FsizeD']='Small'
data.loc[(data['Family_Size']>4),'FsizeD']='Big' | Titanic - Machine Learning from Disaster |
2,751,817 | DATA_DIR = '.. /input/google-quest-challenge'<load_from_csv> | data[data["Fare"].isnull() ] | Titanic - Machine Learning from Disaster |
2,751,817 | sub = pd.read_csv(f'{DATA_DIR}/sample_submission.csv')
sub.head()<load_from_csv> | fa = data[data["Pclass"]==3]
data['Fare'].fillna(fa['Fare'].median() , inplace = True ) | Titanic - Machine Learning from Disaster |
2,751,817 | train = pd.read_csv(f'{DATA_DIR}/train.csv')
train.head()<load_from_csv> | data.loc[:,'Child']=1
data.loc[(data['Age']>=18),'Child']=0 | Titanic - Machine Learning from Disaster |
2,751,817 | test = pd.read_csv(f'{DATA_DIR}/test.csv')
test.head()<define_variables> | data['Last_Name'] = data['Name'].apply(lambda x: str.split(x, ",")[0])
DEFAULT_SURVIVAL_VALUE = 0.5
data['Family_Survival'] = DEFAULT_SURVIVAL_VALUE
for grp, grp_df in data[['Survived','Name', 'Last_Name', 'Fare', 'Ticket', 'PassengerId',
'SibSp', 'Parch', 'Age', 'Cabin']].groupby(['Last_Name', 'Fare']):
if(len(grp_df... | Titanic - Machine Learning from Disaster |
2,751,817 | MAX_LEN = 512
SEP_TOKEN_ID = 102
class QuestDataset(torch.utils.data.Dataset):
def __init__(self, df, model_type="bert-base-cased", max_len=512, content="Question_Answer", train_mode=True, labeled=True):
self.df = df
self.train_mode = train_mode
self.labeled = labeled
self.max_len = max_len
self.content = content
bert_... | for _, grp_df in data.groupby('Ticket'):
if(len(grp_df)!= 1):
for ind, row in grp_df.iterrows() :
if(row['Family_Survival'] == 0)|(row['Family_Survival']== 0.5):
smax = grp_df.drop(ind)['Survived'].max()
smin = grp_df.drop(ind)['Survived'].min()
passID = row['PassengerId']
if(smax == 1.0):
data.loc[data['PassengerId'] ... | Titanic - Machine Learning from Disaster |
2,751,817 | test_test_loader()<load_pretrained> | data = data.drop(columns = [
'Age',
'Cabin',
'Embarked',
'Name',
'Last_Name',
'Parch',
'SibSp',
'Ticket',
'Family_Size',
])
data.head() | Titanic - Machine Learning from Disaster |
2,751,817 | test_train_loader()<load_pretrained> | target_col = ["Survived"]
id_dataset = ["Type"]
cat_cols = data.nunique() [data.nunique() < 12].keys().tolist()
cat_cols = [x for x in cat_cols ]
num_cols = [x for x in data.columns if x not in cat_cols + target_col + id_dataset]
bin_cols = data.nunique() [data.nunique() == 2].keys().tolist()
multi_cols = [i for i in c... | Titanic - Machine Learning from Disaster |
2,751,817 | class QuestModel(nn.Module):
def __init__(self, model_type="xlnet-base-cased", tokenizer=None, n_classes=30, hidden_layers=[-1, -3, -5, -7, -9]):
super(QuestModel, self ).__init__()
self.model_name = 'QuestModel'
self.model_type = model_type
self.hidden_layers = hidden_layers
if model_type == "bert-base-uncased":
bert_... | train = data[data['Type'] == 1]
test = data[data['Type'] == 0]
train = train.drop(columns = ['Type'])
test = test.drop(columns = ['Type'] ) | Titanic - Machine Learning from Disaster |
2,751,817 | test_model(model_type="bert-base-cased", hidden_layers=[-3, -4, -5, -6, -7] )<load_pretrained> | X = train.drop('Survived', 1)
y = train['Survived']
X_test = test
X_test = X_test.drop(columns = ['Survived'
] ) | Titanic - Machine Learning from Disaster |
2,751,817 | def create_bert_base_uncased_models() :
models = []
for i in range(10):
model = QuestModel(model_type="bert-base-uncased", hidden_layers=[-1, -3, -5, -7, -9])
model.load_state_dict(torch.load(f'.. /input/qabertuncasedaugdiffv2swa/fold_{i}_checkpoint_swa.pth'))
model.eval()
models.append(model)
return models
def creat... | random_state = 42
X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size = 0.2, random_state = random_state ) | Titanic - Machine Learning from Disaster |
2,751,817 | def predict(models, test_loader):
all_scores = []
with torch.no_grad() :
for ids, seg_ids in tqdm(test_loader, total=test_loader.num // test_loader.batch_size):
ids, seg_ids = ids.cuda() , seg_ids.cuda()
scores = []
for model in models:
model = model.cuda()
outputs = torch.sigmoid(model(ids, seg_ids)).cpu()
scores.appe... | fit_params = {"early_stopping_rounds" : 100,
"eval_metric" : 'auc',
"eval_set" : [(X_train,y_train)],
'eval_names': ['valid'],
'verbose': 0,
'categorical_feature': 'auto'}
param_test = {'learning_rate' : [0.01, 0.02, 0.03, 0.04, 0.05, 0.08, 0.1, 0.2, 0.3, 0.4],
'n_estimators' : [100, 200, 300, 400, 500, 600, 800, 1000,... | Titanic - Machine Learning from Disaster |
2,751,817 | test_loader, tokenizer = get_test_loader(model_type="roberta-base", content="Question_Answer", batch_size=32 )<predict_on_test> | %%time
lgbm_clf = lgbm.LGBMClassifier(**opt_parameters)
lgbm_clf.fit(X_train, y_train)
y_pred = lgbm_clf.predict(X_valid)
y_score = lgbm_clf.predict_proba(X_valid)[:,1]
model_performance('lgbm_clf' ) | Titanic - Machine Learning from Disaster |
2,751,817 | roberta_base_models = create_roberta_base_models(tokenizer)
roberta_base_preds = predict(roberta_base_models, test_loader )<set_options> | lgbm_clf = lgbm.LGBMClassifier(**opt_parameters)
lgbm_clf.fit(X, y)
y_pred = lgbm_clf.predict(X_test ) | Titanic - Machine Learning from Disaster |
2,751,817 | del roberta_base_models, test_loader
torch.cuda.empty_cache()
gc.collect()<load_pretrained> | visualizer = DiscriminationThreshold(lgbm_clf)
visualizer.fit(X, y)
visualizer.poof() | Titanic - Machine Learning from Disaster |
2,751,817 | test_loader, _ = get_test_loader(model_type="xlnet-base-cased", batch_size=32 )<predict_on_test> | temp = pd.DataFrame(pd.read_csv(".. /input/test.csv")['PassengerId'])
temp['Survived'] = y_pred
temp.to_csv(".. /working/submission.csv", index = False ) | Titanic - Machine Learning from Disaster |
10,385,931 | xlnet_base_cased_models = create_xlnet_base_cased_models()
xlnet_base_cased_preds = predict(xlnet_base_cased_models, test_loader )<set_options> | training = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv')
training['train_test'] = 1
test['train_test'] = 0
test['Survived'] = np.NaN
all_data = pd.concat([training,test])
%matplotlib inline
all_data.columns | Titanic - Machine Learning from Disaster |
10,385,931 | del xlnet_base_cased_models, test_loader
torch.cuda.empty_cache()
gc.collect()<load_pretrained> | df_num = training[['Age','SibSp','Parch','Fare']]
df_cat = training[['Survived','Pclass','Sex','Ticket','Cabin','Embarked']] | Titanic - Machine Learning from Disaster |
10,385,931 | test_loader, _ = get_test_loader(model_type="xlnet-base-cased", content="Question", batch_size=32 )<predict_on_test> | pd.pivot_table(training, index = 'Survived', values = ['Age','SibSp','Parch','Fare'] ) | Titanic - Machine Learning from Disaster |
10,385,931 | xlnet_base_cased_question_models = create_xlnet_base_cased_question_models()
xlnet_base_cased_question_preds = predict(xlnet_base_cased_question_models, test_loader )<set_options> | print(pd.pivot_table(training, index = 'Survived', columns = 'Pclass', values = 'Ticket' ,aggfunc ='count'))
print()
print(pd.pivot_table(training, index = 'Survived', columns = 'Sex', values = 'Ticket' ,aggfunc ='count'))
print()
print(pd.pivot_table(training, index = 'Survived', columns = 'Embarked', values = 'Ticket... | Titanic - Machine Learning from Disaster |
10,385,931 | del xlnet_base_cased_question_models, test_loader
torch.cuda.empty_cache()
gc.collect()<load_pretrained> | df_cat.Cabin
training['cabin_multiple'] = training.Cabin.apply(lambda x: 0 if pd.isna(x)else len(x.split(' ')))
training['cabin_multiple'].value_counts() | Titanic - Machine Learning from Disaster |
10,385,931 | test_loader, _ = get_test_loader(model_type="xlnet-base-cased", content="Answer", batch_size=32 )<predict_on_test> | pd.pivot_table(training, index = 'Survived', columns = 'cabin_multiple', values = 'Ticket' ,aggfunc ='count' ) | Titanic - Machine Learning from Disaster |
10,385,931 | xlnet_base_cased_answer_models = create_xlnet_base_cased_answer_models()
xlnet_base_cased_answer_preds = predict(xlnet_base_cased_answer_models, test_loader )<set_options> | training['cabin_adv'] = training.Cabin.apply(lambda x: str(x)[0])
| Titanic - Machine Learning from Disaster |
10,385,931 | del xlnet_base_cased_answer_models, test_loader
torch.cuda.empty_cache()
gc.collect()<concatenate> | print(training.cabin_adv.value_counts())
pd.pivot_table(training,index='Survived',columns='cabin_adv', values = 'Name', aggfunc='count' ) | Titanic - Machine Learning from Disaster |
10,385,931 | xlnet_base_cased_question_answer_preds = np.concatenate([xlnet_base_cased_question_preds, xlnet_base_cased_answer_preds], axis=1 )<load_pretrained> | training['numeric_ticket'] = training.Ticket.apply(lambda x: 1 if x.isnumeric() else 0)
training['ticket_letters'] = training.Ticket.apply(lambda x: ''.join(x.split(' ')[:-1] ).replace('.','' ).replace('/','' ).lower() if len(x.split(' ')[:-1])>0 else 0)
| Titanic - Machine Learning from Disaster |
10,385,931 | test_loader, tokenizer = get_test_loader(model_type="roberta-base", content="Question", batch_size=32 )<predict_on_test> | training['numeric_ticket'].value_counts() | Titanic - Machine Learning from Disaster |
10,385,931 | roberta_base_question_models = create_roberta_base_question_models(tokenizer)
roberta_base_question_preds = predict(roberta_base_question_models, test_loader )<set_options> | pd.set_option("max_rows", None)
training['ticket_letters'].value_counts()
| 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.