kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,965,787 | train['selected_text_cleaned0'][176]="can`t wait to see her bad n grown ****! lol"
train['selected_text'][176]="can`t wait to see her bad n grown ****! Lol"
train['sentiment'][176]='positive'
train['selected_text_cleaned0'][254]="lol :p"
train['selected_text'][254]="lol :p"
train['sentiment'][254]='positive'
train['sel... | pstem = PorterStemmer()
def clean_text(text):
text= text.lower()
text= re.sub('[0-9]', '', text)
text = "".join([char for char in text if char not in string.punctuation])
tokens = word_tokenize(text)
tokens=[pstem.stem(word)for word in tokens]
text = ' '.join(tokens)
return text | Natural Language Processing with Disaster Tweets |
13,965,787 | train['selected_text_cleaned0'][870]="oh no!!"
train['selected_text'][870]="Oh no!!"
train['sentiment'][870]='negative'
train['sentiment'][982]='negative'
train['sentiment'][1871]='negative'
train['sentiment'][2665]='negative'
train['sentiment'][2976]='negative'
train['selected_text_cleaned0'][7457]="sorry your still n... | train["clean"]=train["text"].apply(clean_text)
test["clean"]=test["text"].apply(clean_text ) | Natural Language Processing with Disaster Tweets |
13,965,787 | 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')
start_tokens_values=[]
end_token... | list_= []
for i in train.clean:
list_ += i
list_= ''.join(list_)
allWords=list_.split()
vocabulary= set(allWords)
len(vocabulary ) | Natural Language Processing with Disaster Tweets |
13,965,787 | ct = test.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.shape[0]):
text1_cleaned = " "+" ".join(test.loc[k,'text_cleaned'].split())
enc_cleaned = tokenizer.encode(text1... | tfidf = TfidfVectorizer(sublinear_tf=True,max_features=60000, min_df=1, norm='l2', ngram_range=(1,2))
features = tfidf.fit_transform(train.clean ).toarray()
features.shape | Natural Language Processing with Disaster Tweets |
13,965,787 | 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<compute_test_metric> | features_test = tfidf.transform(test.clean ).toarray() | Natural Language Processing with Disaster Tweets |
13,965,787 | def loss_fn(y_true, y_pred):
weight_ratio=0.05
weight_offset=1
ll = tf.shape(y_pred)[1]
y_true = y_true[:, :ll]
true_index=tf.argmax(y_true, axis=1)
pred_index=tf.argmax(y_pred, axis=1)
true_index=tf.cast(true_index, tf.float32)
pred_index=tf.cast(pred_index, tf.float32)
weight=abs(true_index-pred_index)*weight_rat... | skf = StratifiedKFold(n_splits=4, random_state=48, shuffle=True)
accuracy=[]
n=1
y=train['target'] | Natural Language Processing with Disaster Tweets |
13,965,787 | 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)
padding = tf.cast(tf.equal(ids, PAD_ID), tf.int32)
lens = MAX_LEN - tf.reduce_sum(padding, -1)
max_len = tf.reduce_max(lens)... | for trn_idx, test_idx in skf.split(features, y):
start_time = time()
X_tr,X_val=features[trn_idx],features[test_idx]
y_tr,y_val=y.iloc[trn_idx],y.iloc[test_idx]
model= LogisticRegression(max_iter=1000,C=3)
model.fit(X_tr,y_tr)
s = model.predict(X_val)
sub[str(n)]= model.predict(features_test)
accuracy.append(accura... | Natural Language Processing with Disaster Tweets |
13,965,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> | np.mean(accuracy)*100 | Natural Language Processing with Disaster Tweets |
13,965,787 | 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))
val_epoch_start = np.zeros(( input_ids.shape[0],MAX_LEN))
val_epoch_end = np.zeros(( input_ids.shape[0],MAX_LEN))
preds_start = np.zeros(( input_ids_t.shape[0],MAX_LEN))
preds_end = np.zer... | from sklearn.metrics import confusion_matrix, classification_report | Natural Language Processing with Disaster Tweets |
13,965,787 | with open('Predictions_Validation.pickle', 'wb')as f:
pickle.dump([oof_start, oof_end], f)
<feature_engineering> | pred_valid_y = model.predict(X_val)
print(classification_report(y_val, pred_valid_y)) | Natural Language Processing with Disaster Tweets |
13,965,787 | print('>>>> OVERALL 5Fold CV Jaccard =',np.mean(jac))<string_transform> | print(confusion_matrix(y_val, pred_valid_y)) | Natural Language Processing with Disaster Tweets |
13,965,787 | all = []
log_indices=[]
for k in range(oof_start.shape[0]):
a = np.argmax(oof_start[k,])
b = np.argmax(oof_end[k,])
a2=Tokenizer_indices_cleaned_MaxLen[k,a-1]
b2=Tokenizer_indices_cleaned_MaxLen[k,b-1]
if a>b:
log_indices.append(k)
st = train.loc[k,'text']
else:
text1 = " "+" ".join(train.loc[k,'text'].split())
enc... | df=sub[['1','2','3','4']].mode(axis=1)
sub['target']=df[0]
sub=sub[['id','target']]
sub['target']=sub['target'].apply(lambda x : int(x)) | Natural Language Processing with Disaster Tweets |
13,965,787 | all = []
log_indices=[]
for k in range(oof_start.shape[0]):
a = np.argmax(oof_start[k,])
b = np.argmax(oof_end[k,])
a2=Tokenizer_indices_cleaned_MaxLen[k,a-1]
b2=Tokenizer_indices_cleaned_MaxLen[k,b-1]
if train.loc[k,'sentiment']=='neutral':
st = train.loc[k,'text']
else:
if a>b:
log_indices.append(k)
st = train.loc... | sub.to_csv('submission.csv',index=False ) | Natural Language Processing with Disaster Tweets |
13,983,655 | all = []
offset_train=train.shape[0]
for k in range(input_ids_t.shape[0]):
a = np.argmax(preds_start[k,])
b = np.argmax(preds_end[k,])
k_shift=k+offset_train
a2=Tokenizer_indices_cleaned_MaxLen[k_shift,a-1]
b2=Tokenizer_indices_cleaned_MaxLen[k_shift,b-1]
if test.loc[k,'sentiment']=='neutral':
st = test.loc[k,'text']... | train_df = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test_df = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv" ) | Natural Language Processing with Disaster Tweets |
13,983,655 | test['selected_text'] = all
test[['textID','selected_text']].to_csv('submission.csv',index=False)
pd.set_option('max_colwidth', 60)
test.sample(25 )<set_options> | print(len(train_df))
train_df = train_df.drop_duplicates('text', keep='last')
print(len(train_df)) | Natural Language Processing with Disaster Tweets |
13,983,655 | %matplotlib inline
warnings.filterwarnings("ignore")
<load_from_csv> | train_df['target'].value_counts() | Natural Language Processing with Disaster Tweets |
13,983,655 | train_data = pd.read_csv('/kaggle/input/tweet-sentiment-extraction/train.csv')
test_data = pd.read_csv('/kaggle/input/tweet-sentiment-extraction/test.csv')
submission = pd.read_csv('/kaggle/input/tweet-sentiment-extraction/sample_submission.csv' )<save_to_csv> | wordLemm = WordNetLemmatizer() | Natural Language Processing with Disaster Tweets |
13,983,655 | x = datetime.datetime.now()
print(x)
minute_now = int(x.strftime("%M"))
print(minute_now)
if(minute_now<44):
test_data.to_csv('submission.csv',index=False)
train_data = []
test_data = []<count_missing_values> | def preprocess_text(text):
text = re.sub(r"http\S+", "", text)
text = re.sub(URLPATTERN,' URL',text)
for emoji in EMOJIS.keys() :
text = text.replace(emoji, "EMOJI" + EMOJIS[emoji])
text = re.sub(USERPATTERN,' URL',text)
text = re.sub('[^a-zA-z]'," ",text)
text = re.sub(SEQPATTERN,SEQREPLACE,text)
text = text.spl... | Natural Language Processing with Disaster Tweets |
13,983,655 | print("No of nan values in text column = ",train_data['text'].isna().sum())
print("No of nan values in selected_text column = ",train_data['selected_text'].isna().sum())
print("
Id of null text column = ", train_data[train_data['text'].isna() ]['textID'])
print("Id of null selected_text column = ", train_data[train_... | train_df['text_cleaned'] = train_df['text'].apply(lambda s : clean(s))
test_df['text_cleaned'] = test_df['text'].apply(lambda s : clean(s)) | Natural Language Processing with Disaster Tweets |
13,983,655 | mn = np.mean(train_data[train_data['sentiment']=='positive']['text'].str.len())
md = np.median(train_data[train_data['sentiment']=='positive']['text'].str.len())
print('Mean length of positive review is ', mn)
print('Median length of positive review is ', md)
mn = np.mean(train_data[train_data['sentiment']=='negati... | !pip install -U tensorflow_text==2.3 | Natural Language Processing with Disaster Tweets |
13,983,655 | stopwords= ['i', 'me', 'my', 'myself', 'we', 'our', 'ours', 'ourselves', 'you', "you're", "you've",\
"you'll", "you'd", 'your', 'yours', 'yourself', 'yourselves', 'he', 'him', 'his', 'himself', \
'she', "she's", 'her', 'hers', 'herself', 'it', "it's", 'its', 'itself', 'they', 'them', 'their',\
'theirs', 'themselves', '... | !pip install -q tf-models-official==2.3 | Natural Language Processing with Disaster Tweets |
13,983,655 | arr = []
for i in train_data['selected_text']:
words = i.split()
cnt = 0
for i in words:
if(i in stopwords):
cnt+=1
if(cnt!=0):
k = round(( float(cnt)/len(words)) *100.0, 0)
else:
k = 0
arr.append(k)
print("There are on average {}% stopwords in one selected_text
".format(round(np.mean(arr), 0)))
<feature_engineering> | import tensorflow as tf
import tensorflow_hub as hub
import tensorflow_text as text
from official.nlp import optimization | Natural Language Processing with Disaster Tweets |
13,983,655 | mn = np.mean(train_data[train_data['sentiment']=='positive']['selected_text'].str.len())
md = np.median(train_data[train_data['sentiment']=='positive']['selected_text'].str.len())
print('Mean length of selected_text in positive review is ', mn)
print('Median length of selected_text in positive review is ', md)
mn =... | X_train, X_valid, y_train, y_valid = train_test_split(train_df['text'].tolist() ,\
train_df['target'].tolist() ,\
test_size=0.15,\
stratify = train_df['target'].tolist() ,\
random_state=0)
| Natural Language Processing with Disaster Tweets |
13,983,655 | x = []
y = []
same_cnt = 0
arr = []
sentences = []
length = train_data.shape[0]
for index, row in train_data.iterrows() :
first = row['text'].split()
d = {}
for j in first:
if(d.get(j)) :
d[j] = d[j]+1
else:
d[j] = 1
cnt = 0
scd = row['selected_text'].split()
for j in scd:
if(d.get(j)!=None and d[j]>0):
cnt+=1
d[j]-=1;... | batch_size = 26
seed = 42
train_ds = tf.data.Dataset.from_tensor_slices(( train_df['text'].tolist() ,train_df['target'].tolist())).batch(batch_size)
valid_ds = tf.data.Dataset.from_tensor_slices(( X_valid,y_valid)).batch(batch_size)
| Natural Language Processing with Disaster Tweets |
13,983,655 | 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))<compute_test_metric> | bert_model_name = 'bert_en_uncased_L-12_H-768_A-12'
map_name_to_handle = {
'bert_en_uncased_L-12_H-768_A-12':
'https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3',
}
map_model_to_preprocess = {
'bert_en_uncased_L-12_H-768_A-12':
'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
}
tfhub_handle_enc... | Natural Language Processing with Disaster Tweets |
13,983,655 | length = train_data.shape[0]
pos_score = []
neg_score = []
neu_score = []
for index, row in train_data.iterrows() :
sent =row['sentiment']
if(sent == 'positive'):
pos_score.append(jaccard(row['text'], row['selected_text']))
if(sent == 'negative'):
neg_score.append(jaccard(row['text'], row['selected_text']))
if(sent == ... | def build_classifier_model() :
text_input = tf.keras.layers.Input(shape=() , dtype=tf.string, name='text')
preprocessing_layer = hub.KerasLayer(tfhub_handle_preprocess, name='preprocessing')
encoder_inputs = preprocessing_layer(text_input)
encoder = hub.KerasLayer(tfhub_handle_encoder, trainable=True, name='BERT_enc... | Natural Language Processing with Disaster Tweets |
13,983,655 | print('TF version',tf.__version__ )<define_variables> | loss = tf.keras.losses.BinaryCrossentropy(from_logits=True)
metrics = tf.metrics.BinaryAccuracy()
| Natural Language Processing with Disaster Tweets |
13,983,655 | train = train_data
test = test_data
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_SMOOTHI... | epochs = 30
steps_per_epoch = tf.data.experimental.cardinality(train_ds ).numpy()
num_train_steps = steps_per_epoch * epochs
num_warmup_steps = int(0.1*num_train_steps)
init_lr = 3e-5
optimizer = optimization.create_optimizer(init_lr=init_lr,
num_train_steps=num_train_steps,
num_warmup_steps=num_warmup_steps,
optimize... | Natural Language Processing with Disaster Tweets |
13,983,655 | 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]):
... | classifier_model.compile(optimizer=optimizer,
loss=loss,
metrics=metrics ) | Natural Language Processing with Disaster Tweets |
13,983,655 | ct = test.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.shape[0]):
text1 = " "+" ".join(test.loc[k,'text'].split())
enc = tokenizer.encode(text1)
s_tok = sentiment_id[... | print(f'Training model with {tfhub_handle_encoder}')
history = classifier_model.fit(x=train_ds, epochs=epochs,validation_data=valid_ds)
| Natural Language Processing with Disaster Tweets |
13,983,655 | 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... | classifier_model.save("./model.h5" ) | Natural Language Processing with Disaster Tweets |
13,983,655 | 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... | probs = classifier_model.predict(test_df["text"])
threshold = 0.40
preds = np.where(probs[:,] > threshold, 1, 0 ) | Natural Language Processing with Disaster Tweets |
13,983,655 | print('>>>> OVERALL 5Fold CV Jaccard =',np.mean(jac))<string_transform> | submission=pd.read_csv('/kaggle/input/nlp-getting-started/sample_submission.csv' ) | Natural Language Processing with Disaster Tweets |
13,983,655 | 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 )<save_to_csv> | submission["target"]=preds | Natural Language Processing with Disaster Tweets |
13,983,655 | <define_variables><EOS> | submission.to_csv('submission.csv', index=False, header=True ) | Natural Language Processing with Disaster Tweets |
13,904,651 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<define_variables> | df = pd.read_csv('.. /input/nlp-getting-started/train.csv',index_col=0)
df_test = pd.read_csv('.. /input/nlp-getting-started/test.csv',index_col=0)
temp = [(x,y)for x,y in zip(list(df['text']),list(df['target'])) ]
random.shuffle(temp)
tweets = [t[0] for t in temp]
y = [t[1] for t in temp]
y = np.array(y ).astype('f... | Natural Language Processing with Disaster Tweets |
13,904,651 | %%time
!python.. /input/tweet-inference-scripts/inference_bert_wwm.py<define_variables> | print('Observations in training set')
print(df['target'].count())
print()
print('Label proportion in training set')
print(df['target'].value_counts() /(sum(df['target'].value_counts())))
print()
print('Observations in test set')
print(df_test['text'].count() ) | Natural Language Processing with Disaster Tweets |
13,904,651 | %%time
!python.. /input/tweet-inference-scripts/inference_albert.py<install_modules> | import tensorflow as tf
from transformers import RobertaTokenizerFast, TFRobertaForSequenceClassification | Natural Language Processing with Disaster Tweets |
13,904,651 | %%time
!pip install /kaggle/input/bertweet-libs/sacrebleu-1.4.10-py3-none-any.whl
!cp -R /kaggle/input/bertweet-libs/fairseq-0.9.0/fairseq-0.9.0 /kaggle/working
!cp -R /kaggle/input/bertweet-libs/fastBPE-0.1.0/fastBPE-0.1.0/ /kaggle/working
!pip install /kaggle/working/fairseq-0.9.0/
!pip install /kaggle/working/fastBP... | model_name = 'roberta-large'
roberta_tokenizer = RobertaTokenizerFast.from_pretrained(model_name)
roberta_seq = TFRobertaForSequenceClassification.from_pretrained(model_name ) | Natural Language Processing with Disaster Tweets |
13,904,651 | %%time
!python.. /input/tweet-inference-scripts/inference_roberta_anton.py<load_pretrained> | for t in tweets:
if '&' in re.sub(r'(&|>|<)','',t):
print(t ) | Natural Language Processing with Disaster Tweets |
13,904,651 | %%time
!python.. /input/tweet-inference-scripts/inference_roberta_large_hiki.py<define_variables> | for t in tweets:
if any([x in t for x in [' btw ',' omg ',' lol ',' thx ']]):
print(t ) | Natural Language Processing with Disaster Tweets |
13,904,651 | %%time
!python.. /input/tweet-inference-scripts/inference_roberta_hiki.py<categorify> | def process_tweets(tweets):
r = tweets
r = [re.sub(r'https?://t.co/\w+','',t)for t in r]
r = [re.sub('&','&',t)for t in r]
r = [re.sub('>','gt',t)for t in r]
r = [re.sub('<','lt',t)for t in r]
return r
tweets = process_tweets(tweets ) | Natural Language Processing with Disaster Tweets |
13,904,651 | def string_from_preds_char_level(texts, preds):
selected_texts = []
n_models = len(preds)
for idx in range(len(texts)) :
data = texts[idx]
start_probas = np.mean(
[preds[i][0][idx] for i in range(n_models)], 0)
end_probas = np.mean(
[preds[i][1][idx] for i in range(n_models)], 0)
start_idx = np.argmax(start_probas... | temp = roberta_tokenizer(tweets[:5],padding='max_length',max_length=50)
temp.keys() | Natural Language Processing with Disaster Tweets |
13,904,651 | print('TF version',tf.__version__ )<load_from_csv> | print('Original tweet:')
print(tweets[0])
print('Encoded tweet:')
print(temp['input_ids'][0])
print('Decoded tweet:')
print(roberta_tokenizer.decode(temp['input_ids'][0])) | Natural Language Processing with Disaster Tweets |
13,904,651 | 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... | all_tweets = list(pd.concat([df,df_test],axis=0)['text'])
all_tweets = process_tweets(all_tweets)
max_len = max([len(t)for t in roberta_tokenizer(all_tweets)['input_ids']])
print(max_len ) | Natural Language Processing with Disaster Tweets |
13,904,651 | 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> | X_train, X_test, y_train, y_test = train_test_split(tweets,y,test_size=0.30)
X_train = roberta_tokenizer(X_train,padding='max_length',max_length=max_len,return_tensors='tf')
X_test = roberta_tokenizer(X_test,padding='max_length',max_length=max_len,return_tensors='tf' ) | Natural Language Processing with Disaster Tweets |
13,904,651 | MAX_LEN = 196
EPOCHS = 3
BATCH_SIZE = 32
PAD_ID = 1
SEED = 42
N_SPLITS = 5
LABEL_SMOOTHING = 0.1
tf.random.set_seed(SEED)
np.random.seed(SEED)
PATH = '.. /input/tf-roberta/'
tokenizer = tokenizers.ByteLevelBPETokenizer(
vocab_file=PATH+'vocab-roberta-base.json',
merges_file=PATH+'merges-roberta-base.txt',
lowercase=... | batch_size = 8
train_dataset = tf.data.Dataset.from_tensor_slices(( dict(X_train),y_train))
train_dataset = train_dataset.batch(batch_size)
test_dataset = tf.data.Dataset.from_tensor_slices(( dict(X_test),y_test))
test_dataset = test_dataset.batch(batch_size ) | Natural Language Processing with Disaster Tweets |
13,904,651 | 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... | temp_x, temp_y = next(iter(test_dataset))
temp = roberta_seq(temp_x,temp_y)
temp | Natural Language Processing with Disaster Tweets |
13,904,651 | 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... | optimizer = tf.keras.optimizers.Adam(learning_rate=5e-6)
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
roberta_seq.compile(optimizer=optimizer,loss=loss,metrics=['accuracy'] ) | Natural Language Processing with Disaster Tweets |
13,904,651 | 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... | history = roberta_seq.fit(train_dataset,epochs=3,
validation_data=test_dataset,
callbacks=[callback_chkpt] ) | Natural Language Processing with Disaster Tweets |
13,904,651 | 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)
padding = tf.cast(tf.equal(ids, PAD_ID), tf.int32)
lens = MAX_LEN - tf.reduce_sum(padding, -1)
max_len = tf.reduce_max(lens)... | roberta_seq.load_weights(chkpt ) | Natural Language Processing with Disaster Tweets |
13,904,651 | 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=N_SPLITS,shuffle=True,random_state=SEED)
for f... | outputs = roberta_seq.predict(test_dataset)
y_pred = outputs[0].argmax(axis=1 ) | Natural Language Processing with Disaster Tweets |
13,904,651 | print('>>>> OVERALL 5Fold CV Jaccard =',np.mean(jac))<string_transform> | print('Confusion matrix:')
print(confusion_matrix(y_test,y_pred,labels=[0,1]))
print()
print('Classification report:')
print(classification_report(y_test,y_pred,labels=[0,1],target_names=['not a disaster','disaster'])) | Natural Language Processing with Disaster Tweets |
13,904,651 | 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_df.loc[k,'text']
else:
text1 = " "+" ".join(test_df.loc[k,'text'].split())
enc = tokenizer.encode(text1)
st = tokenizer.decode(enc.ids[a-2:b-1])
all.append(st )<save_to_csv> | tweets_test = list(df_test['text'])
tweets_test = process_tweets(tweets_test)
X_real_test = roberta_tokenizer(tweets_test,padding='max_length',max_length=max_len,return_tensors='tf')
real_test_dataset = tf.data.Dataset.from_tensor_slices(dict(X_real_test))
real_test_dataset = real_test_dataset.batch(batch_size)
rea... | Natural Language Processing with Disaster Tweets |
13,904,651 | test_df['selected_text'] = all
test_df[['textID','selected_text']].to_csv('submission.csv',index=False)
pd.set_option('max_colwidth', 60)
test_df.sample(25 )<save_to_csv> | outputs_test = roberta_seq.predict(real_test_dataset)
y_pred_test = outputs_test[0].argmax(axis=1 ) | Natural Language Processing with Disaster Tweets |
13,904,651 | test_df['selected_text'] = all
test_df[['textID','selected_text']].to_csv('submission.csv',index=False )<set_options> | results = pd.Series(y_pred_test,index=df_test.index,name='target')
results.to_csv('./submission.csv' ) | Natural Language Processing with Disaster Tweets |
13,420,777 | stop=set(stopwords.words('english'))
warnings.filterwarnings("ignore")
cufflinks.go_offline()
cufflinks.set_config_file(world_readable=True, theme='pearl')
<compute_test_metric> | import numpy as np
import pandas as pd
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 | Natural Language Processing with Disaster Tweets |
13,420,777 | 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))
Actual_1 = 'Twitter Sentiment Analysis'
Predict_1 = 'Sentiment Analysis'
Actual_2 = 'Twitter Sentiment Analysis'
Predict_2 = ... | !wget --quiet https://raw.githubusercontent.com/tensorflow/models/master/official/nlp/bert/tokenization.py | Natural Language Processing with Disaster Tweets |
13,420,777 | ori_train=pd.read_csv('.. /input/tweet-sentiment-extraction/train.csv')
ori_test=pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv')
train = ori_train
test = ori_test
ori_train = ori_train.fillna("")
ori_test = ori_test.fillna("")
train.head(10)
print("There are {} rows and {} columns in train file".forma... | import tokenization | Natural Language Processing with Disaster Tweets |
13,420,777 | train = ori_train
test = ori_test<count_values> | 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 |
13,420,777 | def count_values(df,feature):
total=df.loc[:,feature].value_counts(dropna=False)
percent=round(df.loc[:,feature].value_counts(dropna=False,normalize=True)*100,2)
return pd.concat([total,percent],axis=1,keys=['Total','Percent'] )<set_options> | 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 |
13,420,777 | def hover(hover_color="
return dict(selector="tr:hover",
props=[("background-color", "%s" % hover_color)] )<feature_engineering> | 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 |
13,420,777 | def find_link(string):
url = re.findall('http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F])) +', string)
return "".join(url)
train['target_url']=train['selected_text'].apply(lambda x: find_link(x))
df2=pd.DataFrame(train.loc[train['target_url']!=""]['sentiment'].value_counts() ).reset_index(... | %%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 |
13,420,777 | def create_corpus_text(target):
corpus=[]
for x in train[train['sentiment']==target]['text'].str.split() :
for i in x:
corpus.append(i)
return corpus<categorify> | 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 |
13,420,777 | corpus=create_corpus_text("positive")
dic=defaultdict(int)
for word in corpus:
if word in stop:
dic[word]+=1
top_0=sorted(dic.items() , key=lambda x:x[1],reverse=True)[:20]
corpus=create_corpus_text("negative")
dic=defaultdict(int)
for word in corpus:
if word in stop:
dic[word]+=1
top_1=sorted(dic.items() , key=lam... | 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 |
13,420,777 | def create_corpus_selected_text(target):
corpus=[]
for x in train[train['sentiment']==target]['selected_text'].str.split() :
for i in x:
corpus.append(i)
return corpus<import_modules> | callback = tf.keras.callbacks.EarlyStopping(monitor='loss', patience=3)
train_history = model.fit(
train_input, train_labels,
validation_split=0.2,
epochs=20,
batch_size=8,
callbacks=[callback]
)
model.save('model_bert.h5' ) | Natural Language Processing with Disaster Tweets |
13,420,777 | print('TF version',tf.__version__ )<define_variables> | prediction= model.predict(test_input ) | Natural Language Processing with Disaster Tweets |
13,420,777 | 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_seed(SEED)
n... | submission['target'] = prediction.round().astype(int)
submission.to_csv('submission.csv', index=False ) | Natural Language Processing with Disaster Tweets |
13,420,777 | <categorify><EOS> | train_history = model.fit(
train_input, train_labels,
validation_split=0.2,
epochs=2,
batch_size=8
)
model.save('model_bert.h5' ) | Natural Language Processing with Disaster Tweets |
19,181,160 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<train_model> | !pip install tensorflow_hub
!pip install bert-for-tf2
!pip install tensorflow
!pip install sentencepiece
!pip install transformers | Natural Language Processing with Disaster Tweets |
19,181,160 | 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... | BertTokenizer = bert.bert_tokenization.FullTokenizer
bert_layer = hub.KerasLayer("https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/1", trainable=False)
vocabulary_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
to_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = Ber... | Natural Language Processing with Disaster Tweets |
19,181,160 | 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)
padding = tf.cast(tf.equal(ids, PAD_ID), tf.int32)
lens = MAX_LEN - tf.reduce_sum(padding, -1)
max_len = tf.reduce_max(lens)... | stopwrds = set(stopwords.words('english'))
TAG_RE = re.compile(r'<[^>]+>')
def remove_tags(text):
return TAG_RE.sub('', text)
def preprocess_text(sen):
sentence = emoji.demojize(sen)
sentence = re.sub(r"http:\S+",'',sentence)
sentence = ' '.join([x for x in nltk.word_tokenize(sentence)if x not in stopwrds])
senten... | Natural Language Processing with Disaster Tweets |
19,181,160 | 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... | def tokenize_bert(data):
tokenized = data.apply(( lambda x: tokenizer.convert_tokens_to_ids(['[CLS]'])+ tokenizer.convert_tokens_to_ids(tokenizer.tokenize(x))))
return tokenized
def pad_mask(data_tokenized,max_len):
padded = tf.keras.preprocessing.sequence.pad_sequences(data_tokenized, maxlen=max_len, dtype='int32', pa... | Natural Language Processing with Disaster Tweets |
19,181,160 | print('>>>> OVERALL 5Fold CV Jaccard =',np.mean(jac))<string_transform> | def encode(df):
tweet = tf.ragged.constant([tokenizer.convert_tokens_to_ids(tokenizer.tokenize(s)) for s in df])
cls1 = [tokenizer.convert_tokens_to_ids(['[CLS]'])]*tweet.shape[0]
input_word_ids = tf.concat([cls1, tweet], axis=-1)
input_mask = tf.ones_like(input_word_ids ).to_tensor()
type_cls = tf.zeros_like(cls1)
... | Natural Language Processing with Disaster Tweets |
19,181,160 | 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 )<save_to_csv> | finetune_train = pd.read_csv('/kaggle/input/twitter-sentiment-analysis-hatred-speech/train.csv',encoding="utf-8")
finetune_test = pd.read_csv('/kaggle/input/twitter-sentiment-analysis-hatred-speech/test.csv',encoding="utf-8")
finetune_train["hashtags"]=finetune_train["tweet"].apply(lambda x:re.findall(r"
finetune_tes... | Natural Language Processing with Disaster Tweets |
19,181,160 | test['selected_text'] = all
test[['textID','selected_text']].to_csv('submission.csv',index=False)
pd.set_option('max_colwidth', 60)
test.sample(25 )<import_modules> | train = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv",encoding="utf-8")
test = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv",encoding="utf-8")
train["hashtags"]=train["text"].apply(lambda x:re.findall(r"
test["hashtags"]=test["text"].apply(lambda x:re.findall(r"
train["hashtags"]=train["hashtag... | Natural Language Processing with Disaster Tweets |
19,181,160 | 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 import metrics
import transformers
import tokenizers
from transformers import AdamW
from transformers import get_linea... | finetune_train["clean"] = finetune_train["tweet"].apply(lambda x: preprocess_text(x.lower()))
finetune_test["clean"] = finetune_test["tweet"].apply(lambda x: preprocess_text(x.lower()))
print("length of finetune train set:",len(finetune_train))
print("length of finetune test set:",len(finetune_test)) | Natural Language Processing with Disaster Tweets |
19,181,160 | MAX_LEN = 192
TRAIN_BATCH_SIZE = 8
VALID_BATCH_SIZE = 4
EPOCHS = 5
ROBERTA_PATH = ".. /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
)
<load_pretrained> | train["clean"] = train["text"].apply(lambda x: preprocess_text(x.lower()))
test["clean"] = test["text"].apply(lambda x: preprocess_text(x.lower()))
print("length of train set:",len(train))
print("length of test set:",len(test)) | Natural Language Processing with Disaster Tweets |
19,181,160 | class RoBertaModel(transformers.BertPreTrainedModel):
def __init__(self):
model_config = transformers.RobertaConfig.from_pretrained(ROBERTA_PATH)
model_config.output_hidden_states = True
super(RoBertaModel, self ).__init__(model_config)
self.roberta = transformers.RobertaModel.from_pretrained(ROBERTA_PATH, config=mod... | def extract_features(df,test_df):
txt=' '.join(df[df["target"]==1]["clean"])
disaster_unigram=nltk.FreqDist(nltk.word_tokenize(txt))
txt=' '.join(df[df["target"]==0]["clean"])
nondisaster_unigram=nltk.FreqDist(nltk.word_tokenize(txt))
txt=' '.join(df[df["target"]==1]["clean"])
disaster_bigram=nltk.FreqDist(nltk.bigr... | Natural Language Processing with Disaster Tweets |
19,181,160 | 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: ... | finetune_train,finetune_test = extract_features(finetune_train,finetune_test)
finetune_train.head(2 ) | Natural Language Processing with Disaster Tweets |
19,181,160 | 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... | train,test = extract_features(train,test)
train.head(2 ) | Natural Language Processing with Disaster Tweets |
19,181,160 | def calculate_jaccard_score(
original_tweet,
target_string,
sentiment_val,
best_idxs,
offsets,
verbose=False):
if best_idxs[1] < best_idxs[0]:
best_idxs[1] = best_idxs[0]
filtered_output = ""
for ix in range(best_idxs[0], best_idxs[1] + 1):
filtered_output += original_tweet[offsets[ix][0]: offsets[ix][1]]
if(ix+1)< le... | def build_bert(max_len):
input_ids = keras.layers.Input(shape=(max_len,), name="input_ids", dtype=tf.int32)
input_typ = keras.layers.Input(shape=(max_len,), name="input_type_ids", dtype=tf.int32)
input_mask = keras.layers.Input(shape=(max_len,), name="input_mask", dtype=tf.int32)
input_features = keras.layers.Input(... | Natural Language Processing with Disaster Tweets |
19,181,160 | device = torch.device("cuda")
model1 = RoBertaModel()
model1.to(device)
model1.load_state_dict(torch.load("/kaggle/input/roberta-conv-8fold/trained_models/model_0.bin"))
model1.eval()
model2 = RoBertaModel()
model2.to(device)
model2.load_state_dict(torch.load("/kaggle/input/roberta-conv-8fold/trained_models/model_1.... | all_df = pd.concat([finetune_train,finetune_test])
max_len = get_max_len(all_df["clean"])+ 1
encode_ds_all = encode(all_df["clean"] ) | Natural Language Processing with Disaster Tweets |
19,181,160 | df_test = pd.read_csv(".. /input/tweet-sentiment-extraction/test.csv")
df_test.loc[:, "selected_text"] = df_test.text.values
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.DataL... | encode_ds_tr = {'input_ids':encode_ds_all["input_ids"][0:31962,:],
'input_mask':encode_ds_all["input_mask"][0:31962,:],
'input_type_ids':encode_ds_all["input_type_ids"][0:31962,:]} | Natural Language Processing with Disaster Tweets |
19,181,160 | 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... | features = ['unigram_disas','unigram_nondisas','unigram_disas_hash','unigram_nondisas_hash','bigram_disas','bigram_nondisas']
encode_features_tr = all_df[features].iloc[0:31962,:] | Natural Language Processing with Disaster Tweets |
19,181,160 | fin_output_start = []
fin_output_end = []
fin_padding_lens = []
fin_tweet_tokens = []
fin_orig_sentiment = []
fin_orig_tweet = []
tk0 = tqdm(data_loader, total=len(data_loader))
for bi, d in enumerate(tk0):
ids = d["ids"]
token_type_ids = d["token_type_ids"]
mask = d["mask"]
sentiment = d["sentiment"]
orig_selected = d... | y_enc = finetune_train["target"]
loss = tf.keras.losses.BinaryCrossentropy(from_logits=False)
optimizer = keras.optimizers.Adam(lr=1e-3,decay=1e-3/64)
model.compile(optimizer=optimizer, loss=[loss, loss],metrics=["accuracy"])
checkpoint = tf.keras.callbacks.ModelCheckpoint('model.h5', monitor='val_accuracy', save_be... | Natural Language Processing with Disaster Tweets |
19,181,160 | def get_indicies(text, find_text):
indicies = []
index = 0
while index < len(text):
index = text.find(find_text, index)
if index == -1:
break
indicies.append(index)
index += len(find_text)
return indicies
def add_noise(tweet, pred, sentiment):
pred_idx = tweet.find(pred)
len_pred = len(pred)
ds_idxs = get_indicies... | all_df = pd.concat([train,test])
max_len = get_max_len(train["clean"])+ 1
encode_ds_all = encode(all_df["clean"] ) | Natural Language Processing with Disaster Tweets |
19,181,160 | text_list = df_test.text.values.tolist()
pred_list = final_output
sentiment_list = df_test.sentiment.values.tolist()
<categorify> | encode_ds_tr = {'input_ids':encode_ds_all["input_ids"][0:7613,:],
'input_mask':encode_ds_all["input_mask"][0:7613,:],
'input_type_ids':encode_ds_all["input_type_ids"][0:7613,:]}
encode_ds_tr | Natural Language Processing with Disaster Tweets |
19,181,160 | new_preds = []
for i in range(0,len(text_list)) :
new_pred = add_noise(text_list[i], pred_list[i].strip() , sentiment_list[i])
new_preds.append(new_pred )<load_from_csv> | encode_features_tr = all_df[features].iloc[0:7613,:] | Natural Language Processing with Disaster Tweets |
19,181,160 | sample = pd.read_csv(".. /input/tweet-sentiment-extraction/sample_submission.csv")
sample.loc[:, 'selected_text'] = new_preds
<save_to_csv> | y_enc = train["target"]
loss = tf.keras.losses.BinaryCrossentropy(from_logits=False)
optimizer = keras.optimizers.Adam(lr=1e-5,decay=1e-5/64)
model.compile(optimizer=optimizer, loss=[loss, loss],metrics=["accuracy"])
checkpoint = tf.keras.callbacks.ModelCheckpoint('model.h5', monitor='val_accuracy', save_best_only=T... | Natural Language Processing with Disaster Tweets |
19,181,160 | 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(lambda x: x.replace('.. ', '.')if len(x.split())==1 else x)
sample['selected_text'] = sample['selected_text'].apply(lambda x: x.replace('...', '.... | y_pred=model.predict([encode_ds_tr,encode_features_tr])
y_pred = y_pred.round()
print(classification_report(y_enc,y_pred)) | Natural Language Processing with Disaster Tweets |
19,181,160 | import copy
from transformers import *
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
from tqdm import tqdm
from functools import partial
from multiprocessing import Pool, cpu_count
import tokenizers<init_hyperparams> | encode_ds_ts = {'input_ids':encode_ds_all["input_ids"][7613:,:],
'input_mask':encode_ds_all["input_mask"][7613:,:],
'input_type_ids':encode_ds_all["input_type_ids"][7613:,:]}
encode_ds_ts | Natural Language Processing with Disaster Tweets |
19,181,160 | class Config:
def __init__(self):
self.max_seq_length = 192
self.val_batch_size = 256
self.num_workers = 8<set_options> | encode_features_ts = all_df[features].iloc[7613:,:] | Natural Language Processing with Disaster Tweets |
19,181,160 | Config = Config()<string_transform> | y_pred=model.predict([encode_ds_ts,encode_features_ts])
y_pred= y_pred.round()
submission=pd.read_csv('/kaggle/input/nlp-getting-started/sample_submission.csv')
submission['id']=test['id']
submission['target']=y_pred
submission['target']=submission['target'].astype(int)
submission.head(10)
| Natural Language Processing with Disaster Tweets |
19,181,160 | <import_modules><EOS> | submission.to_csv('sample_submission.csv',index=False ) | Natural Language Processing with Disaster Tweets |
19,079,889 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<load_from_csv> | pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', 20)
pd.set_option('display.max_colwidth', -1 ) | Natural Language Processing with Disaster Tweets |
19,079,889 | def get_test_loader(data_path=".. /input/tweet-sentiment-extraction/",
csv_name="test.csv",
max_seq_length=384,
model_type="bert-base-uncased",
batch_size=4,
num_workers=4):
CURR_PATH = ".. /input/"
csv_path = os.path.join(data_path, csv_name)
df_test = pd.read_csv(csv_path)
df_test.loc[:, "selected_text"] = df_test.... | df = pd.read_csv('.. /input/nlp-getting-started/train.csv')
print(len(df))
print(df.columns)
df | Natural Language Processing with Disaster Tweets |
19,079,889 | class TweetBert(nn.Module):
def __init__(self, model_type="bert-large-uncased", hidden_layers=None):
super(TweetBert, self ).__init__()
self.model_name = 'TweetBert'
self.model_type = model_type
if hidden_layers is None:
hidden_layers = [-1]
self.hidden_layers = hidden_layers
if model_type == "bert-large-uncased":
bert... | def clean_text(text):
text = re.sub(r'http\S+', '', text)
text = re.sub(r"(?:\@)\w+", '', text)
text = re.sub(r'[^a-zA-Z0-9'.,?$&\s]', '', text)
text = text.lower()
return text
for i in range(10):
index = np.random.randint(low=0, high=len(df))
print('Raw text:', df['text'][index])
print('Cleaned text:', clean_text(... | Natural Language Processing with Disaster Tweets |
19,079,889 | def load_check_point(model, checkpoint_path, skip_layers=[]):
checkpoint_to_load = torch.load(checkpoint_path)
model_state_dict = checkpoint_to_load['model']
state_dict = model.state_dict()
keys = list(state_dict.keys())
for key in keys:
if any(s in key for s in skip_layers):
continue
try:
state_dict[key] = model_sta... | def convert_to_features(data, tokenizer, max_len=None):
data = data.replace('
', '')
if max_len is not None:
tokenized = tokenizer.encode_plus(
data,
padding ='max_length',
max_length=max_len,
truncation=True,
return_tensors='np',
return_attention_mask=True,
return_token_type_ids=True,
)
else:
tokenized = tokenizer... | Natural Language Processing with Disaster Tweets |
19,079,889 | def get_logits(model, checkpoint_path, folds, all_input_ids, all_attention_masks, all_token_type_ids=None):
for model_idx, fold in enumerate(folds):
checkpoint = os.path.join(checkpoint_path, "fold_{}.pth".format(fold))
model = load_check_point(model, checkpoint, skip_layers=[])
model.eval()
outputs = model(input_id... | base_model = 'bert-base-uncased'
bert_tokenizer = transformers.BertTokenizer.from_pretrained(base_model)
max_len = 80 | 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.