kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,385,931 | del roberta_base_question_models, test_loader, tokenizer
torch.cuda.empty_cache()
gc.collect()<load_pretrained> | pd.pivot_table(training,index='Survived',columns='numeric_ticket', values = 'Ticket', aggfunc='count' ) | Titanic - Machine Learning from Disaster |
10,385,931 | test_loader, tokenizer = get_test_loader(model_type="roberta-base", content="Answer", batch_size=32 )<predict_on_test> | training.Name.head(50)
training['name_title'] = training.Name.apply(lambda x: x.split(',')[1].split('.')[0].strip())
| Titanic - Machine Learning from Disaster |
10,385,931 | roberta_base_answer_models = create_roberta_base_answer_models(tokenizer)
roberta_base_answer_preds = predict(roberta_base_answer_models, test_loader )<set_options> | training['name_title'].value_counts() | Titanic - Machine Learning from Disaster |
10,385,931 | del roberta_base_answer_models, test_loader, tokenizer
torch.cuda.empty_cache()
gc.collect()<concatenate> | all_data['cabin_multiple'] = all_data.Cabin.apply(lambda x: 0 if pd.isna(x)else len(x.split(' ')))
all_data['cabin_adv'] = all_data.Cabin.apply(lambda x: str(x)[0])
all_data['numeric_ticket'] = all_data.Ticket.apply(lambda x: 1 if x.isnumeric() else 0)
all_data['ticket_letters'] = all_data.Ticket.apply(lambda x: ''.... | Titanic - Machine Learning from Disaster |
10,385,931 | roberta_base_question_answer_preds = np.concatenate([roberta_base_question_preds, roberta_base_answer_preds], axis=1 )<load_pretrained> | scale = StandardScaler()
all_dummies_scaled = all_dummies.copy()
all_dummies_scaled[['Age','SibSp','Parch','norm_fare']]= scale.fit_transform(all_dummies_scaled[['Age','SibSp','Parch','norm_fare']])
all_dummies_scaled
X_train_scaled = all_dummies_scaled[all_dummies_scaled.train_test == 1].drop(['train_test'], axis =1)... | Titanic - Machine Learning from Disaster |
10,385,931 | test_loader, _ = get_test_loader(model_type="bert-base-cased", content="Question", batch_size=32 )<predict_on_test> | from sklearn.model_selection import cross_val_score
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
from sklearn import tree
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC | Titanic - Machine Learning from Disaster |
10,385,931 | bert_base_cased_question_models = create_bert_base_cased_question_models()
bert_base_cased_question_preds = predict(bert_base_cased_question_models, test_loader )<set_options> | gnb = GaussianNB()
cv = cross_val_score(gnb,X_train_scaled,y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,385,931 | del bert_base_cased_question_models, test_loader
torch.cuda.empty_cache()
gc.collect()<load_pretrained> | lr = LogisticRegression(max_iter = 2000)
cv = cross_val_score(lr,X_train,y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,385,931 | test_loader, _ = get_test_loader(model_type="bert-base-cased", content="Answer", batch_size=32 )<predict_on_test> | lr = LogisticRegression(max_iter = 2000)
cv = cross_val_score(lr,X_train_scaled,y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,385,931 | bert_base_cased_answer_models = create_bert_base_cased_answer_models()
bert_base_cased_answer_preds = predict(bert_base_cased_answer_models, test_loader )<set_options> | dt = tree.DecisionTreeClassifier(random_state = 1)
cv = cross_val_score(dt,X_train,y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,385,931 | del bert_base_cased_answer_models, test_loader
torch.cuda.empty_cache()
gc.collect()<concatenate> | dt = tree.DecisionTreeClassifier(random_state = 1)
cv = cross_val_score(dt,X_train_scaled,y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,385,931 | bert_base_cased_question_answer_preds = np.concatenate([bert_base_cased_question_preds, bert_base_cased_answer_preds], axis=1 )<load_pretrained> | knn = KNeighborsClassifier()
cv = cross_val_score(knn,X_train,y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,385,931 | test_loader, _ = get_test_loader(model_type="bert-base-uncased", content="Question", batch_size=32 )<predict_on_test> | knn = KNeighborsClassifier()
cv = cross_val_score(knn,X_train_scaled,y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,385,931 | bert_base_uncased_question_models = create_bert_base_uncased_question_models()
bert_base_uncased_question_preds = predict(bert_base_uncased_question_models, test_loader )<set_options> | rf = RandomForestClassifier(random_state = 1)
cv = cross_val_score(rf,X_train,y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,385,931 | del bert_base_uncased_question_models, test_loader
torch.cuda.empty_cache()
gc.collect()<load_pretrained> | rf = RandomForestClassifier(random_state = 1)
cv = cross_val_score(rf,X_train_scaled,y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,385,931 | test_loader, _ = get_test_loader(model_type="bert-base-uncased", content="Answer", batch_size=32 )<predict_on_test> | svc = SVC(probability = True)
cv = cross_val_score(svc,X_train_scaled,y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,385,931 | bert_base_uncased_answer_models = create_bert_base_uncased_answer_models()
bert_base_uncased_answer_preds = predict(bert_base_uncased_answer_models, test_loader )<set_options> | xgb = XGBClassifier(random_state =1)
cv = cross_val_score(xgb,X_train_scaled,y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,385,931 | del bert_base_uncased_answer_models, test_loader
torch.cuda.empty_cache()
gc.collect()<concatenate> | voting_clf = VotingClassifier(estimators = [('lr',lr),('knn',knn),('rf',rf),('gnb',gnb),('svc',svc),('xgb',xgb)], voting = 'soft' ) | Titanic - Machine Learning from Disaster |
10,385,931 | bert_base_uncased_question_answer_preds = np.concatenate([bert_base_uncased_question_preds, bert_base_uncased_answer_preds], axis=1 )<load_pretrained> | cv = cross_val_score(voting_clf,X_train_scaled,y_train,cv=5)
print(cv)
print(cv.mean() ) | Titanic - Machine Learning from Disaster |
10,385,931 | test_loader, _ = get_test_loader(model_type="bert-base-cased", batch_size=32 )<predict_on_test> | voting_clf.fit(X_train_scaled,y_train)
y_hat_base_vc = voting_clf.predict(X_test_scaled ).astype(int)
basic_submission = {'PassengerId': test.PassengerId, 'Survived': y_hat_base_vc}
base_submission = pd.DataFrame(data=basic_submission)
base_submission.to_csv('base_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
10,385,931 | bert_base_cased_models = create_bert_base_cased_models()
bert_base_cased_preds = predict(bert_base_cased_models, test_loader )<set_options> | from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import RandomizedSearchCV | Titanic - Machine Learning from Disaster |
10,385,931 | del bert_base_cased_models, test_loader
torch.cuda.empty_cache()
gc.collect()<load_pretrained> | def clf_performance(classifier, model_name):
print(model_name)
print('Best Score: ' + str(classifier.best_score_))
print('Best Parameters: ' + str(classifier.best_params_)) | Titanic - Machine Learning from Disaster |
10,385,931 | test_loader, _ = get_test_loader(model_type="bert-base-uncased", batch_size=32 )<predict_on_test> | lr = LogisticRegression()
param_grid = {'max_iter' : [2000],
'penalty' : ['l1', 'l2'],
'C' : np.logspace(-4, 4, 20),
'solver' : ['liblinear']}
clf_lr = GridSearchCV(lr, param_grid = param_grid, cv = 5, verbose = True, n_jobs = -1)
best_clf_lr = clf_lr.fit(X_train_scaled,y_train)
clf_performance(best_clf_lr,'Logistic ... | Titanic - Machine Learning from Disaster |
10,385,931 | bert_base_uncased_models = create_bert_base_uncased_models()
bert_base_uncased_preds = predict(bert_base_uncased_models, test_loader )<set_options> | knn = KNeighborsClassifier()
param_grid = {'n_neighbors' : [3,5,7,9],
'weights' : ['uniform', 'distance'],
'algorithm' : ['auto', 'ball_tree','kd_tree'],
'p' : [1,2]}
clf_knn = GridSearchCV(knn, param_grid = param_grid, cv = 5, verbose = True, n_jobs = -1)
best_clf_knn = clf_knn.fit(X_train_scaled,y_train)
clf_perfor... | Titanic - Machine Learning from Disaster |
10,385,931 | del bert_base_uncased_models, test_loader
torch.cuda.empty_cache()
gc.collect()<define_variables> | svc = SVC(probability = True)
param_grid = tuned_parameters = [{'kernel': ['rbf'], 'gamma': [.1,.5,1,2,5,10],
'C': [.1, 1, 10, 100, 1000]},
{'kernel': ['linear'], 'C': [.1, 1, 10, 100, 1000]},
{'kernel': ['poly'], 'degree' : [2,3,4,5], 'C': [.1, 1, 10, 100, 1000]}]
clf_svc = GridSearchCV(svc, param_grid = param_grid, ... | Titanic - Machine Learning from Disaster |
10,385,931 | preds =(( bert_base_uncased_preds + bert_base_uncased_question_answer_preds)/2.0 \
+(xlnet_base_cased_preds + xlnet_base_cased_question_answer_preds)/2.0 \
+(bert_base_cased_preds + bert_base_cased_question_answer_preds)/2.0 \
+(roberta_base_preds + roberta_base_question_answer_preds)/2.0)/4.0
<save_to_csv> | Titanic - Machine Learning from Disaster | |
10,385,931 | sub[TARGET_COLUMNS] = bert_base_uncased_question_answer_preds
sub.to_csv('submission_bert_base_uncased.csv', index=False)
sub[TARGET_COLUMNS] =roberta_base_preds
sub.to_csv('submission_roberta_base.csv', index=False)
<prepare_output> | rf = RandomForestClassifier(random_state = 1)
param_grid = {'n_estimators': [400,450,500,550],
'criterion':['gini','entropy'],
'bootstrap': [True],
'max_depth': [15, 20, 25],
'max_features': ['auto','sqrt', 10],
'min_samples_leaf': [2,3],
'min_samples_split': [2,3]}
clf_rf = GridSearchCV(rf, param_grid = param_grid, c... | Titanic - Machine Learning from Disaster |
10,385,931 | sub[TARGET_COLUMNS] = preds<load_from_csv> | best_rf = best_clf_rf.best_estimator_.fit(X_train_scaled,y_train)
feat_importances = pd.Series(best_rf.feature_importances_, index=X_train_scaled.columns)
feat_importances.nlargest(20 ).plot(kind='barh' ) | Titanic - Machine Learning from Disaster |
10,385,931 | test = pd.read_csv(f'{DATA_DIR}/test.csv' )<merge> | Titanic - Machine Learning from Disaster | |
10,385,931 | test = test.set_index('qa_id' ).join(sub.set_index('qa_id'))<normalization> | xgb = XGBClassifier(random_state = 1)
param_grid = {
'n_estimators': [450,500,550],
'colsample_bytree': [0.75,0.8,0.85],
'max_depth': [None],
'reg_alpha': [1],
'reg_lambda': [2, 5, 10],
'subsample': [0.55, 0.6,.65],
'learning_rate':[0.5],
'gamma':[.5,1,2],
'min_child_weight':[0.01],
'sampling_method': ['uniform']
}
cl... | Titanic - Machine Learning from Disaster |
10,385,931 | def postprocessing(oof_df):
scaler = MinMaxScaler()
type_one_column_list = [
'question_conversational', \
'question_has_commonly_accepted_answer', \
'question_not_really_a_question', \
'question_type_choice', \
'question_type_compare', \
'question_type_consequence', \
'question_type_definition', \
'question_type_entity... | y_hat_xgb = best_clf_xgb.best_estimator_.predict(X_test_scaled ).astype(int)
xgb_submission = {'PassengerId': test.PassengerId, 'Survived': y_hat_xgb}
submission_xgb = pd.DataFrame(data=xgb_submission)
submission_xgb.to_csv('xgb_submission3.csv', index=False ) | Titanic - Machine Learning from Disaster |
10,385,931 | test = postprocessing(test )<count_values> | best_lr = best_clf_lr.best_estimator_
best_knn = best_clf_knn.best_estimator_
best_svc = best_clf_svc.best_estimator_
best_rf = best_clf_rf.best_estimator_
best_xgb = best_clf_xgb.best_estimator_
voting_clf_hard = VotingClassifier(estimators = [('knn',best_knn),('rf',best_rf),('svc',best_svc)], voting = 'hard')
voting... | Titanic - Machine Learning from Disaster |
10,385,931 | for column in TARGET_COLUMNS:
print(test[column].value_counts() )<prepare_output> | params = {'weights' : [[1,1,1],[1,2,1],[1,1,2],[2,1,1],[2,2,1],[1,2,2],[2,1,2]]}
vote_weight = GridSearchCV(voting_clf_soft, param_grid = params, cv = 5, verbose = True, n_jobs = -1)
best_clf_weight = vote_weight.fit(X_train_scaled,y_train)
clf_performance(best_clf_weight,'VC Weights')
voting_clf_sub = best_clf_weig... | Titanic - Machine Learning from Disaster |
10,385,931 | sub = test[TARGET_COLUMNS].reset_index()<feature_engineering> | voting_clf_hard.fit(X_train_scaled, y_train)
voting_clf_soft.fit(X_train_scaled, y_train)
voting_clf_all.fit(X_train_scaled, y_train)
voting_clf_xgb.fit(X_train_scaled, y_train)
best_rf.fit(X_train_scaled, y_train)
y_hat_vc_hard = voting_clf_hard.predict(X_test_scaled ).astype(int)
y_hat_rf = best_rf.predict(X_te... | Titanic - Machine Learning from Disaster |
10,385,931 | sub[ sub[TARGET_COLUMNS] > 1.0] = 1.0<load_from_csv> | final_data = {'PassengerId': test.PassengerId, 'Survived': y_hat_rf}
submission = pd.DataFrame(data=final_data)
final_data_2 = {'PassengerId': test.PassengerId, 'Survived': y_hat_vc_hard}
submission_2 = pd.DataFrame(data=final_data_2)
final_data_3 = {'PassengerId': test.PassengerId, 'Survived': y_hat_vc_soft}
submiss... | Titanic - Machine Learning from Disaster |
10,385,931 | test = pd.read_csv(f'{DATA_DIR}/test.csv' )<define_variables> | comparison['difference_rf_vc_hard'] = comparison.apply(lambda x: 1 if x.Survived_vc_hard != x.Survived_rf else 0, axis =1)
comparison['difference_soft_hard'] = comparison.apply(lambda x: 1 if x.Survived_vc_hard != x.Survived_vc_soft else 0, axis =1)
comparison['difference_hard_all'] = comparison.apply(lambda x: 1 if ... | Titanic - Machine Learning from Disaster |
10,385,931 | n=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.)<prepare_output> | comparison.difference_hard_all.value_counts() | Titanic - Machine Learning from Disaster |
10,385,931 | sub['question_type_spelling'] = spelling<count_values> | submission.to_csv('submission_rf.csv', index =False)
submission_2.to_csv('submission_vc_hard.csv',index=False)
submission_3.to_csv('submission_vc_soft.csv', index=False)
submission_4.to_csv('submission_vc_all.csv', index=False)
submission_5.to_csv('submission_vc_xgb2.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,496,503 | sub['question_type_spelling'].value_counts()<save_to_csv> | train, test = pd.read_csv('.. /input/titanic/train.csv'), \
pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
11,496,503 | sub.to_csv('submission.csv', index=False )<save_to_csv> | train.isna().sum() | Titanic - Machine Learning from Disaster |
11,496,503 | sub.to_csv('submission.csv', index=False )<define_variables> | test.isna().sum() | Titanic - Machine Learning from Disaster |
11,496,503 | USE_SAMPLE = False
USE_ONLY_SELECTED_FOLDS = True
selected_folds = [0,1,2]
WEIGHTS = 'softmax'
ROUND = True
USE_LGB = True
USE_XGB = False
USE_3SPLIT_BERT = False
USE_TEST_SAFETY_ADJUSTMENTS = True
beta = 18.5<install_modules> | datasets = [train, test]
for d in datasets:
for i in list(d.columns):
if(d[i].notnull().sum() / d.shape[0] <=.5)\
or i in ['Name', 'Ticket']:
d.drop(i, axis=1, inplace=True)
elif d[i].dtype == float or train[i].dtype == int:
d[i] = d[i].fillna(d[i].mean())
else:
d[i] = d[i].fillna(d[i].mode() [0] ) | Titanic - Machine Learning from Disaster |
11,496,503 | !pip install.. /input/sacremoses0038 > /dev/null
sys.path.insert(0, ".. /input/tokenizers0011/" )<install_modules> | y_train = train['Survived']
x_train, x_test = train.drop('Survived', axis=1), test
x_train.drop('PassengerId', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
11,496,503 | !pip install.. /input/transformers241 > /dev/null --no-dependencies<install_modules> | datasets = [x_train, x_test]
for d in datasets:
d['Embarked'] = d['Embarked'].fillna('S')
d['Embarked'] = d['Embarked'].map({
'S': 0,
'C': 1,
'Q': 2
})
d['Sex'] = d['Sex'].map({
'male': 0,
'female': 1
})
d['FamilySize'] = d['SibSp'] + d['Parch'] + 1 | Titanic - Machine Learning from Disaster |
11,496,503 | !pip install.. /input/fastparquet/fastparquet-0.3.2-cp36-cp36m-linux_x86_64.whl > /dev/null --no-dependencies<install_modules> | scaler = StandardScaler()
for d in datasets:
for c in ['Age', 'Fare', 'Parch', \
'Pclass', 'SibSp', 'FamilySize']:
d[c] = d[c].astype(float)
d[c] = scaler.fit_transform(d[c].values.reshape(-1, 1)) | Titanic - Machine Learning from Disaster |
11,496,503 | !pip install.. /input/fastparquet/thrift-0.13.0-cp36-cp36m-linux_x86_64.whl > /dev/null --no-dependencies<set_options> | model = tf.keras.models.Sequential([
tf.keras.layers.Flatten() ,
tf.keras.layers.Dense(32, input_dim=x_train.shape[1], activation='relu'),
tf.keras.layers.Dropout(0.4),
tf.keras.layers.Dense(32, activation='relu'),
tf.keras.layers.Dense(1, activation='sigmoid')
])
model.compile(
loss='binary_crossentropy',
optimizer... | Titanic - Machine Learning from Disaster |
11,496,503 | np.set_printoptions(suppress=True)
print(tf.__version__)
pd.set_option('display.max_colwidth', 500)
pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
COLOR = 'black'
matplotlib.rcParams['text.color'] = COLOR
matplotlib.rcParams['axes.labelcolor'] = COLOR
matplotlib.rcParams['xtick.co... | num_epochs = 42
history = model.fit(x_train, y_train, epochs=num_epochs, \
batch_size=50, validation_split = 0.2 ) | Titanic - Machine Learning from Disaster |
11,496,503 | PATH = '.. /input/google-quest-challenge/'
BERT_PATH = '.. /input/bert-base-uncased-huggingface-transformer/'
GPT2_PATH = '.. /input/gpt2-hugginface-pretrained/'
XLNET_PATH = '.. /input/xlnet-huggingface-pretrained/'
MAX_SEQUENCE_LENGTH = 512
df_train = pd.read_csv(PATH+'train.csv')
df_test = pd.read_csv(PATH+'test.cs... | scores = model.evaluate(x_train, y_train, batch_size=32 ) | Titanic - Machine Learning from Disaster |
11,496,503 | def save_file(var, name):
pickle.dump(var, open(f"/kaggle/working/{name}.p", "wb"))<categorify> | print(f'Loss: {scores[0]} Accuracy: {scores[1]}' ) | Titanic - Machine Learning from Disaster |
11,496,503 | def _convert_to_transformer_inputs(title, question, answer, tokenizer, max_sequence_length):
def return_id(str1, str2, truncation_strategy, length):
inputs = tokenizer.encode_plus(str1, str2,
add_special_tokens=True,
max_length=length,
truncation_strategy=truncation_strategy)
input_ids = inputs["input_ids"]
input_ma... | x_test_without_ids = x_test.drop('PassengerId', axis=1)
y_predicted = model.predict(x_test_without_ids)
y_test =(y_predicted > 0.5 ).astype(int ).reshape(x_test_without_ids.shape[0] ) | Titanic - Machine Learning from Disaster |
11,496,503 | xlnetcfg = {'architectures': ['XLNetLMHeadModel'],
'attn_type': 'bi',
'bi_data': False,
'bos_token_id': 0,
'clamp_len': -1,
'd_head': 64,
'd_inner': 3072,
'd_model': 768,
'do_sample': False,
'dropout': 0.1,
'end_n_top': 5,
'eos_token_ids': 0,
'ff_activation': 'gelu',
'finetuning_task': None,
'id2label': {0: 'LABEL_0', ... | results = pd.DataFrame()
results['PassengerId'] = x_test['PassengerId']
results['Survived'] = y_test
results.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
4,273,036 | def compute_spearmanr_ignore_nan(trues, preds):
rhos = []
for tcol, pcol in zip(np.transpose(trues), np.transpose(preds)) :
rhos.append(spearmanr(tcol, pcol ).correlation)
return np.nanmean(rhos)
def create_nn_model(output_len, model_type):
q_id = tf.keras.layers.Input(( MAX_SEQUENCE_LENGTH,), dtype=tf.int32)
q_mask... | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
4,273,036 | question_only = ['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... | %matplotlib inline
mpl.style.use('ggplot')
sns.set_style('white')
pylab.rcParams['figure.figsize'] = 12,8 | Titanic - Machine Learning from Disaster |
4,273,036 | answer_and_question = ['answer_level_of_information', 'answer_helpful','answer_plausible','answer_relevance','answer_satisfaction']<define_variables> | data_raw = pd.read_csv('.. /input/train.csv')
data_val = pd.read_csv('.. /input/test.csv')
data1 = data_raw.copy(deep = True)
data_cleaner = [data1, data_val]
print(data_raw.info())
data_raw.sample(10 ) | Titanic - Machine Learning from Disaster |
4,273,036 | answer_only = ['answer_type_instructions', 'answer_type_procedure', 'answer_type_reason_explanation', 'answer_well_written']<define_variables> | for dataset in data_cleaner:
dataset['Age'].fillna(dataset['Age'].median() , inplace = True)
dataset['Embarked'].fillna(dataset['Embarked'].mode() [0], inplace = True)
dataset['Fare'].fillna(dataset['Fare'].median() , inplace = True)
drop_column = ['PassengerId','Cabin', 'Ticket']
data1.drop(drop_column, axis=1, inp... | Titanic - Machine Learning from Disaster |
4,273,036 | AQ_and_AO = answer_and_question + answer_only<split> | for dataset in data_cleaner:
dataset['FamilySize'] = dataset ['SibSp'] + dataset['Parch'] + 1
dataset['IsAlone'] = 1
dataset['IsAlone'].loc[dataset['FamilySize'] > 1] = 0
dataset['Title'] = dataset['Name'].str.split(", ", expand=True)[1].str.split(".", expand=True)[0]
dataset['FareBin'] = pd.qcut(dataset['Fare'], 4)
d... | Titanic - Machine Learning from Disaster |
4,273,036 | gkf10 = GroupKFold(n_splits=10 ).split(X=df_train.question_body, groups=df_train.question_body)
gkf5 = GroupKFold(n_splits=5 ).split(X=df_train.question_body, groups=df_train.question_body)
common_validation_idx = []
val10 = []
val5 = []
val10_fold0 = None
for fold,(train_idx, valid_idx)in enumerate(gkf10):
if fold i... | label = LabelEncoder()
for dataset in data_cleaner:
dataset['Sex_Code'] = label.fit_transform(dataset['Sex'])
dataset['Embarked_Code'] = label.fit_transform(dataset['Embarked'])
dataset['Title_Code'] = label.fit_transform(dataset['Title'])
dataset['AgeBin_Code'] = label.fit_transform(dataset['AgeBin'])
dataset['Far... | Titanic - Machine Learning from Disaster |
4,273,036 | def predict_nn(train_data, valid_data, test_data, weights, model_type):
K.clear_session()
model = create_nn_model(train_data[1].shape[1], model_type)
model.load_weights(weights)
trn_preds = np.zeros(train_data[1].shape)
val_preds = model.predict(valid_data[0])
print(f'Lengths of test list is {len(test_data)}')
tes... | train1_x, test1_x, train1_y, test1_y = model_selection.train_test_split(data1[data1_x_calc], data1[Target], random_state = 0)
train1_x_bin, test1_x_bin, train1_y_bin, test1_y_bin = model_selection.train_test_split(data1[data1_x_bin], data1[Target] , random_state = 0)
train1_x_dummy, test1_x_dummy, train1_y_dummy, tes... | Titanic - Machine Learning from Disaster |
4,273,036 | tokenizer = XLNetTokenizer.from_pretrained('.. /input/gq-manual-uploads/xlnet tokenizer from colab/')
USING_PAD_TOKEN = False
outputs = compute_output_arrays(df_train, output_categories)
inputs = compute_input_arrays(df_train, input_categories, tokenizer, MAX_SEQUENCE_LENGTH)
test_inputs = compute_input_arrays(df_te... | plt.figure(figsize=[16,12])
plt.subplot(231)
plt.boxplot(x=data1['Fare'], showmeans = True, meanline = True)
plt.title('Fare Boxplot')
plt.ylabel('Fare($)')
plt.subplot(232)
plt.boxplot(data1['Age'], showmeans = True, meanline = True)
plt.title('Age Boxplot')
plt.ylabel('Age(Years)')
plt.subplot(233)
plt.boxp... | Titanic - Machine Learning from Disaster |
4,273,036 | model_roor_dir = 'gq-xlnet-pretrained'
MOD_DATA_STUCTURE = '2 split'
n_splits = 10
xlnet_trn, xlnet_val, xlnet_tst = get_nn_all_outputs('XLNET' )<load_pretrained> | MLA = [
ensemble.AdaBoostClassifier() ,
ensemble.BaggingClassifier() ,
ensemble.ExtraTreesClassifier() ,
ensemble.GradientBoostingClassifier() ,
ensemble.RandomForestClassifier() ,
gaussian_process.GaussianProcessClassifier() ,
linear_model.LogisticRegressionCV() ,
linear_model.PassiveAggressiveClassifier() ,
linear_mo... | Titanic - Machine Learning from Disaster |
4,273,036 | tokenizer = BertTokenizer.from_pretrained(BERT_PATH+'bert-base-uncased-vocab.txt')
USING_PAD_TOKEN = True
outputs = compute_output_arrays(df_train, output_categories)
inputs = compute_input_arrays(df_train, input_categories, tokenizer, MAX_SEQUENCE_LENGTH)
test_inputs = compute_input_arrays(df_test, input_categories... | for index, row in data1.iterrows() :
if random.random() >.5:
data1.set_value(index, 'Random_Predict', 1)
else:
data1.set_value(index, 'Random_Predict', 0)
data1['Random_Score'] = 0
data1.loc[(data1['Survived'] == data1['Random_Predict']), 'Random_Score'] = 1
print('Coin Flip Model Accuracy: {:.2f}%'.format(data1['Ran... | Titanic - Machine Learning from Disaster |
4,273,036 | model_roor_dir = 'gq-bert-pretrained'
MOD_DATA_STUCTURE = '2 split'
n_splits = 10
bert_trn, bert_val, bert_tst = get_nn_all_outputs('BERT' )<define_variables> | pivot_female = data1[data1.Sex=='female'].groupby(['Sex','Pclass', 'Embarked','FareBin'])['Survived'].mean()
print('Survival Decision Tree w/Female Node:
',pivot_female)
pivot_male = data1[data1.Sex=='male'].groupby(['Sex','Title'])['Survived'].mean()
print('
Survival Decision Tree w/Male Node:
',pivot_male ) | Titanic - Machine Learning from Disaster |
4,273,036 | model_roor_dir = '3rd-training-2nd-gen-bert-download-from-gdrive'
MOD_DATA_STUCTURE = '3 split'
n_splits = 10
selected_folds = [0]
bert_trn_3split, bert_val_3split, bert_tst_3split = get_nn_all_outputs('BERT')
selected_folds = [0,1,2]<define_variables> | def mytree(df):
Model = pd.DataFrame(data = {'Predict':[]})
male_title = ['Master']
for index, row in df.iterrows() :
Model.loc[index, 'Predict'] = 0
if(df.loc[index, 'Sex'] == 'female'):
Model.loc[index, 'Predict'] = 1
if(( df.loc[index, 'Sex'] == 'female')&
(df.loc[index, 'Pclass'] == 3)&
(df.loc[index, 'Embarked'... | Titanic - Machine Learning from Disaster |
4,273,036 | model_roor_dir = '2nd-training-1st-gen-bert-download-from-gdrive'
MOD_DATA_STUCTURE = '2 split'
n_splits = 5
bert_trn_5fold, bert_val_5fold, bert_tst_5fold = get_nn_all_outputs('BERT' )<load_pretrained> | dtree = tree.DecisionTreeClassifier(random_state = 0)
base_results = model_selection.cross_validate(dtree, data1[data1_x_bin], data1[Target], cv = cv_split)
dtree.fit(data1[data1_x_bin], data1[Target])
print('BEFORE DT Parameters: ', dtree.get_params())
print("BEFORE DT Training w/bin score mean: {:.2f}".format(bas... | Titanic - Machine Learning from Disaster |
4,273,036 | tokenizer = GPT2Tokenizer.from_pretrained('.. /input/gq-manual-uploads/gpt2 config from colab/')
USING_PAD_TOKEN = False
outputs = compute_output_arrays(df_train, output_categories)
inputs = compute_input_arrays(df_train, input_categories, tokenizer, MAX_SEQUENCE_LENGTH)
test_inputs = compute_input_arrays(df_test, i... | dot_data = tree.export_graphviz(dtree, out_file=None,
feature_names = data1_x_bin, class_names = True,
filled = True, rounded = True)
graph = graphviz.Source(dot_data)
graph | Titanic - Machine Learning from Disaster |
4,273,036 | model_roor_dir = 'gq-gpt2-pretrained'
MOD_DATA_STUCTURE = '2 split'
n_splits = 10
gpt2_trn, gpt2_val, gpt2_tst = get_nn_all_outputs('GPT2' )<split> | vote_est = [
('ada', ensemble.AdaBoostClassifier()),
('bc', ensemble.BaggingClassifier()),
('etc',ensemble.ExtraTreesClassifier()),
('gbc', ensemble.GradientBoostingClassifier()),
('rfc', ensemble.RandomForestClassifier()),
('gpc', gaussian_process.GaussianProcessClassifier()),
('lr', linear_model.LogisticRegres... | Titanic - Machine Learning from Disaster |
4,273,036 | model_roor_dir = '2nd-training-1st-gen-gpt-download-from-gdrive'
MOD_DATA_STUCTURE = '2 split'
n_splits = 5
gpt2_trn_5fold, gpt2_val_5fold, gpt2_tst_5fold = get_nn_all_outputs('GPT2' )<feature_engineering> | grid_n_estimator = [10, 50, 100, 300]
grid_ratio = [.1,.25,.5,.75, 1.0]
grid_learn = [.01,.03,.05,.1,.25]
grid_max_depth = [2, 4, 6, 8, 10, None]
grid_min_samples = [5, 10,.03,.05,.10]
grid_criterion = ['gini', 'entropy']
grid_bool = [True, False]
grid_seed = [0]
grid_param = [
[{
'n_estimators': grid_n_estimator,
'lea... | Titanic - Machine Learning from Disaster |
4,273,036 | if USE_LGB:
def remove_articles(df):
for i in ['question_title', 'question_body', 'answer']:
df.loc[:,f'{i}_orig'] = df.loc[:,i]
for i in ['question_title', 'question_body', 'answer']:
df.loc[:,i] = df.loc[:,i].apply(lambda x: x.replace(' the ',' ' ).replace(' a ',' ' ).replace(' an ',' '))
return df
df_train = remove_... | grid_hard = ensemble.VotingClassifier(estimators = vote_est , voting = 'hard')
grid_hard_cv = model_selection.cross_validate(grid_hard, data1[data1_x_bin], data1[Target], cv = cv_split)
grid_hard.fit(data1[data1_x_bin], data1[Target])
grid_soft = ensemble.VotingClassifier(estimators = vote_est , voting = 'soft')
gr... | Titanic - Machine Learning from Disaster |
4,273,036 | if USE_LGB:
df_train.loc[:,'q_users_host'] = df_train.apply(lambda x: x.question_user_name + x.host, axis=1)
df_train.loc[:,'a_users_host'] = df_train.apply(lambda x: x.answer_user_name + x.host, axis=1)
df_test.loc[:,'q_users_host'] = df_test.apply(lambda x: x.question_user_name + x.host, axis=1)
df_test.loc[:,'a_u... | submit.to_csv("titanic_submission.csv", index = False ) | Titanic - Machine Learning from Disaster |
2,547,283 | if USE_LGB:
word_categories = ['adjectives','verbs','nouns','list_maker','digits','modals','posessives','persionals','interjection','direction','past_verb']
adjectives = ['JJ','JJR','JJS','RB','RBR','RBS']
verbs = ['VB','VBD','VBG','VBN','VBP','VBZ']
nouns = ['NN','NNS','NNP','NNPS']
list_maker = ['LS']
digits = ['CD']... | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
train.head() | Titanic - Machine Learning from Disaster |
2,547,283 | if USE_LGB:
def get_uids_all(df):
df.loc[:,'answer_uid'] = df.loc[:,'answer_user_page'].apply(lambda x: int(x.split('/')[-1]))
df.loc[:,'question_uid'] = df.loc[:,'question_user_page'].apply(lambda x: int(x.split('/')[-1]))
for idx in range(df.shape[0]):
split = [i for i in df.loc[idx,'url'].split('/')if i.isdigit() ]
... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
2,547,283 | if USE_LGB:
se_path = ".. /input/stackexchange-data"
se_posts = pd.read_parquet(se_path+"/stackexchange_posts.parquet.gzip", engine='fastparquet')
def get_post_info_se(df):
new_other_features = []
new_features = ['Score','ViewCount','AnswerCount','CommentCount','FavoriteCount','Tags']
df = df.merge(se_posts.loc[:,['Id... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
2,547,283 | if USE_LGB:
def is_answer_accepted(df):
for i in df.loc[(df.host=='stackoverflow.com')& ~(df.QPAGE_accepted_answer_id.isna()),:].index.values:
df.loc[i,'answer_accepted'] = 1 if df.loc[i, 'answer_uid'] == df.loc[i, 'QPAGE_accepted_answer_id'] else 0
for i in df.loc[(df.host!='stackoverflow.com')& ~(df.AcceptedAnswerId.... | test.isnull().sum() | Titanic - Machine Learning from Disaster |
2,547,283 | if USE_LGB:
class Base_Model(object):
def __init__(self, train_df, test_df, features, categoricals=[], n_splits=5, verbose=True, target=None, predict_test=True):
self.train_df = train_df
self.test_df = test_df
self.features = features
self.n_splits = 10
self.categoricals = categoricals
self.target = target
self.cv = se... | train_test_data = [train, test] | Titanic - Machine Learning from Disaster |
2,547,283 | if USE_LGB:
one_lgb_model = pickle.load(open(f'.. /input/gq-lgb/question_opinion_seeking/question_opinion_seeking_0.p', 'rb'))
lgb_pretrained_features = one_lgb_model.feature_name()
for i in lgb_pretrained_features:
if i not in other_features:
print(f'{i} not in other features here, adding zeros')
df_train.loc[:, i] =... | train.groupby('Pclass' ).mean() | Titanic - Machine Learning from Disaster |
2,547,283 | %%time
if USE_LGB:
ACTUAL_FOLDS = 3
lgb_val_scores = []
n_output_categories = len(output_categories)
lgb_val_outputs_all = []
lgb_val_preds_all = []
lgb_tst_preds_all = []
for idx, i in enumerate(output_categories, 1):
lgb_model = Lgb_Model(df_train, df_test, lgb_pretrained_features, target=i, verbose=False)
lgb_val_... | encoder=LabelBinarizer()
train['Sex']=encoder.fit_transform(train['Sex'])
test['Sex']=encoder.fit_transform(test['Sex'])
train.head(10)
| Titanic - Machine Learning from Disaster |
2,547,283 | if USE_XGB:
one_xgb_model = pickle.load(open(f'.. /input/gq-xgb/question_opinion_seeking/question_opinion_seeking_0.p', 'rb'))
xgb_pretrained_features = one_xgb_model.feature_names
for i in xgb_pretrained_features:
if i not in other_features:
print(f'{i} not in other features here, adding zeros')
df_train.loc[:, i] = ... | for dataset in train_test_data:
dataset['Name'] = dataset['Name'].str.extract('([A-Za-z]+)\.', expand=True ) | Titanic - Machine Learning from Disaster |
2,547,283 | %%time
if USE_XGB:
ACTUAL_FOLDS = 3
xgb_val_scores = []
n_output_categories = len(output_categories)
xgb_val_outputs_all = []
xgb_val_preds_all = []
xgb_tst_preds_all = []
for idx, i in enumerate(output_categories, 1):
xgb_model = Xgb_Model(df_train, df_test, xgb_pretrained_features, target=i, verbose=False)
xgb_val_... | train['Name'].value_counts() | Titanic - Machine Learning from Disaster |
2,547,283 | def get_rounding(ys, preds):
rounding_types = ['Normal', 'Ceil', 'Floor']
rounding_funcs = [np.round, np.ceil, np.floor]
dec_places = [1,2,3,4,5]
score = spearmanr(ys, preds ).correlation
if np.isnan(score): score=-100
best_result = {'Type':'No rounding','DP':0, 'func':None}
for r_type, r_func in zip(rounding_types, ro... | replace_name = {'Mlle': 'Miss', 'Major': 'Mr', 'Col': 'Mr', 'Sir': 'Mr', 'Don': 'Mr', 'Mme': 'Miss',
'Jonkheer': 'Mr', 'Lady': 'Mrs', 'Capt': 'Mr', 'Countess': 'Mrs', 'Ms': 'Miss', 'Dona': 'Mrs'} | Titanic - Machine Learning from Disaster |
2,547,283 | def inverse_spearman_r(weights, ys, preds):
mixed_val_preds = np.array([i*w for i,w in zip(preds, weights)] ).sum(axis=0)
score = spearmanr(ys, mixed_val_preds ).correlation
if np.isnan(score): score=-100
return -score
def optimize_mixing_weights(ys, preds):
naive_mix = np.array(preds ).mean(axis=0)
score = spearmanr... | train.replace({'Name' : replace_name}, inplace=True ) | Titanic - Machine Learning from Disaster |
2,547,283 | val10_common = [np.where(val10==i)[0][0] for i in common_validation_idx]
val5_common = [np.where(val5==i)[0][0] for i in common_validation_idx]<define_variables> | test.replace({'Name' : replace_name}, inplace=True ) | Titanic - Machine Learning from Disaster |
2,547,283 | val10_fold0_common = [np.where(val10_fold0==i)[0] for i in common_validation_idx]
val10_fold0_common = [i[0] for i in val10_fold0_common if len(i)>0]<load_from_csv> | train[['Name', 'Survived']].groupby(['Name'], as_index=False ).mean() | Titanic - Machine Learning from Disaster |
2,547,283 | %%time
weights_all = []
weights_for_rounding = []
scores_all = []
df_sub = pd.read_csv(PATH+'sample_submission.csv')
bestonly_raw_scores = []
best_rounded_scores = []
best_weighted_scores = []
if USE_SAMPLE: df_sub=df_sub.iloc[0:round(0.1*df_sub.shape[0]),:]
if USE_LGB:
if len(lgb_val_scores)!= 30:
USE_LGB=False
print... | score_name = {"Rev" : 0, "Mr" : 1, "Dr" : 2, "Master" : 3, "Miss" : 4, "Mrs" : 5}
for dataset in train_test_data:
dataset['Name'] = dataset['Name'].map(score_name)
train.head(10 ) | Titanic - Machine Learning from Disaster |
2,547,283 | save_file(weights_all, 'weights_all')
save_file(weights_for_rounding, 'weights_all')
save_file(scores_all, 'weights_all' )<data_type_conversions> | titles = [0,1,2,3,4,5]
for title in titles:
age_to_impute = train.groupby('Name')['Age'].median() [titles.index(title)]
train.loc[(train['Age'].isnull())&(train['Name'] == title), 'Age'] = age_to_impute
train['Age'].isnull().sum() | Titanic - Machine Learning from Disaster |
2,547,283 | np.max(df_sub.iloc[:,1:].to_numpy().flatten()), np.min(df_sub.iloc[:,1:].to_numpy().flatten()), df_sub.shape<prepare_output> | for title in titles:
age_to_impute = train.groupby('Name')['Age'].median() [titles.index(title)]
test.loc[(test['Age'].isnull())&(test['Name'] == title), 'Age'] = age_to_impute
test['Age'].isnull().sum() | Titanic - Machine Learning from Disaster |
2,547,283 | np.mean(bestonly_raw_scores), np.min(bestonly_raw_scores), np.max(bestonly_raw_scores), len(bestonly_raw_scores )<prepare_output> | for dataset in train_test_data:
dataset['Age_bin'] = pd.cut(train['Age'], 5 ) | Titanic - Machine Learning from Disaster |
2,547,283 | np.mean(best_weighted_scores), np.min(best_weighted_scores), np.max(best_weighted_scores), len(best_weighted_scores )<compute_test_metric> | train[['Age_bin','Survived']].groupby(['Age_bin'], as_index=False ).mean().sort_values(by='Survived' ) | Titanic - Machine Learning from Disaster |
2,547,283 | np.mean(best_rounded_scores), np.min(best_rounded_scores), np.max(best_rounded_scores), len(best_rounded_scores )<define_variables> | group_names = [4,1,3,2,0]
for dataset in train_test_data:
dataset['Age'] = pd.cut(train['Age'], 5, labels=group_names ) | Titanic - Machine Learning from Disaster |
2,547,283 | [(c,np.round(s,3)) for c,s in zip(output_categories, scores_all)]<define_variables> | train[['Age','Survived']].groupby(['Age'], as_index=False ).mean().sort_values(by='Survived' ) | Titanic - Machine Learning from Disaster |
2,547,283 | [(c,np.round(s,3)) for c,s in zip(output_categories, weights_all)]<import_modules> | for dataset in train_test_data:
dataset['Embarked'] = dataset['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
2,547,283 | import os
import re
import gc
import pickle
import random
import lightgbm as lgbm
import numpy as np
import pandas as pd<import_modules> | train[['Embarked','Survived']].groupby(['Embarked'], as_index=False ).mean().sort_values(by='Survived' ) | Titanic - Machine Learning from Disaster |
2,547,283 | import numpy as np
import pandas as pd
import os
import numpy as np
import matplotlib.pyplot as plt
import gensim
from nltk.corpus import brown
import random
from sklearn.model_selection import KFold
import lightgbm as lgb
import gc
from keras.callbacks.callbacks import EarlyStopping
from sklearn.feature_extraction.tex... | embarked_mapping = {"S": 0, "Q": 1, "C": 2}
for dataset in train_test_data:
dataset['Embarked'] = dataset['Embarked'].map(embarked_mapping ) | Titanic - Machine Learning from Disaster |
2,547,283 | np.set_printoptions(suppress=True)
tokenizer = transformers.DistilBertTokenizer.from_pretrained(".. /input/distilbertbaseuncased/")
model = transformers.DistilBertModel.from_pretrained(".. /input/distilbertbaseuncased/" )<load_from_csv> | train['FamilySize'] = train['SibSp'] + train['Parch'] + 1
test['FamilySize'] = test['SibSp'] + test['Parch'] + 1 | Titanic - Machine Learning from Disaster |
2,547,283 | PATH = '.. /input/google-quest-challenge/'
BERT_PATH = '.. /input/bert-base-from-tfhub/bert_en_uncased_L-12_H-768_A-12'
tokenizer = transformers.DistilBertTokenizer.from_pretrained(BERT_PATH+'/assets/vocab.txt')
MAX_SEQUENCE_LENGTH = 512
train = df_train = pd.read_csv(PATH+'train.csv')
test = df_test = pd.read_csv(PA... | train[['FamilySize','Survived']].groupby(['FamilySize'], as_index=False ).mean().sort_values(by='Survived' ) | Titanic - Machine Learning from Disaster |
2,547,283 | seed(42)
tf.random.set_seed(42)
random.seed(42 )<define_variables> | replace_family = {8 : 0, 11 : 0, 6:1, 5: 2, 1:3, 7:4, 2 : 5, 3 :6, 4:7} | Titanic - Machine Learning from Disaster |
2,547,283 | data_dir = '.. /input/google-quest-challenge/'<define_variables> | for dataset in train_test_data:
dataset['FamilySize'] = dataset['FamilySize'].apply(lambda x: replace_family.get(x)) | Titanic - Machine Learning from Disaster |
2,547,283 | 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... | test['Fare'].fillna(train['Fare'].median() , inplace = True ) | Titanic - Machine Learning from Disaster |
2,547,283 | gc.collect()
tfidf = TfidfVectorizer(ngram_range=(1, 3))
tsvd = TruncatedSVD(n_components = 60)
tfidf_question_title = tfidf.fit_transform([simple_prepro_tfidf(l)for l in tqdm.tqdm(train["question_title"].values)])
tfidf_question_title_test = tfidf.transform([simple_prepro_tfidf(l)for l in tqdm.tqdm(test["question_ti... | for dataset in train_test_data:
dataset['Fare_bin'] = pd.cut(train['Fare'], 4 ) | Titanic - Machine Learning from Disaster |
2,547,283 | w2v_model = gensim.models.Word2Vec(brown.sents() )<categorify> | train[['Fare_bin','Survived']].groupby(['Fare_bin'], as_index=False ).mean().sort_values(by='Survived' ) | Titanic - Machine Learning from Disaster |
2,547,283 | def get_word_embeddings(text):
np.random.seed(abs(hash(text)) %(10 ** 8))
words = simple_prepro(text)
vectors = np.zeros(( len(words),100))
if len(words)==0:
vectors = np.zeros(( 1,100))
for i,word in enumerate(simple_prepro(text)) :
try:
vectors[i]=w2v_model[word]
except:
vectors[i]=np.random.uniform(-0.01, 0.01,100)... | train[['Fare','Survived']].groupby(['Fare'], as_index=False ).mean() | 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.