kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
4,060,422 | unique_targets = data.groupby('text' ).agg(unique_target=('target', pd.Series.nunique))
controversial_tweets = unique_targets[unique_targets['unique_target'] > 1].index
data = data[~data['text'].isin(controversial_tweets)]
data = data.drop_duplicates(subset='text', keep='first')
data['text'] = data['text'].apply(clean... | dft2.to_csv('titanic_results.csv', index=False ) | Titanic - Machine Learning from Disaster |
7,957,348 | tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaForSequenceClassification.from_pretrained('roberta-base' )<categorify> | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
7,957,348 | def prepare_features(data_set, labels=None, max_seq_length = 100,
zero_pad = True, include_special_tokens = True):
input_ids = []
attention_masks = []
for sent in data_set:
encoded_dict = tokenizer.encode_plus(
sent,
add_special_tokens = include_special_tokens,
max_length = max_seq_length,
pad_to_max_length = zero_pad... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
7,957,348 | train_input_ids, train_attention_masks, train_labels = prepare_features(
train['text'], train['target'])
val_input_ids, val_attention_masks, val_labels = prepare_features(
val['text'], val['target'])
test_input_ids, test_attention_masks = prepare_features(
test['text'] )<create_dataframe> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
7,957,348 | training_set = TensorDataset(train_input_ids, train_attention_masks, train_labels)
validation_set = TensorDataset(val_input_ids, val_attention_masks, val_labels)
test_set = TensorDataset(test_input_ids, test_attention_masks )<train_model> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
7,957,348 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device )<set_options> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
7,957,348 | torch.cuda.is_available()<define_variables> | %matplotlib inline
sns.set() | Titanic - Machine Learning from Disaster |
7,957,348 | BATCH_SIZE = 32
LEARNING_RATE = 1e-05
EPSILON = 1e-8
MAX_EPOCHS = 10<load_pretrained> | train_test_data = [train, test]
for dataset in train_test_data:
dataset['Title']= dataset['Name'].str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
7,957,348 | loading_params = {'batch_size': BATCH_SIZE,
'shuffle': True,
'drop_last': False,
'num_workers': 1}
training_loader = DataLoader(training_set, **loading_params)
validation_loader = DataLoader(validation_set, **loading_params)
test_loading_params = {'batch_size': BATCH_SIZE,
'shuffle': False,
'drop_last': False,
'num_w... | train['Title'].value_counts() | Titanic - Machine Learning from Disaster |
7,957,348 | loss_function = nn.CrossEntropyLoss()
optimizer = AdamW(model.parameters() ,
lr = LEARNING_RATE,
eps = EPSILON
)
total_steps = len(training_loader)* MAX_EPOCHS
scheduler = get_linear_schedule_with_warmup(optimizer,
num_warmup_steps = 0,
num_training_steps = total_steps )<data_type_conversions> | test['Title'].value_counts() | Titanic - Machine Learning from Disaster |
7,957,348 | def format_time(elapsed):
elapsed_rounded = int(round(( elapsed)))
return str(datetime.timedelta(seconds=elapsed_rounded))<compute_test_metric> | title_mapping = {"Mr": 0, "Miss": 1, "Mrs": 2,
"Master": 3, "Dr": 3, "Rev": 3, "Col": 3, "Major": 3, "Mlle": 3,"Countess": 3,
"Ms": 3, "Lady": 3, "Jonkheer": 3, "Don": 3, "Dona" : 3, "Mme": 3,"Capt": 3,"Sir": 3 }
for dataset in train_test_data:
dataset['Title'] = dataset['Title'].map(title_mapping ) | Titanic - Machine Learning from Disaster |
7,957,348 | def flat_accuracy(preds, labels):
pred_flat = np.argmax(preds, axis=1)
labels_flat = labels
return accuracy_score(labels_flat, pred_flat )<train_model> | train.drop('Name', axis=1, inplace=True)
test.drop('Name', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
7,957,348 | for epoch in tqdm_notebook(range(MAX_EPOCHS)) :
t0 = time.time()
total_train_loss = 0
model.train()
print("EPOCH -- {} / {}".format(epoch, MAX_EPOCHS))
for step, batch in enumerate(training_loader):
if step % 30 == 0 and not step == 0:
elapsed = format_time(time.time() - t0)
print(' Batch {} of {}.Elapsed: {:}'.format... | sex_mapping = {"male": 0, "female": 1}
for dataset in train_test_data:
dataset['Sex'] = dataset['Sex'].map(sex_mapping ) | Titanic - Machine Learning from Disaster |
7,957,348 | model.eval()
predictions = []
for batch in testing_loader:
batch = tuple(t.to(device)for t in batch)
input_ids, input_masks = batch
with torch.no_grad() :
logits = model(input_ids,
token_type_ids=None,
attention_mask=input_masks)[0]
logits = logits.detach().cpu().numpy()
predictions.append(logits )<define_variables> | train["Age"].fillna(train.groupby("Title")["Age"].transform("median"), inplace=True)
test["Age"].fillna(test.groupby("Title")["Age"].transform("median"), inplace=True ) | Titanic - Machine Learning from Disaster |
7,957,348 | flat_predictions = [item for sublist in predictions for item in sublist]
targets = np.argmax(flat_predictions, axis=1 ).flatten()<feature_engineering> | train.groupby("Title")["Age"].transform("median" ) | Titanic - Machine Learning from Disaster |
7,957,348 | test['target'] = targets<data_type_conversions> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
7,957,348 | tokenizer.convert_tokens_to_ids(tokenizer.tokenize('dick'))<save_to_csv> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
7,957,348 | submission = test[['id', 'target']].to_csv("submission_roberta.csv", index=False )<categorify> | for dataset in train_test_data:
dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0,
dataset.loc[(dataset['Age'] > 16)&(dataset['Age'] <= 26), 'Age'] = 1,
dataset.loc[(dataset['Age'] > 26)&(dataset['Age'] <= 36), 'Age'] = 2,
dataset.loc[(dataset['Age'] > 36)&(dataset['Age'] <= 62), 'Age'] = 3,
dataset.loc[ dataset['Age'] > 6... | Titanic - Machine Learning from Disaster |
7,957,348 | def preprocess(texts, allowed_postags=['NOUN', "ADJ", "VERB", "ADV", "DET"]):
texts_out = []
for text in texts:
lowered_text = text.lower()
doc = nlp(lowered_text)
tokens = [token for token in doc if not(token.is_punct |
token.is_space |
token.is_digit)]
tokens = [token for token in tokens if token.is_alpha]
lemmas = ... | Pclass1 = train[train['Pclass']==1]['Embarked'].value_counts()
Pclass2 = train[train['Pclass']==2]['Embarked'].value_counts()
Pclass3 = train[train['Pclass']==3]['Embarked'].value_counts()
df = pd.DataFrame([Pclass1, Pclass2, Pclass3])
df.index = ['1st class','2nd class', '3rd class']
df.plot(kind='bar',stacked=True, ... | Titanic - Machine Learning from Disaster |
7,957,348 | data_pruned = data.copy(deep=True)
data_pruned['text'] = data_pruned['text'].progress_apply(clean_text)
data_pruned['text'] = data_pruned['text'].progress_apply(preprocess )<feature_engineering> | for dataset in train_test_data:
dataset['Embarked']=dataset['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
7,957,348 | test_pruned = test.copy(deep=True)
test_pruned['text'] = test_pruned['text'].apply(clean_text)
test_pruned['text'] = test_pruned['text'].apply(preprocess )<concatenate> | embarked_mapping = {"S": 0, "C": 1, "Q": 2}
for dataset in train_test_data:
dataset['Embarked'] = dataset['Embarked'].map(embarked_mapping ) | Titanic - Machine Learning from Disaster |
7,957,348 | all_text = pd.concat([data_pruned[['text']], test_pruned[['text']]], ignore_index=True )<feature_engineering> | train["Fare"].fillna(train.groupby("Pclass")["Fare"].transform("median"), inplace=True)
test["Fare"].fillna(test.groupby("Pclass")["Fare"].transform("median"), inplace=True)
train.head(50 ) | Titanic - Machine Learning from Disaster |
7,957,348 | cv = CountVectorizer(ngram_range=(1,2))
tfidf_transformer = TfidfTransformer()
x = cv.fit_transform(all_text['text'])
x_all_tfidf = tfidf_transformer.fit_transform(x )<train_model> | for dataset in train_test_data:
dataset.loc[ dataset['Fare'] <= 17, 'Fare'] = 0,
dataset.loc[(dataset['Fare'] > 17)&(dataset['Fare'] <= 30), 'Fare'] = 1,
dataset.loc[(dataset['Fare'] > 30)&(dataset['Fare'] <= 100), 'Fare'] = 2,
dataset.loc[ dataset['Fare'] > 100, 'Fare'] = 3 | Titanic - Machine Learning from Disaster |
7,957,348 | training_samples = data_pruned.shape[0]
X_train = x_all_tfidf[:training_samples,:]
X_test = x_all_tfidf[training_samples:,:]<prepare_x_and_y> | train.Cabin.value_counts() | Titanic - Machine Learning from Disaster |
7,957,348 | y_train = data_pruned['target']<train_model> | for dataset in train_test_data:
dataset['Cabin']=dataset['Cabin'].str[:1] | Titanic - Machine Learning from Disaster |
7,957,348 | mb_classifier = MB().fit(X_train, y_train )<compute_train_metric> | cabin_mapping = {"A": 0, "B": 0.4, "C": 0.8, "D": 1.2, "E": 1.6, "F": 2, "G": 2.4, "T": 2.8}
for dataset in train_test_data:
dataset['Cabin'] = dataset['Cabin'].map(cabin_mapping ) | Titanic - Machine Learning from Disaster |
7,957,348 | pred = mb_classifier.predict(X_train)
c = classification_report(y_train,pred )<find_best_model_class> | train["Cabin"].fillna(train.groupby("Pclass")["Cabin"].transform("median"), inplace=True)
test["Cabin"].fillna(test.groupby("Pclass")["Cabin"].transform("median"), inplace=True ) | Titanic - Machine Learning from Disaster |
7,957,348 | skf = StratifiedKFold(n_splits=5, random_state=RANDOM_STATE)
total_accuracy = []
total_precision = []
total_recall = []
for train_index, val_index in skf.split(X_train, y_train):
current_X_train = X_train[train_index]
current_y_train = y_train.iloc[train_index]
current_X_val = X_train[val_index]
current_y_val = y_trai... | train["FamilySize"] = train["SibSp"] + train["Parch"] + 1
test["FamilySize"] = test["SibSp"] + test["Parch"] + 1 | Titanic - Machine Learning from Disaster |
7,957,348 | test_pruned['target'] = mb_classifier.predict(x_test )<save_to_csv> | family_mapping = {1: 0, 2: 0.4, 3: 0.8, 4: 1.2, 5: 1.6, 6: 2, 7: 2.4, 8: 2.8, 9: 3.2, 10: 3.6, 11: 4}
for dataset in train_test_data:
dataset['FamilySize'] = dataset['FamilySize'].map(family_mapping ) | Titanic - Machine Learning from Disaster |
7,957,348 | test_pruned[['id', 'target']].to_csv("submission_2.csv", index=False )<choose_model_class> | features_drop = ['Ticket', 'SibSp', 'Parch']
train = train.drop(features_drop, axis=1)
test = test.drop(features_drop, axis=1)
train = train.drop(['PassengerId'], axis=1 ) | Titanic - Machine Learning from Disaster |
7,957,348 | clf_svm = svm.SVC(C=1.0, kernel='linear', degree=3, gamma='auto' )<predict_on_test> | from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
import numpy as np | Titanic - Machine Learning from Disaster |
7,957,348 | clf_svm.fit(x_train, y_train)
pred = clf_svm.predict(x_train)
print(classification_report(y_train,pred))<save_to_csv> | k_fold = KFold(n_splits=10, shuffle=True, random_state=0 ) | Titanic - Machine Learning from Disaster |
7,957,348 | test_pruned['target'] = clf_svm.predict(x_test)
test_pruned[['id', 'target']].to_csv("submission_svm.csv", index=False )<prepare_x_and_y> | clf = KNeighborsClassifier(n_neighbors = 13)
scoring = 'accuracy'
score = cross_val_score(clf, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
print(score ) | Titanic - Machine Learning from Disaster |
7,957,348 | TRAIN_VAL_SPLIT = 0.8
train = data.sample(frac=TRAIN_VAL_SPLIT, random_state=RANDOM_STATE)
val = data[~data.index.isin(train.index)]
X_train = train['text'].values
y_train = train['target'].values
X_val = val['text'].values
y_val = val['target'].values
X_test = test['text'].values<categorify> | round(np.mean(score)*100, 2 ) | Titanic - Machine Learning from Disaster |
7,957,348 | def preprocess(texts, allowed_postags=['NOUN', "ADJ", "VERB", "ADV", "PROPN", "DET"]):
texts_out = []
for text in texts:
lowered_text = text.lower()
lowered_text = re.sub(r'https?://\S+|www\.\S+', '', lowered_text)
lowered_text = re.sub(r'<.*?>', '', lowered_text)
doc = nlp(lowered_text)
tokens = [token for token in... | clf = DecisionTreeClassifier()
scoring = 'accuracy'
score = cross_val_score(clf, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
print(score ) | Titanic - Machine Learning from Disaster |
7,957,348 | train_corpus = preprocess(X_train)
val_corpus = preprocess(X_val)
test_corpus = preprocess(X_test )<define_variables> | round(np.mean(score)*100, 2 ) | Titanic - Machine Learning from Disaster |
7,957,348 | corpus = train_corpus + val_corpus + test_corpus<string_transform> | clf = RandomForestClassifier(n_estimators=13)
scoring = 'accuracy'
score = cross_val_score(clf, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
print(score ) | Titanic - Machine Learning from Disaster |
7,957,348 | tokenizer = Tokenizer()
tokenizer.fit_on_texts(corpus)
train_sequences = tokenizer.texts_to_sequences(train_corpus)
val_sequences = tokenizer.texts_to_sequences(val_corpus)
test_sequences = tokenizer.texts_to_sequences(test_corpus)
word_index = tokenizer.word_index
train_max_length = max([len(x)for x in train_seque... | round(np.mean(score)*100, 2 ) | Titanic - Machine Learning from Disaster |
7,957,348 | EMBEDDING_DIM = 30<choose_model_class> | clf = GaussianNB()
scoring = 'accuracy'
score = cross_val_score(clf, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
print(score ) | Titanic - Machine Learning from Disaster |
7,957,348 | model_tuned = Sequential()
model_tuned.add(Embedding(vocab_size, EMBEDDING_DIM, input_length=max_length))
model_tuned.add(GRU(units=30, dropout=0.2, recurrent_dropout=0.2, return_sequences=True))
model_tuned.add(GRU(units=30, dropout=0.2, recurrent_dropout=0.2, return_sequences=True))
model_tuned.add(GRU(units=30, drop... | round(np.mean(score)*100, 2 ) | Titanic - Machine Learning from Disaster |
7,957,348 | history = model_tuned.fit(X_train_pad, y_train, batch_size=128, epochs=25, validation_data=(X_val_pad, y_val), verbose=2 )<predict_on_test> | clf = SVC()
scoring = 'accuracy'
score = cross_val_score(clf, train_data, target, cv=k_fold, n_jobs=1, scoring=scoring)
print(score ) | Titanic - Machine Learning from Disaster |
7,957,348 | y_pred_tuned = model_tuned.predict(X_test_pad )<define_variables> | round(np.mean(score)*100,2 ) | Titanic - Machine Learning from Disaster |
7,957,348 | y_pred_binary = list(map(lambda x: 1 if x >= 0.5 else 0, y_pred_tuned))<feature_engineering> | clf = SVC()
clf.fit(train_data, target)
test_data = test.drop("PassengerId", axis=1 ).copy()
prediction = clf.predict(test_data ) | Titanic - Machine Learning from Disaster |
7,957,348 | test['target'] = y_pred_binary<save_to_csv> | submission = pd.DataFrame({
"PassengerId": test["PassengerId"],
"Survived": prediction
})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
8,140,706 | test[['id', 'target']].to_csv("submission_rnn.csv", index=False )<choose_model_class> | from sklearn.model_selection import train_test_split
import random
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import LabelEncoder
from sklearn.compose import ColumnTransformer
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection i... | Titanic - Machine Learning from Disaster |
8,140,706 | def ConvNet(max_sequence_length, num_words, embedding_dim, labels_index):
embedding_layer = Embedding(num_words,
embedding_dim,
input_length=max_sequence_length)
sequence_input = Input(shape=(max_sequence_length,), dtype='int32')
embedded_sequences = embedding_layer(sequence_input)
convs = []
filter_sizes = [3,4,5,6... | import itertools
import matplotlib.pyplot as plt
import lightgbm as lgb
from sklearn import metrics | Titanic - Machine Learning from Disaster |
8,140,706 | model = ConvNet(max_length, vocab_size, EMBEDDING_DIM, 1 )<train_model> | from sklearn.feature_selection import SelectKBest, f_classif | Titanic - Machine Learning from Disaster |
8,140,706 | hist = model.fit(X_train_pad,
y_train,
epochs=25,
batch_size=128,
validation_data=(X_val_pad, y_val),
verbose=2 )<predict_on_test> | import itertools | Titanic - Machine Learning from Disaster |
8,140,706 | y_pred = model.predict(X_test_pad)
y_pred_binary = list(map(lambda x: 1 if x >= 0.5 else 0, y_pred))<save_to_csv> | def Feature_selection(X):
cat_features = [y for y in X.columns if X[y].dtypes == 'object']
cat_features = [col for col in cat_features if col not in ['Name', 'Ticket', 'Cabin']]
interactions = pd.DataFrame(index=X.index)
for col1, col2 in itertools.combinations(cat_features, 2):
new_col_name = '_'.join([col1, col2])
... | Titanic - Machine Learning from Disaster |
8,140,706 | test['target'] = y_pred_binary
test[['id', 'target']].to_csv("submission_cnn.csv", index=False )<filter> | import category_encoders as ce | Titanic - Machine Learning from Disaster |
8,140,706 | data[data['target'] == 0].values<set_options> | Titanic - Machine Learning from Disaster | |
8,140,706 | stop = set(stopwords.words('english'))
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))<load_from_csv> | def Categorical_Encoding_train(X):
cat_features = [y for y in X.columns if X[y].dtypes == 'object']
cat_features = [col for col in cat_features if col not in ['Name']]
encoder = ce.CatBoostEncoder(cols = cat_features)
encoder.fit(X[cat_features], X['Survived'])
numerical_col = [y for y in X.columns if X[y].dtypes != ... | Titanic - Machine Learning from Disaster |
8,140,706 | train = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv")
target = train['target']
print("Train shape", train.shape)
print("Test shape", test.shape )<string_transform> | def Categorical_Encoding_test(X, encoder):
cat_features = [y for y in X.columns if X[y].dtypes == 'object']
print(cat_features)
cat_features = [col for col in cat_features if col not in ['Name']]
numerical_col = [y for y in X.columns if X[y].dtypes != 'object']
data = X[numerical_col].join(encoder.transform(X[cat_feat... | Titanic - Machine Learning from Disaster |
8,140,706 | def create_corpus(target):
corpus = []
for x in train[train['target'] == target]['text'].str.split() :
for i in x:
corpus.append(i)
return corpus
def filter_specific_word(corpus, filters):
dic = defaultdict(int)
for word in corpus:
if word in filters:
dic[word] += 1
return dic<feature_engineering> | from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer | Titanic - Machine Learning from Disaster |
8,140,706 | def get_top_tweet_bigrams(corpus, n=None):
vec = CountVectorizer(ngram_range=(2, 2)).fit(corpus)
bag_of_words = vec.transform(corpus)
sum_words = bag_of_words.sum(axis=0)
words_freq = [(word, sum_words[0, idx])for word, idx in vec.vocabulary_.items() ]
words_freq = sorted(words_freq, key=lambda x: x[1], reverse=True... | def iterative_imputer(X):
numerical_feature = [y for y in X.columns if X[y].dtypes != 'object'
and X[y].isnull().sum() != 0]
imp_mean = IterativeImputer(max_iter=10, verbose=0)
X[numerical_feature] = imp_mean.fit_transform(X[numerical_feature])
return X | Titanic - Machine Learning from Disaster |
8,140,706 | df = pd.concat([train, test], axis=0, sort=False)
df.shape<drop_column> | def numerical_imputer(X):
numerical_feature = [y for y in X.columns if X[y].dtypes != 'object'
and X[y].isnull().sum() != 0]
my_imputer = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X[numerical_feature] = pd.DataFrame(my_imputer.fit_transform(X[numerical_feature]))
return X | Titanic - Machine Learning from Disaster |
8,140,706 | def remove_url(text):
url = re.compile('https?://\S+|www\.\S+')
return url.sub(r'', text)
remove_url('http://www.kaggle.com/rakkaalhazimi/nlp-disaster-classification/edit?rvi=1' )<feature_engineering> | import lightgbm as lgb | Titanic - Machine Learning from Disaster |
8,140,706 | df['text'] = df['text'].apply(lambda x: remove_url(x))
retain = df['text'].str.contains(r'http[s]*' ).sum()
print("{} words were left behind".format(retain))<string_transform> | def train_and_predict(train_X, train_y, valid_X, valid_y, X_test):
dtrain = lgb.Dataset(train_X, label=train_y)
dvalid = lgb.Dataset(valid_X, label=valid_y)
param = {'num_leaves': 64, 'objective': 'binary'}
param['metric'] = 'auc'
num_round = 1000
bst = lgb.train(param, dtrain, num_round,
valid_sets=[dvalid], early_s... | Titanic - Machine Learning from Disaster |
8,140,706 | residual = df[df['text'].str.contains(r'http[s]*')]
left_word = []
for i in range(len(residual)) :
print(residual['text'].values[i])
left_word.append(residual['text'].values[i] )<categorify> | if __name__ == '__main__':
seed = 123
random.seed(seed)
print('Loading Training Data')
baseline_data = pd.read_csv('/kaggle/input/titanic/train.csv')
baseline_data = Feature_selection(baseline_data)
baseline_data = numerical_imputer(baseline_data)
encoded_data, encoder = Categorical_Encoding_train(baseline_data)
... | Titanic - Machine Learning from Disaster |
8,140,706 | for word in left_word:
compiler = re.compile(r'.http.+')
result = compiler.sub('', word)
print(result )<feature_engineering> | Titanic - Machine Learning from Disaster | |
8,140,706 | df['text'] = df['text'].str.replace(r'.http.+', '')
print("http words found {}".format(df['text'].str.contains('http' ).sum()))<drop_column> | baseline_data.groupby('Pclass')['Survived'].count() | Titanic - Machine Learning from Disaster |
8,140,706 | <feature_engineering><EOS> | baseline_data.groupby('Embarked')['Survived'].count() | Titanic - Machine Learning from Disaster |
8,355,010 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<drop_column> | sns.set(style='whitegrid', palette='muted', font_scale=1.5)
rcParams['figure.figsize'] = 10, 6
RANDOM_SEED = 42
np.random.seed(RANDOM_SEED)
def print_metrics(y_true,y_pred):
conf_mx = confusion_matrix(y_true,y_pred)
print("------------------------------------------")
print(" Accuracy : ", accuracy_score(y_true,y_pr... | Titanic - Machine Learning from Disaster |
8,355,010 | def remove_emoji(text):
emoji_pattern = re.compile("["
u"\U0001F600-\U0001F64F"
u"\U0001F300-\U0001F5FF"
u"\U0001F680-\U0001F6FF"
u"\U0001F1E0-\U0001F1FF"
u"\U00002702-\U000027B0"
u"\U000024C2-\U0001F251"
"]+", flags=re.UNICODE)
return emoji_pattern.sub(r'', text)
remove_emoji("Omg another Earthquake 😔😔" )<feature_... | train_df = pd.read_csv('/kaggle/input/titanic/train.csv')
test_df = pd.read_csv('/kaggle/input/titanic/test.csv')
submit_df = pd.read_csv('/kaggle/input/titanic/gender_submission.csv')
train_df.head(10 ) | Titanic - Machine Learning from Disaster |
8,355,010 | df['text'] = df['text'].apply(lambda x: remove_emoji(x))<categorify> | def feature_eng(df,columnshoice):
df['TicketLetter'] = df['Ticket'].apply(lambda x : str(x)[0])
df['TicketLetter'] = df['TicketLetter'].apply(lambda x : re.sub('[0-9]','N',x))
df['Title'] = df.Name.apply(lambda name: name.split(',')[1].split('.')[0].strip())
normalized_titles = {
"Capt": "Officer",
"Col": "Officer",
... | Titanic - Machine Learning from Disaster |
8,355,010 | def remove_punct(text):
table = str.maketrans('', '', string.punctuation)
return text.translate(table)
example = "I am King
remove_punct(example )<feature_engineering> | model = tf.keras.models.Sequential([
tf.keras.layers.Dense(units=64, activation='relu',input_dim=X.shape[1]),
tf.keras.layers.Dense(units=32, activation='relu'),
tf.keras.layers.Dense(units=32, activation='relu'),
tf.keras.layers.Dense(units=1, activation='sigmoid')
])
early_stop = keras.callbacks.EarlyStopping(
mon... | Titanic - Machine Learning from Disaster |
8,355,010 | df['text'] = df['text'].apply(lambda x: remove_punct(x))<load_from_csv> | history = model.fit(
x=X,
y=y,
shuffle=True,
epochs=100,
validation_split=0.1,
verbose=0,
callbacks=[early_stop]
) | Titanic - Machine Learning from Disaster |
8,355,010 | df = pd.read_csv(".. /input/nlp-disaster-cleaned/tweetDisaster.csv" )<remove_duplicates> | predictions = model.predict(X)
predictions = tf.round(predictions ).numpy().flatten().astype(int ) | Titanic - Machine Learning from Disaster |
8,355,010 | def create_corpus(df):
copy_df = df.copy()
corpus = []
for tweet in tqdm(copy_df["text"]):
words = [word.lower() for word in word_tokenize(tweet)if(( word.isalpha() == 1)&(word not in stop)) ]
corpus.append(words)
return corpus<statistical_test> | print_metrics(y,predictions)
| Titanic - Machine Learning from Disaster |
8,355,010 | <define_variables><EOS> | y_sub= model.predict(test)
y_sub = tf.round(y_sub ).numpy().flatten().astype(int)
submission = pd.DataFrame({
"PassengerId": test_df["PassengerId"],
"Survived": y_sub
})
submission.to_csv('titanic.csv', index=False ) | Titanic - Machine Learning from Disaster |
9,074,751 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | %matplotlib inline
def transform_dataset(ds):
transformed_dataset = ds.copy()
transformed_dataset['Age'].fillna(transformed_dataset['Age'].median() , inplace=True)
transformed_dataset['Fare'].fillna(transformed_dataset['Fare'].median() , inplace=True)
transformed_dataset['Sex'] = pd.factorize(transformed_dataset['Sex... | Titanic - Machine Learning from Disaster |
9,074,751 | print("Embedding shape :({},{})".format(len(embedding_dict),
len(embedding_dict['the'])) )<string_transform> | dataset = pd.read_csv('.. /input/titanic/train.csv')
dataset.info() | Titanic - Machine Learning from Disaster |
9,074,751 | MAX_LEN = 50
tokenizer_obj = Tokenizer()
tokenizer_obj.fit_on_texts(corpus)
sequences = tokenizer_obj.texts_to_sequences(corpus)
tweet_pad = pad_sequences(sequences, maxlen=MAX_LEN, truncating='post', padding='post' )<count_unique_values> | transformed_dataset = transform_dataset(dataset)
transformed_dataset.info() | Titanic - Machine Learning from Disaster |
9,074,751 | word_index = tokenizer_obj.word_index
print("Number of unique words:", len(word_index))<sort_values> | X = transformed_dataset.drop(['Survived'], axis=1)
Y = dataset['Survived'] | Titanic - Machine Learning from Disaster |
9,074,751 | top = sorted(word_index, key=lambda x: word_index[x], reverse=True)[:10]
unknown_index = []
for word in top:
scores =(word, word_index[word])
unknown_index.append(scores)
unknown_index<categorify> | X_train, X_test, Y_train, Y_test = model_selection.train_test_split(X, Y, test_size = 0.2, random_state = 21 ) | Titanic - Machine Learning from Disaster |
9,074,751 | num_words = len(word_index)+ 1
embedding_matrix = np.zeros(( num_words, 100))
for word, i in tqdm(word_index.items()):
if i > num_words:
continue
emb_vec = embedding_dict.get(word)
if emb_vec is not None:
embedding_matrix[i] = emb_vec<split> | param_grid =[ {'n_estimators' : [10, 15, 20, 25, 30, 35, 40], 'max_depth' : [5,10,15, 20]},]
rf = ensemble.RandomForestClassifier(random_state=21, max_features= 3)
model = GridSearchCV(rf,param_grid, cv = 5 ) | Titanic - Machine Learning from Disaster |
9,074,751 | train = tweet_pad[:train.shape[0]]
test = tweet_pad[train.shape[0]:]<choose_model_class> | model.fit(X_train,Y_train)
print('train score = ', model.score(X_train,Y_train), '
test score = ', model.score(X_test,Y_test), '
', model.best_params_ ) | Titanic - Machine Learning from Disaster |
9,074,751 | model = Sequential()
embedding = Embedding(num_words, 100, embeddings_initializer=Constant(embedding_matrix),
input_length=MAX_LEN, trainable=False)
model.add(embedding)
model.add(Bidirectional(LSTM(128,
dropout=0.2,
recurrent_dropout=0.2))
)
model.add(Dense(1, activation='sigmoid'))
optimizer = Adam(learning_rate=... | test = pd.read_csv('.. /input/titanic/test.csv')
test.info() | Titanic - Machine Learning from Disaster |
9,074,751 | history = model.fit(train, target, batch_size=32, epochs=15,
validation_split=0.2, verbose=1 )<load_from_csv> | passenger_id = test['PassengerId'] | Titanic - Machine Learning from Disaster |
9,074,751 | sample_sub = pd.read_csv("/kaggle/input/nlp-getting-started/sample_submission.csv")
sample_sub.shape<save_to_csv> | transformed_test = transform_dataset(test)
transformed_test.info() | Titanic - Machine Learning from Disaster |
9,074,751 | y_pred = model.predict(test)
y_pred = np.round(y_pred ).astype(int ).reshape(3263)
sub = pd.DataFrame({'id': sample_sub['id'].values.tolist() , 'target': y_pred})
sub.to_csv("submission.csv", index=False )<import_modules> | Y_predict = model.predict(transformed_test)
Y_p = pd.DataFrame(Y_predict, columns=['Survived'])
Y_p | Titanic - Machine Learning from Disaster |
9,074,751 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import re
import string
from tqdm import tqdm
from gensim.parsing.preprocessing import remove_stopwords
from bs4 import BeautifulSoup
from nltk.stem.snowball import SnowballStemmer
from nltk.stem.wordnet import WordNetLemmatize... | res = pd.concat([passenger_id, Y_p], axis=1)
res | Titanic - Machine Learning from Disaster |
9,074,751 | train = pd.read_csv(r'/kaggle/input/nlp-getting-started/train.csv')
test = pd.read_csv(r'/kaggle/input/nlp-getting-started/test.csv' )<categorify> | res.to_csv('res.csv', index=None ) | Titanic - Machine Learning from Disaster |
3,808,829 | def remove_shortforms(phrase):
phrase = re.sub(r"won't", "will not", phrase)
phrase = re.sub(r"can't", "can not", phrase)
phrase = re.sub(r"n't", " not", phrase)
phrase = re.sub(r"'re", " are", phrase)
phrase = re.sub(r"'s", " is", phrase)
phrase = re.sub(r"'d", " would", phrase)
phrase = re.sub(r"'ll", " will", ... | discriminant_analysis, tree, gaussian_process, model_selection
| Titanic - Machine Learning from Disaster |
3,808,829 | Y = train['target']
train = train.drop('target',axis=1)
data = pd.concat([train,test],axis=0 ).reset_index(drop=True)
data.head()<feature_engineering> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
3,808,829 | for i in range(len(data['text'])) :
data['text'][i] = str(data['text'][i] )<feature_engineering> | passenger_id = test['PassengerId'].copy() | Titanic - Machine Learning from Disaster |
3,808,829 | for i in range(len(data['text'])) :
data['text'][i] = remove_shortforms(data['text'][i])
data['text'][i] = remove_special_char(data['text'][i])
data['text'][i] = remove_wordswithnum(data['text'][i])
data['text'][i] = lowercase(data['text'][i])
data['text'][i] = remove_stop_words(data['text'][i])
text = data['text'... | traintest = pd.concat([train, test], axis=0, sort=False ) | Titanic - Machine Learning from Disaster |
3,808,829 | cv = CountVectorizer(ngram_range=(1,3))
text_bow = cv.fit_transform(data['text'])
print(text_bow.shape )<split> | isnull = traintest.isnull().sum().reset_index()
isnull.columns = ['Feature', 'Total_null']
total_null = isnull[isnull['Total_null']>0]
total_null | Titanic - Machine Learning from Disaster |
3,808,829 | train_text = text_bow[:train.shape[0]]
test_text = text_bow[train.shape[0]:]<split> | traintest['Title'] = traintest['Name'].str.split(", ", expand=True)[1].str.split(".", expand=True)[0]
replace = {
'Ms': 'Miss',
'Dona': 'Miss',
'Mlle': 'Miss',
'Mme': 'Miss',
'Don': 'Mr',
'Sir': 'Mr'
}
traintest.replace({'Title': replace}, inplace=True ) | Titanic - Machine Learning from Disaster |
3,808,829 | X_train,X_test,Y_train,Y_test = train_test_split(train_text,Y,test_size=0.2)
print(X_train.shape)
print(X_test.shape)
print(Y_train.shape)
print(Y_test.shape )<compute_train_metric> | df_nan_ages = traintest['Age'].isnull()
title_ages = traintest[['Title', 'Age']].groupby('Title' ).mean().to_dict() ['Age']
traintest['Age'][df_nan_ages] = traintest[df_nan_ages]['Title'].apply(lambda x: title_ages[x])
traintest.fillna({
'Fare': traintest['Fare'].mode() [0],
'Embarked': traintest['Embarked'].mode() [0... | Titanic - Machine Learning from Disaster |
3,808,829 | lr = LogisticRegression(C=10,penalty='l2')
lr.fit(X_train,Y_train)
pred = lr.predict(X_test)
print("F1 score :",f1_score(Y_test,pred))
print("Classification Report
:",classification_report(Y_test,pred))<prepare_output> | traintest['FamilySize'] = traintest.SibSp + traintest.Parch + 1
traintest['IsAlone'] =(traintest['FamilySize'] == 1)*1
traintest['AgeStage'] = traintest['Age']
traintest['AgeStage'][traintest['Age'] <= 11] = 'Child'
traintest['AgeStage'][(traintest['Age'] <= 20)&(traintest['Age'] > 11)] = 'Young'
traintest['AgeStage'][... | Titanic - Machine Learning from Disaster |
3,808,829 | lr = LogisticRegression(C=10,penalty='l2',max_iter=2000)
lr.fit(train_text,Y)
pred = lr.predict(test_text)
submit = pd.DataFrame(test['id'],columns=['id'])
print(len(pred))
submit.head()<save_to_csv> | isnull = traintest.isnull().sum().reset_index()
isnull.columns = ['Feature', 'Total_null']
total_null = isnull[isnull['Total_null']>0]
total_null | Titanic - Machine Learning from Disaster |
3,808,829 | submit['target'] = pred
submit.to_csv("realnlp.csv",index=False )<categorify> |
categorical_vars = ["Pclass", "Sex", "Ticket", 'Embarked', 'Title', 'AgeStage']
numerical_vars = ['Fare', 'Age', 'FamilySize', 'Parch', 'SibSp']
traintest_set = []
traintest[categorical_vars] = traintest[categorical_vars].astype('category')
traintest_labelEncoding = traintest.copy()
label_encoder = preprocessing.Lab... | Titanic - Machine Learning from Disaster |
3,808,829 | tfidf = TfidfVectorizer(ngram_range=(1,3))
text_tfidf = tfidf.fit_transform(data['text'])
print(text_tfidf.shape )<split> | X_trains, y_train, X_tests = [], None,[]
for traintest in traintest_set:
train = traintest[traintest['Survived'].notnull() ]
y_train = train['Survived']
X_train = train.drop(columns='Survived')
print("X train shape: ", X_train.shape)
print("Y train shape: ", y_train.shape)
X_trains.append(X_train)
test = traintest[... | Titanic - Machine Learning from Disaster |
3,808,829 | X_train,X_test,Y_train,Y_test = train_test_split(train_text,Y,test_size=0.2)
print(X_train.shape)
print(X_test.shape)
print(Y_train.shape)
print(Y_test.shape )<compute_train_metric> | 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 |
3,808,829 | lr = LogisticRegression(C=100,penalty='l2',max_iter=2000)
lr.fit(X_train,Y_train)
pred = lr.predict(X_test)
print("F1 score :",f1_score(Y_test,pred))
print("Classification Report :",classification_report(Y_test,pred))<count_missing_values> | cv_split = model_selection.ShuffleSplit(n_splits = 10, test_size =.3, train_size =.7, random_state = 0 ) | Titanic - Machine Learning from Disaster |
3,808,829 | print("Number of null values in data keywords column : ",data['keyword'].isnull().sum() )<data_type_conversions> | MLAs = [copy.deepcopy(MLA), copy.deepcopy(MLA)]
MLA_columns = ['MLA Name', 'MLA Parameters','MLA Train Accuracy Mean', 'MLA Test Accuracy Mean', 'MLA Test Accuracy 3*STD' ,'MLA Time']
result_table = []
for i in range(len(X_trains)) :
MLA_compare = pd.DataFrame(columns = MLA_columns)
MLA_predict = y_train.copy()
print(... | Titanic - Machine Learning from Disaster |
3,808,829 | data['keyword'] = data['keyword'].fillna("unknown")
data.head()<feature_engineering> | MLA_compare = result_table[0][0]
MLA_compare.sort_values(by = ['MLA Test Accuracy Mean'], ascending = False, inplace = True)
MLA_compare | Titanic - Machine Learning from Disaster |
3,808,829 | combined_text = [None] * len(data['text'])
for i in range(len(data['text'])) :
if data['keyword'][i] == 'unknown':
combined_text[i] = data['text'][i]
else:
combined_text[i] = data['text'][i] + " " + data['keyword'][i] + " " + data['keyword'][i] + " " + data['keyword'][i]
data['combined_text'] = combined_text<feature_e... | MLA_compare = result_table[1][0]
MLA_compare.sort_values(by = ['MLA Test Accuracy Mean'], ascending = False, inplace = True)
MLA_compare | Titanic - Machine Learning from Disaster |
3,808,829 | for i in range(len(data['combined_text'])) :
data['combined_text'][i] = str(data['combined_text'][i] )<feature_engineering> | prediction_df = pd.DataFrame()
alg_name = 'XGBClassifier'
feature_index = 0
alg_index = 19
prediction = MLAs[feature_index][alg_index].predict(X_tests[feature_index])
temp = {'PassengerID': passenger_id, 'Survived': prediction.astype(int)}
result = pd.DataFrame(temp)
result.to_csv('result_%s_feature%s.csv'%(alg_name,... | 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.