kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,566,591 | submission = pd.DataFrame({
"PassengerId":test2['PassengerId'],
"Survived":y_predicted
} )<save_to_csv> | train_df.columns[train_df.isnull().any() ] | Titanic - Machine Learning from Disaster |
10,566,591 | submission.to_csv('first_kaggale_titanic_submission.csv',index=False )<import_modules> | train_df.isnull().sum() | Titanic - Machine Learning from Disaster |
10,566,591 | import numpy as np
import pandas as pd
import os
import tokenizers
import string
import torch
import transformers
import torch.nn as nn
from torch.nn import functional as F
from tqdm import tqdm
import re<define_variables> | train_df[train_df["Embarked"].isnull() ] | Titanic - Machine Learning from Disaster |
10,566,591 | MAX_LEN = 128
TRAIN_BATCH_SIZE = 32
VALID_BATCH_SIZE = 16
EPOCHS = 5
ROBERTA_PATH = ".. /input/roberta-base"
TOKENIZER = tokenizers.ByteLevelBPETokenizer(
vocab_file=f"{ROBERTA_PATH}/vocab.json",
merges_file=f"{ROBERTA_PATH}/merges.txt",
lowercase=True,
add_prefix_space=True
)<define_search_model> | train_df["Embarked"] = train_df["Embarked"].fillna("C" ) | Titanic - Machine Learning from Disaster |
10,566,591 | class TweetModel(transformers.BertPreTrainedModel):
def __init__(self, conf):
super(TweetModel, self ).__init__(conf)
self.roberta = transformers.RobertaModel.from_pretrained(ROBERTA_PATH, config=conf)
self.drop_out = nn.Dropout(0.1)
self.l0 = nn.Linear(768 * 2, 2)
torch.nn.init.normal_(self.l0.weight, std=0.02)
d... | train_df.columns[train_df.isnull().any() ] | Titanic - Machine Learning from Disaster |
10,566,591 | def process_data(tweet, selected_text, sentiment, tokenizer, max_len):
tweet = " " + " ".join(str(tweet ).split())
selected_text = " " + " ".join(str(selected_text ).split())
len_st = len(selected_text)- 1
idx0 = None
idx1 = None
for ind in(i for i, e in enumerate(tweet)if e == selected_text[1]):
if " " + tweet[ind: ... | train_df[train_df["Fare"].isnull() ] | Titanic - Machine Learning from Disaster |
10,566,591 | def calculate_jaccard_score(
original_tweet,
target_string,
sentiment_val,
idx_start,
idx_end,
offsets,
verbose=False):
if idx_end < idx_start:
idx_end = idx_start
filtered_output = ""
for ix in range(idx_start, idx_end + 1):
filtered_output += original_tweet[offsets[ix][0]: offsets[ix][1]]
if(ix+1)< len(offsets)and o... | train_df["Fare"] = train_df["Fare"].fillna(np.mean(train_df[train_df["Pclass"]==3]["Fare"]))
train_df[train_df["Fare"].isnull() ] | Titanic - Machine Learning from Disaster |
10,566,591 | df_test = pd.read_csv(".. /input/tweet-sentiment-extraction/test.csv")
df_test.loc[:, "selected_text"] = df_test.text.values<load_pretrained> | pd.set_option('mode.chained_assignment', None)
| Titanic - Machine Learning from Disaster |
10,566,591 | device = torch.device("cuda")
model_config = transformers.RobertaConfig.from_pretrained(ROBERTA_PATH)
model_config.output_hidden_states = True<load_pretrained> | gender_submission = pd.read_csv('.. /input/titanic/gender_submission.csv')
train_df = pd.read_csv('.. /input/titanic/train.csv')
test_df = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
10,566,591 | model1 = TweetModel(conf=model_config)
model1.to(device)
model1.load_state_dict(torch.load(".. /input/tweet-rob-model/model_0.bin"))
model1.eval()
model2 = TweetModel(conf=model_config)
model2.to(device)
model2.load_state_dict(torch.load(".. /input/tweet-rob-model/model_1.bin"))
model2.eval()
model3 = TweetModel(co... | train_df.PassengerId[train_df.Cabin.notnull() ].count() | Titanic - Machine Learning from Disaster |
10,566,591 | final_output = []<create_dataframe> | train_df.PassengerId[train_df.Age.notnull() ].count() | Titanic - Machine Learning from Disaster |
10,566,591 | test_dataset = TweetDataset(
tweet=df_test.text.values,
sentiment=df_test.sentiment.values,
selected_text=df_test.selected_text.values
)
data_loader = torch.utils.data.DataLoader(
test_dataset,
shuffle=False,
batch_size=VALID_BATCH_SIZE,
num_workers=1
)
with torch.no_grad() :
tk0 = tqdm(data_loader, total=len(dat... | train_df.Age = train_df.Age.median()
train_df.Age | Titanic - Machine Learning from Disaster |
10,566,591 | sample = pd.read_csv(".. /input/tweet-sentiment-extraction/sample_submission.csv")
sample.loc[:, 'selected_text'] = final_output
sample.to_csv("submission.csv", index=False )<set_options> | train_df[train_df.Embarked.isnull() ] | Titanic - Machine Learning from Disaster |
10,566,591 | tf.get_logger().setLevel(logging.ERROR)
warnings.filterwarnings("ignore")
tf.config.optimizer.set_jit(True)
tf.config.optimizer.set_experimental_options(
{"auto_mixed_precision": True} )<load_from_csv> | MaxPassEmbarked = train_df.groupby('Embarked' ).count() ['PassengerId']
train_df.Embarked[train_df.Embarked.isnull() ] = MaxPassEmbarked[MaxPassEmbarked == MaxPassEmbarked.max() ].index[0] | Titanic - Machine Learning from Disaster |
10,566,591 | train_df = pd.read_csv('.. /input/tweet-sentiment-extraction/train.csv')
train_df.dropna(inplace=True)
test_df = pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv')
test_df.loc[:, "selected_text"] = test_df.text.values
submission_df = pd.read_csv('.. /input/tweet-sentiment-extraction/sample_submission.csv')... | train_df = train_df.drop(['PassengerId','Name','Ticket','Cabin'],axis=1)
train_df | Titanic - Machine Learning from Disaster |
10,566,591 | def preprocess(tweet, selected_text, sentiment):
tweet = tweet.decode('utf-8')
selected_text = selected_text.decode('utf-8')
sentiment = sentiment.decode('utf-8')
tweet = " ".join(str(tweet ).split())
selected_text = " ".join(str(selected_text ).split())
idx_start, idx_end = None, None
for index in(i for i, c in... | train_df.columns[train_df.isnull().any() ] | Titanic - Machine Learning from Disaster |
10,566,591 | class BertQAModel(TFBertPreTrainedModel):
DROPOUT_RATE = 0.5
NUM_HIDDEN_STATES = 2
def __init__(self, config, *inputs, **kwargs):
super().__init__(config, *inputs, **kwargs)
self.bert = TFBertMainLayer(config, name="bert")
self.concat = L.Concatenate()
self.dropout = L.Dropout(self.DROPOUT_RATE)
self.hidden_output=L... | label = LabelEncoder()
dicts = {}
label.fit(train_df.Sex.drop_duplicates())
dicts['Sex'] = list(label.classes_)
train_df.Sex = label.transform(train_df.Sex)
label.fit(train_df.Embarked.drop_duplicates())
dicts['Embarked'] = list(label.classes_)
train_df.Embarked = label.transform(train_df.Embarked)
train_df | Titanic - Machine Learning from Disaster |
10,566,591 | num_folds = 8
num_epochs = 3
batch_size = 32
learning_rate = 3e-5
optimizer = tf.keras.optimizers.Adam(learning_rate)
optimizer = tf.keras.mixed_precision.experimental.LossScaleOptimizer(
optimizer, 'dynamic')
if PATH == ".. /input/bert-base-uncased/":
config = BertConfig(output_hidden_states=True, num_labels=2)
el... | test_df.Age[test_df.Age.isnull() ] = test_df.Age.mean()
test_df.Fare[test_df.Fare.isnull() ] = test_df.Fare.median()
MaxPassEmbarked = test_df.groupby('Embarked' ).count() ['PassengerId']
test_df.Embarked[test_df.Embarked.isnull() ] = MaxPassEmbarked[MaxPassEmbarked == MaxPassEmbarked.max() ].index[0]
result = pd.DataF... | Titanic - Machine Learning from Disaster |
10,566,591 | import os
import torch
import pandas as pd
import torch.nn as nn
import numpy as np
import torch.nn.functional as F
from torch.optim import lr_scheduler
from sklearn import model_selection
from sklearn import metrics
import transformers
import tokenizers
from transformers import AdamW
from transformers import get_linea... | target = train_df.Survived
train_df = train_df.drop(['Survived'], axis=1)
kfold = 5
itog_val = {} | Titanic - Machine Learning from Disaster |
10,566,591 | class config:
MAX_LEN = 128
TRAIN_BATCH_SIZE = 64
VALID_BATCH_SIZE = 16
EPOCHS = 5
BERT_PATH = ".. /input/bert-base-uncased/"
MODEL_PATH = "model.bin"
TRAINING_FILE = ".. /input/tweet-train-folds/train_folds.csv"
TOKENIZER = tokenizers.BertWordPieceTokenizer(
f"{BERT_PATH}/vocab.txt",
lowercase=True
)<define_variables... | ROCtrainTRN, ROCtestTRN, ROCtrainTRG, ROCtestTRG = train_test_split(train_df, target, test_size=0.25 ) | Titanic - Machine Learning from Disaster |
10,566,591 | def process_data(tweet, selected_text, sentiment, tokenizer, max_len):
len_st = len(selected_text)
idx0 = None
idx1 = None
for ind in(i for i, e in enumerate(tweet)if e == selected_text[0]):
if tweet[ind: ind+len_st] == selected_text:
idx0 = ind
idx1 = ind + len_st - 1
break
char_targets = [0] * len(tweet)
if idx0 ... | model_rfc = RandomForestClassifier(n_estimators = 80, max_features='auto', criterion='entropy',max_depth=4)
model_knc = KNeighborsClassifier(n_neighbors = 18)
model_lr = LogisticRegression(penalty='l2', tol=0.01)
model_svc = svm.SVC() | Titanic - Machine Learning from Disaster |
10,566,591 | class TweetDataset:
def __init__(self, tweet, sentiment, selected_text):
self.tweet = tweet
self.sentiment = sentiment
self.selected_text = selected_text
self.tokenizer = config.TOKENIZER
self.max_len = config.MAX_LEN
def __len__(self):
return len(self.tweet)
def __getitem__(self, item):
data = process_data(
self.t... | model_rfc.fit(train_df, target)
result.insert(1,'Survived', model_rfc.predict(test_df))
result.to_csv('predictions.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,184,790 | class TweetModel(transformers.BertPreTrainedModel):
def __init__(self, conf):
super(TweetModel, self ).__init__(conf)
self.bert = transformers.BertModel.from_pretrained(config.BERT_PATH, config=conf)
self.drop_out = nn.Dropout(0.1)
self.l0 = nn.Linear(768 * 2, 2)
torch.nn.init.normal_(self.l0.weight, std=0.02)
d... | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from numpy import mean
from numpy import std
import string
import warnings | Titanic - Machine Learning from Disaster |
11,184,790 | def loss_fn(start_logits, end_logits, start_positions, end_positions):
loss_fct = nn.CrossEntropyLoss()
start_loss = loss_fct(start_logits, start_positions)
end_loss = loss_fct(end_logits, end_positions)
total_loss =(start_loss + end_loss)
return total_loss<choose_model_class> | from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
| Titanic - Machine Learning from Disaster |
11,184,790 | def train_fn(data_loader, model, optimizer, device, scheduler=None):
model.train()
losses = utils.AverageMeter()
jaccards = utils.AverageMeter()
tk0 = tqdm(data_loader, total=len(data_loader))
for bi, d in enumerate(tk0):
ids = d["ids"]
token_type_ids = d["token_type_ids"]
mask = d["mask"]
targets_start = d["targets_... | from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler | Titanic - Machine Learning from Disaster |
11,184,790 | def calculate_jaccard_score(
original_tweet,
target_string,
sentiment_val,
idx_start,
idx_end,
offsets,
verbose=False):
if idx_end < idx_start:
idx_end = idx_start
filtered_output = ""
for ix in range(idx_start, idx_end + 1):
filtered_output += original_tweet[offsets[ix][0]: offsets[ix][1]]
if(ix+1)< len(offsets)and... | dfTrain = pd.read_csv(dirname+"/train.csv")
dfTest = pd.read_csv(dirname+"/test.csv")
dfGenderSubmission = pd.read_csv(dirname+"/gender_submission.csv" ) | Titanic - Machine Learning from Disaster |
11,184,790 | def run(fold):
dfx = pd.read_csv(config.TRAINING_FILE)
df_train = dfx[dfx.kfold != fold].reset_index(drop=True)
df_valid = dfx[dfx.kfold == fold].reset_index(drop=True)
train_dataset = TweetDataset(
tweet=df_train.text.values,
sentiment=df_train.sentiment.values,
selected_text=df_train.selected_text.values
)
tr... | def concat_df(train_data, test_data):
return pd.concat([train_data, test_data], sort=True ).reset_index(drop=True)
def divide_df(all_data):
return all_data.loc[:890], all_data.loc[891:].drop(['Survived'], axis=1)
dfMrg = concat_df(dfTrain,dfTest)
dfMrg.isna().sum() | Titanic - Machine Learning from Disaster |
11,184,790 | df_test = pd.read_csv(".. /input/tweet-sentiment-extraction/test.csv")
df_test.loc[:, "selected_text"] = df_test.text.values<load_pretrained> | titleyouth = dfMrg[(dfMrg['Title'] == 'Miss')|(dfMrg['Title'] == 'Mr')]
dfMrg.loc[titleyouth[(titleyouth['Age'] < 21)].index.tolist() ,'Title'] = 'Youth' | Titanic - Machine Learning from Disaster |
11,184,790 | device = torch.device("cuda")
model_config = transformers.BertConfig.from_pretrained(config.BERT_PATH)
model_config.output_hidden_states = True<load_pretrained> | titleDr = dfMrg[(dfMrg['Title'] == 'Dr')].dropna()
dfMrg.loc[titleDr[(titleDr['Sex'] == 'female')].index.tolist() ,'Title'] = 'Mrs'
dfMrg['Title'] = dfMrg['Title'].replace(['Dr'],'Mr')
pd.crosstab(dfMrg['Title'],dfMrg['Sex'] ) | Titanic - Machine Learning from Disaster |
11,184,790 | model1 = TweetModel(conf=model_config)
model1.to(device)
model1.load_state_dict(torch.load("model_0.bin"))
model1.eval()
model2 = TweetModel(conf=model_config)
model2.to(device)
model2.load_state_dict(torch.load("model_1.bin"))
model2.eval()
model3 = TweetModel(conf=model_config)
model3.to(device)
model3.load_sta... | dfMrg.set_index('Title' ).isna().sum(level=0)['Age'] | Titanic - Machine Learning from Disaster |
11,184,790 | final_output = []
test_dataset = TweetDataset(
tweet=df_test.text.values,
sentiment=df_test.sentiment.values,
selected_text=df_test.selected_text.values
)
data_loader = torch.utils.data.DataLoader(
test_dataset,
shuffle=False,
batch_size=config.VALID_BATCH_SIZE,
num_workers=1
)
with torch.no_grad() :
tk0 = tqdm(d... | age_by_pclass_sex = dfMrg.groupby(['Sex', 'Pclass'] ).median() ['Age'] | Titanic - Machine Learning from Disaster |
11,184,790 | def post_process(selected):
return " ".join(set(selected.lower().split()))<save_to_csv> | dfMrg['Age'] = dfMrg.groupby(['Sex', 'Pclass'])['Age'].apply(lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
11,184,790 | sample = pd.read_csv(".. /input/tweet-sentiment-extraction/sample_submission.csv")
sample.loc[:, 'selected_text'] = final_output
sample.selected_text = sample.selected_text.map(post_process)
sample.to_csv("submission.csv", index=False )<import_modules> | dfMrg[dfMrg['Embarked'].isnull() ]
dfMrg['Embarked'] = dfMrg['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
11,184,790 | import numpy as np
import pandas as pd
import json<load_from_csv> | dfMrg[dfMrg['Fare'].isnull() ]
med_fare = dfMrg.groupby(['Pclass', 'Parch', 'SibSp'] ).Fare.median() [3][0][0]
dfMrg['Fare'] = dfMrg['Fare'].fillna(med_fare ) | Titanic - Machine Learning from Disaster |
11,184,790 | pd_train = pd.read_csv('/kaggle/input/tweet-sentiment-extraction/train.csv')
pd_test = pd.read_csv('/kaggle/input/tweet-sentiment-extraction/test.csv' )<prepare_x_and_y> | dfMrg['Deck'] = dfMrg['Cabin'].apply(lambda s: s[0] if pd.notnull(s)else 'M' ) | Titanic - Machine Learning from Disaster |
11,184,790 | train = np.array(pd_train)
test = np.array(pd_test )<find_best_params> | df_all_decks = dfMrg.groupby(['Deck', 'Pclass'] ).count().drop(columns=['Survived', 'Sex', 'Age', 'SibSp', 'Parch',
'Fare', 'Embarked', 'Cabin', 'PassengerId', 'Ticket'] ).rename(columns={'Name': 'Count'} ).transpose() | Titanic - Machine Learning from Disaster |
11,184,790 | def find_all(input_str, search_str):
l1 = []
length = len(input_str)
index = 0
while index < length:
i = input_str.find(search_str, index)
if i == -1:
return l1
l1.append(i)
index = i + 1
return l1<define_variables> | def get_pclass_dist(df):
deck_counts = {'A': {}, 'B': {}, 'C': {}, 'D': {}, 'E': {}, 'F': {}, 'G': {}, 'M': {}, 'T': {}}
decks = df.columns.levels[0]
for deck in decks:
for pclass in range(1, 4):
try:
count = df[deck][pclass][0]
deck_counts[deck][pclass] = count
except KeyError:
deck_counts[deck][pclass] = 0
df_decks =... | Titanic - Machine Learning from Disaster |
11,184,790 | output = {}
output['version'] = 'v1.0'
output['data'] = []
for line in train:
paragraphs = []
context = line[1]
qas = []
question = line[-1]
qid = line[0]
answers = []
answer = line[2]
if type(answer)!= str or type(context)!= str or type(question)!= str:
print(context, type(context))
print(answer, type(answer))
print(q... | all_deck_count, all_deck_per = get_pclass_dist(df_all_decks)
display_pclass_dist(all_deck_per ) | Titanic - Machine Learning from Disaster |
11,184,790 | output = {}
output['version'] = 'v1.0'
output['data'] = []
for line in test:
paragraphs = []
context = line[1]
qas = []
question = line[-1]
qid = line[0]
if type(context)!= str or type(question)!= str:
print(context, type(context))
print(answer, type(answer))
print(question, type(question))
continue
answers = []
answer... | idx = dfMrg[dfMrg['Deck'] == 'T'].index
dfMrg.loc[idx, 'Deck'] = 'A' | Titanic - Machine Learning from Disaster |
11,184,790 | !python /kaggle/input/pytorchtransformers/transformers-2.5.1/examples/run_squad.py \
--model_type roberta \
--model_name_or_path roberta-large \
--do_lower_case \
--do_train \
--do_eval \
--data_dir./data \
--cache_dir /kaggle/input/cached-roberta-large-pretrained/cache \
--train_file train.json \
--predict_file test.j... | df_all_decks_survived = dfMrg.groupby(['Deck', 'Survived'] ).count().drop(columns=['Sex', 'Age', 'SibSp', 'Parch', 'Fare',
'Embarked', 'Pclass', 'Cabin', 'PassengerId', 'Ticket'] ).rename(columns={'Name':'Count'} ).transpose() | Titanic - Machine Learning from Disaster |
11,184,790 | def f(selected):
return " ".join(set(selected.lower().split()))<load_from_csv> | def get_survived_dist(df):
surv_counts = {'A':{}, 'B':{}, 'C':{}, 'D':{}, 'E':{}, 'F':{}, 'G':{}, 'M':{}}
decks = df.columns.levels[0]
for deck in decks:
for survive in range(0, 2):
surv_counts[deck][survive] = df[deck][survive][0]
df_surv = pd.DataFrame(surv_counts)
surv_percentages = {}
for col in df_surv.columns:
s... | Titanic - Machine Learning from Disaster |
11,184,790 | predictions = json.load(open('results_roberta_large/predictions_.json', 'r'))
submission = pd.read_csv(open('/kaggle/input/tweet-sentiment-extraction/sample_submission.csv', 'r'))
for i in range(len(submission)) :
id_ = submission['textID'][i]
if pd_test['sentiment'][i] == 'neutral':
submission.loc[i, 'selected_text'] ... | dfMrg['Deck'] = dfMrg['Deck'].replace(['A', 'B', 'C'], 'ABC')
dfMrg['Deck'] = dfMrg['Deck'].replace(['D', 'E'], 'DE')
dfMrg['Deck'] = dfMrg['Deck'].replace(['F', 'G'], 'FG' ) | Titanic - Machine Learning from Disaster |
11,184,790 | submission.to_csv('submission.csv', index=False )<init_hyperparams> | dfMrg['Deck'].value_counts() | Titanic - Machine Learning from Disaster |
11,184,790 | batch_size = 16
lr = 5e-5
epochs = 2
max_seq_len = 128
doc_stride = 64
cross_validation = True
K = 2
post_processing = True<import_modules> | dfMrg.drop(['Cabin'], inplace=True, axis=1 ) | Titanic - Machine Learning from Disaster |
11,184,790 | import numpy as np
import pandas as pd
import json
import os<load_from_csv> | df_train, df_test = divide_df(dfMrg)
dfs = [df_train, df_test] | Titanic - Machine Learning from Disaster |
11,184,790 | pd_train = pd.read_csv('/kaggle/input/tweet-sentiment-extraction/train.csv')
pd_test = pd.read_csv('/kaggle/input/tweet-sentiment-extraction/test.csv' )<prepare_x_and_y> | def display_missing(df):
for col in df.columns.tolist() :
print('{} column missing values: {}'.format(col, df[col].isnull().sum()))
print('
')
for df in dfs:
display_missing(df ) | Titanic - Machine Learning from Disaster |
11,184,790 | np_train = np.array(pd_train)
np_test = np.array(pd_test )<split> | dfMrg = concat_df(df_train, df_test)
dfMrg.head() | Titanic - Machine Learning from Disaster |
11,184,790 | def split_data(num_examples, K):
np.random.seed(0)
idx = np.arange(num_examples)
np.random.shuffle(idx)
boundary = num_examples // K
splits = [{} for _ in range(K)]
for i in range(K):
splits[i]['valid_idx'] = idx[i*boundary:(i+1)*boundary]
splits[i]['train_idx'] = np.concatenate(( idx[:i*boundary], idx[(i+1)*boundar... | dfMrg['Fare'] = pd.qcut(dfMrg['Fare'], 13 ) | Titanic - Machine Learning from Disaster |
11,184,790 | splits = split_data(len(np_train), K )<categorify> | dfMrg['Age'] = pd.qcut(dfMrg['Age'],10 ) | Titanic - Machine Learning from Disaster |
11,184,790 | def convert_data(data, directory, filename):
def find_all(input_str, search_str):
l1 = []
length = len(input_str)
index = 0
while index < length:
i = input_str.find(search_str, index)
if i == -1:
return l1
l1.append(i)
index = i + 1
return l1
output = {}
output['version'] = 'v1.0'
output['data'] = []
for line in dat... | dfMrg['Ticket_Frequency'] = dfMrg.groupby('Ticket')['Ticket'].transform('count' ) | Titanic - Machine Learning from Disaster |
11,184,790 | for i, split in enumerate(splits):
data = np_train[split['train_idx']]
directory = 'split_' + str(i+1)
filename = 'train.json'
convert_data(data, directory, filename )<categorify> | def extract_surname(data):
families = []
for i in range(len(data)) :
name = data.iloc[i]
if '(' in name:
name_no_bracket = name.split('(')[0]
else:
name_no_bracket = name
family = name_no_bracket.split(',')[0]
title = name_no_bracket.split(',')[1].strip().split(' ')[0]
for c in string.punctuation:
family = family.repla... | Titanic - Machine Learning from Disaster |
11,184,790 | data = np_train
directory = 'original'
filename = 'train.json'
convert_data(data, directory, filename)
data = np_test
filename = 'test.json'
convert_data(data, directory, filename )<load_pretrained> | mean_survival_rate = np.mean(df_train['Survived'])
train_family_survival_rate = []
train_family_survival_rate_NA = []
test_family_survival_rate = []
test_family_survival_rate_NA = []
for i in range(len(df_train)) :
if df_train['Family'][i] in family_rates:
train_family_survival_rate.append(family_rates[df_train['Famil... | Titanic - Machine Learning from Disaster |
11,184,790 | def run_script(train_file, predict_file, batch_size=16, lr=5e-5, epochs=2, max_seq_len=128, doc_stride=64):
!python /kaggle/input/pytorchtransformers/transformers-2.5.1/examples/run_squad.py \
--model_type distilbert \
--model_name_or_path distilbert-base-uncased \
--cache_dir /kaggle/input/cached-distilbert-base-uncas... | for df in [df_train, df_test]:
df['Survival_Rate'] =(df['Ticket_Survival_Rate'] + df['Family_Survival_Rate'])/ 2
df['Survival_Rate_NA'] =(df['Ticket_Survival_Rate_NA'] + df['Family_Survival_Rate_NA'])/ 2 | Titanic - Machine Learning from Disaster |
11,184,790 | if cross_validation:
for i in range(1, K+1):
train_file = "split_" + str(i)+ "/train.json"
predict_file = "original/train.json"
run_script(train_file, predict_file, batch_size, lr, epochs, max_seq_len, doc_stride)
!mv "results/predictions_.json" "results/predictions_"$i".json"<string_transform> | non_numeric_features = ['Embarked', 'Sex', 'Deck', 'Title', 'Family_Size_Grouped', 'Age', 'Fare']
for df in dfs:
for feature in non_numeric_features:
df[feature] = LabelEncoder().fit_transform(df[feature] ) | Titanic - Machine Learning from Disaster |
11,184,790 | def jaccard(str1, str2):
a = set(str1.lower().split())
b = set(str2.lower().split())
c = a.intersection(b)
return float(len(c)) /(len(a)+ len(b)- len(c))<load_from_disk> | cat_features = ['Pclass', 'Sex', 'Deck', 'Embarked', 'Title', 'Family_Size_Grouped']
encoded_features = []
for df in dfs:
for feature in cat_features:
encoded_feat = OneHotEncoder().fit_transform(df[feature].values.reshape(-1, 1)).toarray()
n = df[feature].nunique()
cols = ['{}_{}'.format(feature, n)for n in range(1, n... | Titanic - Machine Learning from Disaster |
11,184,790 | def evaluate(splits, np_train, post_processing=False):
K = len(splits)
predictions = [json.load(open('results/predictions_' + str(i+1)+ '.json', 'r')) for i in range(K)]
train_score = [{'neutral':[], 'positive':[], 'negative':[], 'total':[]} for _ in range(K+1)]
valid_score = [{'neutral':[], 'positive':[], 'negative':... | dfMrg = concat_df(df_train, df_test)
drop_cols = ['Deck', 'Embarked', 'Family', 'Family_Size', 'Family_Size_Grouped', 'Survived',
'Name', 'Parch', 'PassengerId', 'Pclass', 'Sex', 'SibSp', 'Ticket', 'Title',
'Ticket_Survival_Rate', 'Family_Survival_Rate', 'Ticket_Survival_Rate_NA', 'Family_Survival_Rate_NA']
dfMrg.drop... | Titanic - Machine Learning from Disaster |
11,184,790 | if cross_validation:
evaluate(splits, np_train, post_processing )<split> | X_train = StandardScaler().fit_transform(df_train.drop(columns=drop_cols))
y_train = df_train['Survived'].values
X_test = StandardScaler().fit_transform(df_test.drop(columns=drop_cols))
print('X_train shape: {}'.format(X_train.shape))
print('y_train shape: {}'.format(y_train.shape))
print('X_test shape: {}'.format(X_te... | Titanic - Machine Learning from Disaster |
11,184,790 | train_file = "original/train.json"
predict_file = "original/test.json"
run_script(train_file, predict_file, batch_size, lr, epochs, max_seq_len, doc_stride)
!mv results/predictions_.json results/test_predictions.json<load_from_csv> | y_test = dfGenderSubmission.drop("PassengerId", axis=1 ).copy() | Titanic - Machine Learning from Disaster |
11,184,790 | predictions = json.load(open('results/test_predictions.json', 'r'))
submission = pd.read_csv(open('/kaggle/input/tweet-sentiment-extraction/sample_submission.csv', 'r'))
for i in range(len(submission)) :
id_ = submission['textID'][i]
if post_processing and(pd_test['sentiment'][i] == 'neutral' or len(pd_test['text'][i].... | SEED = 42
| Titanic - Machine Learning from Disaster |
11,184,790 | submission.to_csv('submission.csv', index=False )<set_options> | single_best_model = RandomForestClassifier(criterion='gini',
n_estimators=1100,
max_depth=5,
min_samples_split=4,
min_samples_leaf=5,
max_features='auto',
oob_score=True,
random_state=SEED,
n_jobs=-1,
verbose=1)
leaderboard_model = RandomForestClassifier(criterion='gini',
n_estimators=1750,
max_depth=7,
min_samples_sp... | Titanic - Machine Learning from Disaster |
11,184,790 | tf.get_logger().setLevel(logging.ERROR)
warnings.filterwarnings("ignore")
tf.config.optimizer.set_jit(True)
tf.config.optimizer.set_experimental_options(
{"auto_mixed_precision": True} )<load_from_csv> | from sklearn.metrics import roc_curve, auc
from sklearn.model_selection import StratifiedKFold
| Titanic - Machine Learning from Disaster |
11,184,790 | train_df = pd.read_csv('.. /input/tweet-sentiment-extraction/train.csv')
train_df.dropna(inplace=True)
test_df = pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv')
test_df.loc[:, "selected_text"] = test_df.text.values
submission_df = pd.read_csv('.. /input/tweet-sentiment-extraction/sample_submission.csv')... | N = 5
oob = 0
probs = pd.DataFrame(np.zeros(( len(X_test), N * 2)) , columns=['Fold_{}_Prob_{}'.format(i, j)for i in range(1, N + 1)for j in range(2)])
importances = pd.DataFrame(np.zeros(( X_train.shape[1], N)) , columns=['Fold_{}'.format(i)for i in range(1, N + 1)], index=dfMrg.columns)
fprs, tprs, scores = [], [],... | Titanic - Machine Learning from Disaster |
11,184,790 | <choose_model_class><EOS> | class_survived = [col for col in probs.columns if col.endswith('Prob_1')]
probs['1'] = probs[class_survived].sum(axis=1)/ N
probs['0'] = probs.drop(columns=class_survived ).sum(axis=1)/ N
probs['pred'] = 0
pos = probs[probs['1'] >= 0.5].index
probs.loc[pos, 'pred'] = 1
y_pred = probs['pred'].astype(int)
submission_df ... | Titanic - Machine Learning from Disaster |
5,902,397 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<choose_model_class> | def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn | Titanic - Machine Learning from Disaster |
5,902,397 | num_folds = 4
num_epochs = 3
batch_size = 32
learning_rate = 3e-5
optimizer = tf.keras.optimizers.Adam(learning_rate)
optimizer = tf.keras.mixed_precision.experimental.LossScaleOptimizer(
optimizer, 'dynamic')
config = BertConfig(output_hidden_states=True, num_labels=2)
BertQAModel.DROPOUT_RATE = 0.2
BertQAModel.NU... | test = pd.read_csv('.. /input/titanic/test.csv')
test['Boy'] =(test.Name.str.split().str[1] == 'Master.' ).astype('int')
test['Family'] = test['SibSp'] + test['Parch']
submission = pd.DataFrame({'PassengerId': test['PassengerId'], 'Survived': pd.Series(dtype='int32')})
test['Survived'] = [1 if(x == 'female')else 0 f... | Titanic - Machine Learning from Disaster |
5,902,397 | tf.get_logger().setLevel(logging.ERROR)
warnings.filterwarnings("ignore")
tf.config.optimizer.set_jit(True)
tf.config.optimizer.set_experimental_options(
{"auto_mixed_precision": True} )<load_from_csv> | def highlight(value):
if value >= 0.5:
style = 'background-color: palegreen'
else:
style = 'background-color: pink'
return style
train = pd.read_csv('.. /input/titanic/train.csv')
pd.pivot_table(train, values='Survived', index=['Sex'] ).style.applymap(highlight ) | Titanic - Machine Learning from Disaster |
5,902,397 | train_df = pd.read_csv('.. /input/tweet-sentiment-extraction/train.csv')
train_df.dropna(inplace=True)
test_df = pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv')
test_df.loc[:, "selected_text"] = test_df.text.values
submission_df = pd.read_csv('.. /input/tweet-sentiment-extraction/sample_submission.csv')... | test['Survived'] = [1 if(x == 'female')else 0 for x in test['Sex']]
test.loc[(test.Boy == 1), 'Survived'] = 1
test.loc[(( test.Pclass == 3)&(test.Embarked == 'S')) , 'Survived'] = 0
test.loc[(( test.Pclass == 3)&(test.Embarked == 'S')&(test.Boy == 1)&(test.Family > 0)&(test.Family < 4)) , 'Survived'] = 1 | Titanic - Machine Learning from Disaster |
5,902,397 | def preprocess(tweet, selected_text, sentiment):
tweet = tweet.decode('utf-8')
selected_text = selected_text.decode('utf-8')
sentiment = sentiment.decode('utf-8')
tweet = " ".join(str(tweet ).split())
selected_text = " ".join(str(selected_text ).split())
idx_start, idx_end = None, None
for index in(i for i, c in... | test['Survived'] = [1 if(x == 'female')else 0 for x in test['Sex']]
test.loc[(test.Boy == 1), 'Survived'] = 1
test.loc[(( test.Pclass == 3)&(test.Embarked == 'S')& ~(( test.Boy == 1)&(test.Family > 0)&(test.Family < 4))), 'Survived'] = 0 | Titanic - Machine Learning from Disaster |
2,038,144 | class BertQAModel(TFBertPreTrainedModel):
DROPOUT_RATE = 0.1
NUM_HIDDEN_STATES = 2
def __init__(self, config, *inputs, **kwargs):
super().__init__(config, *inputs, **kwargs)
self.bert = TFBertMainLayer(config, name="bert")
self.concat = L.Concatenate()
self.dropout = L.Dropout(self.DROPOUT_RATE)
self.qa_outputs = L.... | df_train = pd.read_csv('.. /input/train.csv', index_col='PassengerId')
df_test = pd.read_csv('.. /input/test.csv', index_col='PassengerId')
df_gender_sub = pd.read_csv(".. /input/gender_submission.csv", index_col='PassengerId' ) | Titanic - Machine Learning from Disaster |
2,038,144 | num_folds = 4
num_epochs = 3
batch_size = 32
learning_rate = 3e-5
optimizer = tf.keras.optimizers.Adam(learning_rate)
optimizer = tf.keras.mixed_precision.experimental.LossScaleOptimizer(
optimizer, 'dynamic')
config = BertConfig(output_hidden_states=True, num_labels=2)
BertQAModel.DROPOUT_RATE = 0.2
BertQAModel.NU... | Survived = df_train.loc[:,'Survived']
df_train = df_train.drop(['Survived'], axis=1 ).copy()
train_index = df_train.index
test_index = df_test.index
df_all = pd.concat([df_train, df_test])
| Titanic - Machine Learning from Disaster |
2,038,144 | tf.get_logger().setLevel(logging.ERROR)
warnings.filterwarnings("ignore")
tf.config.optimizer.set_jit(True)
tf.config.optimizer.set_experimental_options(
{"auto_mixed_precision": True} )<load_from_csv> | def nullAnalysis(df):
tab_info=pd.DataFrame(df.dtypes ).T.rename(index={0:'column type'})
tab_info=tab_info.append(pd.DataFrame(df.isnull().sum() ).T.rename(index={0:'null values(nb)'}))
tab_info=tab_info.append(pd.DataFrame(df.isnull().sum() /df.shape[0]*100)
.T.rename(index={0:'null values(%)'}))
return tab_info | Titanic - Machine Learning from Disaster |
2,038,144 | train_df = pd.read_csv('.. /input/tweet-sentiment-extraction/train.csv')
train_df.dropna(inplace=True)
test_df = pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv')
test_df.loc[:, "selected_text"] = test_df.text.values
submission_df = pd.read_csv('.. /input/tweet-sentiment-extraction/sample_submission.csv')... | nullAnalysis(df_all ) | Titanic - Machine Learning from Disaster |
2,038,144 | def preprocess(tweet, selected_text, sentiment):
tweet = tweet.decode('utf-8')
selected_text = selected_text.decode('utf-8')
sentiment = sentiment.decode('utf-8')
tweet = " ".join(str(tweet ).split())
selected_text = " ".join(str(selected_text ).split())
idx_start, idx_end = None, None
for index in(i for i, c in... | df_all.groupby('Pclass')['Age'].agg('mean' ) | Titanic - Machine Learning from Disaster |
2,038,144 | class BertQAModel(TFBertPreTrainedModel):
DROPOUT_RATE = 0.1
NUM_HIDDEN_STATES = 2
def __init__(self, config, *inputs, **kwargs):
super().__init__(config, *inputs, **kwargs)
self.bert = TFBertMainLayer(config, name="bert")
self.concat = L.Concatenate()
self.dropout = L.Dropout(self.DROPOUT_RATE)
self.qa_outputs = L.... | df_all.loc[(df_all['Age'].isnull())&(df_all['Pclass'] == 1), ['Age']] = round(df_all.groupby('Pclass')['Age'].agg('mean')[1],0)
df_all.loc[(df_all['Age'].isnull())&(df_all['Pclass'] == 2), ['Age']] = round(df_all.groupby('Pclass')['Age'].agg('mean')[2],0)
df_all.loc[(df_all['Age'].isnull())&(df_all['Pclass'] == 3), [... | Titanic - Machine Learning from Disaster |
2,038,144 | num_folds = 4
num_epochs = 3
batch_size = 32
learning_rate = 3e-5
optimizer = tf.keras.optimizers.Adam(learning_rate)
optimizer = tf.keras.mixed_precision.experimental.LossScaleOptimizer(
optimizer, 'dynamic')
config = BertConfig(output_hidden_states=True, num_labels=2)
BertQAModel.DROPOUT_RATE = 0.2
BertQAModel.NU... | df_all[df_all['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
2,038,144 | import numpy as np
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from scipy.sparse import hstack
from scipy.special import logit, expit<load_from_csv> | df_all.groupby('Pclass', as_index=False)['Fare'].agg('mean' ) | Titanic - Machine Learning from Disaster |
2,038,144 | train = pd.read_csv('.. /input/train.csv' ).fillna(' ')
test = pd.read_csv('.. /input/test.csv' ).fillna(' ' )<define_variables> | df_all.loc[1044,['Fare']] = 13.30 | Titanic - Machine Learning from Disaster |
2,038,144 | class_names = ['toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate']<concatenate> | print("Count of cabins with nan data: ")
df_all.loc[(df_all.loc[:,'Cabin'].isnull())== True]['Name'].count() | Titanic - Machine Learning from Disaster |
2,038,144 | train_text = train['comment_text']
test_text = test['comment_text']
all_text = pd.concat([train_text, test_text] )<feature_engineering> | df_all.groupby('Pclass' ).agg('count')[['Name','Cabin']] | Titanic - Machine Learning from Disaster |
2,038,144 | word_vectorizer = TfidfVectorizer(
sublinear_tf=True,
strip_accents='unicode',
analyzer='word',
token_pattern=r'\w{1,}',
ngram_range=(1, 1),
max_features=10000)
word_vectorizer.fit(all_text)
train_word_features = word_vectorizer.transform(train_text)
test_word_features = word_vectorizer.transform(test_text )<featur... | ( df_all.groupby('Pclass' ).agg('count')['Cabin'] / df_all.groupby('Pclass' ).agg('count')['Name'])*100 | Titanic - Machine Learning from Disaster |
2,038,144 | char_vectorizer = TfidfVectorizer(
sublinear_tf=True,
strip_accents='unicode',
analyzer='char',
ngram_range=(1, 5),
max_features=30000)
char_vectorizer.fit(all_text)
train_char_features = char_vectorizer.transform(train_text)
test_char_features = char_vectorizer.transform(test_text )<concatenate> | df_all[df_all['Cabin'].str.contains(' ', regex=False)== True].sort_values(by='Cabin' ) | Titanic - Machine Learning from Disaster |
2,038,144 | train_features = hstack([train_char_features, train_word_features])
test_features = hstack([test_char_features, test_word_features])
<find_best_model_class> | df_cabin_expand = df_all.loc[:,'Cabin'].str.split(' ', expand=True)
df_cabin_expand[df_cabin_expand.loc[:,1].isnull() == False].groupby([0] ).count() | Titanic - Machine Learning from Disaster |
2,038,144 | losses = []
predictions = {'id': test['id']}
for class_name in class_names:
train_target = train[class_name]
classifier = LogisticRegression(solver='sag')
cv_loss = np.mean(cross_val_score(classifier, train_features, train_target, cv=3, scoring='roc_auc'))
losses.append(cv_loss)
print('CV score for class {} is {}'.fo... | df_all[df_all['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
2,038,144 | submission = pd.DataFrame.from_dict(predictions)
submission.to_csv('word_submission.csv', index=False )<import_modules> | df_all['Embarked'] = df_all['Embarked'].fillna(method='bfill' ) | Titanic - Machine Learning from Disaster |
2,038,144 | import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import BernoulliNB
from sklearn.linear_model import LogisticRegression
from sklearn import linear_model
from sklearn.metrics import log_loss
from sklearn.feature_extraction.text import TfidfVectorizer
fr... | df_name_salutation = df_all.loc[:,'Name'].str.split(' ', expand=True ).copy()
df_name_salutation.groupby(1 ).count() | Titanic - Machine Learning from Disaster |
2,038,144 | stopwords = nltk.corpus.stopwords.words('english' )<set_options> | df_newsal_1 = df_name_salutation[df_name_salutation[1].str.contains('.', regex=False)][1]
df_newsal_2 = df_name_salutation[df_name_salutation[2].str.contains('.', regex=False)][2]
df_newsal_3 = df_name_salutation[(df_name_salutation[3].isnull() == False)&(df_name_salutation[3].str.contains('.', regex=False)) ][3]
df_ne... | Titanic - Machine Learning from Disaster |
2,038,144 | sns.set_style("dark" )<load_from_csv> | df_all.groupby('Salutation' ).count() | Titanic - Machine Learning from Disaster |
2,038,144 | train = pd.read_csv('.. /input/train.csv', error_bad_lines=False ).fillna(' ')
test = pd.read_csv('.. /input/test.csv', error_bad_lines=False ).fillna(' ')
subm = pd.read_csv('.. /input/sample_submission.csv' )<data_type_conversions> | df_all.loc[:,'Family'] =(( df_all['SibSp'] > 0)|(df_all['Parch'] > 0)).replace(True, 1, inplace=False)
df_all.loc[:,'Family'] = df_all.loc[:,'Family'].astype(int ) | Titanic - Machine Learning from Disaster |
2,038,144 | vectorizer = TfidfVectorizer(ngram_range=(1, 2),
max_df=0.5,
min_df=4,
max_features=1000)
vector_space_model = vectorizer.fit_transform(train['comment_text'].values.astype('U' ).tolist())
n_comments = vector_space_model.shape[0]
print('%d Total Comments' % n_comments )<train_model> | df_familynames = df_all.loc[:,'Name'].str.split(' ', expand=True ).copy()
l_singleLastname = df_familynames[(df_familynames[0].str.contains(',', regex=False)==True)].index
l_doubleLastname = df_familynames[(df_familynames[0].str.contains(',', regex=False)==False)
&(df_familynames[1].str.contains(',', regex=False)==Tru... | Titanic - Machine Learning from Disaster |
2,038,144 | training_set_size = int(n_comments * 0.33)
X = vector_space_model[:training_set_size,:]
Z = vector_space_model[training_set_size:vector_space_model.shape[0]-1,:]
print('%d comments for the estimation of the parameters and %d for the evaluation' %
(X.shape[0], Z.shape[0]))<train_model> | df_lastname_count = df_familynames.groupby('Lastname', as_index=False ).count()
df_lastname_count = df_lastname_count.drop([1,2,3,4,5,6,7,8,9,10,11,12,13], axis=1)
df_familynames = df_familynames.drop([0,1,2,3,4,5,6,7,8,9,10,11,12,13], axis=1)
df_familynames = df_familynames.join(df_lastname_count.set_index('Lastname... | Titanic - Machine Learning from Disaster |
2,038,144 | X = X.toarray()
Y = train['toxic'][:training_set_size]
model = linear_model.BayesianRidge(verbose=True)
model.fit(X, Y )<predict_on_test> | df_all = pd.merge(df_all , df_familynames, right_index=True, left_index=True)
df_all['Lastname'] = df_all['Lastname'].str.rstrip(',' ) | Titanic - Machine Learning from Disaster |
2,038,144 | ground_truth = train['toxic'][training_set_size:vector_space_model.shape[0]-1]
prediction = model.predict(Z)
prediction = binarize(prediction.reshape(-1, 1), 0.5 )<define_variables> | df_all.loc[df_all['Family'] == 0,'Number_of_Familymembers'] = 1 | Titanic - Machine Learning from Disaster |
2,038,144 | toxic_ids = [i for i, c in enumerate(prediction)if c == 1]
toxic_ids<predict_on_test> | df_all.groupby(['Parch'] ).agg('count' ) | Titanic - Machine Learning from Disaster |
2,038,144 | comment_id = toxic_ids[0]
print('Content of the comment:
%s
' % train['comment_text'][training_set_size+comment_id])
print('Is this comment "toxic" according to the model?
%s' % str(model.predict(Z[comment_id,:])>0.5))<predict_on_test> | df_sal_distr = df_all.groupby('Salutation' ).count()
df_sal_distr.reset_index(level=0, inplace=True)
df_sal_distr = df_sal_distr[['Salutation','Pclass']]
df_sal_distr = df_sal_distr.rename(columns = {'Pclass':"Salutation_Count"})
df_sal_distr | Titanic - Machine Learning from Disaster |
2,038,144 | comment_id = toxic_ids[1]
print('Content of the comment:
%s
' % train['comment_text'][training_set_size+comment_id])
print('Is this comment "toxic" according to the model?
%s' % str(model.predict(Z[comment_id,:])>0.5))<predict_on_test> | df_survivalinfo = pd.concat([df_all.loc[train_index,:], Survived], axis=1 ) | Titanic - Machine Learning from Disaster |
2,038,144 | comment_id = toxic_ids[2]
print('Content of the comment:
%s
' % train['comment_text'][training_set_size+comment_id])
print('Is this comment "toxic" according to the model?
%s' % str(model.predict(Z[comment_id,:])>0.5))<string_transform> | gp_survived_gender = df_survivalinfo.groupby(['Survived','Sex'])['Name'].count() [1]
gp_gender_survived = df_survivalinfo.groupby(['Sex','Survived'] ).count() ['Name']
gp_survived_yn = df_survivalinfo.groupby(['Survived'] ).agg('count')['Name']
gp_survival_total = df_survivalinfo.groupby(['Sex','Survived'] ).count().xs... | Titanic - Machine Learning from Disaster |
2,038,144 | comment_text_list = train.apply(lambda row : nltk.word_tokenize(row['comment_text']),axis=1 )<feature_engineering> | ptbl = pd.DataFrame.pivot_table(df_survivalinfo, values=['Fare', 'Survived'], index=['Pclass'],
aggfunc={'Survived': ['sum'], 'Fare': [min,max,np.mean]})
ptbl
| Titanic - Machine Learning from Disaster |
2,038,144 | rate_punctuation=0.7
rate_capital=0.7
def odd_comment(comment):
punctuation_count=0
capital_letter_count=0
total_letter_count=0
for token in comment:
if token in list(string.punctuation):
punctuation_count+=1
capital_letter_count+=sum(1 for c in token if c.isupper())
total_letter_count+=len(token)
return(( punctuatio... | df_survival_sal = df_survivalinfo.groupby(['Salutation','Survived'], as_index=False)['Name'].count()
df_survival_sal = df_survival_sal.rename(columns={"Name": "Total"})
df_survival_sal_total = df_survival_sal.groupby('Salutation', as_index=False)['Total'].agg(sum)
df_survival_sal_nsuv = pd.DataFrame(df_survival_sal[d... | Titanic - Machine Learning from Disaster |
2,038,144 | odd_ones=odd[odd==True]
odd_comments=train.loc[list(odd_ones.index)]
odd_comments[odd_comments.clean==False].count() /len(odd_comments )<filter> | ptbl_survived = pd.DataFrame.pivot_table(df_survivalinfo, values=['Fare', 'Age', 'Survived'], index=['Sex', 'Pclass'],
aggfunc={'Fare': np.mean,'Age': [min, max, np.mean], 'Survived': ['sum']})
ptbl_survived | Titanic - Machine Learning from Disaster |
2,038,144 | empty_comments=train[train.comment_text==""]
empty_comments<count_duplicates> | df_all_knn_hot = df_all.copy()
df_all_knn_hot = df_all_knn_hot.drop(['Name','Cabin','Fare','Ticket','Lastname'], axis=1)
df_all_knn_hot = pd.get_dummies(df_all_knn_hot, columns=['Sex','Salutation','Embarked'])
X_train, X_test, y_train, y_test = train_test_split(df_all_knn_hot.loc[train_index,:],
Survived, test_size =... | 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.