kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,292,835 | model = Sequential()
model.add(Conv2D(64,(3,3), padding='same', input_shape=(28, 28, 1)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Conv2D(64,(3,3), padding='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Conv2D(128,(3,3), padding='same'))
model.add(Batc... | submission = pd.DataFrame(
{'id': list(test_df.index.values),
'target': list(classes),
} ).set_index('id' ) | Natural Language Processing with Disaster Tweets |
11,292,835 | <set_options><EOS> | submission.to_csv('submission.csv' ) | Natural Language Processing with Disaster Tweets |
10,997,615 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<choose_model_class> | pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 1000 ) | Natural Language Processing with Disaster Tweets |
10,997,615 | reduce_lr = LearningRateScheduler(scheduler)
epochs = 20
batch_size = 128<train_model> | train = pd.read_csv('.. /input/nlp-getting-started/train.csv',)
test = pd.read_csv('.. /input/nlp-getting-started/test.csv')
submission = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv" ) | Natural Language Processing with Disaster Tweets |
10,997,615 | model.fit_generator(datagen.flow(train_X,train_Y, batch_size=batch_size),
epochs = epochs, steps_per_epoch = math.ceil(train_X.shape[0]*1.0/batch_size),
validation_data =(val_X,val_Y), callbacks=[reduce_lr],verbose=1 )<load_from_csv> | train['word_count'] = train['text'].apply(lambda x: len(str(x ).split()))
test['word_count'] = test['text'].apply(lambda x: len(str(x ).split()))
train['unique_word_count'] = train['text'].apply(lambda x: len(set(str(x ).split())))
test['unique_word_count'] = test['text'].apply(lambda x: len(set(str(x ).split())))
tr... | Natural Language Processing with Disaster Tweets |
10,997,615 | test_csv = pd.read_csv(".. /input/Kannada-MNIST/test.csv" )<predict_on_test> | def generate_ngrams(text,ngram=1, n=None):
vec = CountVectorizer(ngram_range=(ngram, ngram)).fit(text)
bag_of_words = vec.transform(text)
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... | Natural Language Processing with Disaster Tweets |
10,997,615 | results = np.zeros(( X_test.shape[0],10))
results = model.predict(X_test)
results = np.argmax(results,axis = 1 )<save_to_csv> | def remove_URL(text):
url = re.compile(r'https?://\S+|www\.\S+')
return url.sub(r'',text)
train['text'] = train['text'].apply(lambda x: remove_URL(x))
test['text'] = test['text'].apply(lambda x: remove_URL(x)) | Natural Language Processing with Disaster Tweets |
10,997,615 | submission = pd.read_csv(".. /input/Kannada-MNIST/sample_submission.csv")
submission['label'] = results
submission.to_csv("submission.csv",index=False )<load_from_csv> | PUNCT_TO_REMOVE = string.punctuation
def remove_punctuation(text):
return text.translate(str.maketrans(' ',' ',PUNCT_TO_REMOVE))
train['text'] = train['text'].apply(lambda text: remove_punctuation(text))
test['text'] = test['text'].apply(lambda text: remove_punctuation(text)) | Natural Language Processing with Disaster Tweets |
10,997,615 | data = pd.read_csv('/kaggle/input/Kannada-MNIST/train.csv')
print(data.shape)
test_data = pd.read_csv('/kaggle/input/Kannada-MNIST/test.csv')
print(test_data.shape )<prepare_x_and_y> | def remove_special_char(text):
text = text.replace('\r',' ')
text = text.replace('
',' ')
text = text.replace('\t',' ')
return text
train['text'] = train['text'].apply(lambda x: remove_special_char(x))
test['text'] = test['text'].apply(lambda x: remove_special_char(x)) | Natural Language Processing with Disaster Tweets |
10,997,615 | train = data[:]
val = data[55000:]
train_label = np.float32(train.label)
val_label = np.float32(val.label)
train_image = np.float32(train[train.columns[1:]])
val_image = np.float32(val[val.columns[1:]])
test_image = np.float32(test_data[test_data.columns[1:]] )<choose_model_class> | def clean(tweet):
tweet = re.sub(r"\x89Û_", "", tweet)
tweet = re.sub(r"\x89ÛÒ", "", tweet)
tweet = re.sub(r"\x89ÛÓ", "", tweet)
tweet = re.sub(r"\x89ÛÏWhen", "When", tweet)
tweet = re.sub(r"\x89ÛÏ", "", tweet)
tweet = re.sub(r"China\x89Ûªs", "China's", tweet)
tweet = re.sub(r"let\x89Ûªs", "let's", tweet)
tweet ... | Natural Language Processing with Disaster Tweets |
10,997,615 | datagen = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.2,
height_shift_range=0.2,
zoom_range=0.15 )<categorify> | train['text'] = train['text'].apply(lambda x: clean(x))
test['text'] = test['text'].apply(lambda x: clean(x)) | Natural Language Processing with Disaster Tweets |
10,997,615 | encoder = OneHotEncoder(sparse=False,categories='auto')
yy = [[0],[1],[2],[3],[4],[5],[6],[7],[8],[9]]
encoder.fit(yy)
train_label = train_label.reshape(-1,1)
val_label = val_label.reshape(-1,1)
train_label = encoder.transform(train_label)
val_label = encoder.transform(val_label)
print('train_label shape: %s'%str... | abbreviations = {
"$" : " dollar ",
"€" : " euro ",
"4ao" : "for adults only",
"a.m" : "before midday",
"a3" : "anytime anywhere anyplace",
"aamof" : "as a matter of fact",
"acct" : "account",
"adih" : "another day in hell",
"afaic" : "as far as i am concerned",
"afaict" : "as far as i can tell",
"afaik" : "as far as i... | Natural Language Processing with Disaster Tweets |
10,997,615 | model = Sequential()
model.add(Conv2D(64, kernel_size=3, activation='relu', input_shape=(28, 28, 1),padding='same'))
model.add(BatchNormalization())
model.add(Conv2D(64, kernel_size=3, activation='relu',padding='same'))
model.add(BatchNormalization())
model.add(Conv2D(64, kernel_size=3, padding='same', activation='re... | def convert_abbrev(word):
return abbreviations[word.lower() ] if word.lower() in abbreviations.keys() else word | Natural Language Processing with Disaster Tweets |
10,997,615 | BATCH_SIZE = 128
EPOCHS = 40
model.compile(loss='categorical_crossentropy',optimizer=Adadelta() ,metrics=['accuracy'])
datagen.fit(train_image)
history = model.fit_generator(datagen.flow(train_image,train_label, batch_size=BATCH_SIZE),
epochs = EPOCHS,
validation_data =(val_image,val_label),
verbose = 1,
steps_per_ep... | def convert_abbrev_in_text(text):
text = text.lower()
tokens = word_tokenize(text)
tokens = [convert_abbrev(word)for word in tokens]
text = ' '.join(tokens)
return text
train['text'] = train['text'].apply(lambda x: convert_abbrev_in_text(x))
test['text'] = test['text'].apply(lambda x: convert_abbrev_in_text(x)) | Natural Language Processing with Disaster Tweets |
10,997,615 | label = model.predict(test_image)
label = np.argmax(label,1)
id_ = np.arange(0,label.shape[0] )<load_from_csv> | def remove_digit(text):
return re.sub('\w*\d+',' ',text)
train['text'] = train['text'].apply(lambda text: remove_digit(text))
test['text'] = test['text'].apply(lambda text: remove_digit(text)) | Natural Language Processing with Disaster Tweets |
10,997,615 | sim = pd.read_csv('/kaggle/input/Kannada-MNIST/sample_submission.csv')
print(sim.head(10))<save_to_csv> | def extra_space(text):
return re.sub(r'\s+', ' ',text)
train['text'] = train['text'].apply(lambda text: extra_space(text))
test['text'] = test['text'].apply(lambda text: extra_space(text)) | Natural Language Processing with Disaster Tweets |
10,997,615 | save = pd.DataFrame({'id':id_,'label':label})
print(save.head(10))
save.to_csv('submission.csv',index=False )<define_variables> | nlp = spacy.load('en_core_web_lg')
def stop_word_lemma(text):
doc = nlp(text)
text1 = ''
for token in doc:
if not token.is_stop:
text1 = text1+ ' '+ token.lemma_
return text1
train['text'] = train['text'].apply(lambda text: stop_word_lemma(text))
test['text'] = test['text'].apply(lambda text: stop_word_lemma(text)) | Natural Language Processing with Disaster Tweets |
10,997,615 | tqdm.pandas()
MAX_LEN = 96
PATH = '.. /input/tf-roberta/'
tokenizer = tokenizers.ByteLevelBPETokenizer(
vocab_file=PATH+'vocab-roberta-base.json',
merges_file=PATH+'merges-roberta-base.txt',
lowercase=True,
add_prefix_space=True
)
EPOCHS = 3
BATCH_SIZE = 32
PAD_ID = 1
SEED = 88888
LABEL_SMOOTHING = 0.1
tf.random.set... | cnt = Counter()
for text in train['text'].values:
for word in text.split() :
cnt[word]+=1
cnt.most_common(10 ) | Natural Language Processing with Disaster Tweets |
10,997,615 | train.isnull().sum()<count_missing_values> | FREQ_WORDS = set([w for(w,wc)in cnt.most_common(5)])
def remove_freqwords(text):
return " ".join([word for word in text.split() if word not in FREQ_WORDS])
train['text'] = train['text'].apply(lambda text: remove_freqwords(text))
test['text'] = test['text'].apply(lambda text: remove_freqwords(text)) | Natural Language Processing with Disaster Tweets |
10,997,615 | train.isnull().sum()<count_missing_values> | n_rare_words = 10
RAREWORDS = set([w for(w,wc)in cnt.most_common() [:-n_rare_words-1: -1]])
def remove_rarewords(text):
return " ".join([word for word in str(text ).split() if word not in RAREWORDS])
train['text'] = train['text'].apply(lambda text: remove_rarewords(text))
test['text'] = test['text'].apply(lambda text... | Natural Language Processing with Disaster Tweets |
10,997,615 | train = train.dropna(axis = 0)
train.isnull().sum()<string_transform> | X = train.text
Y = train.target
X_train,X_test,Y_train,Y_test = train_test_split(X,Y,test_size=0.15 ) | Natural Language Processing with Disaster Tweets |
10,997,615 | def process(text, selected_text, ib_space):
added_extra_space = False
splitted = text.split(selected_text)
if splitted[0][-1] == ' ':
added_extra_space = True
splitted = text.split(" " + selected_text)
sub = len(splitted[0])- len(" ".join(splitted[0].split()))
if sub == 1 and text[0] == ' ':
splitted = text.split(sel... | clf = Pipeline([("vectorizer", TfidfVectorizer(max_features = 10000,ngram_range=(1,2))),("classifier", OneVsRestClassifier(LogisticRegression() , n_jobs = 4)) ] ) | Natural Language Processing with Disaster Tweets |
10,997,615 | train['new_selected_text'] = train.selected_text
train = train[train.textID != '12f21c8f19']
train['new_selected_text'] = train.progress_apply(lambda x: process_selected_text(x.text, x.selected_text), axis=1 )<save_to_csv> | clf.fit(X_train, Y_train ) | Natural Language Processing with Disaster Tweets |
10,997,615 | train.to_csv('new_train.csv',index = False )<load_from_csv> | y_pred = clf.predict(X_test)
accuracy_score(Y_test,y_pred ) | Natural Language Processing with Disaster Tweets |
10,997,615 | train = pd.read_csv('/kaggle/working/new_train.csv')
train.head(5 )<define_variables> | !wget --quiet https://raw.githubusercontent.com/tensorflow/models/master/official/nlp/bert/tokenization.py | Natural Language Processing with Disaster Tweets |
10,997,615 | ct = train.shape[0]
input_ids = np.ones(( ct,MAX_LEN),dtype='int32')
attention_mask = np.zeros(( ct,MAX_LEN),dtype='int32')
token_type_ids = np.zeros(( ct,MAX_LEN),dtype='int32')
start_tokens = np.zeros(( ct,MAX_LEN),dtype='int32')
end_tokens = np.zeros(( ct,MAX_LEN),dtype='int32')
for k in range(train.shape[0]):
... | import tensorflow as tf
from tensorflow.keras.layers import Dense, Input
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.models import Model
from tensorflow.keras.callbacks import ModelCheckpoint
import tensorflow_hub as hub
import tokenization
| Natural Language Processing with Disaster Tweets |
10,997,615 | def save_weights(model, dst_fn):
weights = model.get_weights()
with open(dst_fn, 'wb')as f:
pickle.dump(weights, f)
def load_weights(model, weight_fn):
with open(weight_fn, 'rb')as f:
weights = pickle.load(f)
model.set_weights(weights)
return model
def loss_fn(y_true, y_pred):
ll = tf.shape(y_pred)[1]
y_true = y_tru... | 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 |
10,997,615 | def jaccard(str1, str2):
a = set(str1.lower().split())
b = set(str2.lower().split())
if(len(a)==0)&(len(b)==0): return 0.5
c = a.intersection(b)
return float(len(c)) /(len(a)+ len(b)- len(c))<define_variables> | Dropout_num =0
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([i... | Natural Language Processing with Disaster Tweets |
10,997,615 | jac = []; VER='v0'; DISPLAY=1
oof_start = np.zeros(( input_ids.shape[0],MAX_LEN))
oof_end = np.zeros(( input_ids.shape[0],MAX_LEN))
preds_start = np.zeros(( input_ids_t.shape[0],MAX_LEN))
preds_end = np.zeros(( input_ids_t.shape[0],MAX_LEN))
skf = StratifiedKFold(n_splits=5,shuffle=True,random_state=SEED)
for fold,(id... | from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from keras.models import Sequential
from keras.layers import Embedding, LSTM,Dense, SpatialDropout1D, Dropout
from keras.initializers import Constant
from keras.optimizers import Adam | Natural Language Processing with Disaster Tweets |
10,997,615 | print('>>>> OVERALL 5Fold CV Jaccard =',np.mean(jac))<save_to_csv> | module_url = 'https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/1'
bert_layer = hub.KerasLayer(module_url, trainable=True ) | Natural Language Processing with Disaster Tweets |
10,997,615 | all = []
for k in range(input_ids_t.shape[0]):
a = np.argmax(preds_start[k,])
b = np.argmax(preds_end[k,])
if a>b:
st = test.loc[k,'text']
else:
text1 = " "+" ".join(test.loc[k,'text'].split())
enc = tokenizer.encode(text1)
st = tokenizer.decode(enc.ids[a-2:b-1])
all.append(st)
test['selected_text'] = all
test[['... | 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 ) | Natural Language Processing with Disaster Tweets |
10,997,615 | import numpy as np
import pandas as pd
import os
import tokenizers
import string
import torch
import transformers
import torch.nn as nn
from torch.nn import functional as F
from tqdm import tqdm
import pickle
import re
import string
<define_variables> | train_input = bert_encode(train.text.values, tokenizer, max_len=160)
test_input = bert_encode(test.text.values, tokenizer, max_len=160)
train_labels = train.target.values | Natural Language Processing with Disaster Tweets |
10,997,615 | MAX_LEN = 168
VALID_BATCH_SIZE = 8
EPOCHS = 5
ROBERTA_PATH = ".. /input/roberta-base"
ROBERTA_PATH_NEW = ".. /input/rb-base"
TOKENIZER = tokenizers.ByteLevelBPETokenizer(
vocab_file=f"{ROBERTA_PATH}/vocab.json",
merges_file=f"{ROBERTA_PATH}/merges.txt",
lowercase=True,
add_prefix_space=True
)<choose_model_class> | learning_rate = 1e-5
model_BERT = build_model(bert_layer, max_len=160)
model_BERT.summary() | Natural Language Processing with Disaster Tweets |
10,997,615 | class TweetModel(transformers.BertPreTrainedModel):
def __init__(self, conf):
super(TweetModel, self ).__init__(conf)
self.roberta = transformers.RobertaModel.from_pretrained(ROBERTA_PATH, config=conf)
self.drop_out = nn.Dropout(0.3)
self.l0 = nn.Linear(768, 2)
torch.nn.init.normal_(self.l0.weight, std=0.02)
def f... | checkpoint = ModelCheckpoint('model_BERT.h5', monitor='val_loss', save_best_only=True)
train_history = model_BERT.fit(
train_input, train_labels,
validation_split = 0.1,
epochs = 5,
callbacks=[checkpoint],
batch_size = 16
) | Natural Language Processing with Disaster Tweets |
10,997,615 | link_re = re.compile('http[s]?://\S+')
re_username = '^(\_)\w+'
re_username2 = '^@(\_)\w+'
def clean_text(text, sentiment):
cleaned_text = " ".join(str(text ).split() ).strip()
if sentiment != 'neutral':
if '_it_good' in text or '_in_love' in text or '_violence' in text:
return text
if re.search(re_username, cleaned_t... | model_BERT.load_weights('model_BERT.h5')
test_pred_BERT = model_BERT.predict(test_input)
test_pred_BERT_int = test_pred_BERT.round().astype('int' ) | Natural Language Processing with Disaster Tweets |
10,997,615 | def process_data(tweet, selected_text, sentiment, tokenizer, max_len):
tweet = " " + " ".join(str(tweet ).split())
selected_text = " " + " ".join(str(selected_text ).split())
len_st = len(selected_text)- 1
idx0 = None
idx1 = None
for ind in(i for i, e in enumerate(tweet)if e == selected_text[1]):
if " " + tweet[ind: ... | pred = pd.DataFrame(test_pred_BERT, columns=['preds'])
pred.plot.hist() | Natural Language Processing with Disaster Tweets |
10,997,615 | class TweetDataset:
def __init__(self, tweet, sentiment, selected_text):
self.tweet = tweet
self.sentiment = sentiment
self.selected_text = selected_text
self.tokenizer = TOKENIZER
self.max_len = MAX_LEN
def __len__(self):
return len(self.tweet)
def __getitem__(self, item):
data = process_data(
self.tweet[item],
self... | submission['target'] = test_pred_BERT_int
submission.head(10 ) | Natural Language Processing with Disaster Tweets |
10,997,615 | punc = "!."
def postprocess(text, predicted_text):
splitted = text.split(predicted_text)[0]
sub = len(splitted)- len(" ".join(splitted.split()))
splitted1 = text.split(predicted_text.strip())[0]
sub1 = len(splitted1)- len(" ".join(splitted1.split()))
if sub1 == 2 and text.strip() != predicted_text.strip() and text[:2] ... | submission.to_csv("submission.csv", index=False, header=True ) | Natural Language Processing with Disaster Tweets |
10,967,380 |
<define_variables> | if torch.cuda.is_available() :
device = torch.device("cuda")
print('There are %d GPU(s)available.' % torch.cuda.device_count())
print('We will use the GPU:', torch.cuda.get_device_name(0))
else:
print('No GPU available, using the CPU instead.')
device = torch.device("cpu" ) | Natural Language Processing with Disaster Tweets |
10,967,380 | def calculate_jaccard_score(
original_tweet,
target_string,
sentiment_val,
idx_start,
idx_end,
offsets,
verbose=False):
if idx_end < idx_start:
idx_end = idx_start
filtered_output = ""
for ix in range(idx_start, idx_end + 1):
filtered_output += original_tweet[offsets[ix][0]: offsets[ix][1]]
if(ix+1)< len(offsets)and o... | train_df = pd.read_csv('/kaggle/input/nlp-getting-started/train.csv',encoding='UTF-8')
print('Number of training sentences: {:,}
'.format(train_df.shape[0]))
train_df.sample(10 ) | Natural Language Processing with Disaster Tweets |
10,967,380 | df_test = pd.read_csv(".. /input/tweet-sentiment-extraction/test.csv")
df_test.loc[:, "selected_text"] = df_test.text.values<load_from_csv> | with open('.. /input/bert-prediction/predictions.pkl','rb')as f:
predictions = pickle.load(f)
| Natural Language Processing with Disaster Tweets |
10,967,380 |
<load_pretrained> | train_df['infold_pred'] = predictions['infold_pred']
train_df['outfold_pred'] = predictions['outfold_pred'] | Natural Language Processing with Disaster Tweets |
10,967,380 | device = torch.device("cuda")
model_config = transformers.RobertaConfig.from_pretrained(ROBERTA_PATH)
<define_variables> | remove_rows_based_on_cv = True
model_name = 'albert'
model_shortcut_name = 'albert-base-v1'
do_lower_case = True
learning_rate = 5e-6
epochs = 6
batch_size = 16
run_test_to_get_best_epoch = False
epochs_final = 2
score_to_take_best = 'val_f1_score'
score_to_take_best_order = False | Natural Language Processing with Disaster Tweets |
10,967,380 | MODEL_BASE_PATH_OLD = '.. /input/roberta-base-uncased4'
MODEL_BASE_PATH = '.. /input/roberta-pp2'<choose_model_class> | if remove_rows_based_on_cv:
train_df = train_df[(( train_df['target']==0)&(train_df['outfold_pred']<0.3)) |(( train_df['target']==1)&(train_df['outfold_pred']>0.7)) ] | Natural Language Processing with Disaster Tweets |
10,967,380 | ENSEMBLES = [
{'model': TweetModel(conf=model_config), 'state_dict': f"{MODEL_BASE_PATH}/model_0.bin", 'weight': 1},
{'model': TweetModel(conf=model_config), 'state_dict': f"{MODEL_BASE_PATH}/model_1.bin", 'weight': 1},
{'model': TweetModel(conf=model_config), 'state_dict': f"{MODEL_BASE_PATH}/model_2.bin", 'weight': 1... | train_df.index = range(train_df.shape[0] ) | Natural Language Processing with Disaster Tweets |
10,967,380 | models = []
weights = []
for val in ENSEMBLES:
model = val['model']
model.to(device)
model.load_state_dict(torch.load(val['state_dict']))
model.eval()
models.append(model)
weights.append(val['weight'] )<find_best_params> | sentences = train_df.text.values
labels = train_df.target.values | Natural Language Processing with Disaster Tweets |
10,967,380 | def get_best_start_end_idxs(_start_logits, _end_logits):
best_logit = -1000
best_idxs = None
for start_idx, start_logit in enumerate(_start_logits):
for end_idx, end_logit in enumerate(_end_logits[start_idx:]):
logit_sum =(start_logit + end_logit ).item()
if logit_sum > best_logit:
best_logit = logit_sum
best_idxs =(st... | if model_name == 'roberta':
print('Loading RoBERTa tokenizer...')
tokenizer = RobertaTokenizer.from_pretrained(model_shortcut_name, do_lower_case=do_lower_case)
elif model_name == 'bert':
print('Loading BERT tokenizer...')
tokenizer = BertTokenizer.from_pretrained(model_shortcut_name, do_lower_case=do_lower_case)
e... | Natural Language Processing with Disaster Tweets |
10,967,380 | final_output = []
test_dataset = TweetDataset(
tweet=df_test.text.values,
sentiment=df_test.sentiment.values,
selected_text=df_test.selected_text.values
)
data_loader = torch.utils.data.DataLoader(
test_dataset,
shuffle=False,
batch_size=VALID_BATCH_SIZE,
num_workers=1
)
with torch.no_grad() :
tk0 = tqdm(data_loa... | print(' Original: ', sentences[0])
print('Tokenized: ', tokenizer.tokenize(sentences[0]))
print('Token IDs: ', tokenizer.convert_tokens_to_ids(tokenizer.tokenize(sentences[0])) ) | Natural Language Processing with Disaster Tweets |
10,967,380 | df_test['selected_text'] = final_output
df_test['selected_text'] = df_test.apply(lambda x: postprocess(x.text, x.selected_text), axis=1 )<string_transform> | max_len = 0
for sent in sentences:
input_ids = tokenizer.encode(sent, add_special_tokens=True)
max_len = max(max_len, len(input_ids))
print('Max sentence length: ', max_len ) | Natural Language Processing with Disaster Tweets |
10,967,380 | def place_in_back(x):
splitted = x.text.split(x.selected_text)[0]
sub = len(splitted)- len(" ".join(splitted.split()))
select=x.selected_text
ind = x.text.find(x.selected_text.strip())-1
if(( ind >0)&(select.startswith('.')!=1)&(sub>0)) :
if(( x.text[ind] in string.punctuation)&(x.sentiment!='neutral')&(sub==1)) :
sele... | input_ids = []
attention_masks = []
for sent in sentences:
encoded_dict = tokenizer.encode_plus(
sent,
add_special_tokens = True,
max_length = 100,
pad_to_max_length = True,
return_attention_mask = True,
return_tensors = 'pt',
)
input_ids.append(encoded_dict['input_ids'])
attention_masks.append(encoded_dict['attent... | Natural Language Processing with Disaster Tweets |
10,967,380 | df_test['selected_text']=df_test.apply(lambda x : place_in_back(x),axis=1 )<feature_engineering> | dataset = TensorDataset(input_ids, attention_masks, labels)
train_size = int(0.9 * len(dataset))
val_size = len(dataset)- train_size
train_dataset, val_dataset = random_split(dataset, [train_size, val_size])
label_temp_list = []
for a,b,c in train_dataset:
label_temp_list.append(c)
print('{:>5,} training samples'.fo... | Natural Language Processing with Disaster Tweets |
10,967,380 | sample = pd.read_csv(".. /input/tweet-sentiment-extraction/sample_submission.csv")
sample.loc[:, 'selected_text'] = df_test['selected_text']
sample['selected_text'] = sample['selected_text'].apply(lambda x: x.replace('!!!', '!')if len(x.split())==1 else x)
sample['selected_text'] = sample['selected_text'].apply(lambd... | train_dataloader = DataLoader(
train_dataset,
sampler = RandomSampler(train_dataset),
batch_size = batch_size
)
full_train_dataloader = DataLoader(
dataset,
sampler = SequentialSampler(dataset),
batch_size = batch_size
)
validation_dataloader = DataLoader(
val_dataset,
sampler = SequentialSampler(val_dataset),
b... | Natural Language Processing with Disaster Tweets |
10,967,380 | import os
import torch
import pandas as pd
import torch.nn as nn
import numpy as np
import torch.nn.functional as F
from torch.optim import lr_scheduler
from sklearn import model_selection
from sklearn.model_selection import KFold
from sklearn import metrics
from transformers import RobertaModel, RobertaConfig
import t... | def start_model(model_name,model_shortcut_name):
if model_name == 'bert':
model = BertForSequenceClassification.from_pretrained(
model_shortcut_name,
num_labels = 2,
output_attentions = False,
output_hidden_states = False,
)
elif model_name == 'roberta':
model = RobertaForSequenceClassification.from_pretrained(
mod... | Natural Language Processing with Disaster Tweets |
10,967,380 | class config:
MAX_LEN = 128
TRAIN_BATCH_SIZE = 64
VALID_BATCH_SIZE = 16
EPOCHS = 3
MODEL_PATH = ".. /input/roberta-base/pytorch_model.bin"
TRAINING_FILE = ".. /input/tweet-sentiment-extraction/train.csv"
TOKENIZER = tokenizers.ByteLevelBPETokenizer(
vocab_file='.. /input/roberta-base/vocab.json',
merges_file='.. /inpu... | model = start_model(model_name,model_shortcut_name ) | Natural Language Processing with Disaster Tweets |
10,967,380 | def run(fold):
dfx = pd.read_csv(config.TRAINING_FILE)
kf = KFold(n_splits = 10, shuffle = True, random_state = 42)
kf_r = next(kf.split(dfx), None)
df_train = dfx.iloc[kf_r[0]].reset_index(drop=True)
df_valid = dfx.iloc[kf_r[1]].reset_index(drop=True)
train_dataset = TweetDataset(
tweet=df_train.text.values,
sen... | params = list(model.named_parameters())
print('The BERT model has {:} different named parameters.
'.format(len(params)))
print('==== Embedding Layer ====
')
for p in params[0:5]:
print("{:<55} {:>12}".format(p[0], str(tuple(p[1].size()))))
print('
==== First Transformer ====
')
for p in params[5:21]:
print("{:<55}... | Natural Language Processing with Disaster Tweets |
10,967,380 | for fold in range(3):
print(f"Fold={fold}")
run(fold )<find_best_params> | def get_optimizer_and_scheduler(learning_rate,train_dataloader,epochs):
optimizer = AdamW(model.parameters() ,
lr = learning_rate,
eps = 1e-8
)
total_steps = len(train_dataloader)* epochs
scheduler = get_linear_schedule_with_warmup(optimizer,
num_warmup_steps = 0,
num_training_steps = total_steps)
return optimizer,s... | Natural Language Processing with Disaster Tweets |
10,967,380 | device = torch.device("cuda")
modelo1 = TweetModel()
modelo1.to(device)
modelo1.load_state_dict(torch.load("modelo_0.bin"))
modelo1.eval()
modelo2 = TweetModel()
modelo2.to(device)
modelo2.load_state_dict(torch.load("modelo_1.bin"))
modelo2.eval()
modelo3 = TweetModel()
modelo3.to(device)
modelo3.load_state_dict(to... | optimizer,scheduler = get_optimizer_and_scheduler(learning_rate,train_dataloader,epochs ) | Natural Language Processing with Disaster Tweets |
10,967,380 | final_output = []
df_test = pd.read_csv(".. /input/tweet-sentiment-extraction/test.csv")
df_test.loc[:, "selected_text"] = df_test.text.values<create_dataframe> | def flat_accuracy(preds, labels):
pred_flat = np.argmax(preds, axis=1 ).flatten()
labels_flat = labels.flatten()
return np.sum(pred_flat == labels_flat)/ len(labels_flat ) | Natural Language Processing with Disaster Tweets |
10,967,380 | test_dataset = TweetDataset(
tweet=df_test.text.values,
sentiment=df_test.sentiment.values,
selected_text=df_test.selected_text.values
)
data_loader = torch.utils.data.DataLoader(
test_dataset,
shuffle=False,
batch_size=config.VALID_BATCH_SIZE,
num_workers=1
)
with torch.no_grad() :
tk0 = tqdm(data_loader, total=... | def flat_f1_score(preds, labels):
pred_flat = np.argmax(preds, axis=1 ).flatten()
labels_flat = labels.flatten()
return f1_score(labels_flat,pred_flat ) | Natural Language Processing with Disaster Tweets |
10,967,380 | submission = pd.read_csv(".. /input/tweet-sentiment-extraction/sample_submission.csv")
submission.loc[:, 'selected_text'] = final_output
submission.to_csv("submission.csv", index=False )<import_modules> | if run_test_to_get_best_epoch:
seed_val = 66
random.seed(seed_val)
np.random.seed(seed_val)
torch.manual_seed(seed_val)
torch.cuda.manual_seed_all(seed_val)
training_stats = []
total_t0 = time.time()
for epoch_i in range(0, epochs):
print("")
print('======== Epoch {:} / {:} ========'.format(epoch_i + 1, epochs))
p... | Natural Language Processing with Disaster Tweets |
10,967,380 | import numpy as np
import pandas as pd
import os
import tokenizers
import string
import torch
import transformers
import torch.nn as nn
from torch.nn import functional as F
from tqdm.autonotebook import tqdm
import re
from torch.optim import lr_scheduler
from sklearn import model_selection
from sklearn import metrics
f... | if run_test_to_get_best_epoch:
df_stats = pd.DataFrame(data=training_stats)
df_stats = df_stats.set_index('epoch')
print(df_stats.to_csv() ) | Natural Language Processing with Disaster Tweets |
10,967,380 | class config:
MAX_LEN = 128
TRAIN_BATCH_SIZE = 64
VALID_BATCH_SIZE = 32
EPOCHS = 3
ELECTRA_PATH = "/kaggle/input/electrabase/electra/base/model"
MODEL_PATH = "pytorch_model.bin"
TRAINING_FILE = ".. /input/tweet-train-folds/train_folds.csv"
TOKENIZER = tokenizers.BertWordPieceTokenizer(
"/kaggle/input/berthub/assets/vo... | if run_test_to_get_best_epoch:
pd.set_option('precision', 3)
df_stats | Natural Language Processing with Disaster Tweets |
10,967,380 | PATH="/kaggle/output"<string_transform> | Natural Language Processing with Disaster Tweets | |
10,967,380 | def jaccard(str1, str2):
a = set(str1.lower().split())
b = set(str2.lower().split())
c = a.intersection(b)
return float(len(c)) /(len(a)+ len(b)- len(c))<init_hyperparams> | Natural Language Processing with Disaster Tweets | |
10,967,380 | class AverageMeter:
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
class EarlyStopping:
def __init__(self, patience=20, mode="max", delta=0.001):
sel... | if run_test_to_get_best_epoch:
best_epoch = df_stats.sort_values(score_to_take_best,ascending=score_to_take_best_order ).head(1 ).index[0]
if epochs_final:
best_epoch = epochs_final
print(best_epoch ) | Natural Language Processing with Disaster Tweets |
10,967,380 | def process_data(tweet, selected_text, sentiment, tokenizer, max_len):
len_st = len(selected_text)
idx0 = None
idx1 = None
for ind in(i for i, e in enumerate(tweet)if e == selected_text[0]):
if tweet[ind: ind+len_st] == selected_text:
idx0 = ind
idx1 = ind + len_st - 1
break
char_targets = [0] * len(tweet)
if idx0 !=... | model = start_model(model_name,model_shortcut_name)
optimizer,scheduler = get_optimizer_and_scheduler(learning_rate,full_train_dataloader,best_epoch ) | Natural Language Processing with Disaster Tweets |
10,967,380 | class TweetDataset:
def __init__(self, tweet, sentiment, selected_text):
self.tweet = tweet
self.sentiment = sentiment
self.selected_text = selected_text
self.tokenizer = config.TOKENIZER
self.max_len = config.MAX_LEN
def __len__(self):
return len(self.tweet)
def __getitem__(self, item):
data = process_data(
self.twe... | seed_val = 66
random.seed(seed_val)
np.random.seed(seed_val)
torch.manual_seed(seed_val)
torch.cuda.manual_seed_all(seed_val)
training_stats = []
total_t0 = time.time()
for epoch_i in range(0, best_epoch):
print("")
print('======== Epoch {:} / {:} ========'.format(epoch_i + 1, best_epoch))
print('Training...')
t0... | Natural Language Processing with Disaster Tweets |
10,967,380 | class TweetModel(transformers.BertPreTrainedModel):
def __init__(self, conf):
super(TweetModel, self ).__init__(conf)
self.bert = transformers.ElectraModel.from_pretrained(config.ELECTRA_PATH, config=conf)
self.drop_out = nn.Dropout(0.2)
self.l0 = nn.Linear(768 * 2, 2)
torch.nn.init.normal_(self.l0.weight, std=0.00... | df = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv')
submission = pd.read_csv("/kaggle/input/nlp-getting-started/sample_submission.csv")
print('Number of test sentences: {:,}
'.format(df.shape[0]))
sentences = df.text.values
input_ids = []
attention_masks = []
for sent in sentences:
encoded_dict = tokenizer... | Natural Language Processing with Disaster Tweets |
10,967,380 | def loss_fn(start_logits, end_logits, start_positions, end_positions):
loss_fct = nn.CrossEntropyLoss()
start_loss = loss_fct(start_logits, start_positions)
end_loss = loss_fct(end_logits, end_positions)
total_loss =(start_loss + end_loss)
return total_loss
def train_fn(data_loader, model, optimizer, device, schedul... | print('Predicting labels for {:,} test sentences...'.format(len(input_ids)))
model.eval()
predictions , true_labels = [], []
for batch in prediction_dataloader:
batch = tuple(t.to(device)for t in batch)
b_input_ids, b_input_mask = batch
with torch.no_grad() :
outputs = model(b_input_ids, token_type_ids=None,
attentio... | Natural Language Processing with Disaster Tweets |
10,967,380 | def calculate_jaccard_score(
original_tweet,
target_string,
sentiment_val,
idx_start,
idx_end,
offsets,
verbose=False):
if idx_end < idx_start:
idx_end = idx_start
filtered_output = ""
for ix in range(idx_start, idx_end + 1):
filtered_output += original_tweet[offsets[ix][0]: offsets[ix][1]]
if(ix+1)< len(offsets)and o... | flat_predictions = np.concatenate(predictions, axis=0)
flat_predictions = np.argmax(flat_predictions, axis=1 ).flatten()
df['target'] = flat_predictions
| Natural Language Processing with Disaster Tweets |
10,967,380 | def run(fold):
dfx = pd.read_csv(config.TRAINING_FILE)
df_train = dfx[dfx.kfold != fold].reset_index(drop=True)
df_valid = dfx[dfx.kfold == fold].reset_index(drop=True)
train_dataset = TweetDataset(
tweet=df_train.text.values,
sentiment=df_train.sentiment.values,
selected_text=df_train.selected_text.values
)
trai... | submission['target'] = flat_predictions
submission.to_csv('torch_prediction.csv', index=False ) | Natural Language Processing with Disaster Tweets |
10,967,380 | df_test = pd.read_csv(".. /input/tweet-sentiment-extraction/test.csv")
df_test.loc[:, "selected_text"] = df_test.text.values<normalization> | Natural Language Processing with Disaster Tweets | |
10,967,380 | device = torch.device("cuda")
model_config = transformers.ElectraConfig.from_pretrained(config.ELECTRA_PATH)
model_config.output_hidden_states = True<load_pretrained> | Natural Language Processing with Disaster Tweets | |
10,967,380 | model1 = TweetModel(conf=model_config)
model1.to(device)
model1.load_state_dict(torch.load(".. /input/tweetmodel1/example_run_5(1 ).bin"))
model1.eval()
<create_dataframe> | Natural Language Processing with Disaster Tweets | |
10,967,380 | final_output = []
test_dataset = TweetDataset(
tweet=df_test.text.values,
sentiment=df_test.sentiment.values,
selected_text=df_test.selected_text.values
)
data_loader = torch.utils.data.DataLoader(
test_dataset,
shuffle=False,
batch_size=config.VALID_BATCH_SIZE,
num_workers=1
)
with torch.no_grad() :
tk0 = tqdm(d... | Natural Language Processing with Disaster Tweets | |
10,967,380 | <save_to_csv><EOS> | Natural Language Processing with Disaster Tweets | |
10,340,126 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<install_modules> | seed(1)
| Natural Language Processing with Disaster Tweets |
10,340,126 | %%bash
apt-get install -y xarchiver || true
SAVED_MODEL_PATH="/kaggle/input/tse2020-roberta-pytorch-multi-tpu-10-skfd-d"
NEW_MODEL_PATH="/kaggle/working"
for model_file in $(ls $SAVED_MODEL_PATH/*.pth)
do
just_filename=$(basename "${model_file%.*}")
if [[ ! -e "$NEW_MODEL_PATH/$just_filename.pth" ]]; then
echo "Copyi... | tweet = pd.read_csv('/kaggle/input/nlp-getting-started/train.csv')
testset = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv')
submission = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
tweet.head() | Natural Language Processing with Disaster Tweets |
10,340,126 | warnings.filterwarnings("ignore")
<define_variables> | def create_corpus() :
corpus=[]
for x in tweet['text'].str.split() :
for i in x:
corpus.append(i)
return corpus | Natural Language Processing with Disaster Tweets |
10,340,126 | MAX_LEN = 128
TRAIN_BATCH_SIZE = 32
VALID_BATCH_SIZE = 16
EPOCHS = 5
ROBERTA_PATH = "/kaggle/input/roberta-base"
TOKENIZER = tokenizers.ByteLevelBPETokenizer(
vocab_file=f"{ROBERTA_PATH}/vocab.json",
merges_file=f"{ROBERTA_PATH}/merges.txt",
lowercase=True,
add_prefix_space=True
)
SAVED_MODEL_PATH="/kaggle/working/"... | 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=Tru... | Natural Language Processing with Disaster Tweets |
10,340,126 | def seed_everything(seed_value):
random.seed(seed_value)
np.random.seed(seed_value)
torch.manual_seed(seed_value)
os.environ['PYTHONHASHSEED'] = str(seed_value)
seed = 42
seed_everything(seed )<feature_engineering> | def build_vocab(X):
tweets = X.apply(lambda s: s.split() ).values
vocab = {}
for tweet in tweets:
for word in tweet:
try:
vocab[word] += 1
except KeyError:
vocab[word] = 1
return vocab
def check_embeddings_coverage(X, embeddings):
vocab = build_vocab(X)
covered = {}
oov = {}
n_covered = 0
n_oov = 0
for word in vocab:
... | Natural Language Processing with Disaster Tweets |
10,340,126 | class TweetDataset(torch.utils.data.Dataset):
def __init__(self, df, max_len=96):
self.df = df
self.max_len = max_len
self.labeled = 'selected_text' in df
self.tokenizer = tokenizers.ByteLevelBPETokenizer(
vocab_file='.. /input/roberta-base/vocab.json',
merges_file='.. /input/roberta-base/merges.txt',
lowercase=True,
... | embedding_dict={}
with open('.. /input/glove-global-vectors-for-word-representation/glove.6B.100d.txt','r')as f:
for line in f:
values=line.split()
word=values[0]
vectors=np.asarray(values[1:],'float32')
embedding_dict[word]=vectors
f.close() | Natural Language Processing with Disaster Tweets |
10,340,126 | class TweetModel(nn.Module):
def __init__(self):
super(TweetModel, self ).__init__()
config = RobertaConfig.from_pretrained(
f'{ROBERTA_PATH}/config.json', output_hidden_states=True)
config.output_hidden_states = True
self.roberta = RobertaModel.from_pretrained(
f'{ROBERTA_PATH}/pytorch_model.bin', config=config)
s... | train_glove_oov, train_glove_vocab_coverage, train_glove_text_coverage = check_embeddings_coverage(tweet["text"], embedding_dict)
test_glove_oov, test_glove_vocab_coverage, test_glove_text_coverage = check_embeddings_coverage(testset['text'], embedding_dict)
print('GloVe Embeddings cover {:.2%} of vocabulary and {:.2... | Natural Language Processing with Disaster Tweets |
10,340,126 | def get_selected_text(text, start_idx, end_idx, offsets):
selected_text = ""
for ix in range(start_idx, end_idx + 1):
selected_text += text[offsets[ix][0]: offsets[ix][1]]
if(ix + 1)< len(offsets)and offsets[ix][1] < offsets[ix + 1][0]:
selected_text += " "
return selected_text
def jaccard(str1, str2):
a = set(str1.low... | def utils_preprocess_text(text):
text = re.sub(r'[^\w\s]', '', str(text ).lower().strip())
url = re.compile(r'https?://\S+|www\.\S+')
text = url.sub(r'',text)
url = re.compile(r'http?://\S+|www\.\S+')
text = url.sub(r'',text)
html=re.compile(r'<.*?>')
html.sub(r'',text)
text = re.sub(r'mh370','flight crash',text... | Natural Language Processing with Disaster Tweets |
10,340,126 | %env JOBLIB_TEMP_FOLDER=/tmp
%env JOBLIB_START_METHOD="forkserver"
%env TMPDIR=/tmp<load_pretrained> | df=pd.concat([tweet,testset])
df.shape | Natural Language Processing with Disaster Tweets |
10,340,126 | device = torch.device("cuda")
model_config = transformers.RobertaConfig.from_pretrained(ROBERTA_PATH)
model_config.output_hidden_states = True<load_pretrained> | df["text_clean"] = df["text"].apply(lambda x: utils_preprocess_text(x))
df.head() | Natural Language Processing with Disaster Tweets |
10,340,126 | %%time
models = {}
for index in range(NUM_OF_SAVED_MODELS):
model_filename=f"{SAVED_MODEL_PATH}/roberta_fold{index}.pth"
print(f"Loading model {index} from {model_filename}")
models[index] = TweetModel()
models[index].to(device)
models[index].load_state_dict(torch.load(model_filename))
models[index].eval()<load_from_... | df_glove_oov, df_glove_vocab_coverage, df_glove_text_coverage = check_embeddings_coverage(df["text_clean"], embedding_dict)
print('GloVe Embeddings cover {:.2%} of vocabulary and {:.2%} of text in Training Set'.format(df_glove_vocab_coverage, df_glove_text_coverage))
| Natural Language Processing with Disaster Tweets |
10,340,126 | %%time
test_df = pd.read_csv('/kaggle/input/tweet-sentiment-extraction/test.csv')
test_df['text'] = test_df['text'].astype(str)
test_loader = get_test_loader(test_df)
predictions = []
for data in test_loader:
print('Reading test data via the test loader...')
ids = data['ids'].cuda()
masks = data['masks'].cuda()
twe... | corpus = []
corpus = df["text_clean"] | Natural Language Processing with Disaster Tweets |
10,340,126 | sample = pd.read_csv(".. /input/tweet-sentiment-extraction/test.csv")
sample.loc[:, 'selected_text'] = predictions
sample[['textID','selected_text']].to_csv("submission.csv", index=False )<load_from_csv> | 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' ) | Natural Language Processing with Disaster Tweets |
10,340,126 | train_data = pd.read_csv('/kaggle/input/tweet-sentiment-extraction/train.csv')
test_data = pd.read_csv('/kaggle/input/tweet-sentiment-extraction/test.csv' )<count_missing_values> | word_index=tokenizer_obj.word_index
print('Number of unique words:',len(word_index)) | Natural Language Processing with Disaster Tweets |
10,340,126 | print(train_data.notnull().sum())
print(train_data.isnull().sum() )<correct_missing_values> | 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:
emb_vec=embedding_dict.get(word)
if emb_vec is not None:
embedding_matrix[i]=emb_vec | Natural Language Processing with Disaster Tweets |
10,340,126 | train_data.dropna(axis = 0,inplace=True )<count_missing_values> | model=Sequential()
embedding=Embedding(num_words,100,embeddings_initializer=Constant(embedding_matrix),
input_length=MAX_LEN,trainable=False)
model.add(embedding)
model.add(SpatialDropout1D(0.2))
model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(1, activation='sigmoid'))
optimzer=Adam(learning_... | Natural Language Processing with Disaster Tweets |
10,340,126 | print(test_data.notnull().sum())
print(test_data.isnull().sum() )<feature_engineering> | train=tweet_pad[:tweet.shape[0]]
test=tweet_pad[tweet.shape[0]:] | Natural Language Processing with Disaster Tweets |
10,340,126 | def remove_punctuation(text):
no_punct = "".join([c for c in text if c not in string.punctuation])
return no_punct
train_data['s_text_clean'] = train_data['selected_text'].apply(str ).apply(lambda x: remove_punctuation(x.lower()))
train_data.head(20 )<feature_engineering> | X_train,X_test,y_train,y_test=train_test_split(train,tweet['target'].values,test_size=0.2)
print('Shape of train',X_train.shape)
print("Shape of Validation ",X_test.shape ) | Natural Language Processing with Disaster Tweets |
10,340,126 | tokenizer = RegexpTokenizer(r'\w+')
train_data['s_text_tokens'] = train_data['s_text_clean'].apply(str ).apply(lambda x: tokenizer.tokenize(x))
train_data.head(20 )<feature_engineering> | history=model.fit(X_train,y_train,batch_size=32,epochs=10,validation_data=(X_test,y_test),verbose=2 ) | Natural Language Processing with Disaster Tweets |
10,340,126 | def remove_stopwords(text):
words = [w for w in text if(w not in stopwords.words('english')or w not in 'im')]
return words
train_data['s_text_tokens_NOTstop'] = train_data['s_text_tokens'].apply(lambda x: remove_stopwords(x))
train_data.head(20 )<feature_engineering> | train_pred_GloVe = model.predict(train)
train_pred_GloVe_int = train_pred_GloVe.round().astype('int' ) | Natural Language Processing with Disaster Tweets |
10,340,126 | <string_transform><EOS> | test_pred_GloVe = model.predict(test)
test_pred_GloVe_int = test_pred_GloVe.round().astype('int')
submission['target'] = test_pred_GloVe_int
submission.head(10)
submission.to_csv("submission.csv", index=False, header=True)
| Natural Language Processing with Disaster Tweets |
10,981,838 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<filter> | !pip -q install pyspellchecker optuna | Natural Language Processing with Disaster Tweets |
10,981,838 | positive_train = train_data[train_data['sentiment']=='positive']
neutral_train = train_data[train_data['sentiment']=='neutral']
negative_train = train_data[train_data['sentiment']=='negative']<define_variables> | import os
import optuna
import pandas as pd
import numpy as np
import random
import re
from scipy import sparse
from spellchecker import SpellChecker
import string
import warnings
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.base import BaseEstimator, ClassifierMixin
from sklearn.feature_extractio... | Natural Language Processing with Disaster Tweets |
10,981,838 | max_len = 128
tokenizer = tokenizers.ByteLevelBPETokenizer(
vocab_file = '/kaggle/input/roberta-base/vocab.json',
merges_file = '/kaggle/input/roberta-base/merges.txt',
lowercase =True,
add_prefix_space=True
)
sentiment_id = {'positive':tokenizer.encode('positive' ).ids[0],
'negative':tokenizer.encode('negative' ).i... | optuna.logging.set_verbosity(0)
warnings.filterwarnings("ignore" ) | 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.