kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
22,263,006 | <merge><EOS> | submission(bert_classifier, test_ds ) | Natural Language Processing with Disaster Tweets |
22,200,665 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<categorify> | !wget --quiet https://raw.githubusercontent.com/tensorflow/models/master/official/nlp/bert/tokenization.py
| Natural Language Processing with Disaster Tweets |
22,200,665 | X_train = prepare_data(df_train, building, weather_train )<set_options> | SEED = 1002
def seed_everything(seed):
np.random.seed(seed)
tf.random.set_seed(seed)
seed_everything(SEED ) | Natural Language Processing with Disaster Tweets |
22,200,665 | del df_train
gc.collect()<create_dataframe> | train = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv")
submission = pd.read_csv("/kaggle/input/nlp-getting-started/sample_submission.csv")
for i, val in enumerate(train.iloc[:2]["text"].to_list()):
print("Tweet {}: {}".format(i+1, val)) | Natural Language Processing with Disaster Tweets |
22,200,665 | def LGBM(X_train, y_train):
X_half_1 = X_train[:int(X_train.shape[0] / 2)]
X_half_2 = X_train[int(X_train.shape[0] / 2):]
y_half_1 = y_train[:int(X_train.shape[0] / 2)]
y_half_2 = y_train[int(X_train.shape[0] / 2):]
categorical_features = ["hour", "weekday"]
d_half_1 = lgb.Dataset(X_half_1, label=y_half_1, categorical_... | def bert_encode(texts, tokenizer, max_len=512):
all_tokens = []
all_masks = []
all_segments = []
for text in texts:
text = tokenizer.tokenize(text)
text = text[:max_len-2]
input_sequence = ["[CLS]"] + text + ["[SEP]"]
pad_len = max_len - len(input_sequence)
tokens = tokenizer.convert_tokens_to_ids(input_sequence)
to... | Natural Language Processing with Disaster Tweets |
22,200,665 | def modeling(X_train, stop=999999):
drop_list = ["building_id", "meter", "meter_reading"]
ids = np.sort(X_train["building_id"].unique())
df_model = pd.DataFrame(columns=["building_id", "meter", "half_1", "half_2"])
index = 0
for bid in ids:
if stop < bid:
break
meters = np.sort(X_train[X_train["building_id"] == bid][... | def build_model(bert_layer, max_len=512):
input_word_ids = Input(shape=(max_len,), dtype=tf.int32, name="input_word_ids")
input_mask = Input(shape=(max_len,), dtype=tf.int32, name="input_mask")
segment_ids = Input(shape=(max_len,), dtype=tf.int32, name="segment_ids")
_, sequence_output = bert_layer([input_word_ids, ... | Natural Language Processing with Disaster Tweets |
22,200,665 | df_model = pd.read_pickle(path_model)
df_model<features_selection> | module_url = "https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/1"
bert_layer = hub.KerasLayer(module_url, trainable=True ) | Natural Language Processing with Disaster Tweets |
22,200,665 | drop_list = ["building_id", "meter", "meter_reading"]
model_names = ["half_1", "half_2"]
colmuns = X_train[(X_train["building_id"] == 0)&(X_train["meter"] == 0)].drop(drop_list, axis=1 ).columns.values
for bid in [31, 15, 75]:
meters = np.sort(X_train[X_train["building_id"] == bid]["meter"].unique())
for meter in mete... | vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = tokenization.FullTokenizer(vocab_file, do_lower_case)
train_input = bert_encode(train.text.values, tokenizer, max_len=160)
test_input = bert_encode(test.text.values, token... | Natural Language Processing with Disaster Tweets |
22,200,665 | del X_train
gc.collect()<load_from_csv> | checkpoint = ModelCheckpoint('model.h5', monitor='val_accuracy', save_best_only=True)
train_history = model.fit(
train_input, train_labels,
validation_split=0.1,
epochs=3,
callbacks=[checkpoint],
batch_size=16
) | Natural Language Processing with Disaster Tweets |
22,200,665 | <set_options><EOS> | test_pred = model.predict(test_input)
submission['target'] = test_pred.round().astype(int)
submission.to_csv('submission.csv', index=False ) | Natural Language Processing with Disaster Tweets |
17,056,491 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<predict_on_test> | !pip install -q transformers ekphrasis keras-tuner | Natural Language Processing with Disaster Tweets |
17,056,491 | def predicting(X_test, df_model, stop=9999999):
drop_list = ["building_id", "meter", "row_id"]
ids = np.sort(X_test["building_id"].unique())
submission = pd.DataFrame(columns=["row_id", "meter_reading"])
for bid in ids:
if stop < bid:
break
meters = np.sort(X_test[X_test["building_id"] == bid]["meter"].unique())
for... | Input,
Dense,
Embedding,
Flatten,
Dropout,
GlobalMaxPooling1D,
GRU,
concatenate,
)
DistilBertTokenizerFast,
TFDistilBertModel,
DistilBertConfig,
)
| Natural Language Processing with Disaster Tweets |
17,056,491 | submission = predicting(X_test, df_model)
submission<save_to_csv> | def print_metrics(model, x_train, y_train, x_val, y_val):
train_acc = dict(model.evaluate(x_train, y_train, verbose=0, return_dict=True)) [
"accuracy"
]
val_acc = dict(model.evaluate(x_val, y_val, verbose=0, return_dict=True)) [
"accuracy"
]
val_preds = model.predict(x_val)
val_preds_bool = val_preds >= 0.5
print("")
... | Natural Language Processing with Disaster Tweets |
17,056,491 | submission.to_csv("submission.csv", index=False )<set_options> | model_class, tokenizer_class, pretrained_weights =(TFDistilBertModel, DistilBertTokenizerFast, 'distilbert-base-uncased')
pretrained_bert_tokenizer = tokenizer_class.from_pretrained(pretrained_weights)
def get_pretrained_bert_model(config=pretrained_weights):
if not config:
config = DistilBertConfig(num_labels=2)
re... | Natural Language Processing with Disaster Tweets |
17,056,491 | py.init_notebook_mode(connected=True)
<set_options> | train_df = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test_df = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv" ) | Natural Language Processing with Disaster Tweets |
17,056,491 | def reduce_mem_usage(df, use_float16=False):
start_mem = df.memory_usage().sum() / 1024**2
print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))
for col in df.columns:
if is_datetime(df[col])or is_categorical_dtype(df[col]):
continue
col_type = df[col].dtype
if col_type != object:
c_min = df[col].min()
c_... | print("label counts:")
train_df.target.value_counts() | Natural Language Processing with Disaster Tweets |
17,056,491 | %%time
root = Path('.. /input/ashrae-feather-format-for-fast-loading')
train_df = pd.read_feather(root/'train.feather')
test_df = pd.read_feather(root/'test.feather')
building_meta_df = pd.read_feather(root/'building_metadata.feather' )<feature_engineering> | print("train precentage of nulls:")
print(round(train_df.isnull().sum() / train_df.count() * 100, 2)) | Natural Language Processing with Disaster Tweets |
17,056,491 | leak_df = pd.read_feather('.. /input/ashrae-leak-data-station/leak.feather')
leak_df.fillna(0, inplace=True)
leak_df = leak_df[(leak_df.timestamp.dt.year > 2016)&(leak_df.timestamp.dt.year < 2019)]
leak_df.loc[leak_df.meter_reading < 0, 'meter_reading'] = 0
leak_df = leak_df[leak_df.building_id!=245]<count_values> | print("test precentage of nulls:")
print(round(test_df.isnull().sum() / test_df.count() * 100, 2)) | Natural Language Processing with Disaster Tweets |
17,056,491 | leak_df.meter.value_counts()<count_duplicates> | classes = np.unique(train_df["target"])
class_weights = sklearn.utils.class_weight.compute_class_weight(
"balanced", classes=classes, y=train_df["target"]
)
class_weights = {clazz : weight for clazz, weight in zip(classes, class_weights)} | Natural Language Processing with Disaster Tweets |
17,056,491 | print(leak_df.duplicated().sum() )<feature_engineering> | train_df.drop_duplicates(subset="text", inplace=True, keep=False)
print("train rows:", len(train_df.index))
print("test rows:", len(test_df.index)) | Natural Language Processing with Disaster Tweets |
17,056,491 | print(len(leak_df)/ len(train_df))<set_options> | class TweetPreProcessor:
def __init__(self):
self.text_processor = TextPreProcessor(
normalize=[
"url",
"email",
"phone",
"user",
"time",
"date",
],
annotate={"repeated", "elongated"},
segmenter="twitter",
spell_correction=True,
corrector="twitter",
unpack_hashtags=False,
unpack_contractions=False,
spell_correct_elo... | Natural Language Processing with Disaster Tweets |
17,056,491 | del train_df
gc.collect()<load_from_csv> | for tweet in train_df[100:120]["text"]:
print("original: ", tweet)
print("processed: ", tweet_preprocessor.preprocess_tweet(tweet))
print("" ) | Natural Language Processing with Disaster Tweets |
17,056,491 | sample_submission1 = pd.read_csv('.. /input/ashrae-kfold-lightgbm-without-leak-1-08/submission.csv', index_col=0)
sample_submission2 = pd.read_csv('.. /input/ashrae-half-and-half/submission.csv', index_col=0)
sample_submission3 = pd.read_csv('.. /input/ashrae-highway-kernel-route4/submission.csv', index_col=0 )<featu... | train_df["text"] = train_df["text"].apply(tweet_preprocessor.preprocess_tweet)
test_df["text"] = test_df["text"].apply(tweet_preprocessor.preprocess_tweet ) | Natural Language Processing with Disaster Tweets |
17,056,491 | test_df['pred1'] = sample_submission1.meter_reading
test_df['pred2'] = sample_submission2.meter_reading
test_df['pred3'] = sample_submission3.meter_reading
test_df.loc[test_df.pred3<0, 'pred3'] = 0
del sample_submission1, sample_submission2, sample_submission3
gc.collect()
test_df = reduce_mem_usage(test_df)
leak_df =... | train_df["keyword"].fillna("", inplace=True)
test_df["keyword"].fillna("", inplace=True)
train_df["keyword"] = train_df["keyword"].apply(urllib.parse.unquote)
test_df["keyword"] = test_df["keyword"].apply(urllib.parse.unquote ) | Natural Language Processing with Disaster Tweets |
17,056,491 | leak_df = leak_df.merge(test_df[['building_id', 'meter', 'timestamp', 'pred1', 'pred2', 'pred3', 'row_id']], left_on = ['building_id', 'meter', 'timestamp'], right_on = ['building_id', 'meter', 'timestamp'], how = "left")
leak_df = leak_df.merge(building_meta_df[['building_id', 'site_id']], on='building_id', how='left... | x_train, x_val, y_train, y_val = sklearn.model_selection.train_test_split(
train_df[["text", "keyword"]], train_df["target"], test_size=0.3, random_state=42, stratify=train_df["target"]
) | Natural Language Processing with Disaster Tweets |
17,056,491 | leak_df['pred1_l1p'] = np.log1p(leak_df.pred1)
leak_df['pred2_l1p'] = np.log1p(leak_df.pred2)
leak_df['pred3_l1p'] = np.log1p(leak_df.pred3)
leak_df['meter_reading_l1p'] = np.log1p(leak_df.meter_reading )<filter> | def tokenize_encode(tweets, max_length=None):
return pretrained_bert_tokenizer(
tweets,
add_special_tokens=True,
truncation=True,
padding="max_length",
max_length=max_length,
return_tensors="tf",
)
max_length_tweet = 72
max_length_keyword = 8
train_tweets_encoded = tokenize_encode(x_train["text"].to_list() , max_len... | Natural Language Processing with Disaster Tweets |
17,056,491 | leak_df[leak_df.pred1_l1p.isnull() ]<compute_train_metric> | train_dataset = tf.data.Dataset.from_tensor_slices(
(dict(train_tweets_encoded), y_train)
)
val_dataset = tf.data.Dataset.from_tensor_slices(
(dict(validation_tweets_encoded), y_val)
)
train_multi_input_dataset = tf.data.Dataset.from_tensor_slices(
(train_inputs_encoded, y_train)
)
val_multi_input_dataset = tf.data.... | Natural Language Processing with Disaster Tweets |
17,056,491 | leak_df['mean_pred'] = np.mean(leak_df[['pred1', 'pred2', 'pred3']].values, axis=1)
leak_df['mean_pred_l1p'] = np.log1p(leak_df.mean_pred)
leak_score = np.sqrt(mean_squared_error(leak_df.mean_pred_l1p, leak_df.meter_reading_l1p))
sns.distplot(leak_df.mean_pred_l1p)
sns.distplot(leak_df.meter_reading_l1p)
print('mea... | tfidf_vectorizer = sklearn.feature_extraction.text.TfidfVectorizer(
tokenizer=tweet_preprocessor, min_df=1, ngram_range=(1, 1), norm="l2"
)
train_vectors = tfidf_vectorizer.fit_transform(raw_documents=x_train["text"] ).toarray()
validation_vectors = tfidf_vectorizer.transform(x_val["text"] ).toarray() | Natural Language Processing with Disaster Tweets |
17,056,491 | N = 10
scores = np.zeros(N,)
for i in range(N):
p = i * 1./N
v = p * leak_df['pred1'].values +(1.-p)* leak_df ['pred3'].values
vl1p = np.log1p(v)
scores[i] = np.sqrt(mean_squared_error(vl1p, leak_df.meter_reading_l1p))<find_best_params> | logisticRegressionClf = LogisticRegression(n_jobs=-1, C=2.78)
logisticRegressionClf.fit(train_vectors, y_train)
def print_metrics_sk(clf, x_train, y_train, x_val, y_val):
print(f"Train Accuracy: {clf.score(x_train, y_train):.2%}")
print(f"Validation Accuracy: {clf.score(x_val, y_val):.2%}")
print("")
print(f"f1 sc... | Natural Language Processing with Disaster Tweets |
17,056,491 | best_weight = np.argmin(scores)* 1./N
print(scores.min() , best_weight )<compute_test_metric> | feature_extractor = get_pretrained_bert_model()
model_outputs = feature_extractor.predict(
train_dataset.batch(32)
)
train_sentence_vectors = model_outputs.last_hidden_state[:, 0, :]
train_word_vectors = model_outputs.last_hidden_state[:, 1:, :]
model_outputs = feature_extractor.predict(
val_dataset.batch(32)
)
val... | Natural Language Processing with Disaster Tweets |
17,056,491 | scores = np.zeros(N,)
for i in range(N):
p = i * 1./N
v = p *(best_weight * leak_df['pred1'].values +(1.-best_weight)* leak_df ['pred3'].values)+(1.-p)* leak_df ['pred2'].values
vl1p = np.log1p(v)
scores[i] = np.sqrt(mean_squared_error(vl1p, leak_df.meter_reading_l1p))<find_best_params> | logisticRegressionClf = LogisticRegression(n_jobs=-1, class_weight=class_weights)
logisticRegressionClf.fit(train_sentence_vectors, y_train)
print_metrics_sk(
logisticRegressionClf,
train_sentence_vectors,
y_train,
validation_sentence_vectors,
y_val,
) | Natural Language Processing with Disaster Tweets |
17,056,491 | best_weight2 = np.argmin(scores)* 1./N
print(scores.min() , best_weight2)
<define_search_space> | def create_gru_model() -> keras.Model:
model = keras.Sequential()
model.add(keras.layers.InputLayer(input_shape=train_word_vectors.shape[1:]))
model.add(GRU(32, return_sequences=True))
model.add(GlobalMaxPooling1D())
model.add(Dense(1, activation="sigmoid"))
model.compile(
optimizer=keras.optimizers.Adam() ,
loss="bi... | Natural Language Processing with Disaster Tweets |
17,056,491 | all_combinations = list(np.linspace(0.2,0.5,31))
all_combinations<import_modules> | def create_multi_input_model() -> keras.Model:
keyword_ids = keras.Input(( 8,), name="keywords")
keyword_features = Embedding(input_dim=feature_extractor.config.vocab_size, output_dim=16, input_length=8, mask_zero=True )(keyword_ids)
keyword_features = Flatten()(keyword_features)
keyword_features = Dense(1 )(keyword... | Natural Language Processing with Disaster Tweets |
17,056,491 | import itertools<concatenate> | def create_multi_input_rnn_model() -> keras.Model:
keyword_ids = keras.Input(( 8,), name="keywords")
keyword_features = Embedding(input_dim=feature_extractor.config.vocab_size, output_dim=16, input_length=8, mask_zero=True )(keyword_ids)
keyword_features = Flatten()(keyword_features)
keyword_features = Dense(1 )(key... | Natural Language Processing with Disaster Tweets |
17,056,491 | l = [all_combinations, all_combinations, all_combinations]
all_l = list(itertools.product(*l)) + list(itertools.product(*reversed(l)) )<define_variables> | def create_candidate_model_with_fx(hp: kerastuner.HyperParameters)-> keras.Model:
keyword_ids = keras.Input(( 8,), name="keywords")
keyword_features = Embedding(input_dim=feature_extractor.config.vocab_size, output_dim=16, input_length=8, mask_zero=True )(keyword_ids)
keyword_features = Flatten()(keyword_features)
k... | Natural Language Processing with Disaster Tweets |
17,056,491 | filtered_combis = [l for l in all_l if l[0] + l[1] + l[2] > 0.95 and l[0] + l[1] + l[2] < 1.05]<compute_test_metric> | MAX_EPOCHS = 10
FACTOR = 3
ITERATIONS = 3
print(f"Number of models in each bracket: {math.ceil(1 + math.log(MAX_EPOCHS, FACTOR)) }")
print(f"Number of epochs over all trials: {round(ITERATIONS *(MAX_EPOCHS *(math.log(MAX_EPOCHS, FACTOR)** 2)))}" ) | Natural Language Processing with Disaster Tweets |
17,056,491 | best_combi = []
for i, combi in enumerate(filtered_combis):
score1 = combi[0]
score2 = combi[1]
score3 = combi[2]
v = score1 * leak_df['pred1'].values + score2 * leak_df['pred3'].values + score3 * leak_df['pred2'].values
vl1p = np.log1p(v)
curr_score = np.sqrt(mean_squared_error(vl1p, leak_df.meter_reading_l1p))
if be... | tuner = kerastuner.Hyperband(
create_candidate_model_with_fx,
max_epochs=MAX_EPOCHS,
hyperband_iterations=ITERATIONS,
factor=FACTOR,
objective="val_accuracy",
directory="hyperparam-search",
project_name="architecture-hyperband",
)
tuner.search(
train_inputs,
y_train,
validation_data=(validation_inputs, y_val),
clas... | Natural Language Processing with Disaster Tweets |
17,056,491 | sample_submission = pd.read_feather(os.path.join(root, 'sample_submission.feather'))
final_combi = filtered_combis[best_combi[0][0]]
w1 = final_combi[0]
w2 = final_combi[1]
w3 = final_combi[2]
print("The weights are: w1=" + str(w1)+ ", w2=" + str(w2)+ ", w3=" + str(w3))
sample_submission['meter_reading'] = w1 * test_df... | best_model = tuner.get_best_models() [0]
print("")
best_arch_hp = tuner.get_best_hyperparameters() [0]
pprint.pprint(best_arch_hp.values, indent=4)
print("")
print_metrics(best_model, train_inputs, y_train, validation_inputs, y_val ) | Natural Language Processing with Disaster Tweets |
17,056,491 | leak_df = leak_df[['meter_reading', 'row_id']].set_index('row_id' ).dropna()
sample_submission.loc[leak_df.index, 'meter_reading'] = leak_df['meter_reading']<save_to_csv> | def create_bert_simple_for_ft() :
input_ids = Input(shape=(max_length_tweet,), dtype="int32", name="input_ids")
attention_mask = Input(shape=(max_length_tweet,), dtype="int32", name="attention_mask")
pretrained_bert_model = get_pretrained_bert_model()
bert_outputs = pretrained_bert_model(input_ids, attention_mask)
p... | Natural Language Processing with Disaster Tweets |
17,056,491 | sample_submission.to_csv('submission.csv', index=False, float_format='%.4f' )<load_from_csv> | def create_bert_rnn_for_ft() :
pretrained_bert_model = get_pretrained_bert_model()
keyword_ids = keras.Input(( 8,), name="keywords")
keyword_features = Embedding(input_dim=pretrained_bert_model.config.vocab_size, output_dim=16, input_length=8, mask_zero=True )(keyword_ids)
keyword_features = Flatten()(keyword_feature... | Natural Language Processing with Disaster Tweets |
17,056,491 | register_matplotlib_converters()
sub = None
for dirname, _, filenames in os.walk('/kaggle/input/ultimaincercare/'):
for filename in filenames:
filename = os.path.join(dirname, filename)
print(filename)
if sub is None:
sub = pd.read_csv(filename)
else:
sub.meter_reading += pd.read_csv(filename, usecols=['meter_readin... | def create_model_candidate() -> keras.Model:
pretrained_bert_model = get_pretrained_bert_model()
keyword_ids = keras.Input(( 8,), name="keywords")
keyword_features = Embedding(input_dim=pretrained_bert_model.config.vocab_size, output_dim=16, input_length=8, mask_zero=True )(keyword_ids)
keyword_features = Flatten()(k... | Natural Language Processing with Disaster Tweets |
17,056,491 | sub.to_csv(f'submission-final-1.csv', index=False, float_format='%g' )<import_modules> | model = create_model_candidate()
history = model.fit(
train_multi_input_dataset.batch(32),
validation_data=val_multi_input_dataset.batch(32),
epochs=6,
class_weight=class_weights,
callbacks=[
keras.callbacks.EarlyStopping(
monitor="val_accuracy", restore_best_weights=True
)
],
)
best_epoch = len(history.history["... | Natural Language Processing with Disaster Tweets |
17,056,491 | FileLink('submission-final-1.csv' )<define_variables> | test_tweets_encoded = tokenize_encode(test_df["text"].to_list() , max_length_tweet)
test_inputs_encoded = dict(test_tweets_encoded)
test_dataset = tf.data.Dataset.from_tensor_slices(test_inputs_encoded)
test_keywords_encoded = tokenize_encode(test_df["keyword"].to_list() , max_length_keyword)
test_inputs_encoded["k... | Natural Language Processing with Disaster Tweets |
17,056,491 | path_data = "/kaggle/input/ashrae-energy-prediction/"
path_train = path_data + "train.csv"
path_test = path_data + "test.csv"
path_building = path_data + "building_metadata.csv"
path_weather_train = path_data + "weather_train.csv"
path_weather_test = path_data + "weather_test.csv"
myfavouritenumber = 13
seed = myfavour... | full_train_dataset = train_multi_input_dataset.concatenate(val_multi_input_dataset)
model = create_model_candidate()
model.fit(
full_train_dataset.batch(32),
epochs=best_epoch,
class_weight=class_weights,
) | Natural Language Processing with Disaster Tweets |
17,056,491 | <set_options><EOS> | preds = np.squeeze(model.predict(test_multi_input_dataset.batch(32)))
preds =(preds >= 0.5 ).astype(int)
pd.DataFrame({"id": test_df.id, "target": preds} ).to_csv("submission.csv", index=False ) | Natural Language Processing with Disaster Tweets |
17,120,655 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<categorify> | import numpy as np
import pandas as pd
import os
| Natural Language Processing with Disaster Tweets |
17,120,655 | df_train = reduce_mem_usage(df_train, use_float16=True)
df_test = reduce_mem_usage(df_test, use_float16=True)
weather_train.timestamp = pd.to_datetime(weather_train.timestamp, format='%Y-%m-%d %H:%M:%S')
weather_test.timestamp = pd.to_datetime(weather_test.timestamp, format='%Y-%m-%d %H:%M:%S')
weather_train = redu... | import re
import seaborn as sns
import matplotlib.pyplot as plt
from collections import defaultdict, Counter
from sklearn.feature_extraction.text import CountVectorizer
import nltk
from nltk.corpus import stopwords
from wordcloud import WordCloud
from nltk.tokenize import word_tokenize | Natural Language Processing with Disaster Tweets |
17,120,655 | df_train["hour"] = df_train.timestamp.dt.hour
df_train["weekday"] = df_train.timestamp.dt.weekday
df_test["hour"] = df_test.timestamp.dt.hour
df_test["weekday"] = df_test.timestamp.dt.weekday<merge> | nltk.download('stopwords', quiet=True)
stopwords = stopwords.words('english')
sns.set(style="white", font_scale=1.2)
plt.rcParams["figure.figsize"] = [10,8]
pd.set_option.display_max_columns = 0
pd.set_option.display_max_rows = 0 | Natural Language Processing with Disaster Tweets |
17,120,655 | df_building_meter = df_train.groupby(["building_id", "meter"] ).agg(mean_building_meter=("log_meter_reading", "mean"),
median_building_meter=("log_meter_reading", "median")).reset_index()
df_train = df_train.merge(df_building_meter, on=["building_id", "meter"])
df_test = df_test.merge(df_building_meter, on=["building_... | train = pd.read_csv(".. /input/nlp-getting-started/train.csv")
test = pd.read_csv(".. /input/nlp-getting-started/test.csv" ) | Natural Language Processing with Disaster Tweets |
17,120,655 | def create_lag_features(df, window):
feature_cols = ["air_temperature", "cloud_coverage", "dew_temperature", "precip_depth_1_hr"]
df_site = df.groupby("site_id")
df_rolled = df_site[feature_cols].rolling(window=window, min_periods=0)
df_mean = df_rolled.mean().reset_index().astype(np.float16)
df_median = df_rolled... | null_counts = pd.DataFrame({"Num_Null": train.isnull().sum() })
null_counts["Pct_Null"] = null_counts["Num_Null"] / train.count() * 100
null_counts | Natural Language Processing with Disaster Tweets |
17,120,655 | weather_train = create_lag_features(weather_train, 18)
weather_train.drop(["air_temperature", "cloud_coverage", "dew_temperature", "precip_depth_1_hr"], axis=1, inplace=True)
df_train = df_train.merge(weather_train, on=["site_id", "timestamp"], how="left")
del weather_train
gc.collect()<define_variables> | len(train["keyword"].value_counts() ) | Natural Language Processing with Disaster Tweets |
17,120,655 | categorical_features = [
"building_id",
"primary_use",
"meter",
"weekday",
"hour"
]
all_features = [col for col in df_train.columns if col not in ["timestamp", "site_id", "meter_reading", "log_meter_reading"]]<split> | disaster_keywords = train.loc[train["target"] == 1]["keyword"].value_counts()
nondisaster_keywords = train.loc[train["target"] == 0]["keyword"].value_counts()
| Natural Language Processing with Disaster Tweets |
17,120,655 | cv = 2
models = {}
cv_scores = {"site_id": [], "cv_score": []}
for site_id in tqdm(range(16), desc="site_id"):
print(cv, "fold CV for site_id:", site_id)
kf = KFold(n_splits=cv, random_state=seed)
models[site_id] = []
X_train_site = df_train[df_train.site_id==site_id].reset_index(drop=True)
y_train_site = X_train_si... | def keyword_disaster_probabilities(x):
tweets_w_keyword = np.sum(train["keyword"].fillna("" ).str.contains(x))
tweets_w_keyword_disaster = np.sum(train["keyword"].fillna("" ).str.contains(x)& train["target"] == 1)
return tweets_w_keyword_disaster / tweets_w_keyword
keywords_vc["Disaster_Probability"] = keywords_vc.ind... | Natural Language Processing with Disaster Tweets |
17,120,655 | pd.DataFrame.from_dict(cv_scores )<drop_column> | keywords_vc.sort_values(by="Disaster_Probability", ascending=False ).head(10 ) | Natural Language Processing with Disaster Tweets |
17,120,655 | del df_train, X_train_site, y_train_site, X_train, y_train, dtrain, X_valid, y_valid, dvalid, y_pred_train_site, y_pred_valid, rmse, score, cv_scores
gc.collect()<drop_column> | len(train["location"].value_counts() ) | Natural Language Processing with Disaster Tweets |
17,120,655 | weather_test = create_lag_features(weather_test, 18)
weather_test.drop(["air_temperature", "cloud_coverage", "dew_temperature", "precip_depth_1_hr"], axis=1, inplace=True )<merge> | def create_corpus(target):
corpus = []
for w in train.loc[train["target"] == target]["text"].str.split() :
for i in w:
corpus.append(i)
return corpus
def create_corpus_dict(target):
corpus = create_corpus(target)
stop_dict = defaultdict(int)
for word in corpus:
if word in stopwords:
stop_dict[word] += 1
return sorte... | Natural Language Processing with Disaster Tweets |
17,120,655 | df_test_sites = []
for site_id in tqdm(range(16), desc="site_id"):
print("Preparing test data for site_id", site_id)
X_test_site = df_test[df_test.site_id==site_id]
weather_test_site = weather_test[weather_test.site_id==site_id]
X_test_site = X_test_site.merge(weather_test_site, on=["site_id", "timestamp"], how="left"... | corpus_disaster, corpus_non_disaster = create_corpus(1), create_corpus(0)
counter_disaster, counter_non_disaster = Counter(corpus_disaster), Counter(corpus_non_disaster)
x_disaster, y_disaster, x_non_disaster, y_non_disaster = [], [], [], []
counter = 0
for word, count in counter_disaster.most_common() [0:100]:
if(wo... | Natural Language Processing with Disaster Tweets |
17,120,655 | df_test_site.loc[df_test_site['site_id']==0, 'meter_reading'] = df_test_site.loc[df_test_site['site_id']==0, 'meter_reading'] * 3.4118<save_to_csv> | def bigrams(target):
corpus = train[train["target"] == target]["text"]
count_vec = CountVectorizer(ngram_range=(2, 2)).fit(corpus)
bag_of_words = count_vec.transform(corpus)
sum_words = bag_of_words.sum(axis=0)
words_freq = [(word, sum_words[0, idx])for word, idx in count_vec.vocabulary_.items() ]
words_freq =sorted... | Natural Language Processing with Disaster Tweets |
17,120,655 | submit = pd.concat(df_test_sites)
submit.meter_reading = np.clip(np.expm1(submit.meter_reading), 0, a_max=None)
submit.to_csv("submission_noleak.csv", index=False )<load_from_csv> | def remove_pattern(input_txt, pattern):
r = re.findall(pattern, input_txt)
for i in r:
input_txt = re.sub(i, '', input_txt)
return input_txt | Natural Language Processing with Disaster Tweets |
17,120,655 | leak0 = pd.read_csv("/kaggle/input/ashrae-leak-data/site0.csv")
leak1 = pd.read_csv("/kaggle/input/ashrae-leak-data/site1.csv")
leak2 = pd.read_csv("/kaggle/input/ashrae-leak-data/site2.csv")
leak4 = pd.read_csv("/kaggle/input/ashrae-leak-data/site4.csv")
leak15 = pd.read_csv("/kaggle/input/ashrae-leak-data/site15.... | train['tweet'] = np.vectorize(remove_pattern )(train['text'], "
test['tweet'] = np.vectorize(remove_pattern )(test['text'], "
train.head() | Natural Language Processing with Disaster Tweets |
17,120,655 | import os, gc
import datetime
import numpy as np
import pandas as pd
import category_encoders
from sklearn.impute import SimpleImputer
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import KFold
from sklearn.preprocessing import LabelEncoder
from sklearn.linear_model import Lasso
from sklea... | train['tweet'] = train['tweet'].str.replace("[^a-zA-Z
test['tweet'] = test['tweet'].str.replace("[^a-zA-Z
train.head() | Natural Language Processing with Disaster Tweets |
17,120,655 | PATH = '.. /input/ashrae-energy-prediction/'<load_from_csv> | train['tweet'] = train['tweet'].apply(lambda x: ' '.join([w for w in x.split() if len(w)>3]))
test['tweet'] = test['tweet'].apply(lambda x: ' '.join([w for w in x.split() if len(w)>3]))
train.head()
| Natural Language Processing with Disaster Tweets |
17,120,655 | train = pd.read_csv(f'{PATH}train.csv')
weather_train = pd.read_csv(f'{PATH}weather_train.csv')
metadata = pd.read_csv(f'{PATH}building_metadata.csv' )<filter> | train['tweet'] = train['tweet'].str.lower()
test['tweet'] = test['tweet'].str.lower() | Natural Language Processing with Disaster Tweets |
17,120,655 | train = train[train['building_id'] != 1099]
train = train.query('not(building_id <= 104 & meter == 0 & timestamp <= "2016-05-20")' )<define_variables> | set(stopwords.words('english'))
stops = set(stopwords.words('english')) | Natural Language Processing with Disaster Tweets |
17,120,655 | def weather_data_parser(weather_data)-> pd.DataFrame:
time_format = '%Y-%m-%d %H:%M:%S'
start_date = datetime.datetime.strptime(weather_data['timestamp'].min() , time_format)
end_date = datetime.datetime.strptime(weather_data['timestamp'].max() , time_format)
total_hours = int(((end_date - start_date ).total_seconds(... | train['tokenized_sents'] = train.apply(lambda row: nltk.word_tokenize(row['tweet']), axis=1)
test['tokenized_sents'] = test.apply(lambda row: nltk.word_tokenize(row['tweet']), axis=1)
| Natural Language Processing with Disaster Tweets |
17,120,655 | weather_train = weather_data_parser(weather_train )<categorify> | def remove_stops(row):
my_list = row['tokenized_sents']
meaningful_words = [w for w in my_list if not w in stops]
return(meaningful_words ) | Natural Language Processing with Disaster Tweets |
17,120,655 | train = reduce_mem_usage(train, use_float16=True)
weather_train = reduce_mem_usage(weather_train, use_float16=True)
metadata = reduce_mem_usage(metadata, use_float16=True )<merge> | train['clean_tweet'] = train.apply(remove_stops, axis=1)
test['clean_tweet'] = test.apply(remove_stops, axis=1)
train.drop(["tweet","tokenized_sents"], axis = 1, inplace = True)
test.drop(["tweet","tokenized_sents"], axis = 1, inplace = True)
| Natural Language Processing with Disaster Tweets |
17,120,655 | train = train.merge(metadata, on='building_id', how='left')
train = train.merge(weather_train, on=['site_id', 'timestamp'], how='left')
del weather_train; gc.collect()<feature_engineering> | def rejoin_words(row):
my_list = row['clean_tweet']
joined_words =(" ".join(my_list))
return joined_words
train['clean_tweet'] = train.apply(rejoin_words, axis=1)
test['clean_tweet'] = test.apply(rejoin_words, axis=1)
train.head() | Natural Language Processing with Disaster Tweets |
17,120,655 | def data_parser(data)-> pd.DataFrame:
data.sort_values('timestamp')
data.reset_index(drop=True)
data['timestamp'] = pd.to_datetime(data['timestamp'], format='%Y-%m-%d %H:%M:%S')
data['weekday'] = data['timestamp'].dt.weekday
data['hour'] = data['timestamp'].dt.hour
data['square_feet'] = np.log1p(data['square_feet'])... | import gc
import time
import math
import random
import warnings | Natural Language Processing with Disaster Tweets |
17,120,655 | train = data_parser(train )<prepare_x_and_y> | warnings.filterwarnings("ignore" ) | Natural Language Processing with Disaster Tweets |
17,120,655 | target = np.log1p(train['meter_reading'])
features = train.drop(['meter_reading'], axis = 1)
del train; gc.collect()<categorify> | import string
import folium
from colorama import Fore, Back, Style, init
| Natural Language Processing with Disaster Tweets |
17,120,655 | categorical_features = ['building_id', 'site_id', 'meter', 'primary_use']
encoder = category_encoders.CountEncoder(cols=categorical_features)
encoder.fit(features)
features = encoder.transform(features)
features_size = features.shape[0]
for feature in categorical_features:
features[feature] = features[feature] / fea... | import scipy as sp
import networkx as nx
from pandas import Timestamp
from PIL import Image
from IPython.display import SVG
from keras.utils import model_to_dot
import requests
from IPython.display import HTML | Natural Language Processing with Disaster Tweets |
17,120,655 | imputer = SimpleImputer(missing_values=np.nan, strategy='median')
imputer.fit(features)
features = imputer.transform(features )<choose_model_class> | tqdm.pandas() | Natural Language Processing with Disaster Tweets |
17,120,655 | lightgbm = LGBMRegressor(objective='regression', learning_rate=0.05, num_leaves=1024,
feature_fraction=0.8, bagging_fraction=0.9, bagging_freq=5)
ridge = Ridge(alpha=0.3)
lasso = Lasso(alpha=0.3 )<find_best_model_class> | import plotly.express as px
import plotly.graph_objects as go
import plotly.figure_factory as ff
from plotly.subplots import make_subplots
import transformers
import tensorflow as tf | Natural Language Processing with Disaster Tweets |
17,120,655 | kfold = KFold(n_splits=2, shuffle=False)
models = []
for idx,(train_idx, val_idx)in enumerate(kfold.split(features)) :
train_features, train_target = features[train_idx], target[train_idx]
val_features, val_target = features[val_idx], target[val_idx]
model = StackingRegressor(regressors=(lightgbm, ridge, lasso),
meta_... | from tensorflow.keras.callbacks import Callback
from sklearn.metrics import accuracy_score, roc_auc_score
from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau, CSVLogger
| Natural Language Processing with Disaster Tweets |
17,120,655 | test = pd.read_csv(f'{PATH}test.csv')
weather_test = pd.read_csv(f'{PATH}weather_test.csv' )<drop_column> | from tensorflow.keras.models import Model
from kaggle_datasets import KaggleDatasets
from tensorflow.keras.optimizers import Adam
from tokenizers import BertWordPieceTokenizer
from tensorflow.keras.layers import Dense, Input, Dropout, Embedding
from tensorflow.keras.layers import LSTM, GRU, Conv1D, SpatialDropout1D
| Natural Language Processing with Disaster Tweets |
17,120,655 | row_ids = test['row_id']
test.drop('row_id', axis=1, inplace=True )<feature_engineering> | from tensorflow.keras import layers
from tensorflow.keras import optimizers
from tensorflow.keras import activations
from tensorflow.keras import constraints
from tensorflow.keras import initializers
from tensorflow.keras import regularizers
import tensorflow.keras.backend as K
from tensorflow.keras.layers import *
fro... | Natural Language Processing with Disaster Tweets |
17,120,655 | weather_test = weather_data_parser(weather_test )<normalization> | from sklearn import metrics
from sklearn.utils import shuffle
from gensim.models import Word2Vec
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA
from sklearn.feature_extraction.text import TfidfVectorizer,CountVectorizer,HashingVectorizer
from sklearn.model_selection import train_test_split
fro... | Natural Language Processing with Disaster Tweets |
17,120,655 | test = reduce_mem_usage(test, use_float16=True)
weather_test = reduce_mem_usage(weather_test, use_float16=True )<merge> | from nltk.stem.wordnet import WordNetLemmatizer
from nltk.tokenize import word_tokenize
from nltk.tokenize import TweetTokenizer
import nltk
from textblob import TextBlob
from nltk.corpus import wordnet
from nltk.corpus import stopwords
from nltk import WordNetLemmatizer
from nltk.stem import WordNetLemmatizer,PorterSt... | Natural Language Processing with Disaster Tweets |
17,120,655 | test = test.merge(metadata, on='building_id', how='left')
test = test.merge(weather_test, on=['site_id', 'timestamp'], how='left')
del metadata; gc.collect()<categorify> | stopword=set(STOPWORDS)
lem = WordNetLemmatizer()
tokenizer=TweetTokenizer()
np.random.seed(0)
random_state = 42 | Natural Language Processing with Disaster Tweets |
17,120,655 | test = data_parser(test)
test = encoder.transform(test)
for feature in categorical_features:
test[feature] = test[feature] / features_size
test = imputer.transform(test )<predict_on_test> | !pip install GPUtil
| Natural Language Processing with Disaster Tweets |
17,120,655 | predictions = 0
for model in models:
predictions += np.expm1(model.predict(np.array(test)))/ len(models)
del model; gc.collect()
del test, models; gc.collect()<save_to_csv> | from torch import nn
from transformers import AdamW, BertConfig, BertModel, BertTokenizer
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler, TensorDataset, random_split
from transformers import get_linear_schedule_with_warmup
from sklearn.metrics import f1_score, accuracy_score | Natural Language Processing with Disaster Tweets |
17,120,655 | submission = pd.DataFrame({
'row_id': row_ids,
'meter_reading': np.clip(predictions, 0, a_max=None)
})
submission.to_csv('submission.csv', index=False, float_format='%.4f' )<import_modules> | def free_gpu_cache() :
print("Initial GPU Usage")
gpu_usage()
torch.cuda.empty_cache()
cuda.select_device(0)
cuda.close()
cuda.select_device(0)
for obj in gc.get_objects() :
if torch.is_tensor(obj):
del obj
gc.collect()
print("GPU Usage after emptying the cache")
gpu_usage() | Natural Language Processing with Disaster Tweets |
17,120,655 | import numpy as np
import sys
import pandas as pd
from skimage.io import imread, imsave
from skimage.color import gray2rgb
from skimage.color import rgb2gray
import matplotlib.pyplot as plt
from functools import reduce
import os<load_from_csv> | from torch import nn
from transformers import AdamW, BertConfig, BertModel, BertTokenizer
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler, TensorDataset, random_split
from transformers import get_linear_schedule_with_warmup
from sklearn.metrics import f1_score, accuracy_score | Natural Language Processing with Disaster Tweets |
17,120,655 | sub = pd.read_csv(".. /input/ashrae-energy-prediction/sample_submission.csv" )<import_modules> | train = pd.read_csv(".. /input/nlp-getting-started/train.csv" ).loc[:,["text","target"]]
train | Natural Language Processing with Disaster Tweets |
17,120,655 |
<load_from_csv> | if torch.cuda.is_available() :
device = torch.device("cuda")
else:
device = torch.device("cpu")
device | Natural Language Processing with Disaster Tweets |
17,120,655 | df0 = pd.read_csv(".. /input/ashrae-public/ashrae-highway-kernel-route2.csv")
df1 = pd.read_csv(".. /input/ashrae-public/ashrae-leak-validation-and-more.csv")
df2 = pd.read_csv(".. /input/ashrae-public/ashrae-leak-validation-bruteforce-heuristic-search.csv")
df3 = pd.read_csv(".. /input/ashrae-public/ashrae-may-make... | dupli_sum = train.duplicated().sum()
if(dupli_sum>0):
print(dupli_sum, " duplicates found
removing...")
train = train.loc[False==train.duplicated() , :]
else:
print("no duplicates found")
train | Natural Language Processing with Disaster Tweets |
17,120,655 | blend1 = df0['meter_reading']*0.5 + df4['meter_reading']*0.3 + df5['meter_reading']*0.2<prepare_output> | X_train = train["text"].values
y_train = train["target"].values | Natural Language Processing with Disaster Tweets |
17,120,655 | sub['meter_reading'] = blend1
df11 = sub<define_variables> | tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True)
lens = []
for text in X_train:
encoded_dict = tokenizer.encode_plus(text, add_special_tokens=True, return_tensors='pt')
lens.append(encoded_dict['input_ids'].size() [1] ) | Natural Language Processing with Disaster Tweets |
17,120,655 | blend2 = df11['meter_reading']*0.1 + df1['meter_reading']*0.15 + df2['meter_reading']*0.6 + df3['meter_reading']*0.15<load_from_csv> | sequence_length = 58
X_train_tokens = []
for text in X_train:
encoded_dict = tokenizer.encode_plus(text,
add_special_tokens=True,
max_length=sequence_length,
padding="max_length",
return_tensors='pt',
truncation=True)
X_train_tokens.append(encoded_dict['input_ids'] ) | Natural Language Processing with Disaster Tweets |
17,120,655 | sub1 = pd.read_csv(".. /input/ashrae-energy-prediction/sample_submission.csv" )<feature_engineering> | X_train_tokens = torch.cat(X_train_tokens, dim=0)
y_train = torch.tensor(y_train ) | Natural Language Processing with Disaster Tweets |
17,120,655 | sub1['meter_reading'] = blend2
sub1.head()<save_to_csv> | print('Original:
', X_train[5])
print('Tokenization:
', X_train_tokens[5] ) | Natural Language Processing with Disaster Tweets |
17,120,655 | sub1.to_csv(f'submission.csv', index=False, float_format='%g' )<import_modules> | batch_size = 32
dataset = TensorDataset(X_train_tokens, y_train.float())
train_size = int(0.80 * len(dataset))
val_size = len(dataset)- train_size
train_set, val_set = random_split(dataset, [train_size, val_size])
train_dataloader = DataLoader(train_set,
sampler=RandomSampler(train_set),
batch_size=batch_size)
valid... | Natural Language Processing with Disaster Tweets |
17,120,655 | print(os.listdir(".. /input"))
<load_from_csv> | bert = BertModel.from_pretrained("bert-base-uncased")
bert.to(device)
for batch in train_dataloader:
batch_features = batch[0].to(device)
bert_output = bert(input_ids=batch_features)
print("bert output: ", type(bert_output), len(bert_output))
print("first entry: ", type(bert_output[0]), bert_output[0].size())
prin... | Natural Language Processing with Disaster Tweets |
17,120,655 | EMBEDDING_FILE = '.. /input/glove840b300dtxt/glove.840B.300d.txt'
train_df = pd.read_csv('.. /input/jigsaw-toxic-comment-classification-challenge/train.csv')
test_df = pd.read_csv('.. /input/jigsaw-toxic-comment-classification-challenge/test.csv')
MAX_SEQUENCE_LENGTH = 150
MAX_NB_WORDS = 100000
EMBEDDING_DIM = 300
VA... | class BertClassifier(nn.Module):
def __init__(self):
super(BertClassifier, self ).__init__()
self.bert = BertModel.from_pretrained('bert-base-uncased')
self.linear = nn.Linear(768, 1)
self.sigmoid = nn.Sigmoid()
def forward(self, tokens):
bert_output = self.bert(input_ids=tokens)
linear_output = self.linear(bert_out... | Natural Language Processing with Disaster Tweets |
17,120,655 | color = sns.color_palette()
sns.set_style("dark" )<string_transform> | def eval(y_batch, probas):
preds_batch_np = np.round(probas.cpu().detach().numpy())
y_batch_np = y_batch.cpu().detach().numpy()
acc = accuracy_score(y_true=y_batch_np, y_pred=preds_batch_np)
f1 = f1_score(y_true=y_batch_np, y_pred=preds_batch_np, average='weighted')
return acc, f1
| Natural Language Processing with Disaster Tweets |
17,120,655 | def cleanData(text, stemming = False, lemmatize=False):
text = text.lower().split()
text = " ".join(text)
text = re.sub(r"[^A-Za-z0-9^,!.\/'+\-=]", " ", text)
text = re.sub(r"what's", "what is ", text)
text = re.sub(r"'s", " ", text)
text = re.sub(r"'ve", " have ", text)
text = re.sub(r"can't", "cannot ", text)
t... | def train(model, optimizer, scheduler, epochs, name):
history = []
best_f1 = 0
model.train()
for epoch in range(epochs):
print("=== Epoch: ", epoch+1, " / ", epochs, " ===")
acc_total = 0
f1_total = 0
for it, batch in enumerate(train_dataloader):
x_batch, y_batch = [batch[0].to(device), batch[1].to(device)]
probas = t... | Natural Language Processing with Disaster Tweets |
17,120,655 | print('Indexing word vectors')
count = 0
embeddings_index = {}
f = open(EMBEDDING_FILE)
for line in f:
values = line.split()
word = ' '.join(values[:-300])
coefs = np.asarray(values[-300:], dtype='float32')
embeddings_index[word] = coefs.reshape(-1)
coef = embeddings_index[word]
f.close()
print('Found %d word vect... | epochs = 10
baseline_bert_clf = BertClassifier()
baseline_bert_clf = baseline_bert_clf.to(device)
adam = AdamW(baseline_bert_clf.parameters() , lr=5e-5, eps=1e-8)
total_steps = len(train_dataloader)* epochs
sched = get_linear_schedule_with_warmup(adam, num_warmup_steps=0, num_training_steps=total_steps ) | Natural Language Processing with Disaster Tweets |
17,120,655 | import os
import re
import csv
import codecs
import numpy as np
import pandas as pd
from nltk.corpus import stopwords
from nltk.stem import SnowballStemmer
from string import punctuation
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from keras.layers import *
from... | baseline_bert_clf, history = train(model=baseline_bert_clf,
optimizer=adam,
scheduler=sched,
epochs=10,
name="baseline_bert_clf" ) | Natural Language Processing with Disaster Tweets |
17,120,655 | print('Processing text dataset')
train_df['comment_text'] = train_df['comment_text'].map(lambda x: cleanData(x, stemming=False, lemmatize=False))
test_df['comment_text'] = test_df['comment_text'].map(lambda x: cleanData(x, stemming=False, lemmatize=False))
special_character_removal=re.compile(r'[^a-z\d ]',re.IGNORECAS... | history_df = pd.DataFrame(history)
history_df | Natural Language Processing with Disaster Tweets |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.