kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,195,195 | warnings.filterwarnings('ignore' )<define_variables> | print('Number of training sentences: {:,}
'.format(train.shape[0]))
print('Number of test sentences: {:,}
'.format(test.shape[0])) | Natural Language Processing with Disaster Tweets |
14,195,195 | seed=42<feature_engineering> | def clean_text(text):
text = text.lower()
text = re.sub(r'[!]+','!',text)
text = re.sub(r'[?]+','?',text)
text = re.sub(r'[.]+','.',text)
text = re.sub(r"'","",text)
text = re.sub('\s+', '', text ).strip()
text = re.sub(r'&?',r'and', text)
text = re.sub(r"https?:\/\/t.co\/[A-Za-z0-9]+", "", text)
text = re.su... | Natural Language Processing with Disaster Tweets |
14,195,195 | 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,
... | sentences = train.text.values
labels = train.target.values
sentences_test = test.text.values
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True ) | Natural Language Processing with Disaster Tweets |
14,195,195 | 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... | 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 |
14,195,195 | 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<statistical_test> | max_len = 0
for sent in sentences:
input_ids = tokenizer.encode(sent, add_special_tokens=True)
max_len = max(max_len, len(input_ids))
print('Max sentence length: ', max_len)
| Natural Language Processing with Disaster Tweets |
14,195,195 | 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... | 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 |
14,195,195 | def train_model(model, dataloaders_dict, criterion, optimizer, num_epochs, filename):
model.cuda()
for epoch in 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(dataloaders_dict[phase]):
ids = data['ids'].cuda()
mask... | dataset = TensorDataset(input_ids, attention_masks, labels)
train_size = int(0.8 * 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(val_size)) | Natural Language Processing with Disaster Tweets |
14,195,195 | num_epochs = 10
batch_size = 32
skf = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed )<load_from_csv> | 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 |
14,195,195 | %%time
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 ... | 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 |
14,195,195 | %%time
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}.pt... | optimizer = AdamW(model.parameters() ,
lr = 2e-5,
eps = 1e-8
)
epochs = 4
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 |
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('.. ... | 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)
def format_time(elapsed):
elapsed_rounded = int(round(( elapsed)))
return str(datetime.timedelta(seconds=elapsed_rounded)) | Natural Language Processing with Disaster Tweets |
14,195,195 | warnings.filterwarnings('ignore' )<load_from_csv> | 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.time()
total_train_loss = 0
model.train()
for step, batch in enumerate(train_dataloader):
if step % 40 == 0 and not step == 0:
ela... | Natural Language Processing with Disaster Tweets |
14,195,195 | train_data = pd.read_csv('.. /input/tweet-sentiment-extraction/train.csv')
test_data = pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv' )<count_missing_values> | print('Number of test sentences: {:,}
'.format(test.shape[0]))
sentences_test = test.text.values
input_ids = []
attention_masks = []
for sent in sentences_test:
encoded_dict = tokenizer.encode_plus(
sent,
add_special_tokens = True,
max_length = 64,
pad_to_max_length = True,
return_attention_mask = True,
return_tensors... | Natural Language Processing with Disaster Tweets |
14,195,195 | print(train_data.notnull().sum())
print(train_data.isnull().sum() )<correct_missing_values> | 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 |
14,195,195 | train_data.dropna(axis = 0,inplace=True )<count_missing_values> | all_logits = torch.cat(predictions, dim=0)
probs = F.softmax(all_logits, dim=1 ).cpu().numpy()
probs | Natural Language Processing with Disaster Tweets |
14,195,195 | print(test_data.notnull().sum())
print(test_data.isnull().sum() )<set_options> | threshold = 0.5
preds = np.where(probs[:, 1] > threshold, 1, 0)
preds | Natural Language Processing with Disaster Tweets |
14,195,195 | 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.... | print("Number of tweets labeled as true disaster tweet: ", preds.sum() ) | Natural Language Processing with Disaster Tweets |
14,195,195 | 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-transformers-pytorch/roberta-base/vocab.json',
merges_file='.. /input/roberta-trans... | Y_test = preds | Natural Language Processing with Disaster Tweets |
14,195,195 | <statistical_test><EOS> | df_submission = pd.read_csv('.. /input/nlp-getting-started/sample_submission.csv', index_col=0 ).fillna('')
df_submission['target'] = Y_test
df_submission.to_csv('submission.csv')
!head submission.csv | Natural Language Processing with Disaster Tweets |
14,411,143 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<train_model> | warnings.filterwarnings('ignore')
stop = set(stopwords.words('english'))
%matplotlib inline
plt.style.use('ggplot')
| Natural Language Processing with Disaster Tweets |
14,411,143 | def train_model(model, dataloaders_dict, criterion, optimizer, num_epochs, filename):
model.cuda()
for epoch in 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(dataloaders_dict[phase]):
ids = data['ids'].cuda()
mask... | train = pd.read_csv('.. /input/nlp-getting-started/train.csv')
test = pd.read_csv('.. /input/nlp-getting-started/test.csv')
submission = pd.read_csv('.. /input/nlp-getting-started/sample_submission.csv')
train_sent, test_sent, train_label = train.text.values, test.text.values, train.target.values | Natural Language Processing with Disaster Tweets |
14,411,143 | num_epochs = 3
batch_size = 32
skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=seed )<load_from_csv> | word_tokenizer = Tokenizer()
word_tokenizer.fit_on_texts(train_sent)
vocab_length = len(word_tokenizer.word_index)+ 1 | Natural Language Processing with Disaster Tweets |
14,411,143 | %%time
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 ... | longest_train = max(train_sent, key=lambda sentence: len(word_tokenize(sentence)))
length_long_sentence = len(word_tokenize(longest_train))
padded_sentences = pad_sequences(embed(train_sent), length_long_sentence, padding='post')
test_sentences = pad_sequences(embed(test_sent), length_long_sentence, padding='post' ) | Natural Language Processing with Disaster Tweets |
14,411,143 | 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... | %%time
embeddings_dictionary = dict()
embedding_dim = 100
glove_file = open('.. /input/glove-file/glove.6B.100d.txt')
for line in glove_file:
records = line.split()
word = records[0]
vector_dimensions = np.asarray(records[1:], dtype='float32')
embeddings_dictionary[word] = vector_dimensions
glove_file.close()
embeddi... | Natural Language Processing with Disaster Tweets |
14,411,143 | 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('.. ... | X_train, X_test, y_train, y_test = train_test_split(padded_sentences,
train_label,
test_size=0.25,
random_state=42,
shuffle=True)
| Natural Language Processing with Disaster Tweets |
14,411,143 | print('TF version',tf.__version__ )<load_from_csv> | def training(model, model_name):
checkpoint = ModelCheckpoint(model_name + '.h5', monitor = 'val_loss', verbose = 1, save_best_only = True)
reduce_lr = ReduceLROnPlateau(monitor = 'val_loss', factor = 0.2, verbose = 1, patience = 5, min_lr = 0.001)
early_stop = EarlyStopping(monitor='val_loss', patience=1)
start_tim... | Natural Language Processing with Disaster Tweets |
14,411,143 | 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 CNN() :
model = Sequential()
model.add(Embedding(input_dim=embedding_matrix.shape[0],
output_dim=embedding_matrix.shape[1],
weights=[embedding_matrix],
input_length=length_long_sentence))
model.add(Conv1D(filters=32, kernel_size=8, activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(Flatten())
model... | Natural Language Processing with Disaster Tweets |
14,411,143 | train_list = train_df.to_dict('records' )<define_variables> | training(model, 'model_cnn' ) | Natural Language Processing with Disaster Tweets |
14,411,143 | MAX_SEQUENCE_LENGTH = 0
for image_data in train_list:
MAX_SEQUENCE_LENGTH = max(MAX_SEQUENCE_LENGTH, len(image_data['text'].split(' ')))
print(MAX_SEQUENCE_LENGTH )<define_variables> | def RNN() :
model = Sequential()
model.add(Embedding(input_dim=embedding_matrix.shape[0],
output_dim=embedding_matrix.shape[1],
weights=[embedding_matrix],
input_length=length_long_sentence))
model.add(Bidirectional(SimpleRNN(length_long_sentence, return_sequences = True, recurrent_dropout=0.2)))
model.add(GlobalMaxPo... | Natural Language Processing with Disaster Tweets |
14,411,143 | MAX_SEQUENCE_LENGTH = 0
for image_data in train_list:
MAX_SEQUENCE_LENGTH = max(MAX_SEQUENCE_LENGTH, len(image_data['selected_text'].split(' ')))
print(MAX_SEQUENCE_LENGTH )<string_transform> | training(model, 'model_rnn' ) | Natural Language Processing with Disaster Tweets |
14,411,143 | 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> | def BiGRU() :
model = Sequential()
model.add(Embedding(input_dim=embedding_matrix.shape[0],
output_dim=embedding_matrix.shape[1],
weights=[embedding_matrix],
input_length=length_long_sentence))
model.add(Bidirectional(GRU(length_long_sentence, return_sequences = True, recurrent_dropout=0.2)))
model.add(GlobalMaxPool1D... | Natural Language Processing with Disaster Tweets |
14,411,143 | 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}<define_variables> | training(model, 'model_bigru' ) | Natural Language Processing with Disaster Tweets |
14,411,143 | 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... | def BiLSTM() :
model = Sequential()
model.add(Embedding(input_dim=embedding_matrix.shape[0],
output_dim=embedding_matrix.shape[1],
weights=[embedding_matrix],
input_length=length_long_sentence))
model.add(Bidirectional(LSTM(length_long_sentence, return_sequences = True, recurrent_dropout=0.2)))
model.add(GlobalMaxPool... | Natural Language Processing with Disaster Tweets |
14,411,143 | 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... | training(model, 'model_bilstm' ) | Natural Language Processing with Disaster Tweets |
14,411,143 | <load_pretrained><EOS> | submission.target = model.predict_classes(test_sentences)
submission.to_csv("submission.csv", index=False ) | Natural Language Processing with Disaster Tweets |
14,308,769 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<define_variables> | import tensorflow as tf
from tensorflow import keras
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt | Natural Language Processing with Disaster Tweets |
14,308,769 | n_splits = 5<choose_model_class> | df = pd.read_csv('.. /input/nlp-getting-started/train.csv', index_col=0)
df.head() | Natural Language Processing with Disaster Tweets |
14,308,769 | '<predict_on_test> | df.keyword.value_counts() | Natural Language Processing with Disaster Tweets |
14,308,769 | 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/roberta-kim-cnn/v7-roberta-%i.h5'%i)
print('Predicting Test...')
preds = model.predic... | df.keyword.value_counts(dropna=False ) | Natural Language Processing with Disaster Tweets |
14,308,769 | 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-1:b])
all.append(st)
<save_to_csv> | df.location.value_counts(dropna=False ) | Natural Language Processing with Disaster Tweets |
14,308,769 | test_df['selected_text'] = all
test_df[['textID','selected_text']].to_csv('submission.csv',index=False)
<set_options> | glove = {}
with open(".. /input/glove6b/glove.6B.100d.txt")as f:
for line in f:
glove[line.split() [0]] = line.split() [1:] | Natural Language Processing with Disaster Tweets |
14,308,769 | warnings.filterwarnings('ignore' )<set_options> | word_counts = df.text.str.lower().str.split().explode().value_counts()
word_counts.cumsum() [10000] / word_counts.sum() | Natural Language Processing with Disaster Tweets |
14,308,769 | 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.... | NUM_WORDS = 10000
MAXLEN = 30
texts = df.text.str.lower()
tokenizer = keras.preprocessing.text.Tokenizer(num_words=NUM_WORDS)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
word_index = tokenizer.word_index
data = keras.preprocessing.sequence.pad_sequences(sequences, maxlen=MAXLEN ) | Natural Language Processing with Disaster Tweets |
14,308,769 | 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-transformers-pytorch/roberta-base/vocab.json',
merges_file='.. /input/roberta-trans... | labels = df.target | Natural Language Processing with Disaster Tweets |
14,308,769 | class TweetModel(nn.Module):
def __init__(self):
super(TweetModel, self ).__init__()
config = RobertaConfig.from_pretrained(
'.. /input/roberta-transformers-pytorch/roberta-base/config.json', output_hidden_states=True)
self.roberta = RobertaModel.from_pretrained(
'.. /input/roberta-transformers-pytorch/roberta-base/... | x_train = data
y_train = labels | Natural Language Processing with Disaster Tweets |
14,308,769 | 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<statistical_test> | EMBEDDING_DIM = len(glove["the"])
embedding_matrix = np.zeros(( NUM_WORDS, EMBEDDING_DIM))
for word, i in word_index.items() :
if i < NUM_WORDS:
embedding_vector = glove.get(word)
if embedding_vector is not None:
embedding_matrix[i] = embedding_vector | Natural Language Processing with Disaster Tweets |
14,308,769 | 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... | model = keras.Sequential([
layers.Embedding(NUM_WORDS, EMBEDDING_DIM, input_length=MAXLEN,
name='embedding'),
layers.Bidirectional(layers.GRU(32,
dropout=.2,
recurrent_dropout=.2,)) ,
layers.Dense(1, activation='sigmoid'),
])
model.get_layer('embedding' ).set_weights([embedding_matrix])
model.get_layer('embedding' ).... | Natural Language Processing with Disaster Tweets |
14,308,769 | def train_model(model, dataloaders_dict, criterion, optimizer, num_epochs, filename):
model.cuda()
for epoch in 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(dataloaders_dict[phase]):
ids = data['ids'].cuda()
mask... | early_stopping = keras.callbacks.EarlyStopping(
patience=10,
restore_best_weights=True,
)
lr_decay = keras.callbacks.ReduceLROnPlateau()
history = model.fit(
x_train, y_train,
epochs=50,
batch_size=32,
validation_split=.2,
callbacks=[early_stopping, lr_decay]
) | Natural Language Processing with Disaster Tweets |
14,308,769 | num_epochs = 3
batch_size = 32
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=seed )<load_from_csv> | test_df = pd.read_csv(".. /input/nlp-getting-started/test.csv",
index_col=0)
def preprocess(texts, labels=None, tokenizer=tokenizer):
NUM_WORDS = 10000
MAXLEN = 30
texts = pd.Series(texts ).str.lower()
sequences = tokenizer.texts_to_sequences(texts)
data = keras.preprocessing.sequence.pad_sequences(sequences, maxlen=... | Natural Language Processing with Disaster Tweets |
14,308,769 | <load_from_csv><EOS> | answer_df = pd.read_csv(
'.. /input/nlp-getting-started/sample_submission.csv',
index_col=0
)
answer_df['target'] =(preds > 0.5 ).astype('uint8')
answer_df.to_csv('submission.csv')
!head submission.csv | Natural Language Processing with Disaster Tweets |
14,201,894 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<save_to_csv> | !pip install -U tensorflow-text==2.3 | Natural Language Processing with Disaster Tweets |
14,201,894 | 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('.. ... | !pip install -U tf-models-official==2.3 | Natural Language Processing with Disaster Tweets |
14,201,894 | if not sys.warnoptions:
warnings.simplefilter("ignore")
tqdm.pandas()
print(transformers.__version__)
<choose_model_class> | print("TF version: ", tf.__version__ ) | Natural Language Processing with Disaster Tweets |
14,201,894 | class PoolerStartLogits(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, 1)
def forward(self, hidden_states, p_mask=None):
x = self.dense(hidden_states ).squeeze(-1)
if p_mask is not None:
if next(self.parameters() ).dtype == torch.float16:
x = x *(1 - p_mask)- 655... | train_df = pd.read_csv(".. /input/nlp-getting-started/train.csv")
train_df.info()
train_df.head(6 ) | Natural Language Processing with Disaster Tweets |
14,201,894 | batch_size = 64
beam_size = 3
max_sequence_length = 128<compute_train_metric> | test_df = pd.read_csv(".. /input/nlp-getting-started/test.csv")
test_df.info()
test_df.head(6 ) | Natural Language Processing with Disaster Tweets |
14,201,894 | def find_best_combinations(start_top_log_probs, start_top_index, end_top_log_probs, end_top_index, valid_start= 0, valid_end=512):
best =(valid_start, valid_end - 1)
best_score = -9999
for i in range(len(start_top_log_probs)) :
for j in range(end_top_log_probs.shape[0]):
if valid_start <= start_top_index[i] < valid_en... | for df in [train_df, test_df]:
for col in ['keyword', 'location']:
df[col] = df[col].fillna(f'no_{col}' ) | Natural Language Processing with Disaster Tweets |
14,201,894 | test_df = pd.read_csv(".. /input/tweet-sentiment-extraction/test.csv")
test_df["sep_text"] = test_df.text.apply(lambda x: " ".join(x.split() ).lower())
def get_predictions(x_test, x_type_test, model, is_xlnet=False,drop_head=True):
all_start_top_log_probs = None
all_start_top_index = None
all_end_top_log_probs = None... | mislabeledData = train_df.groupby(['text'] ).nunique().sort_values(by='target', ascending=False)
mislabeledData = mislabeledData[mislabeledData['target'] > 1]['target']
print(f"Total {mislabeledData.shape[0]} mislabled data" ) | Natural Language Processing with Disaster Tweets |
14,201,894 | all_preds = dict()
!mkdir configs
!cp.. /input/roberta-large-quest/roberta-large-vocab.json./configs/vocab.json
!cp.. /input/bart-large/config.json./configs/config.json
!cp.. /input/roberta-large-quest/roberta-large-merges.txt./configs/merges.txt
tokenizer = BartTokenizer.from_pretrained('./configs', do_lower_case=Fals... | train_df['target_relabeled'] = train_df['target'].copy()
train_df.loc[train_df['text'] == 'like for the music video I want some real action shit like burning buildings and police chases not some weak ben winston shit', 'target_relabeled'] = 0
train_df.loc[train_df['text'] == 'Hellfire is surrounded by desires so be car... | Natural Language Processing with Disaster Tweets |
14,201,894 | def get_features(line, tokenizer, sentiment, span=None):
MAX_LEN = 114
MAX_CHAR = 146
pad_token_id = 1
sep_token_id = 2
cls_token_id = 0
encoding = tokenizer.encode(line)
offsets = np.array(encoding.offsets)
token_lenghts = list(np.diff(offsets, axis =1)[:,0])
while sum(token_lenghts)>(MAX_CHAR-4):
token_lenghts = t... | def clean_special_characters(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... | Natural Language Processing with Disaster Tweets |
14,201,894 | all_vals2 = []
for i in tqdm(range(len(test_start_logits))):
test_start_preds, test_end_preds = get_preds(test_start_logits[i], test_end_logits[i], valid_start= 3, valid_end=146)
curr_val = []
for i in range(len(test_text)) :
curr_val += [test_text[i][test_start_preds[i]-3:test_end_preds[i]-3]]
all_vals2.append(curr_v... | def restore_contractions(tweet):
tweet = re.sub(r"he's", "he is", tweet)
tweet = re.sub(r"there's", "there is", tweet)
tweet = re.sub(r"We're", "We are", tweet)
tweet = re.sub(r"That's", "That is", tweet)
tweet = re.sub(r"won't", "will not", tweet)
tweet = re.sub(r"they're", "they are", tweet)
tweet = re.sub(r"Ca... | Natural Language Processing with Disaster Tweets |
14,201,894 | all_vals = [val for val in all_preds.values() ] + all_vals2
print(len(all_vals))
ensembled = []
sep_texts = test_df.text.values
for i in tqdm(range(len(test_df))):
if " " in sep_texts[i]:
ensembled.append(test_pred_text[i])
else:
predictions = [val[i] for val in all_vals]
ensembled.append(ensemble(sep_texts[i], predic... | def restore_character_entity_references(tweet):
tweet = re.sub(r">", ">", tweet)
tweet = re.sub(r"<", "<", tweet)
tweet = re.sub(r"&", "&", tweet)
return tweet | Natural Language Processing with Disaster Tweets |
14,201,894 | if len(all_vals)== 60:
test_df["selected_text"] = ensembled
test_df[["textID","selected_text"]].to_csv("submission.csv",index=False )<set_options> | def restore_typos_slang_and_informal_abbreviations(tweet):
tweet = re.sub(r"w/e", "whatever", tweet)
tweet = re.sub(r"w/", "with", tweet)
tweet = re.sub(r"USAgov", "USA government", tweet)
tweet = re.sub(r"recentlu", "recently", tweet)
tweet = re.sub(r"Ph0tos", "Photos", tweet)
tweet = re.sub(r"amirite", "am I rig... | Natural Language Processing with Disaster Tweets |
14,201,894 | warnings.filterwarnings('ignore' )<set_options> | def restore_hashtags_usernames(tweet):
tweet = re.sub(r"IranDeal", "Iran Deal", tweet)
tweet = re.sub(r"ArianaGrande", "Ariana Grande", tweet)
tweet = re.sub(r"camilacabello97", "camila cabello", tweet)
tweet = re.sub(r"RondaRousey", "Ronda Rousey", tweet)
tweet = re.sub(r"MTVHottest", "MTV Hottest", tweet)
tweet ... | Natural Language Processing with Disaster Tweets |
14,201,894 | 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.... | def restore_acronyms(tweet):
tweet = re.sub(r"MH370", "Malaysia Airlines Flight 370", tweet)
tweet = re.sub(r"m̼sica", "music", tweet)
tweet = re.sub(r"okwx", "Oklahoma City Weather", tweet)
tweet = re.sub(r"arwx", "Arkansas Weather", tweet)
tweet = re.sub(r"gawx", "Georgia Weather", tweet)
tweet = re.sub(r"scwx"... | Natural Language Processing with Disaster Tweets |
14,201,894 | roberta_folder = 'fine-tuning-roberta/roberta_finetuned/'<feature_engineering> | def restore_grouping_same_words_without_embeddings(tweet):
tweet = re.sub(r"Bestnaijamade", "bestnaijamade", tweet)
tweet = re.sub(r"SOUDELOR", "Soudelor", tweet)
return tweet | Natural Language Processing with Disaster Tweets |
14,201,894 | 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=f'.. /input/{roberta_folder}/vocab.json',
merges_file=f'.. /input/{roberta_folder}/merges.txt',
lowerc... | def remove_urls(tweet):
tweet = re.sub("https?:\/\/t.co\/[A-Za-z0-9]*", '', tweet)
return tweet | Natural Language Processing with Disaster Tweets |
14,201,894 | class TweetModel(nn.Module):
def __init__(self):
super(TweetModel, self ).__init__()
config = RobertaConfig.from_pretrained(
f'.. /input/{roberta_folder}/config.json', output_hidden_states=True)
self.roberta = RobertaModel.from_pretrained(
f'.. /input/{roberta_folder}/pytorch_model.bin', config=config)
self.dropout... | def remove_emojis(tweet):
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)
tweet = emoji_pattern.sub(r'', tweet)
return tweet | Natural Language Processing with Disaster Tweets |
14,201,894 | 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
<statistical_test> | def remove_punctuations(tweet):
tweet = tweet.translate(str.maketrans('', '', string.punctuation))
return tweet | Natural Language Processing with Disaster Tweets |
14,201,894 | 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... | %%time
def clean(tweet):
tweet = clean_special_characters(tweet)
tweet = restore_contractions(tweet)
tweet = restore_character_entity_references(tweet)
tweet = restore_typos_slang_and_informal_abbreviations(tweet)
tweet = restore_hashtags_usernames(tweet)
tweet = restore_acronyms(tweet)
tweet = restore_grouping_s... | Natural Language Processing with Disaster Tweets |
14,201,894 | def train_model(model, dataloaders_dict, criterion, optimizer, num_epochs, filename):
model.cuda()
for epoch in 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(dataloaders_dict[phase]):
ids = data['ids'].cuda()
mask... | concat_df = pd.concat([train_df, test_df], axis = 0 ).reset_index(drop = True)
MAX_SEQ_LEN = len(max(concat_df.text_cleaned, key = len))
print('The maximum length of each sequence is:', MAX_SEQ_LEN ) | Natural Language Processing with Disaster Tweets |
14,201,894 | num_epochs = 3
batch_size = 32
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=seed )<import_modules> | AUTOTUNE = tf.data.experimental.AUTOTUNE
BATCH_SIZE = 32
SEED = 42 | Natural Language Processing with Disaster Tweets |
14,201,894 | import gc<load_from_csv> | K = 2
skf = StratifiedKFold(n_splits=K, random_state=SEED, shuffle=True)
DISASTER = train_df['target_relabeled'] == 1
print('Whole Training Set Shape = {}'.format(train_df.shape[0]))
print('Whole Training Set Unique keyword Count = {}'.format(train_df['keyword'].nunique()))
print('Whole Training Set Target Rate(Disast... | Natural Language Processing with Disaster Tweets |
14,201,894 | %%time
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 ... | test_ds_raw = tf.data.Dataset.from_tensor_slices(test_df['text_cleaned'].values)
for text in test_ds_raw.take(5):
print(f'Review: {text}' ) | Natural Language Processing with Disaster Tweets |
14,201,894 | %%time
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}.pt... | BERT_MODEL = 'https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3'
PREPROCESS_MODEL = 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2'
print(f'BERT model selected : {BERT_MODEL}')
print(f'Preprocess model auto-selected: {PREPROCESS_MODEL}' ) | Natural Language Processing with Disaster Tweets |
14,201,894 | sub_df = pd.read_csv('.. /input/tweet-sentiment-extraction/sample_submission.csv')
sub_df['selected_text'] = predictions
sub_df.to_csv('submission.csv', index=False)
sub_df.head()<import_modules> | def make_bert_preprocess_model(sentence_features, seq_length=128):
input_segments = [
tf.keras.layers.Input(shape=() , dtype=tf.string, name=ft)
for ft in sentence_features]
bert_preprocess = hub.load(PREPROCESS_MODEL)
tokenizer = hub.KerasLayer(bert_preprocess.tokenize, name='tokenizer')
segments = [tokenizer(s)f... | Natural Language Processing with Disaster Tweets |
14,201,894 | print('TF version',tf.__version__)
<define_variables> | def build_classifier_model() :
inputs = dict(
input_word_ids=tf.keras.layers.Input(shape=(None,), dtype=tf.int32, name='word_ids'),
input_mask=tf.keras.layers.Input(shape=(None,), dtype=tf.int32, name='mask'),
input_type_ids=tf.keras.layers.Input(shape=(None,), dtype=tf.int32, name='type_ids'),
)
encoder = hub.Keras... | Natural Language Processing with Disaster Tweets |
14,201,894 | 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}
train = pd.read_csv('.. /input/... | def build_classifier_model_em_proc() :
text_input = tf.keras.layers.Input(shape=() , dtype=tf.string, name='text')
preprocessing_layer = hub.KerasLayer(PREPROCESS_MODEL, name='preprocessing')
encoder_inputs = preprocessing_layer(text_input)
encoder = hub.KerasLayer(BERT_MODEL, trainable=True, name='BERT_encoder')
o... | Natural Language Processing with Disaster Tweets |
14,201,894 | 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]):
... | train_ds = train_ds_list[0]
train_ds = train_ds.shuffle(SEED ).batch(BATCH_SIZE)
train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)
valid_ds = valid_ds_list[0]
valid_ds = valid_ds.batch(BATCH_SIZE)
valid_ds = valid_ds.cache().prefetch(buffer_size=AUTOTUNE ) | Natural Language Processing with Disaster Tweets |
14,201,894 | test = pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv' ).fillna('')
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(... | loss = tf.keras.losses.BinaryCrossentropy(from_logits=True)
metrics = tf.metrics.BinaryAccuracy() | Natural Language Processing with Disaster Tweets |
14,201,894 | 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... | EPOCHS = 10
INIT_LR = 3e-5
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)
optimizer = optimization.create_optimizer(init_lr = INIT_LR,
num_train_steps = num_train_steps,
num_warmup_steps = num_warmup_steps,
... | Natural Language Processing with Disaster Tweets |
14,201,894 | 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> | model_em_proc.compile(optimizer=optimizer,
loss=loss,
metrics=metrics ) | Natural Language Processing with Disaster Tweets |
14,201,894 | 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=777)
for fold,(idx... | print('Training model with embedded preprocess model')
history_em_proc = model_em_proc.fit(x=train_ds,
validation_data=valid_ds,
epochs = EPOCHS ) | Natural Language Processing with Disaster Tweets |
14,201,894 | print('>>>> OVERALL 5Fold CV Jaccard =',np.mean(jac))<string_transform> | test_ds = test_ds_raw.batch(BATCH_SIZE ).cache().prefetch(buffer_size=AUTOTUNE)
predict_result_em_proc = tf.sigmoid(model_em_proc.predict(test_ds))
print(predict_result_em_proc ) | Natural Language Processing with Disaster Tweets |
14,201,894 | 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 )<save_to_csv> | train_ds = train_ds_list[1]
train_ds = train_ds.shuffle(SEED ).batch(BATCH_SIZE)
train_ds = train_ds.map(lambda x, y:(preprocess_model(x), y))
train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)
valid_ds = valid_ds_list[1]
valid_ds = valid_ds.batch(BATCH_SIZE)
valid_ds = valid_ds.map(lambda x, y:(preprocess_m... | Natural Language Processing with Disaster Tweets |
14,201,894 | 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> | 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)
optimizer = optimization.create_optimizer(init_lr = INIT_LR,
num_train_steps = num_train_steps,
num_warmup_steps = num_warmup_steps,
optimizer_type = 'adamw' ) | Natural Language Processing with Disaster Tweets |
14,201,894 | print('TF version',tf.__version__ )<define_variables> | model.compile(optimizer=optimizer,
loss=loss,
metrics=metrics ) | Natural Language Processing with Disaster Tweets |
14,201,894 | MAX_LEN = 100
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 = 7
BATCH_SIZE = 32
PAD_ID = 1
SEED = 88888
LABEL_SMOOTHING = 0.1
tf.random.set_seed(SEED)
... | print('Training model without embedded preprocess model')
history_model = model.fit(x=train_ds,
validation_data=valid_ds,
epochs = EPOCHS ) | Natural Language Processing with Disaster Tweets |
14,201,894 | sentiment_id = {'positive': 1313, 'negative': 2430, 'neutral': 7974}
train = pd.read_csv('.. /input/tweet-sentiment-extraction/train.csv' ).fillna('')
train.head()<load_from_csv> | test_ds = test_ds_raw.batch(BATCH_SIZE ).cache().prefetch(buffer_size=AUTOTUNE)
test_ds = test_ds.map(lambda x: preprocess_model(x))
predict_result = tf.sigmoid(model.predict(test_ds))
print(predict_result ) | Natural Language Processing with Disaster Tweets |
14,201,894 | test = pd.read_csv('.. /input/tweet-sentiment-extraction/test.csv' ).fillna('')
test.head()<drop_column> | result_1 = predict_result_em_proc.numpy()
result_2 = predict_result.numpy()
result = []
for i in range(len(result_1)) :
result.append(( result_1[i] + result_2[i])/2)
result = np.round(result)
sample_submission = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
ids = sample_submission.id
final_submi... | Natural Language Processing with Disaster Tweets |
13,965,787 | empties=[]
for x in range(0,train.shape[0]):
text1=train['text'][x]
if text1=="":
empties.append(x)
train=train.drop([x])
train=train.reset_index(drop=True )<drop_column> | %matplotlib inline
nltk.download('stopwords')
nltk.download('punkt')
| Natural Language Processing with Disaster Tweets |
13,965,787 | empties2=[]
url_parts=['http://','https://','www.']
for x in range(0,train.shape[0]):
text1=train['text'][x]
for y in range(0,len(url_parts)) :
url_part=url_parts[y]
idx = text1.find(url_part)
if idx>=0:
if idx<3:
len_url=text1[idx:].find(' ')
if len_url==-1:
empties2.append(x)
train=train.drop([x])
train=train.res... | train = pd.read_csv('.. /input/nlp-getting-started/train.csv')
test = pd.read_csv('.. /input/nlp-getting-started/test.csv')
sub = pd.read_csv('.. /input/nlp-getting-started/sample_submission.csv' ) | Natural Language Processing with Disaster Tweets |
13,965,787 | def lower_text(text):
return text.lower()
train['text_cleaned']=train['text'].apply(lambda x : lower_text(x))
train['selected_text_cleaned0']=train['selected_text'].apply(lambda x : lower_text(x))
test['text_cleaned']=test['text'].apply(lambda x : lower_text(x))<feature_engineering> | train.isnull().sum() | Natural Language Processing with Disaster Tweets |
13,965,787 | def Fix_Spaces(text):
return " ".join(text.split())
train['text_cleaned']=train['text_cleaned'].apply(lambda x : Fix_Spaces(x))
train['selected_text_cleaned0']=train['selected_text_cleaned0'].apply(lambda x : Fix_Spaces(x))
test['text_cleaned']=test['text_cleaned'].apply(lambda x : Fix_Spaces(x))<concatenate> | train=train.drop_duplicates(subset=['text', 'target'], keep='first')
train.shape | Natural Language Processing with Disaster Tweets |
13,965,787 | test['selected_text']=-1
test.head()
df_data=pd.concat([train,test],ignore_index=True, sort=True )<feature_engineering> | train.target.value_counts() | Natural Language Processing with Disaster Tweets |
13,965,787 | df_data['text_cleaned_0']=df_data['text_cleaned']<define_variables> | train['text_length'] = train.text.apply(lambda x: len(x.split()))
test['text_length'] = test.text.apply(lambda x: len(x.split())) | Natural Language Processing with Disaster Tweets |
13,965,787 | tic = timeit.default_timer()
replace_text='[url]'
enc_url_replace=tokenizer.encode(replace_text ).ids
MAX_LEN=200
Tokenizer_indices_orig = np.zeros(( df_data.shape[0],MAX_LEN))
Tokenizer_indices_cleaned = np.zeros(( df_data.shape[0],MAX_LEN))
Tokenizer_encoding_orig = np.zeros(( df_data.shape[0],MAX_LEN))
Tokenizer_enc... | list_= []
for i in train.text:
list_ += i
list_= ''.join(list_)
allWords=list_.split()
vocabulary= set(allWords ) | Natural Language Processing with Disaster Tweets |
13,965,787 | length1=[]
index=[]
for x in range(0,df_data.shape[0]):
text=df_data['text_cleaned'][x]
enc1 = tokenizer.encode(text)
length1.append(len(enc1.ids))
if length1[x] >= max(length1):
index.append(x)
MAX_LEN=max(length1)
MAX_LEN=MAX_LEN+5
Tokenizer_encoding_cleaned_MaxLen=Tokenizer_encoding_cleaned[:,:MAX_LEN]
Tokenizer_... | def create_corpus(df,target):
corpus=[]
for x in df[df['target']==target]['text'].str.split() :
for i in x:
corpus.append(i)
return corpus | Natural Language Processing with Disaster Tweets |
13,965,787 | test=df_data[df_data.selected_text==-1]
test.drop('selected_text',axis=1,inplace=True)
test=test.reset_index(drop=True)
test.shape<sort_values> | string.punctuation | Natural Language Processing with Disaster Tweets |
13,965,787 | train_mislabeled2 = train.groupby(['text_cleaned'] ).nunique().sort_values(by='sentiment', ascending=False)
train_mislabeled2 = train_mislabeled2[train_mislabeled2 ['sentiment'] > 1]['sentiment']
train_mislabeled2.index.tolist()
print(train_mislabeled2)
train_mislabeled3 = train.groupby(['text_cleaned'] ).nunique().s... | stopwords.words('english' ) | Natural Language Processing with Disaster Tweets |
13,965,787 | train['sentiment'][16438]='positive'
train['selected_text_cleaned0'][11431]="holy **** it`s super sunny, friday and whitsun, my tube is deeeesearted.wish i was in the park"
train['selected_text'][11431]="Holy **** it's super sunny, Friday and Whitsun, my tube is deeeesearted.Wish I was in the park"
train['sentiment'][1... | text='hey this is me and I am here to help you '
tokens = word_tokenize(text)
tokens=[word for word in tokens if word not in stopwords.words('english')]
' '.join(tokens ) | 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.