kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
16,302,634 | df['emoji'] = df['text'].apply(lambda x: find_emoji(x))<drop_column> | score_metrics(y_test_word2vec, y_predicted_word2vec_lr ) | Natural Language Processing with Disaster Tweets |
16,302,634 | def remove_emoji(text):
emoji_pattern = re.compile("["
u"\U0001F600-\U0001F64F"
u"\U0001F300-\U0001F5FF"
u"\U0001F680-\U0001F6FF"
u"\U0001F1E0-\U0001F1FF"
u"\U00002702-\U000027B0"
u"\U000024C2-\U0001F251"
"]+", flags=re.UNICODE)
return emoji_pattern.sub(r'', text )<drop_column> | compare_list = []
for(i,j)in zip(y_test_word2vec, y_predicted_word2vec_lr):
k = i - j
compare_list.append(k)
wrong_num = [i for i,j in enumerate(compare_list)if j != 0]
text_series[0:train_data.shape[0]][wrong_num] | Natural Language Processing with Disaster Tweets |
16,302,634 | sentence="Its all about \U0001F600 face"
print(sentence)
remove_emoji(sentence )<feature_engineering> | lenlen = []
for i in range(len(data_list)) :
content = data_list[i]
perlen = len(content)
lenlen.append(perlen)
print(max(lenlen)) | Natural Language Processing with Disaster Tweets |
16,302,634 | df['text']=df['text'].apply(lambda x: remove_emoji(x))<string_transform> | max_sequence_length = 26
embedding_dim = 300 | Natural Language Processing with Disaster Tweets |
16,302,634 | def stop_word_fn(text):
stop_words=set(stopwords.words('english'))
word_tokens= word_tokenize(text)
non_stop_word=[w for w in word_tokens if not w in stop_words ]
stop_words = [w for w in word_tokens if w in stop_words]
return stop_words<drop_column> | tokenizer = Tokenizer()
tokenizer.fit_on_texts(data_list)
sequences = tokenizer.texts_to_sequences(data_list)
word_index = tokenizer.word_index
cnn_data = pad_sequences(sequences, maxlen = max_sequence_length)
cnn_label = to_categorical(np.asarray(train_data['target']))
print('len of word_index:', len(word_index))
p... | Natural Language Processing with Disaster Tweets |
16,302,634 | example_sent = "This is a sample sentence, showing off the stop words filtration."
stop_word_fn(example_sent )<feature_engineering> | trainCNN_data = cnn_data[0:train_data.shape[0]]
X_train_cnn, X_test_cnn, y_train_cnn, y_test_cnn = train_test_split(trainCNN_data, cnn_label,
test_size = 0.2, random_state = 4)
X_cnn, X_val_cnn, y_cnn, y_val_cnn = train_test_split(X_train_cnn, y_train_cnn,
test_size = 0.2, random_state = 4 ) | Natural Language Processing with Disaster Tweets |
16,302,634 | df['stop_words']=df['text'].apply(lambda x : stop_word_fn(x))<set_options> | CNNmodel = Sequential()
CNNmodel.add(Embedding(len(word_index)+1, embedding_dim, input_length = max_sequence_length))
CNNmodel.add(Conv1D(filters=250, kernel_size=3, strides=1, padding='valid', activation = 'relu'))
CNNmodel.add(MaxPooling1D(pool_size=3))
CNNmodel.add(Flatten())
CNNmodel.add(Dense(embedding_dim, activ... | Natural Language Processing with Disaster Tweets |
16,302,634 | stop = set(stopwords.words('english'))
warnings.filterwarnings(action="ignore")
cufflinks.go_offline()
cufflinks.set_config_file(world_readable=True, theme='pearl')
<load_from_csv> | CNNmodel.compile(optimizer='adam', loss=losses.binary_crossentropy, metrics=['accuracy'])
history = CNNmodel.fit(X_cnn, y_cnn, epochs=3, validation_data=(X_val_cnn, y_val_cnn)) | Natural Language Processing with Disaster Tweets |
16,302,634 | train=pd.read_csv('.. /input/tweet-sentiment-extraction/train.csv')
test=pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv')
train.sample(6 )<correct_missing_values> | test_loss, test_acc = CNNmodel.evaluate(X_test_cnn, y_test_cnn, verbose=2)
print('test loss:',test_loss)
print('test acc:',test_acc ) | Natural Language Processing with Disaster Tweets |
16,302,634 | train.dropna()
train.shape<feature_engineering> | embedding_matrix = np.zeros(( len(word_index)+ 1, embedding_dim))
for word, i in word_index.items() :
if word in word2vec_model:
embedding_matrix[i] = np.asarray(word2vec_model.wv[word] ) | Natural Language Processing with Disaster Tweets |
16,302,634 | train['target'] = train['selected_text'].str.lower()<feature_engineering> | embedding_layer = Embedding(len(word_index)+1,
embedding_dim,
weights = [embedding_matrix],
input_length = max_sequence_length,
trainable = False ) | Natural Language Processing with Disaster Tweets |
16,302,634 | train['target_url'] =train['target'].apply(lambda x : find_url(x))<feature_engineering> | model = Sequential()
model.add(embedding_layer)
model.add(Conv1D(filters=150, kernel_size=3, strides=1, padding='valid', activation = 'relu'))
model.add(MaxPooling1D(pool_size=3))
model.add(Flatten())
model.add(Dense(embedding_dim, activation='relu'))
model.add(Dropout(0.8))
model.add(Dense(cnn_label.shape[1], activa... | Natural Language Processing with Disaster Tweets |
16,302,634 | def find_star(text):
try:
line=re.findall(r'[*]{2,5}',text)
except:
line=[]
return len(line)
train['star']=train['target'].apply(lambda x:find_star(x))<feature_engineering> | model.compile(optimizer='adam', loss=losses.binary_crossentropy, metrics=['accuracy'])
history = model.fit(X_cnn, y_cnn, epochs=10, validation_data=(X_val_cnn, y_val_cnn)) | Natural Language Processing with Disaster Tweets |
16,302,634 | def find_only_star(text):
try:
if len(text.split())==1:
line=re.findall(r'[*]{2,5}',text)
return len(line)
else:
return 0
except:
return 0
train['only_star']=train['target'].apply(lambda x:find_only_star(x))<feature_engineering> | test_loss, test_acc = model.evaluate(X_test_cnn, y_test_cnn, verbose=2)
print('test loss:',test_loss)
print('test acc:',test_acc ) | Natural Language Processing with Disaster Tweets |
16,302,634 | train['target']= np.where(train['only_star']==1,"abusive",train['target'] )<feature_engineering> | tf.__version__ | Natural Language Processing with Disaster Tweets |
16,302,634 | def remove_link(string):
try:
text = re.sub('http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F])) +'," ",string)
except:
text=''
return " ".join(text.split())
def remove_punct(text):
try:
line = re.sub(r'[!"\$%&'() *+,\-.\/:;=
except:
line=''
return " ".join(line.split())
train['target']=tra... | hub.__version__ | Natural Language Processing with Disaster Tweets |
16,302,634 | train['target_average_word_len']=train['target'].str.split().apply(lambda x : [len(i)for i in x] ).map(lambda x: np.mean(x))<feature_engineering> | !wget --quiet https://raw.githubusercontent.com/tensorflow/models/master/official/nlp/bert/tokenization.py | Natural Language Processing with Disaster Tweets |
16,302,634 | full_data=pd.concat([train,test])
full_data['text']=full_data['text'].str.lower()
full_data.shape
full_data['text']=full_data['text'].apply(lambda x:remove_link(x))
full_data['text']=full_data['text'].apply(lambda x:remove_punct(x))<filter> | import tensorflow as tf
from tensorflow.keras.callbacks import ModelCheckpoint
import tensorflow_hub as hub
import tokenization | Natural Language Processing with Disaster Tweets |
16,302,634 | full_data.loc[full_data['text']=="",['text']]="nothing"<feature_engineering> | def bert_encode(texts, bert_layer, max_len=128):
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)
all_tokens = []
all_masks = []
all_segments = []
for text in texts:
t... | Natural Language Processing with Disaster Tweets |
16,302,634 | full_data['text_tweet_length']=full_data['text'].str.split().map(lambda x: len(x))
full_data['text_average_word_len']=full_data['text'].str.split().apply(lambda x : [len(i)for i in x] ).map(lambda x: np.mean(x))<prepare_x_and_y> | %%time
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 |
16,302,634 | def corpus_sentiment_stop(data,feature,sentiment):
corpus=create_corpus(data,feature,sentiment)
dic=defaultdict(int)
for word in corpus:
if word in stop:
dic[word]+=1
top=sorted(dic.items() , key=lambda x:x[1],reverse=True)
x,y=zip(*top)
return x,y<define_variables> | train = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
train_input = bert_encode(train.text.values, bert_layer, max_len=128)
train_labels = np.array(train.target ) | Natural Language Processing with Disaster Tweets |
16,302,634 | 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
)
sentiment_id = {'positive': 1313, 'negative': 2430, 'neutral': 7974}<load_from_csv> | test = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv")
test_input = bert_encode(test.text.values, bert_layer, max_len=128)
model.load_weights('model.h5')
test_pred = model.predict(test_input ) | Natural Language Processing with Disaster Tweets |
16,302,634 | <load_from_csv><EOS> | submission = pd.read_csv("/kaggle/input/nlp-getting-started/sample_submission.csv")
submission['target'] = np.round(test_pred ).astype('int')
submission.to_csv('submission.csv', index=False)
submission.groupby('target' ).count() | Natural Language Processing with Disaster Tweets |
16,264,787 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<load_pretrained> | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
data = pd.read_csv('/kaggle/input/nlp-getting-started/train.csv')
data.sample(10 ) | Natural Language Processing with Disaster Tweets |
16,264,787 | def scheduler(epoch):
return 3e-5 * 0.2**epoch
def build_model() :
ids = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
att = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
tok = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
config = RobertaConfig.from_pretrained(PATH+'config-roberta-base.json')
bert_m... | text = data.text
duplicates = data[text.isin(text[text.duplicated() ])].sort_values(by='text')
conflicting_check = pd.DataFrame(duplicates.groupby(['text'] ).target.mean())
conflicting_check.sample(10 ) | Natural Language Processing with Disaster Tweets |
16,264,787 | n_splits=5
preds_start = np.zeros(( input_ids_t.shape[0],MAX_LEN))
preds_end = np.zeros(( input_ids_t.shape[0],MAX_LEN))
DISPLAY=1
for i in range(5):
print('
print('
print('
K.clear_session()
model = build_model()
model.load_weights('.. /input/model4/v4-roberta-%i.h5'%i)
print('Predicting Test...')
preds = model.pred... | conflicting = conflicting_check.loc[(conflicting_check.target != 1)&(conflicting_check.target != 0)].index
data = data.drop(data[text.isin(conflicting)].index)
print('Conflicting samples count:', conflicting.shape[0] ) | Natural Language Processing with Disaster Tweets |
16,264,787 | 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-1:b])
all.append(st)
test['selected_text'] = all
submissio... | 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 |
16,264,787 | import numpy as np
import pandas as pd
import random
import math
import argparse
import pickle
import tokenizers
import tensorflow as tf
import tensorflow.keras.backend as K
from tensorflow.keras import layers as L
from transformers import TFBertMainLayer,TFBertModel,TFBertPreTrainedModel,BertConfig,BertTokenizer
from ... | !pip install transformers | Natural Language Processing with Disaster Tweets |
16,264,787 | def set_seed(args):
random.seed(args.seed)
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
set_seed(args )<load_from_csv> | sentences = data.text.values
labels =data.target.values | Natural Language Processing with Disaster Tweets |
16,264,787 | test_df=pd.read_csv("/kaggle/input/tweet-sentiment-extraction/test.csv")
train_df=pd.read_csv("/kaggle/input/tweet-sentiment-extraction/train.csv")
train_df.dropna(inplace=True)
train_df=train_df.reset_index()<define_variables> | tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True ) | Natural Language Processing with Disaster Tweets |
16,264,787 | def load_data_roberta(df,tokenizer, is_train_eval):
sentiment_id = {'positive': 1313, 'negative': 2430, 'neutral': 7974}
ct = df.shape[0]
MAX_LEN_WORD=args.max_seq_length
input_ids = np.ones(( ct,MAX_LEN_WORD),dtype='int32')
attention_mask = np.zeros(( ct,MAX_LEN_WORD),dtype='int32')
token_type_ids = np.zeros(( ct,MA... | 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 |
16,264,787 | model_path=".. /input/robertatransformer/roberta-base-tf_model.h5"
model_class=TFRobertaModel
config = RobertaConfig.from_pretrained(".. /input/robertatransformer/roberta-base-config.json")
tokenizer = tokenizers.ByteLevelBPETokenizer(vocab_file=".. /input/robertatransformer/roberta-base-vocab.json",
merges_file=".. /... | 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 tweet length: ', max_len ) | Natural Language Processing with Disaster Tweets |
16,264,787 | trainset=load_data_roberta(train_df,tokenizer, is_train_eval=True)
testset=load_data_roberta(test_df,tokenizer, is_train_eval=False )<categorify> | input_ids = []
attention_masks = []
for sent in sentences:
encoded_dict = tokenizer.encode_plus(
sent,
add_special_tokens = True,
max_length = 64,
pad_to_max_length = True,
return_attention_mask = True,
return_tensors = 'pt',
)
input_ids.append(encoded_dict['input_ids'])
attention_masks.append(encoded_dict['attenti... | Natural Language Processing with Disaster Tweets |
16,264,787 | PAD_ID=1
lr=args.learning_rate
def build_model_cnn(model_class,model_path,config):
MAX_LEN_WORD=args.max_seq_length
ids = tf.keras.layers.Input(( MAX_LEN_WORD,), dtype=tf.int32)
att = tf.keras.layers.Input(( MAX_LEN_WORD,), dtype=tf.int32)
tok = tf.keras.layers.Input(( MAX_LEN_WORD,), dtype=tf.int32)
padding = tf.ca... | SPLIT = 0.999
dataset = TensorDataset(input_ids, attention_masks, labels)
train_size = int(SPLIT * len(dataset))
val_size = len(dataset)- train_size
train_dataset, val_dataset = random_split(dataset, [train_size, val_size])
print('{:>5,} training samples'.format(train_size))
print('{:>5,} validation samples'.format(v... | Natural Language Processing with Disaster Tweets |
16,264,787 | LABEL_SMOOTHING=0.1
def loss_fn(y_true, y_pred):
ll = tf.shape(y_pred)[1]
y_true = y_true[:, :ll]
loss = tf.keras.losses.categorical_crossentropy(y_true, y_pred,
from_logits=False, label_smoothing=LABEL_SMOOTHING)
loss = tf.reduce_mean(loss)
return loss
<load_pretrained> | batch_size = 32
train_dataloader = DataLoader(
train_dataset,
sampler = RandomSampler(train_dataset),
batch_size = batch_size
)
validation_dataloader = DataLoader(
val_dataset,
sampler = SequentialSampler(val_dataset),
batch_size = batch_size
) | Natural Language Processing with Disaster Tweets |
16,264,787 | def save_weights(model, dst_fn):
weights = model.get_weights()
with open(dst_fn, 'wb')as f:
pickle.dump(weights, f )<load_pretrained> | model = BertForSequenceClassification.from_pretrained(
"bert-base-uncased",
num_labels = 2,
output_attentions = False,
output_hidden_states = False,
)
model.cuda() | Natural Language Processing with Disaster Tweets |
16,264,787 | def load_weights(model, weight_fn):
with open(weight_fn, 'rb')as f:
weights = pickle.load(f)
model.set_weights(weights)
return model
<compute_test_metric> | optimizer = AdamW(model.parameters() ,
lr = 2e-5,
eps = 1e-8
) | Natural Language Processing with Disaster Tweets |
16,264,787 | 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> | epochs = 2
total_steps = len(train_dataloader)* epochs
scheduler = get_linear_schedule_with_warmup(optimizer,
num_warmup_steps = 0,
num_training_steps = total_steps ) | Natural Language Processing with Disaster Tweets |
16,264,787 | jac = [];
VER='v0';
DISPLAY=1
n_splits=args.cv_splits
lr=args.learning_rate
MAX_LEN=args.max_seq_length
n_best=3
input_ids=trainset['input_ids']
attention_mask=trainset['attention_mask']
token_type_ids=trainset['token_type_ids']
start_tokens=trainset['start_tokens']
end_tokens=trainset['end_tokens']
input_ids_test=test... | 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 |
16,264,787 | print(f'The CV jaccard is {np.mean(jac)}' )<define_variables> | seed_val = 42
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))
print('Training...')
t0 = time.... | Natural Language Processing with Disaster Tweets |
16,264,787 | roberta_models=["roberta-base-1.h5",
"roberta-base-2.h5",
"roberta-base-3.h5",
"roberta-base-4.h5",
"roberta-base-5.h5"]<define_variables> | pd.set_option('precision', 2)
df_stats = pd.DataFrame(data=training_stats)
df_stats = df_stats.set_index('epoch')
df_stats | Natural Language Processing with Disaster Tweets |
16,264,787 | MAX_LEN_WORD=args.max_seq_length
DISPLAY=1
input_ids_test=testset['input_ids']
attention_mask_test=testset['attention_mask']
token_type_ids_test=testset['token_type_ids']
preds_test_start = np.zeros(( ct_test,MAX_LEN_WORD))
preds_test_end = np.zeros(( ct_test,MAX_LEN_WORD))
input_ids_train=trainset['input_ids']
attenti... | test_data = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv')
print('Number of test sentences: {:,}
'.format(test_data.shape[0]))
sentences = test_data.text.values
input_ids = []
attention_masks = []
for sent in sentences:
encoded_dict = tokenizer.encode_plus(
sent,
add_special_tokens = True,
max_length = 64,... | Natural Language Processing with Disaster Tweets |
16,264,787 | model_number=len(roberta_models)
for i in range(model_number):
print(f"predict roberta model----{i+1}")
K.clear_session()
weight_fn=roberta_models[i]
_, padded_model = build_model_cnn(model_class,model_path,config)
load_weights(padded_model, weight_fn)
preds_test = padded_model.predict([input_ids_test,attention_mas... | print('Predicting labels for {:,} test sentences...'.format(len(input_ids)))
model.eval()
predictions = []
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,
attention_mask=b_input_mas... | Natural Language Processing with Disaster Tweets |
16,264,787 | def token_level_to_char_level(text, offsets, preds):
probas_char = np.zeros(len(text))
for i, offset in enumerate(offsets):
if offset[0] or offset[1]:
probas_char[offset[0]:offset[1]] = preds[i]
return probas_char<define_variables> | flat_predictions = np.concatenate(predictions, axis=0)
flat_predictions = np.argmax(flat_predictions, axis=1 ).flatten() | Natural Language Processing with Disaster Tweets |
16,264,787 | <feature_engineering><EOS> | submission = pd.read_csv('/kaggle/input/nlp-getting-started/sample_submission.csv')
submission.target = flat_predictions
submission.to_csv('submission.csv', index=False ) | Natural Language Processing with Disaster Tweets |
15,995,055 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<load_pretrained> | pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 1000)
warnings.filterwarnings("ignore")
eng_stopwords = set(stopwords.words("english")) | Natural Language Processing with Disaster Tweets |
15,995,055 | with open('char_pred_train_start.pkl', 'wb')as handle:
pickle.dump(probas_train_start, handle)
with open('char_pred_train_end.pkl', 'wb')as handle:
pickle.dump(probas_train_end, handle )<feature_engineering> | train_df = pd.read_csv(".. /input/nlp-getting-started/train.csv")
test_df = pd.read_csv(".. /input/nlp-getting-started/test.csv")
submission = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
print("Training Shape rows = {}, columns = {}".format(train_df.shape[0],train_df.shape[1]))
print("Testing ... | Natural Language Processing with Disaster Tweets |
15,995,055 | tokenizer_char = Tokenizer(num_words=None, char_level=True, oov_token='UNK', lower=True)
tokenizer_char.fit_on_texts(train_df['text'].values)
len_voc = len(tokenizer_char.word_index)+ 1
X_train = tokenizer_char.texts_to_sequences(train_df['text'].values)
X_test = tokenizer_char.texts_to_sequences(test_df['text'].val... | train_df.isnull().sum() | Natural Language Processing with Disaster Tweets |
15,995,055 | def get_start_end_string(text, selected_text):
len_selected_text = len(selected_text)
idx_start, idx_end = 0, 0
candidates_idx = [i for i, e in enumerate(text)if e == selected_text[0]]
for idx in candidates_idx:
if text[idx : idx + len_selected_text] == selected_text:
idx_start = idx
idx_end = idx + len_selected_text-... | test_df.isnull().sum() | Natural Language Processing with Disaster Tweets |
15,995,055 | def load_data_second_model(df, X, char_start_probas, char_end_probas, max_len_char, train=True):
ct=len(df)
X = pad_sequences(X, maxlen=max_len_char, padding='post', truncating='post')
start_probas = np.zeros(( ct, max_len_char), dtype=float)
for i, p in enumerate(char_start_probas):
len_ = min(len(p), max_len_char)... | keyword_dist = train_df.groupby("keyword")['target'].value_counts().unstack(fill_value=0)
keyword_dist = keyword_dist.add_prefix(keyword_dist.columns.name ).rename_axis(columns=None ).reset_index() | Natural Language Processing with Disaster Tweets |
15,995,055 | char_dataset_train=load_data_second_model(train_df,
X_train,
probas_train_start,
probas_train_end,
max_len_char=args.max_char_length,
train=True)
char_dataset_test=load_data_second_model(test_df,
X_test,
probas_test_start,
probas_test_end,
max_len_char=args.max_char_length,
train=False )<compute_test_metric> | keyword_dist.sort_values('target1',ascending = False ).head(10 ) | Natural Language Processing with Disaster Tweets |
15,995,055 | LABEL_SMOOTHING=0.1
def loss_fn_2(y_true, y_pred):
loss = tf.keras.losses.categorical_crossentropy(y_true, y_pred,
from_logits=False, label_smoothing=LABEL_SMOOTHING)
loss = tf.reduce_mean(loss)
return loss<define_search_model> | keyword_dist.sort_values('target0',ascending = False ).head(10 ) | Natural Language Processing with Disaster Tweets |
15,995,055 | class ConvBlock(L.Layer):
def __init__(self,out_dim,kernel_size,padding="same"):
super(ConvBlock, self ).__init__()
self.conv=L.Conv1D(out_dim,kernel_size, padding=padding)
self.bn=L.BatchNormalization()
def call(self, inputs):
x=self.conv(inputs)
x=self.bn(x)
x=tf.keras.activations.relu(x)
return x<choose_model_cl... | train_df['word_count'] = train_df['text'].apply(lambda x : len(str(x ).split()))
test_df['word_count'] = test_df['text'].apply(lambda x : len(str(x ).split()))
train_df['unique_word_count'] = train_df['text'].apply(lambda x : len(set(str(x ).split())))
test_df['unique_word_count'] = test_df['text'].apply(lambda x : le... | Natural Language Processing with Disaster Tweets |
15,995,055 | class Logits(L.Layer):
def __init__(self,dim1=32,dim2=2):
super(Logits, self ).__init__()
self.dense1=L.Dense(dim1,activation='relu')
self.dense2=L.Dense(dim2)
def call(self, inputs):
x=self.dense1(inputs)
x=self.dense2(x)
return x<choose_model_class> | def generate_ngrams(text, n_gram=1):
token = [token for token in text.lower().split(' ')if token != '' if token not in eng_stopwords]
ngrams = zip(*[token[i:] for i in range(n_gram)])
return [' '.join(ngram)for ngram in ngrams]
disaster_bigrams = defaultdict(int)
nondisaster_bigrams = defaultdict(int)
for tweet in t... | Natural Language Processing with Disaster Tweets |
15,995,055 | class CharCNN(tf.keras.Model):
def __init__(self,len_voc,cnn_dim=32, char_embed_dim=16, sent_embed_dim=16,
proba_cnn_dim=16, kernel_size=3,max_len_char=args.max_char_length):
super(CharCNN, self ).__init__()
self.CharEmbedding = L.Embedding(input_dim=len_voc, output_dim=char_embed_dim)
self.SentimentEmbedding = L.Embe... | disaster_trigrams = defaultdict(int)
nondisaster_trigrams = defaultdict(int)
for tweet in train_df[train_df['target']==1]['text']:
for word in generate_ngrams(tweet, n_gram=3):
disaster_trigrams[word] += 1
for tweet in train_df[train_df['target']==0]['text']:
for word in generate_ngrams(tweet, n_gram=3):
nondisaster_... | Natural Language Processing with Disaster Tweets |
15,995,055 | inpTest=[char_dataset_test['ids'],
char_dataset_test['sentiment_input'],
char_dataset_test['probas_start'],
char_dataset_test['probas_end']]<split> | 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 |
15,995,055 | n_splits=args.cv_splits_2
char_pred_oof_start=np.zeros(( ct_train,args.max_char_length))
char_pred_oof_end=np.zeros(( ct_train,args.max_char_length))
char_pred_test_start=np.zeros(( ct_test,args.max_char_length))
char_pred_test_end=np.zeros(( ct_test,args.max_char_length))
jac_2=[]
splits = list(StratifiedKFold(n_split... | def 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)
tokens ... | Natural Language Processing with Disaster Tweets |
15,995,055 | print(f'The mean Jaccard value is {np.mean(jac_2)}' )<categorify> | 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 |
15,995,055 | def convert_prob_to_string(dataset, pred_start, pred_end):
ct=len(dataset['text'])
pred=[]
for k in range(ct):
start_idx=np.argmax(pred_start[k])
end_idx=np.argmax(pred_end[k])
if start_idx>end_idx:
pred_selected_text=dataset['text'][k]
else:
pred_selected_text=dataset['text'][k][start_idx:end_idx+1]
pred.append(pre... | %%time
bert_layer = hub.KerasLayer('https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/1', trainable=True ) | Natural Language Processing with Disaster Tweets |
15,995,055 | pred=convert_prob_to_string(char_dataset_test,char_pred_test_start, char_pred_test_end)
test_df['selected_text']=pred
test_df.to_csv('submission.csv',columns=['textID','selected_text'], index=False)
<import_modules> | 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 |
15,995,055 | import os
import torch
import random
import statistics
import tokenizers
import numpy as np
import pandas as pd
import torch.nn as nn
from sklearn.model_selection import StratifiedKFold
from torch.utils.data import TensorDataset, DataLoader, SequentialSampler, RandomSampler
from transformers import BertPreTrainedModel,... | train_input = encode(train_df.text_cleaned.values, tokenizer, max_len=160)
test_input = encode(test_df.text_cleaned.values, tokenizer, max_len=160)
train_labels = train_df.target.values | Natural Language Processing with Disaster Tweets |
15,995,055 | roberta_path = "/kaggle/input/roberta-base/"
max_len = 108
hidden_size = 768
batch_size = 32
epochs = 5
lr = 2.5e-5
dropout_rate = 0.0
hidden_dropout_prob = 0.1
attention_probs_dropout_prob = 0.2
num_classes = 2
n_splits = 5
random_seed = 0
warmup_steps = 199
tokenizer = tokenizers.ByteLevelBPETokenizer(vocab_file = f"... | checkpoint = ModelCheckpoint('model.h5', monitor='val_loss', save_best_only=True)
train_history = model.fit(
train_input, train_labels,
validation_split=0.2,
epochs=3,
callbacks=[checkpoint],
batch_size=32
) | Natural Language Processing with Disaster Tweets |
15,995,055 | chars = [".", "!", "?"]
def seed_everything(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True
def find_sub_list(l,sl):
if len(sl)== 0:
return []
el... | model.load_weights('model.h5')
test_pred_BERT = model.predict(test_input)
test_pred_BERT_int = test_pred_BERT.round().astype('int' ) | Natural Language Processing with Disaster Tweets |
15,995,055 | <train_model><EOS> | submission['target'] = test_pred_BERT_int
submission.to_csv("submission_BERT.csv", index=False, header=True ) | Natural Language Processing with Disaster Tweets |
14,567,170 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<create_dataframe> | confusion_matrix)
| Natural Language Processing with Disaster Tweets |
14,567,170 | train_dataset = TweetDataset(train_df)
test_dataset = TweetDataset(test_df)
train_metadata = train_dataset.get_metadata()
test_metadata = test_dataset.get_metadata()<define_variables> | PRETRAINED_MODEL_NAME = 'bert-base-uncased'
LABELS_NUMBER = 2
MAX_LENGHT = 512
BATCH_SIZE = 6
LEARNING_RATE = 2e-5
EPOCHS_NUMBER = 1
N_PREDICTIONS_TO_SHOW = 10 | Natural Language Processing with Disaster Tweets |
14,567,170 | def train_loop() :
kf = StratifiedKFold(n_splits=n_splits, random_state=random_seed, shuffle=True)
val_start_logits = [0 for tm in train_metadata]
val_end_logits = [0 for tm in train_metadata]
test_start_logits = [torch.zeros(len(tm["input_ids"]), dtype=torch.float)for tm in test_metadata]
test_end_logits = [torch.zer... | train_data = pd.read_csv('.. /input/nlp-getting-started/train.csv')
print(train_data.shape)
train_data.head(3 ) | Natural Language Processing with Disaster Tweets |
14,567,170 | %%time
device = torch.device("cuda")
val_start_logits, val_end_logits, test_start_logits, test_end_logits = train_loop()<define_variables> | test_data = pd.read_csv('.. /input/nlp-getting-started/test.csv')
print(test_data.shape)
test_data.head(3 ) | Natural Language Processing with Disaster Tweets |
14,567,170 | jaccs = []
predictions = []
br = 0
for e, meta in enumerate(train_metadata):
text = meta["text"]
preprocessed_text = meta["preprocessed_text"]
selected_text = meta["selected_text"]
loss_mask = meta["loss_mask"]
tokens = meta["tokens"]
offsets = meta["offsets"]
actives = np.asarray(meta["loss_mask"] ).reshape(-1)== 1
st... | tokenizer = BertTokenizer.from_pretrained(PRETRAINED_MODEL_NAME,
do_lower_case=True ) | Natural Language Processing with Disaster Tweets |
14,567,170 | test_raw["selected_text"] = ""
test_raw.loc[test_raw.sentiment == "neutral", "selected_text"] = test_raw.loc[test_raw.sentiment == "neutral", "text"]
<define_variables> | vocabulary = tokenizer.get_vocab()
print(f'Size of the vocabulary: {len(vocabulary)}')
print(f'Some tokens of the vocabulary: {list(vocabulary.keys())[5000:5010]}' ) | Natural Language Processing with Disaster Tweets |
14,567,170 | predictions = []
br = 0
for e, meta in enumerate(test_metadata):
text = meta["text"]
preprocessed_text = meta["preprocessed_text"]
loss_mask = meta["loss_mask"]
tokens = meta["tokens"]
offsets = meta["offsets"]
actives = np.asarray(meta["loss_mask"] ).reshape(-1)== 1
start_probs = test_start_logits[e][actives].sigmoid(... | def prepare_sequence(text):
prepared_sequence = tokenizer.encode_plus(
text,
add_special_tokens = True,
max_length = MAX_LENGHT,
padding = 'max_length',
return_attention_mask = True
)
return prepared_sequence | Natural Language Processing with Disaster Tweets |
14,567,170 | test_raw.loc[test_raw.sentiment != "neutral", "selected_text"] = predictions
<save_to_csv> | test_sentence = 'Is this jacksonville?'
test_sentence_encoded = prepare_sequence(test_sentence)
token_ids = test_sentence_encoded["input_ids"]
print(f'Test sentence: {test_sentence}')
print(f'Keys: {test_sentence_encoded.keys() }')
print(f'Tokens: {tokenizer.convert_ids_to_tokens(token_ids)[:12]}')
print(f'Token ID... | Natural Language Processing with Disaster Tweets |
14,567,170 | submission = test_raw.drop(columns = ["text", "sentiment"])
submission.to_csv("submission.csv", index=False )<install_modules> | def map_example_to_dict(input_ids, attention_masks, token_type_ids, label):
mapped_example = {
"input_ids": input_ids,
"token_type_ids": token_type_ids,
"attention_mask": attention_masks,
}
return mapped_example, label
def encode_examples(texts_and_labels):
input_ids_list = []
token_type_ids_list = []
attention_mas... | Natural Language Processing with Disaster Tweets |
14,567,170 | !pip install '/kaggle/input/simple-transformers-pypi/seqeval-0.0.12-py3-none-any.whl' -q
!pip install '/kaggle/input/simple-transformers-pypi/simpletransformers-0.22.1-py3-none-any.whl' -q<load_from_csv> | X = train_data["text"]
y = train_data["target"] | Natural Language Processing with Disaster Tweets |
14,567,170 | train_data = list()
train = pd.read_csv('.. /input/tweet-sentiment-extraction/train.csv')
for id, row in train.iterrows() :
template = {
'context': "",
'qas': [
{
'id': "",
'is_impossible': False,
'question': "",
'answers': [
{
'text': "",
'answer_start':''
}
]
}
]
}
template['qas'][0]['id'] = row['textID']
context = ... | X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.10,
random_state=1 ) | Natural Language Processing with Disaster Tweets |
14,567,170 | test_data = list()
test = pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv')
for id, row in test.iterrows() :
template = {
'context': "",
'qas': [
{
'id': "",
'is_impossible': False,
'question': "",
'answers': [
{
'text': "",
'answer_start': ''
}
]
}
]
}
template['context'] = str(row['text'] ).lower()
templa... | n_training_examples = X_train.shape[0]
n_positive_training_examples = y_train.value_counts() [1]
n_negative_training_examples = y_train.value_counts() [0]
print(f'Number examples in training dataset: {n_training_examples}')
print(f'Number of positive examples in training dataset: {n_positive_training_examples}')
prin... | Natural Language Processing with Disaster Tweets |
14,567,170 | logging.basicConfig(level=logging.INFO)
transformers_logger = logging.getLogger("transformers")
transformers_logger.setLevel(logging.WARNING)
with open('train_processed.json', 'r')as f:
train_data = json.load(f)
train_args = {
'reprocess_input_data': True,
'use_multiprocessing': False,
'do_lower_case': True,
"wandb... | train_dataset = list(zip(X_train, y_train))
val_dataset = list(zip(X_val, y_val)) | Natural Language Processing with Disaster Tweets |
14,567,170 | print('TF version',tf.__version__ )<load_from_csv> | ds_train_encoded = encode_examples(train_dataset ).shuffle(10000 ).batch(BATCH_SIZE)
ds_val_encoded = encode_examples(val_dataset ).batch(BATCH_SIZE ) | Natural Language Processing with Disaster Tweets |
14,567,170 | def read_train() :
train=pd.read_csv('.. /input/tweet-sentiment-extraction/train.csv')
train['text']=train['text'].astype(str)
train['selected_text']=train['selected_text'].astype(str)
return train
def read_test() :
test=pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv')
test['text']=test['text'].astype(s... | def get_model() :
config = AutoConfig.from_pretrained(PRETRAINED_MODEL_NAME,
hidden_dropout_prob=0.2,
num_labels=LABELS_NUMBER)
model = TFBertForSequenceClassification.from_pretrained(PRETRAINED_MODEL_NAME,
config=config)
return model | Natural Language Processing with Disaster Tweets |
14,567,170 | def jaccard(str1, str2):
a = set(str(str1 ).lower().split())
b = set(str(str2 ).lower().split())
c = a.intersection(b)
return float(len(c)) /(len(a)+ len(b)- len(c))<define_variables> | model = get_model()
optimizer = tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE)
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
metric = tf.keras.metrics.SparseCategoricalAccuracy('accuracy')
model.compile(optimizer=optimizer, loss=loss, metrics=[metric] ) | Natural Language Processing with Disaster Tweets |
14,567,170 | MAX_LEN = 96
PATH = '.. /input/tf-roberta/'
tokenizer = tokenizers.ByteLevelBPETokenizer(
vocab_file=PATH+'vocab-roberta-base.json',
merges_file=PATH+'merges-roberta-base.txt',
add_prefix_space=True
)
sentiment_id = {'positive': 1313, 'negative': 2430, 'neutral': 7974}<define_variables> | weight_for_0 =(1 / n_negative_training_examples)*(n_training_examples)/2.0
weight_for_1 =(1 / n_positive_training_examples)*(n_training_examples)/2.0
class_weight = {0: weight_for_0, 1: weight_for_1}
print('Weight for class 0: {:.2f}'.format(weight_for_0))
print('Weight for class 1: {:.2f}'.format(weight_for_1)) | Natural Language Processing with Disaster Tweets |
14,567,170 | ct = train_df.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_df.shape... | model.fit(ds_train_encoded, epochs=EPOCHS_NUMBER, validation_data=ds_val_encoded,
class_weight = class_weight ) | Natural Language Processing with Disaster Tweets |
14,567,170 | ct = test_df.shape[0]
input_ids_t = np.ones(( ct,MAX_LEN),dtype='int32')
attention_mask_t = np.zeros(( ct,MAX_LEN),dtype='int32')
token_type_ids_t = np.zeros(( ct,MAX_LEN),dtype='int32')
for k in range(test_df.shape[0]):
text1 = " "+" ".join(test_df.loc[k,'text'].split())
enc = tokenizer.encode(text1)
s_tok = sent... | val_predictions = model.predict(ds_val_encoded)
val_probabilities = softmax(val_predictions[0], axis=1)
y_val_predictions = np.argmax(val_probabilities, axis=1 ).flatten() | Natural Language Processing with Disaster Tweets |
14,567,170 | def build_model() :
ids = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
att = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
tok = tf.keras.layers.Input(( MAX_LEN,), dtype=tf.int32)
config = RobertaConfig.from_pretrained(PATH+'config-roberta-base.json')
bert_model = TFRobertaModel.from_pretrained(PATH+'pre... | def encode_test_examples(texts):
input_ids_list = []
token_type_ids_list = []
attention_mask_list = []
for text in texts:
bert_input = prepare_sequence(text)
input_ids_list.append(bert_input['input_ids'])
token_type_ids_list.append(bert_input['token_type_ids'])
attention_mask_list.append(bert_input['attention_mask... | Natural Language Processing with Disaster Tweets |
14,567,170 | n_splits = 2<init_hyperparams> | X_test = test_data["text"]
test_dataset = list(X_test)
ds_test_encoded = encode_test_examples(test_dataset ).batch(BATCH_SIZE ) | Natural Language Processing with Disaster Tweets |
14,567,170 |
<predict_on_test> | test_predictions = model.predict(ds_test_encoded)
test_probabilities = softmax(test_predictions[0], axis=1)
y_test_predictions = np.argmax(test_probabilities, axis=1 ).flatten() | Natural Language Processing with Disaster Tweets |
14,567,170 | <string_transform><EOS> | final_submission = pd.DataFrame(data={"id":test_data["id"], "target":y_test_predictions})
final_submission.to_csv("submissionTweets.csv", index=False ) | Natural Language Processing with Disaster Tweets |
14,426,199 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<save_to_csv> | warnings.filterwarnings('ignore')
| Natural Language Processing with Disaster Tweets |
14,426,199 | test_df['selected_text'] = all
test_df[['textID','selected_text']].to_csv('submission.csv',index=False )<set_options> | def bert_encode(texts, tokenizer, max_len=512):
all_tokens = []
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)
tokens += [0] * pad_len
pad_masks =... | Natural Language Processing with Disaster Tweets |
14,426,199 | warnings.filterwarnings('ignore')
print('GPU is available: ', torch.cuda.is_available() )<set_options> | 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" ) | Natural Language Processing with Disaster Tweets |
14,426,199 | 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)
if torch.cuda.is_available() :
torch.cuda.manual_seed(seed_value)
torch.cuda.manual_seed_all(seed_value)
torch.backends.cudnn.deterministic = True
torch.... | %%time
model_to_use = 'bert-base-uncased'
if model_to_use.split('-')[0] == 'distilbert':
transformer_layer = transformers.TFDistilBertModel.from_pretrained(model_to_use)
tokenizer = transformers.DistilBertTokenizer.from_pretrained(model_to_use)
if model_to_use.split('-')[0] == 'albert':
transformer_layer = transforme... | Natural Language Processing with Disaster Tweets |
14,426,199 | 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... | max_seq_len = 160
train_input = bert_encode(train.text.values, tokenizer, max_len=max_seq_len)
test_input = bert_encode(test.text.values, tokenizer, max_len=max_seq_len)
train_label = train.target.values
X_train, X_test, y_train, y_test = train_test_split(train_input,
train_label,
test_size=0.25,
random_state=42,
shu... | Natural Language Processing with Disaster Tweets |
14,426,199 | def loss_fn(start_logits, end_logits, start_positions, end_positions):
ce_loss = nn.CrossEntropyLoss()
start_loss = ce_loss(start_logits, start_positions)
end_loss = ce_loss(end_logits, end_positions)
total_loss = start_loss + end_loss
return total_loss<feature_engineering> | def metrics(y_true, y_pred):
print("
F1-score: ", round(f1_score(y_true, y_pred), 2))
print("Precision: ", round(precision_score(y_true, y_pred), 2))
print("Recall: ", round(recall_score(y_true, y_pred), 2)) | Natural Language Processing with Disaster Tweets |
14,426,199 | 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,
... | start_time = time.time()
train_history = model.fit(X_train, y_train, epochs = 3, batch_size = 8)
end_time = time.time()
print("
=>Training time :", round(end_time - start_time, 1), 's' ) | Natural Language Processing with Disaster Tweets |
14,426,199 | class TweetModel(nn.Module):
def __init__(self):
super(TweetModel, self ).__init__()
config = RobertaConfig.from_pretrained(
'.. /input/roberta-base/config.json', output_hidden_states=True)
self.roberta = RobertaModel.from_pretrained(
'.. /input/roberta-base/pytorch_model.bin', config=config)
self.dropout = nn.Drop... | start_time = time.time()
test_pred = model.predict(X_test, verbose=1 ).round().astype(int)
end_time = time.time()
print('
=>Average Inference Time :', round(( end_time - start_time)/ len(test_pred)* 1000, 1), 'ms')
metrics(y_test, test_pred ) | Natural Language Processing with Disaster Tweets |
14,426,199 | def train_model(model, dataloaders_dict, criterion, optimizer, num_epochs, filename):
model.cuda()
for epoch in tqdm(range(num_epochs)) :
for phase in ['train', 'val']:
if phase == 'train':
model.train()
else:
model.eval()
epoch_loss = 0.0
epoch_jaccard = 0.0
for data in tqdm(( dataloaders_dict[phase])) :
ids = data['i... | submission['target'] = model.predict(test_input, verbose=1 ).round().astype(int)
submission.to_csv('submission.csv', index=False ) | Natural Language Processing with Disaster Tweets |
14,195,195 | num_epochs = 5
batch_size = 32
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=seed )<load_from_csv> | !pip install transformers | Natural Language Processing with Disaster Tweets |
14,195,195 | train_df = pd.read_csv('.. /input/tweet-sentiment-extraction/train.csv')
train_df['text'] = train_df['text'].astype(str)
train_df['selected_text'] = train_df['selected_text'].astype(str)
for fold,(train_idx, val_idx)in enumerate(skf.split(train_df, train_df.sentiment), start=1):
print(f'Fold: {fold}')
model = Tweet... | import torch
from torch.utils.data import TensorDataset, random_split
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler
from transformers import BertTokenizer, get_linear_schedule_with_warmup
from transformers import BertForSequenceClassification, AdamW, BertConfig
import torch.nn.functional as ... | Natural Language Processing with Disaster Tweets |
14,195,195 | test_df = pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv')
test_df['text'] = test_df['text'].astype(str)
test_loader = get_test_loader(test_df)
predictions = []
models = []
for fold in range(skf.n_splits):
model = TweetModel()
model.cuda()
model.load_state_dict(torch.load(f'roberta_fold{fold+1}.pth'))
mo... | if torch.cuda.is_available() :
device = torch.device("cuda")
print('There are %d GPU(s)available.{}'.format(torch.cuda.device_count()))
print('We will use the GPU: {}'.format(torch.cuda.get_device_name(0)))
else:
print('No GPU available, using the CPU instead.')
device = torch.device("cpu")
seed_val = 42
random.see... | Natural Language Processing with Disaster Tweets |
14,195,195 | sub_df = pd.read_csv('.. /input/tweet-sentiment-extraction/sample_submission.csv')
sub_df['selected_text'] = predictions
sub_df['selected_text'] = sub_df['selected_text'].apply(lambda x: x.replace('!!!!', '!')if len(x.split())==1 else x)
sub_df['selected_text'] = sub_df['selected_text'].apply(lambda x: x.replace('.. ... | train = pd.read_csv('.. /input/nlp-getting-started/train.csv')
test = pd.read_csv('.. /input/nlp-getting-started/test.csv')
pd.set_option('display.max_colwidth', 150)
train.head() | 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.