kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,251,987 | train_df = pd.read_csv('/kaggle/input/nlp-getting-started/train.csv')
test_df = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv' )<prepare_x_and_y> | raw_models = model_check(X, y, estimators, cv)
display(raw_models.style.background_gradient(cmap='summer_r')) | Titanic - Machine Learning from Disaster |
9,251,987 | X = train_df.loc[:,'text']
y = train_df.loc[:,'target']<define_variables> | def m_roc(estimators, cv, X, y):
fig, axes = plt.subplots(math.ceil(len(estimators)/ 2),
2,
figsize=(25, 50))
axes = axes.flatten()
for ax, estimator in zip(axes, estimators):
tprs = []
aucs = []
mean_fpr = np.linspace(0, 1, 100)
for i,(train, test)in enumerate(cv.split(X, y)) :
estimator.fit(X.loc[train], y.loc[train... | Titanic - Machine Learning from Disaster |
9,251,987 | max_len = 0
for text in X:
max_len = max(max_len, len(text))
max_len<prepare_x_and_y> | m_roc(estimators, cv, X, y ) | Titanic - Machine Learning from Disaster |
9,251,987 | class Dataset(torch.utils.data.Dataset):
def __init__(self,df,y=None,max_len=164):
self.df = df
self.y = y
self.max_len= max_len
self.tokenizer = transformers.RobertaTokenizer.from_pretrained('roberta-base')
def __getitem__(self,index):
row = self.df.iloc[index]
ids,masks = self.get_input_data(row)
data = {}
data['id... | f_imp(estimators, X, y, 14 ) | Titanic - Machine Learning from Disaster |
9,251,987 | train_x,val_x,train_y,val_y = train_test_split(X,y,test_size=0.2,stratify=y)
train_loader = torch.utils.data.DataLoader(Dataset(train_x,train_y),batch_size=16,shuffle=True,num_workers=2)
val_loader = torch.utils.data.DataLoader(Dataset(val_x,val_y),batch_size=16,shuffle=False,num_workers=2 )<normalization> | rf.fit(X, y)
estimator = rf.estimators_[0]
export_graphviz(estimator, out_file='tree.dot',
feature_names = X.columns,
class_names = ['Not Survived','Survived'],
rounded = True, proportion = False,
precision = 2, filled = True)
call(['dot', '-Tpng', 'tree.dot', '-o', 'tree.png', '-Gdpi=600'])
plt.figure(figsize =(40,... | Titanic - Machine Learning from Disaster |
9,251,987 | class Model(nn.Module):
def __init__(self):
super(Model,self ).__init__()
self.distilBert = transformers.RobertaModel.from_pretrained('roberta-base')
self.l0 = nn.Linear(768,512)
self.l1 = nn.Linear(512,256)
self.l2 = nn.Linear(256,1)
self.d0 = nn.Dropout(0.5)
self.d1 = nn.Dropout(0.5)
self.d2 = nn.Dropout(0.5)
... | def f_selector(X, y, est, features):
X_train, X_valid, y_train, y_valid = train_test_split(X,
y,
test_size=0.4,
random_state=42)
rfe = RFE(estimator=est, n_features_to_select=features, verbose=1)
rfe.fit(X_train, y_train)
print(dict(zip(X.columns, rfe.ranking_)))
print(X.columns[rfe.support_])
acc = accuracy_score... | Titanic - Machine Learning from Disaster |
9,251,987 | model = Model().to('cuda')
criterion = nn.BCEWithLogitsLoss(reduction='mean')
optimizer = torch.optim.AdamW(model.parameters() ,lr=3e-5 )<compute_test_metric> | X_sel, X_test_sel = f_selector(X, y, rf, 11 ) | Titanic - Machine Learning from Disaster |
9,251,987 | def accuracy_score(outputs,labels):
outputs = torch.round(torch.sigmoid(outputs))
correct =(outputs == labels ).sum().float()
return correct/labels.size(0 )<import_modules> | pipe = Pipeline([
('scaler', StandardScaler()),
('reducer', PCA(n_components=2)) ,
])
X_sel_red = pipe.fit_transform(X_sel)
X_test_sel_red = pipe.transform(X_test_sel ) | Titanic - Machine Learning from Disaster |
9,251,987 | from tqdm import tqdm<train_on_grid> | def prob_reg(X, y):
figure = plt.figure(figsize=(20, 40))
h =.02
i = 1
X_train, X_test, y_train, y_test = \
train_test_split(X, y, test_size=.4, random_state=42)
x_min, x_max = X_sel_red[:, 0].min() -.5, X_sel_red[:, 0].max() +.5
y_min, y_max = X_sel_red[:, 1].min() -.5, X_sel_red[:, 1].max() +.5
xx, yy = np.meshgrid(... | Titanic - Machine Learning from Disaster |
9,251,987 | epochs = 4
for epoch in range(epochs):
epoch_loss = 0.
model.train()
for data in tqdm(train_loader):
ids = data['ids'].cuda()
masks = data['masks'].cuda()
labels = data['out'].cuda()
labels = labels.unsqueeze(1)
optimizer.zero_grad()
outputs = model(ids,masks)
loss = criterion(outputs,labels)
loss.backward()
optimi... | dec_regs(X_sel_red, y, estimators ) | Titanic - Machine Learning from Disaster |
9,251,987 | test_loader = torch.utils.data.DataLoader(Dataset(test_df['text'],y=None),batch_size=16,shuffle=False,num_workers=2 )<find_best_params> | prob_reg(X_sel_red, y ) | Titanic - Machine Learning from Disaster |
9,251,987 | preds = []
for data in test_loader:
ids = data['ids'].cuda()
masks = data['masks'].cuda()
model.eval()
outputs = model(ids,masks)
preds += outputs.cpu().detach().numpy().tolist()
<prepare_output> | pca_models = model_check(X_sel_red, y, estimators, cv)
display(pca_models.style.background_gradient(cmap='summer_r')) | Titanic - Machine Learning from Disaster |
9,251,987 | pred = np.round(1/(1 + np.exp(-np.array(preds))))<prepare_output> | rand_model_full_data = rf.fit(X, y)
print(accuracy_score(y, rand_model_full_data.predict(X)))
y_pred = rand_model_full_data.predict(X_test ) | Titanic - Machine Learning from Disaster |
9,251,987 | <load_from_csv><EOS> | test_df = pd.read_csv('/kaggle/input/titanic/test.csv')
submission_df = pd.DataFrame(columns=['PassengerId', 'Survived'])
submission_df['PassengerId'] = test_df['PassengerId']
submission_df['Survived'] = y_pred
submission_df.to_csv('submission.csv', header=True, index=False)
submission_df.head(10 ) | Titanic - Machine Learning from Disaster |
1,373,360 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<prepare_output> | class KaggleMember() :
kaggle_member_count=0
def __init__(self, name, surname, level=None):
self.name=name.capitalize()
self.surname=surname.upper()
self._set_level(level)
KaggleMember.kaggle_member_count+=1
self.kaggle_id=KaggleMember.kaggle_member_count
def display_number_of_member(self):
print("There are {} members... | Titanic - Machine Learning from Disaster |
1,373,360 | sub['target'] = pred<save_to_csv> | warnings.filterwarnings('ignore')
print("Warnings were ignored" ) | Titanic - Machine Learning from Disaster |
1,373,360 | sub.to_csv('submission.csv',index=False )<set_options> | class Information() :
def __init__(self):
print("Information object created")
def _get_missing_values(self,data):
missing_values = data.isnull().sum()
missing_values.sort_values(ascending=False, inplace=True)
return missing_values
def info(self,data):
feature_dtypes=data.dtypes
self.missing_values=self._get_mis... | Titanic - Machine Learning from Disaster |
1,373,360 | SEED = 42
torch.manual_seed(SEED)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False<load_from_csv> | class Preprocess() :
def __init__(self):
print("Preprocess object created")
def fillna(self, data, fill_strategies):
for column, strategy in fill_strategies.items() :
if strategy == 'None':
data[column] = data[column].fillna('None')
elif strategy == 'Zero':
data[column] = data[column].fillna(0)
elif strategy == 'Mod... | Titanic - Machine Learning from Disaster |
1,373,360 | train_data = pd.read_csv(".. /input/nlp-getting-started/train.csv")
train_data.info()
train_data.sample(10 )<load_from_csv> | class PreprocessStrategy() :
def __init__(self):
self.data=None
self._preprocessor=Preprocess()
def strategy(self, data, strategy_type="strategy1"):
self.data=data
if strategy_type=='strategy1':
self._strategy1()
elif strategy_type=='strategy2':
self._strategy2()
return self.data
def _base_strategy(self):
drop_strate... | Titanic - Machine Learning from Disaster |
1,373,360 | test_data = pd.read_csv(".. /input/nlp-getting-started/test.csv")
test_data.info()
test_data.sample(10 )<train_model> | class GridSearchHelper() :
def __init__(self):
print("GridSearchHelper Created")
self.gridSearchCV=None
self.clf_and_params=list()
self._initialize_clf_and_params()
def _initialize_clf_and_params(self):
clf= KNeighborsClassifier()
params={'n_neighbors':[5,7,9,11,13,15],
'leaf_size':[1,2,3,5],
'weights':['uniform', 'di... | Titanic - Machine Learning from Disaster |
1,373,360 | print('Training Set Shape = {}'.format(train_data.shape))
print('Test Set Shape = {}'.format(test_data.shape))<count_unique_values> | class Visualizer:
def __init__(self):
print("Visualizer object created!")
def RandianViz(self, X, y, number_of_features):
if number_of_features is None:
features=X.columns.values
else:
features=X.columns.values[:number_of_features]
fig, ax=plt.subplots(1, figsize=(15,12))
radViz=RadViz(classes=['survived', 'not surviv... | Titanic - Machine Learning from Disaster |
1,373,360 | mislabeled_df = train_data.groupby(['text'] ).nunique().sort_values(by='target', ascending=False)
mislabeled_df = mislabeled_df[mislabeled_df['target'] > 1]['target']
mislabeled_list = mislabeled_df.index.tolist()
mislabeled_list<feature_engineering> | class ObjectOrientedTitanic() :
def __init__(self, train, test):
print("ObjectOrientedTitanic object created")
self.testPassengerID=test['PassengerId']
self.number_of_train=train.shape[0]
self.y_train=train['Survived']
self.train=train.drop('Survived', axis=1)
self.test=test
self.all_data=self._get_all_data()
self.... | Titanic - Machine Learning from Disaster |
1,373,360 | train_data['target_relabeled'] = train_data['target'].copy()
train_data.loc[train_data['text'] == 'like for the music video I want some real action shit like burning buildings and police chases not some weak ben winston shit', 'target_relabeled'] = 0
train_data.loc[train_data['text'] == 'Hellfire is surrounded by desir... | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
objectOrientedTitanic=ObjectOrientedTitanic(train, test)
| Titanic - Machine Learning from Disaster |
1,373,360 | <split><EOS> | objectOrientedTitanic.machine_learning() | Titanic - Machine Learning from Disaster |
2,725,427 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | sns.set(style="darkgrid")
warnings.filterwarnings('ignore')
SEED = 42 | Titanic - Machine Learning from Disaster |
2,725,427 | TEXT = data.Field(tokenize = 'spacy', batch_first=True, include_lengths = True)
LABEL = data.LabelField(dtype = torch.float, batch_first=True )<split> | 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)
df_train = pd.read_csv('.. /input/train.csv')
df_test = pd.read_csv('.. /input/test.csv')
df_all = conc... | Titanic - Machine Learning from Disaster |
2,725,427 | class DataFrameDataset(data.Dataset):
def __init__(self, df, fields, is_test=False, **kwargs):
examples = []
for i, row in df.iterrows() :
label = row.target_relabeled if not is_test else None
text = row.text
examples.append(data.Example.fromlist([text, label], fields))
super().__init__(examples, fields, **kwargs)
@st... | 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:
print('{}'.format(df.name))
display_missing(df ) | Titanic - Machine Learning from Disaster |
2,725,427 | fields = [('text',TEXT),('label',LABEL)]
train_ds, val_ds = DataFrameDataset.splits(fields, train_df=train_df, val_df=valid_df )<load_pretrained> | age_by_pclass_sex = df_all.groupby(['Sex', 'Pclass'] ).median() ['Age']
for pclass in range(1, 4):
for sex in ['female', 'male']:
print('Median age of Pclass {} {}s: {}'.format(pclass, sex, age_by_pclass_sex[sex][pclass]))
print('Median age of all passengers: {}'.format(df_all['Age'].median()))
df_all['Age'] = df_all.g... | Titanic - Machine Learning from Disaster |
2,725,427 | vectors = Vectors(name='.. /input/fasttext-crawl-300d-2m/crawl-300d-2M.vec', cache='./')
MAX_VOCAB_SIZE = 100000
TEXT.build_vocab(train_ds,
max_size = MAX_VOCAB_SIZE,
vectors = vectors,
unk_init = torch.Tensor.zero_)
LABEL.build_vocab(train_ds )<count_unique_values> | df_all[df_all['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
2,725,427 | print("Size of TEXT vocabulary:",len(TEXT.vocab))
print("Size of LABEL vocabulary:",len(LABEL.vocab))
print(TEXT.vocab.freqs.most_common(10))
<split> | df_all['Embarked'] = df_all['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
2,725,427 | BATCH_SIZE = 64
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
train_iterator, valid_iterator = data.BucketIterator.splits(
(train_ds, val_ds),
batch_size = BATCH_SIZE,
sort_within_batch = True,
device = device )<init_hyperparams> | df_all[df_all['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
2,725,427 | num_epochs = 25
learning_rate = 0.001
INPUT_DIM = len(TEXT.vocab)
EMBEDDING_DIM = 300
HIDDEN_DIM = 256
OUTPUT_DIM = 1
N_LAYERS = 2
BIDIRECTIONAL = True
DROPOUT = 0.2
PAD_IDX = TEXT.vocab.stoi[TEXT.pad_token]<choose_model_class> | med_fare = df_all.groupby(['Pclass', 'Parch', 'SibSp'] ).Fare.median() [3][0][0]
df_all['Fare'] = df_all['Fare'].fillna(med_fare ) | Titanic - Machine Learning from Disaster |
2,725,427 | class LSTM_net(nn.Module):
def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim, n_layers,
bidirectional, dropout, pad_idx):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx = pad_idx)
self.rnn = nn.LSTM(embedding_dim,
hidden_dim,
num_layers=n_layers,
bidirectiona... | idx = df_all[df_all['Deck'] == 'T'].index
df_all.loc[idx, 'Deck'] = 'A' | Titanic - Machine Learning from Disaster |
2,725,427 | model = LSTM_net(INPUT_DIM,
EMBEDDING_DIM,
HIDDEN_DIM,
OUTPUT_DIM,
N_LAYERS,
BIDIRECTIONAL,
DROPOUT,
PAD_IDX )<find_best_params> | df_all_decks_survived = df_all.groupby(['Deck', 'Survived'] ).count().drop(columns=['Sex', 'Age', 'SibSp', 'Parch', 'Fare',
'Embarked', 'Pclass', 'Cabin', 'PassengerId', 'Ticket'] ).rename(columns={'Name':'Count'} ).transpose()
def get_survived_dist(df):
surv_counts = {'A':{}, 'B':{}, 'C':{}, 'D':{}, 'E':{}, 'F':{}, 'G... | Titanic - Machine Learning from Disaster |
2,725,427 | print(model)
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f'The model has {count_parameters(model):,} trainable parameters' )<feature_engineering> | df_all['Deck'] = df_all['Deck'].replace(['A', 'B', 'C'], 'ABC')
df_all['Deck'] = df_all['Deck'].replace(['D', 'E'], 'DE')
df_all['Deck'] = df_all['Deck'].replace(['F', 'G'], 'FG')
df_all['Deck'].value_counts() | Titanic - Machine Learning from Disaster |
2,725,427 | pretrained_embeddings = TEXT.vocab.vectors
model.embedding.weight.data.copy_(pretrained_embeddings)
model.embedding.weight.data[PAD_IDX] = torch.zeros(EMBEDDING_DIM )<compute_test_metric> | df_all.drop(['Cabin'], inplace=True, axis=1)
df_train, df_test = divide_df(df_all)
dfs = [df_train, df_test]
for df in dfs:
display_missing(df ) | Titanic - Machine Learning from Disaster |
2,725,427 | def binary_accuracy(preds, y):
rounded_preds = torch.round(torch.sigmoid(preds))
correct =(rounded_preds == y ).float()
acc = correct.sum() / len(correct)
return acc<train_on_grid> | corr = df_train_corr_nd['Correlation Coefficient'] > 0.1
df_train_corr_nd[corr] | Titanic - Machine Learning from Disaster |
2,725,427 | def train(model, iterator, optimizer, criterion):
epoch_loss = 0
epoch_acc = 0
model.train()
for batch in iterator:
text, text_lengths = batch.text
optimizer.zero_grad()
predictions = model(text, text_lengths ).squeeze(1)
loss = criterion(predictions, batch.label)
acc = binary_accuracy(predictions, batch.label)
loss... | corr = df_test_corr_nd['Correlation Coefficient'] > 0.1
df_test_corr_nd[corr] | Titanic - Machine Learning from Disaster |
2,725,427 | def evaluate(model, iterator, criterion):
epoch_loss = 0
epoch_acc = 0
model.eval()
with torch.no_grad() :
for batch in iterator:
text, text_lengths = batch.text
predictions = model(text, text_lengths ).squeeze(1)
loss = criterion(predictions, batch.label)
acc = binary_accuracy(predictions, batch.label)
epoch_loss +... | df_all = concat_df(df_train, df_test)
df_all.head() | Titanic - Machine Learning from Disaster |
2,725,427 | t = time.time()
best_valid_loss = float('inf')
model.to(device)
criterion = nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(model.parameters() , lr=learning_rate)
for epoch in range(num_epochs):
train_loss, train_acc = train(model, train_iterator, optimizer, criterion)
valid_loss, valid_acc = evaluate(model, va... | df_all['Fare'] = pd.qcut(df_all['Fare'], 13 ) | Titanic - Machine Learning from Disaster |
2,725,427 | nlp = spacy.load('en')
def predict(model, sentence):
tokenized = [tok.text for tok in nlp.tokenizer(sentence)]
indexed = [TEXT.vocab.stoi[t] for t in tokenized]
length = [len(indexed)]
tensor = torch.LongTensor(indexed ).to(device)
tensor = tensor.unsqueeze(1 ).T
length_tensor = torch.LongTensor(length)
prediction =... | df_all['Age'] = pd.qcut(df_all['Age'], 10 ) | Titanic - Machine Learning from Disaster |
2,725,427 | PATH = ".. /working/best_model.pt"
model.load_state_dict(torch.load(PATH))
predicts = []
for i in range(len(test_data.text)) :
predict_class = predict(model, test_data.text[i])
predicts.append(int(predict_class))<load_from_csv> | df_all['Ticket_Frequency'] = df_all.groupby('Ticket')['Ticket'].transform('count' ) | Titanic - Machine Learning from Disaster |
2,725,427 | submission = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
submission['target'] = predicts
submission<save_to_csv> | df_all['Title'] = df_all['Name'].str.split(', ', expand=True)[1].str.split('.', expand=True)[0]
df_all['Is_Married'] = 0
df_all['Is_Married'].loc[df_all['Title'] == 'Mrs'] = 1 | Titanic - Machine Learning from Disaster |
2,725,427 | submission.to_csv('submission.csv',index=False )<merge> | 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 |
2,725,427 | gt_df = pd.read_csv(".. /input/disasters-on-social-media/socialmedia-disaster-tweets-DFE.csv", encoding='latin_1')
gt_df = gt_df[['choose_one', 'text']]
gt_df['target'] =(gt_df['choose_one']=='Relevant' ).astype(int)
gt_df['id'] = gt_df.index
merged_df = pd.merge(test_data, gt_df, on='id')
merged_df<prepare_x_and_y> | 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 |
2,725,427 | target_df = merged_df[['id', 'target']]
target_df<save_to_csv> | 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 |
2,725,427 | target_df.to_csv('perfect_submission.csv', index=False )<compute_test_metric> | 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 |
2,725,427 | target_df["predict"] = list(submission.target)
print('\t\tCLASSIFICATIION METRICS
')
print(metrics.classification_report(target_df.target, target_df.predict))<set_options> | 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 |
2,725,427 | plt.style.use('ggplot')
warnings.filterwarnings('ignore')
<define_variables> | df_all = 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']
df_all.dr... | Titanic - Machine Learning from Disaster |
2,725,427 | def seed_everything(seed):
os.environ['PYTHONHASHSEED']=str(seed)
tf.random.set_seed(seed)
np.random.seed(seed)
random.seed(seed)
seed_everything(34 )<load_from_csv> | 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 |
2,725,427 | train = pd.read_csv('.. /input/nlp-getting-started/train.csv')
test = pd.read_csv('.. /input/nlp-getting-started/test.csv')
train.head()<categorify> | 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 |
2,725,427 | test_id = test['id']
columns = {'id', 'location'}
train = train.drop(columns = columns)
test = test.drop(columns = columns)
train['keyword'] = train['keyword'].fillna('unknown')
test['keyword'] = test['keyword'].fillna('unknown')
train['text'] = train['text'] + ' ' + train['keyword']
test['text'] = test['text'] + '... | 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=df_all.columns)
fprs, tprs, scores = [], []... | Titanic - Machine Learning from Disaster |
2,725,427 | total['unique word count'] = total['text'].apply(lambda x: len(set(x.split())))
total['stopword count'] = total['text'].apply(lambda x: len([i for i in x.lower().split() if i in wordcloud.STOPWORDS]))
total['stopword ratio'] = total['stopword count'] / total['word count']
total['punctuation count'] = total['text'].app... | 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 |
11,548,643 | def remove_punctuation(x):
return x.translate(str.maketrans('', '', string.punctuation))
def remove_stopwords(x):
return ' '.join([i for i in x.split() if i not in wordcloud.STOPWORDS])
def remove_less_than(x):
return ' '.join([i for i in x.split() if len(i)> 3])
def remove_non_alphabet(x):
return ' '.join([i for i i... | !pip install fastai2 | Titanic - Machine Learning from Disaster |
11,548,643 | strip_all_entities('@shawn Titanic
Times: Telegraph.co.ukTitanic tragedy could have been preve...http://bet.ly/tuN2wx' )<string_transform> | !pip install fastcore==0.1.35 | Titanic - Machine Learning from Disaster |
11,548,643 | !pip install autocorrect
def spell_check(x):
spell = Speller(lang='en')
return " ".join([spell(i)for i in x.split() ])
mispelled = 'Pleaze spelcheck this sentince'
spell_check(mispelled )<feature_engineering> | fastcore.__version__ | Titanic - Machine Learning from Disaster |
11,548,643 | PROCESS_TWEETS = False
if PROCESS_TWEETS:
total['text'] = total['text'].apply(lambda x: x.lower())
total['text'] = total['text'].apply(lambda x: re.sub(r'https?://\S+|www\.\S+', '', x, flags = re.MULTILINE))
total['text'] = total['text'].apply(remove_punctuation)
total['text'] = total['text'].apply(remove_stopwords)
... | fastai2.__version__ | Titanic - Machine Learning from Disaster |
11,548,643 | contractions = {
"ain't": "am not / are not / is not / has not / have not",
"aren't": "are not / am not",
"can't": "cannot",
"can't've": "cannot have",
"'cause": "because",
"could've": "could have",
"couldn't": "could not",
"couldn't've": "could not have",
"didn't": "did not",
"doesn't": "does not",
"don't": "do not",
... | from fastai2.tabular.all import * | Titanic - Machine Learning from Disaster |
11,548,643 | total['text'] = total['text'].apply(expand_contractions )<categorify> | df_test= pd.read_csv('/kaggle/input/titanic-extended/test.csv')
df_train= pd.read_csv('.. /input/titanic-extended/train.csv')
df_train.head() | Titanic - Machine Learning from Disaster |
11,548,643 | def clean(tweet):
tweet = re.sub(r"tnwx", "Tennessee Weather", tweet)
tweet = re.sub(r"azwx", "Arizona Weather", tweet)
tweet = re.sub(r"alwx", "Alabama Weather", tweet)
tweet = re.sub(r"wordpressdotcom", "wordpress", tweet)
tweet = re.sub(r"gawx", "Georgia Weather", tweet)
tweet = re.sub(r"scwx", "South Carolina ... | df_train.isnull().sum().sort_index() /len(df_train ) | Titanic - Machine Learning from Disaster |
11,548,643 | tweets = [tweet for tweet in total['text']]
train = total[:len(train)]
test = total[len(train):]<categorify> | df_train.dtypes
g_train =df_train.columns.to_series().groupby(df_train.dtypes ).groups
g_train | Titanic - Machine Learning from Disaster |
11,548,643 | def generate_ngrams(text, n_gram=1):
token = [token for token in text.lower().split(' ')if token != '' if token not in wordcloud.STOPWORDS]
ngrams = zip(*[token[i:] for i in range(n_gram)])
return [' '.join(ngram)for ngram in ngrams]
disaster_unigrams = defaultdict(int)
for word in total[train['target'] == 1]['text']... | cat_names= [
'Name', 'Sex', 'Ticket', 'Cabin',
'Embarked', 'Name_wiki', 'Hometown',
'Boarded', 'Destination', 'Lifeboat',
'Body'
]
cont_names = [
'PassengerId', 'Pclass', 'SibSp', 'Parch',
'Age', 'Fare', 'WikiId', 'Age_wiki','Class'
]
| Titanic - Machine Learning from Disaster |
11,548,643 | to_exclude = '*+-/() %
[\\]{|}^_`~\t'
to_tokenize = '!"
tokenizer = Tokenizer(filters = to_exclude)
text = 'Why are you so f%
text = re.sub(r'(['+to_tokenize+'])', r' \1 ', text)
tokenizer.fit_on_texts([text])
print(tokenizer.word_index )<feature_engineering> | splits = RandomSplitter(valid_pct=0.2 )(range_of(df_train))
to = TabularPandas(df_train, procs=[Categorify, FillMissing,Normalize],
cat_names = cat_names,
cont_names = cont_names,
y_names='Survived',
splits=splits ) | Titanic - Machine Learning from Disaster |
11,548,643 |
<string_transform> | g_train =to.train.xs.columns.to_series().groupby(to.train.xs.dtypes ).groups
g_train | Titanic - Machine Learning from Disaster |
11,548,643 | tokenizer = Tokenizer()
tokenizer.fit_on_texts(tweets)
sequences = tokenizer.texts_to_sequences(tweets)
word_index = tokenizer.word_index
print('Found %s unique tokens.' % len(word_index))
data = pad_sequences(sequences)
labels = train['target']
print('Shape of data tensor:', data.shape)
print('Shape of label tenso... | to.train | Titanic - Machine Learning from Disaster |
11,548,643 | embeddings_index = {}
with open('.. /input/glove-global-vectors-for-word-representation/glove.6B.200d.txt','r')as f:
for line in tqdm(f):
values = line.split()
word = values[0]
coefs = np.asarray(values[1:], dtype='float32')
embeddings_index[word] = coefs
f.close()
print('Found %s word vectors in the GloVe library' % ... | to.train.xs | Titanic - Machine Learning from Disaster |
11,548,643 | EMBEDDING_DIM = 200<categorify> | X_train, y_train = to.train.xs, to.train.ys.values.ravel()
X_valid, y_valid = to.valid.xs, to.valid.ys.values.ravel() | Titanic - Machine Learning from Disaster |
11,548,643 | embedding_matrix = np.zeros(( len(word_index)+ 1, EMBEDDING_DIM))
for word, i in tqdm(word_index.items()):
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None:
embedding_matrix[i] = embedding_vector
print("Our embedded matrix is of dimension", embedding_matrix.shape )<choose_model_class> | rnf_classifier= RandomForestClassifier(n_estimators=100, n_jobs=-1)
rnf_classifier.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
11,548,643 | embedding = Embedding(len(word_index)+ 1, EMBEDDING_DIM, weights = [embedding_matrix],
input_length = MAX_SEQUENCE_LENGTH, trainable = False)
<normalization> | y_pred=rnf_classifier.predict(X_valid)
accuracy_score(y_pred, y_valid ) | Titanic - Machine Learning from Disaster |
11,548,643 | def scale(df, scaler):
return scaler.fit_transform(df.iloc[:, 2:])
meta_train = scale(train, StandardScaler())
meta_test = scale(test, StandardScaler() )<choose_model_class> | df_test.dtypes
g_train =df_test.columns.to_series().groupby(df_test.dtypes ).groups
g_train | Titanic - Machine Learning from Disaster |
11,548,643 | def create_lstm(spatial_dropout, dropout, recurrent_dropout, learning_rate, bidirectional = False):
activation = LeakyReLU(alpha = 0.01)
nlp_input = Input(shape =(MAX_SEQUENCE_LENGTH,), name = 'nlp_input')
meta_input_train = Input(shape =(7,), name = 'meta_train')
emb = embedding(nlp_input)
emb = SpatialDropout1D(d... | cat_names= [
'Name', 'Sex', 'Ticket', 'Cabin',
'Embarked', 'Name_wiki', 'Hometown',
'Boarded', 'Destination', 'Lifeboat',
'Body'
]
cont_names = [
'PassengerId', 'Pclass', 'SibSp', 'Parch',
'Age', 'Fare', 'WikiId', 'Age_wiki','Class'
] | Titanic - Machine Learning from Disaster |
11,548,643 | lstm = create_lstm(spatial_dropout =.2, dropout =.2, recurrent_dropout =.2,
learning_rate = 3e-4, bidirectional = True)
lstm.summary()<train_model> | test = TabularPandas(df_test, procs=[Categorify, FillMissing,Normalize],
cat_names = cat_names,
cont_names = cont_names,
) | Titanic - Machine Learning from Disaster |
11,548,643 | history1 = lstm.fit([nlp_train, meta_train], labels, validation_split =.2,
epochs = 5, batch_size = 21, verbose = 1 )<choose_model_class> | X_test= test.train.xs | Titanic - Machine Learning from Disaster |
11,548,643 | callback = EarlyStopping(monitor = 'val_loss', patience = 4)
<choose_model_class> | X_test.dtypes
g_train =X_test.columns.to_series().groupby(X_test.dtypes ).groups
g_train | Titanic - Machine Learning from Disaster |
11,548,643 | def create_lstm_2(spatial_dropout, dropout, recurrent_dropout, learning_rate, bidirectional = False):
activation = LeakyReLU(alpha = 0.01)
nlp_input = Input(shape =(MAX_SEQUENCE_LENGTH,), name = 'nlp_input')
meta_input_train = Input(shape =(7,), name = 'meta_train')
emb = embedding(nlp_input)
emb = SpatialDropout1D... | X_test= X_test.drop('Fare_na', axis=1 ) | Titanic - Machine Learning from Disaster |
11,548,643 | lstm_2 = create_lstm_2(spatial_dropout =.4, dropout =.4, recurrent_dropout =.4,
learning_rate = 3e-4, bidirectional = True)
lstm_2.summary()<train_model> | y_pred=rnf_classifier.predict(X_test)
| Titanic - Machine Learning from Disaster |
11,548,643 | history2 = lstm_2.fit([nlp_train, meta_train], labels, validation_split =.2,
epochs = 30, batch_size = 21, verbose = 1 )<predict_on_test> | y_pred= y_pred.astype(int ) | Titanic - Machine Learning from Disaster |
11,548,643 | <choose_model_class><EOS> | output= pd.DataFrame({'PassengerId':df_test.PassengerId, 'Survived': y_pred})
output.to_csv('my_submission_titanic.csv', index=False)
output.head() | Titanic - Machine Learning from Disaster |
4,005,064 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | print(os.listdir(".. /input"))
| Titanic - Machine Learning from Disaster |
4,005,064 | history3 = dual_lstm.fit([nlp_train, meta_train], labels, validation_split =.2,
epochs = 25, batch_size = 21, verbose = 1 )<predict_on_test> | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv")
print("Train shape : ",train_df.shape)
print("Test shape : ",test_df.shape ) | Titanic - Machine Learning from Disaster |
4,005,064 | submission_lstm2 = pd.DataFrame()
submission_lstm2['id'] = test_id
submission_lstm2['prob'] = dual_lstm.predict([nlp_test, meta_test])
submission_lstm2['target'] = submission_lstm2['prob'].apply(lambda x: 0 if x <.5 else 1)
submission_lstm2.head(10 )<define_variables> | tabla_completa = train_df.append(test_df, ignore_index=True ) | Titanic - Machine Learning from Disaster |
4,005,064 | BATCH_SIZE = 32
EPOCHS = 2
USE_META = True
ADD_DENSE = False
DENSE_DIM = 64
ADD_DROPOUT = False
DROPOUT =.2<install_modules> | tabla_completa["Cabin"] = tabla_completa["Cabin"].fillna("N")
letras_cabinas = tabla_completa["Cabin"].str[0].unique().tolist() | Titanic - Machine Learning from Disaster |
4,005,064 | !pip install --quiet transformers
<categorify> | tabla_completa["Letra_Cabina"] = tabla_completa["Cabin"].str[0] | Titanic - Machine Learning from Disaster |
4,005,064 | TOKENIZER = AutoTokenizer.from_pretrained("bert-large-uncased")
enc = TOKENIZER.encode("Encode me!")
dec = TOKENIZER.decode(enc)
print("Encode: " + str(enc))
print("Decode: " + str(dec))<categorify> | dic_titulos_simples = {
"Mr" : "Mr",
"Mrs" : "Mrs",
"Miss" : "Miss",
"Master" : "Master",
"Don" : "Nobleza",
"Rev" : "Oficial",
"Dr" : "Oficial",
"Mme" : "Mrs",
"Ms" : "Mrs",
"Major" : "Oficial",
"Lady" : "Nobleza",
"Sir" : "Nobleza",
"Mlle" : "Miss",
"Col" : "Oficial",
"Capt" : "Oficial",
"Countess" : "Nobleza",
"Jonk... | Titanic - Machine Learning from Disaster |
4,005,064 | def bert_encode(data,maximum_len):
input_ids = []
attention_masks = []
for i in range(len(data.text)) :
encoded = TOKENIZER.encode_plus(data.text[i],
add_special_tokens=True,
max_length=maximum_len,
pad_to_max_length=True,
return_attention_mask=True)
input_ids.append(encoded['input_ids'])
attention_masks.append(encod... | grupo = tabla_completa.groupby(['Sex','Pclass','Titulo'])
tabla_completa['Age'] = grupo['Age'].apply(lambda x: x.fillna(x.median())) | Titanic - Machine Learning from Disaster |
4,005,064 | def build_model(model_layer, learning_rate, use_meta = USE_META, add_dense = ADD_DENSE,
dense_dim = DENSE_DIM, add_dropout = ADD_DROPOUT, dropout = DROPOUT):
input_ids = tf.keras.Input(shape=(60,),dtype='int32')
attention_masks = tf.keras.Input(shape=(60,),dtype='int32')
meta_input = tf.keras.Input(shape =(meta_train... | tabla_completa['Fare'] = tabla_completa['Fare'].fillna(tabla_completa['Fare'].median() ) | Titanic - Machine Learning from Disaster |
4,005,064 | train = pd.read_csv('.. /input/nlp-getting-started/train.csv')
test = pd.read_csv('.. /input/nlp-getting-started/test.csv' )<categorify> | tabla_completa['Num_Familiares'] = tabla_completa['SibSp'] + tabla_completa['Parch'] | Titanic - Machine Learning from Disaster |
4,005,064 | bert_large = TFAutoModel.from_pretrained('bert-large-uncased')
TOKENIZER = AutoTokenizer.from_pretrained("bert-large-uncased")
train_input_ids,train_attention_masks = bert_encode(train,60)
test_input_ids,test_attention_masks = bert_encode(test,60)
print('Train length:', len(train_input_ids))
print('Test length:', l... | tabla_completa['Sex'] = tabla_completa['Sex'].map({"male": 0, "female":1})
dummies_pclass = pd.get_dummies(tabla_completa['Pclass'], prefix="Pclass")
dummies_titulo = pd.get_dummies(tabla_completa['Titulo'], prefix="Titulo")
dummies_letra_cab = pd.get_dummies(tabla_completa['Letra_Cabina'], prefix="Letra_Cabina")
d... | Titanic - Machine Learning from Disaster |
4,005,064 | history_bert = BERT_large.fit([train_input_ids,train_attention_masks, meta_train], train.target,
validation_split =.2, epochs = EPOCHS, callbacks = [checkpoint], batch_size = BATCH_SIZE )<predict_on_test> | train_df = dummies_tabla[ :len(train_df)]
test_df = dummies_tabla[(len(dummies_tabla)- len(test_df)) : ]
train_df['Survived'] = train_df['Survived'].astype(int)
print("Train:
",train_df)
print("Test:
",test_df ) | Titanic - Machine Learning from Disaster |
4,005,064 | BERT_large.load_weights('large_model.h5')
preds_bert = BERT_large.predict([test_input_ids,test_attention_masks,meta_test] )<prepare_output> | test_df = test_df.reset_index(drop = True)
train_df = train_df.reset_index(drop = True)
train_dfX = train_df.drop(['PassengerId','Survived'], axis=1)
train_dfY = train_df['Survived']
submission = pd.DataFrame(data=test_df['PassengerId'].copy())
print(submission)
test_df = test_df.drop(['PassengerId', 'Survived'], ... | Titanic - Machine Learning from Disaster |
4,005,064 | submission_bert = pd.DataFrame()
submission_bert['id'] = test_id
submission_bert['prob'] = preds_bert
submission_bert['target'] = np.round(submission_bert['prob'] ).astype(int)
submission_bert.head(10 )<save_to_csv> | sc = StandardScaler()
train_dfX = sc.fit_transform(train_dfX)
test_df = sc.transform(test_df ) | Titanic - Machine Learning from Disaster |
4,005,064 | submission_bert = submission_bert[['id', 'target']]
submission_bert.to_csv('submission_bert.csv', index = False)
print('Blended submission has been saved to disk' )<set_options> | train_dfX,val_dfX,train_dfY, val_dfY = train_test_split(train_dfX,train_dfY , test_size=0.1, stratify=train_dfY)
print("Entrnamiento: ",train_dfX.shape)
print("Validacion : ",val_dfX.shape ) | Titanic - Machine Learning from Disaster |
4,005,064 | plt.style.use('ggplot')
warnings.filterwarnings('ignore')
<define_variables> | def func_model(arquitectura):
np.random.seed(42)
random_seed = 42
first =True
inp = Input(shape=(train_dfX.shape[1],))
for capa in arquitectura:
if first:
x=Dense(capa, activation="relu", kernel_initializer=initializers.RandomNormal(seed=random_seed), bias_initializer='zeros' )(inp)
first = False
else:
x=Dense(capa, ... | Titanic - Machine Learning from Disaster |
4,005,064 | def seed_everything(seed):
os.environ['PYTHONHASHSEED']=str(seed)
tf.random.set_seed(seed)
np.random.seed(seed)
random.seed(seed)
seed_everything(34 )<load_from_csv> | arq1 = [1024, 1024, 512]
model1 = None
model1 = func_model(arq1)
train_history_tam1 = model1.fit(train_dfX, train_dfY, batch_size=32, epochs=epochs, validation_data=(val_dfX, val_dfY))
graf_model(train_history_tam1)
precision(model1 ) | Titanic - Machine Learning from Disaster |
4,005,064 | train = pd.read_csv('.. /input/nlp-getting-started/train.csv')
test = pd.read_csv('.. /input/nlp-getting-started/test.csv')
train.head()<categorify> | arq2 = [1024, 512, 512]
model2 = None
model2 = func_model(arq2)
train_history_tam2 = model2.fit(train_dfX, train_dfY, batch_size=32, epochs=epochs, validation_data=(val_dfX, val_dfY))
graf_model(train_history_tam2)
precision(model2 ) | Titanic - Machine Learning from Disaster |
4,005,064 | test_id = test['id']
columns = {'id', 'location'}
train = train.drop(columns = columns)
test = test.drop(columns = columns)
train['keyword'] = train['keyword'].fillna('unknown')
test['keyword'] = test['keyword'].fillna('unknown')
train['text'] = train['text'] + ' ' + train['keyword']
test['text'] = test['text'] + '... | arqFinal = [1024, 1024, 1024]
modelF = None
modelF = func_model(arqFinal)
print(modelF.summary())
train_history_tamF = modelF.fit(train_dfX, train_dfY, batch_size=32, epochs=epochs, validation_data=(val_dfX, val_dfY))
graf_model(train_history_tamF)
precision(modelF, True ) | Titanic - Machine Learning from Disaster |
4,005,064 | total['unique word count'] = total['text'].apply(lambda x: len(set(x.split())))
total['stopword count'] = total['text'].apply(lambda x: len([i for i in x.lower().split() if i in wordcloud.STOPWORDS]))
total['stopword ratio'] = total['stopword count'] / total['word count']
total['punctuation count'] = total['text'].app... | def func_model_reg() :
np.random.seed(42)
random_seed = 42
inp = Input(shape=(train_dfX.shape[1],))
x=Dropout(0.1 )(inp)
x=Dense(1024, activation="relu", kernel_initializer=initializers.RandomNormal(seed=random_seed), bias_initializer='zeros', kernel_regularizer=regularizers.l2(0.01))(x)
x=Dropout(0.7 )(x)
x=Dense(... | Titanic - Machine Learning from Disaster |
4,005,064 | def remove_punctuation(x):
return x.translate(str.maketrans('', '', string.punctuation))
def remove_stopwords(x):
return ' '.join([i for i in x.split() if i not in wordcloud.STOPWORDS])
def remove_less_than(x):
return ' '.join([i for i in x.split() if len(i)> 3])
def remove_non_alphabet(x):
return ' '.join([i for i i... | modelReg = None
modelReg = func_model_reg()
train_history_tamReg = modelReg.fit(train_dfX, train_dfY, batch_size=32, epochs=epochs, validation_data=(val_dfX, val_dfY))
graf_model(train_history_tamReg)
precision(modelReg ) | Titanic - Machine Learning from Disaster |
4,005,064 | <string_transform><EOS> | y_test = modelReg.predict(test_df)
submission['Survived'] = y_test.round().astype(int)
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
6,488,543 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | %matplotlib inline
py.init_notebook_mode(connected=True)
warnings.filterwarnings('ignore')
GradientBoostingClassifier, ExtraTreesClassifier)
| 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.