kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,148,670 | submission_df.to_csv("submission.csv", index=False, header=True )<import_modules> | def remove_url(text):
url = re.compile('https?://\S+|www\.\S+')
return url.sub(r'', text)
remove_url('http://www.kaggle.com/rakkaalhazimi/nlp-disaster-classification/edit?rvi=1' ) | Natural Language Processing with Disaster Tweets |
9,148,670 | import transformers
import torch.nn as nn
import torch
from tqdm import tqdm
import torch
import torch.nn as nn
import pandas as pd
import torch.nn as nn
import numpy as np
from sklearn import model_selection
from sklearn import metrics
from transformers import AdamW
from transformers import get_linear_schedule_with_wa... | df['text'] = df['text'].apply(lambda x: remove_url(x))
retain = df['text'].str.contains(r'http[s]*' ).sum()
print("{} words were left behind".format(retain)) | Natural Language Processing with Disaster Tweets |
9,148,670 | MAX_Len = 512
TRAIN_BATCH_SIZE =8
VALID_BATCH_SIZE = 4
BERT_PATH = '.. /input/bert-base-uncased'
TOKENZIER = transformers.BertTokenizer.from_pretrained(BERT_PATH ,do_lower_case = True )<normalization> | residual = df[df['text'].str.contains(r'http[s]*')]
left_word = []
for i in range(len(residual)) :
print(residual['text'].values[i])
left_word.append(residual['text'].values[i] ) | Natural Language Processing with Disaster Tweets |
9,148,670 | class BertBaseUncased(nn.Module):
def __init__(self):
super(BertBaseUncased,self ).__init__()
self.bert = transformers.BertModel.from_pretrained(BERT_PATH)
self.bert_drop = nn.Dropout(0.4)
self.out = nn.Linear(768,1)
def forward(self,ids,mask,token_type_ids):
out1,out2 = self.bert(
ids ,
attention_mask = mask ,
tok... | for word in left_word:
compiler = re.compile(r'.http.+')
result = compiler.sub('', word)
print(result ) | Natural Language Processing with Disaster Tweets |
9,148,670 | class BERTDataset :
def __init__(self,df):
self.text = df['text'].values
self.target = df['target'].values
self.tokenizer = TOKENZIER
self.max_len = MAX_Len
def __len__(self):
return len(self.text)
def __getitem__(self, item):
text = str(self.text[item])
text = " ".join(text.split())
inputs = self.tokenizer.encode_p... | df['text'] = df['text'].str.replace(r'.http.+', '')
print("http words found {}".format(df['text'].str.contains('http' ).sum())) | Natural Language Processing with Disaster Tweets |
9,148,670 | def loss_fn(outputs, targets):
return nn.BCEWithLogitsLoss()(outputs, targets.view(-1, 1))<train_model> | def remove_html(text):
html = re.compile(r'<.*?>')
return html.sub(r'', text)
print(remove_html(example)) | Natural Language Processing with Disaster Tweets |
9,148,670 | def train_fn(data_loader, model, optimizer, scheduler):
model.train()
for bi, d in tqdm(enumerate(data_loader), total=len(data_loader)) :
ids = d["ids"]
token_type_ids = d["token_type_ids"]
mask = d["mask"]
targets = d["targets"]
ids = ids.to(device, dtype=torch.long)
token_type_ids = token_type_ids.to(device, dtype=t... | df['text'] = df['text'].apply(lambda x: remove_html(x)) | Natural Language Processing with Disaster Tweets |
9,148,670 | def eval_fn(data_loader, model):
model.eval()
fin_targets = []
fin_outputs = []
with torch.no_grad() :
for bi, d in tqdm(enumerate(data_loader), total=len(data_loader)) :
ids = d["ids"]
token_type_ids = d["token_type_ids"]
mask = d["mask"]
targets = d["targets"]
ids = ids.to(device, dtype=torch.long)
token_type_ids = ... | def remove_emoji(text):
emoji_pattern = re.compile("["
u"\U0001F600-\U0001F64F"
u"\U0001F300-\U0001F5FF"
u"\U0001F680-\U0001F6FF"
u"\U0001F1E0-\U0001F1FF"
u"\U00002702-\U000027B0"
u"\U000024C2-\U0001F251"
"]+", flags=re.UNICODE)
return emoji_pattern.sub(r'', text)
remove_emoji("Omg another Earthquake 😔😔" ) | Natural Language Processing with Disaster Tweets |
9,148,670 | DEVICE =torch.device("cuda")
device = torch.device("cuda")
def run(model,EPOCHS):
dfx = pd.read_csv('.. /input/nlp-getting-started/train.csv' ).fillna("none")
df_train, df_valid = model_selection.train_test_split(
dfx,
test_size=0.1,
random_state=42,
stratify=dfx.target.values
)
train_dataset = BERTDataset(
df_t... | df['text'] = df['text'].apply(lambda x: remove_emoji(x)) | Natural Language Processing with Disaster Tweets |
9,148,670 | def sentence_prediction(sentence):
tokenizer = TOKENZIER
max_len = MAX_Len
text = str(sentence)
text = " ".join(text.split())
inputs = tokenizer.encode_plus(
text,
None,
add_special_tokens=True,
max_length=max_len
)
ids = inputs["input_ids"]
mask = inputs["attention_mask"]
token_type_ids = inputs["token_type_ids"]... | def remove_punct(text):
table = str.maketrans('', '', string.punctuation)
return text.translate(table)
example = "I am King
remove_punct(example ) | Natural Language Processing with Disaster Tweets |
9,148,670 | test = pd.read_csv('.. /input/nlp-getting-started/test.csv')
test['target'] = test['text'].apply(sentence_prediction )<prepare_output> | df['text'] = df['text'].apply(lambda x: remove_punct(x)) | Natural Language Processing with Disaster Tweets |
9,148,670 | sub = test[['id','target']]<data_type_conversions> | df = pd.read_csv(".. /input/nlp-disaster-cleaned/tweetDisaster.csv" ) | Natural Language Processing with Disaster Tweets |
9,148,670 | sub['target'] = sub['target'].round().astype('int' )<load_from_csv> | def create_corpus(df):
copy_df = df.copy()
corpus = []
for tweet in tqdm(copy_df["text"]):
words = [word.lower() for word in word_tokenize(tweet)if(( word.isalpha() == 1)&(word not in stop)) ]
corpus.append(words)
return corpus | Natural Language Processing with Disaster Tweets |
9,148,670 | train = pd.read_csv('.. /input/nlp-getting-started/train.csv')
train = train.fillna('None')
ag = train.groupby('keyword' ).agg({'text':np.size, 'target':np.mean} ).rename(columns={'text':'Count', 'target':'Disaster Probability'})
ag.sort_values('Disaster Probability', ascending=False ).head(10 )<filter> | corpus = create_corpus(df ) | Natural Language Processing with Disaster Tweets |
9,148,670 | keyword_list = list(ag[(ag['Count']>2)&(ag['Disaster Probability']>=0.9)].index)
keyword_list<feature_engineering> | embedding_dict = {}
with open("/kaggle/input/glove-global-vectors-for-word-representation/glove.6B.100d.txt")as f:
for line in f:
values = line.split()
word = values[0]
vectors = np.asarray(values[1:], 'float32')
embedding_dict[word] = vectors | Natural Language Processing with Disaster Tweets |
9,148,670 | ids = test['id'][test.keyword.isin(keyword_list)].values
sub['target'][sub['id'].isin(ids)] = 1
sub.head()<save_to_csv> | print("Embedding shape :({},{})".format(len(embedding_dict),
len(embedding_dict['the'])) ) | Natural Language Processing with Disaster Tweets |
9,148,670 | sub.to_csv('submission.csv',index=False )<import_modules> | MAX_LEN = 50
tokenizer_obj = Tokenizer()
tokenizer_obj.fit_on_texts(corpus)
sequences = tokenizer_obj.texts_to_sequences(corpus)
tweet_pad = pad_sequences(sequences, maxlen=MAX_LEN, truncating='post', padding='post' ) | Natural Language Processing with Disaster Tweets |
9,148,670 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt<load_from_csv> | word_index = tokenizer_obj.word_index
print("Number of unique words:", len(word_index)) | Natural Language Processing with Disaster Tweets |
9,148,670 | features = pd.read_csv('.. /input/covid19-global-forecasting-week-1/train.csv')
test_features = pd.read_csv('.. /input/covid19-global-forecasting-week-1/test.csv' )<count_missing_values> | top = sorted(word_index, key=lambda x: word_index[x], reverse=True)[:10]
unknown_index = []
for word in top:
scores =(word, word_index[word])
unknown_index.append(scores)
unknown_index | Natural Language Processing with Disaster Tweets |
9,148,670 | features.isnull().sum()<count_missing_values> | num_words = len(word_index)+ 1
embedding_matrix = np.zeros(( num_words, 100))
for word, i in tqdm(word_index.items()):
if i > num_words:
continue
emb_vec = embedding_dict.get(word)
if emb_vec is not None:
embedding_matrix[i] = emb_vec | Natural Language Processing with Disaster Tweets |
9,148,670 | test_features.isnull().sum()<data_type_conversions> | train = tweet_pad[:train.shape[0]]
test = tweet_pad[train.shape[0]:] | Natural Language Processing with Disaster Tweets |
9,148,670 | features["Date"] = features["Date"].apply(lambda x: x.replace("-",""))
features["Date"] = features["Date"].astype(int)
features.head()<data_type_conversions> | model = Sequential()
embedding = Embedding(num_words, 100, embeddings_initializer=Constant(embedding_matrix),
input_length=MAX_LEN, trainable=False)
model.add(embedding)
model.add(Bidirectional(LSTM(128,
dropout=0.2,
recurrent_dropout=0.2))
)
model.add(Dense(1, activation='sigmoid'))
optimizer = Adam(learning_rate=... | Natural Language Processing with Disaster Tweets |
9,148,670 | test_features["Date"] = test_features["Date"].apply(lambda x: x.replace("-",""))
test_features["Date"] = test_features["Date"].astype(int)
test_features.head()<prepare_x_and_y> | history = model.fit(train, target, batch_size=32, epochs=15,
validation_split=0.2, verbose=1 ) | Natural Language Processing with Disaster Tweets |
9,148,670 | train1_x = features[['Lat','Long','Date']]
train1_y = features[['ConfirmedCases']]
test1_x = test_features[['Lat','Long','Date']]<train_model> | sample_sub = pd.read_csv("/kaggle/input/nlp-getting-started/sample_submission.csv")
sample_sub.shape | Natural Language Processing with Disaster Tweets |
9,148,670 | model = RandomForestClassifier(max_depth=200, random_state=1)
model.fit(train1_x, train1_y)
conf_cases = model.predict(test1_x )<prepare_x_and_y> | y_pred = model.predict(test)
y_pred = np.round(y_pred ).astype(int ).reshape(3263)
sub = pd.DataFrame({'id': sample_sub['id'].values.tolist() , 'target': y_pred})
sub.to_csv("submission.csv", index=False ) | Natural Language Processing with Disaster Tweets |
10,165,272 | train2_x = features[['Lat','Long','Date']]
train2_y = features[['Fatalities']]
test2_x = test_features[['Lat','Long','Date']]<predict_on_test> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import re
import string
from tqdm import tqdm
from gensim.parsing.preprocessing import remove_stopwords
from bs4 import BeautifulSoup
from nltk.stem.snowball import SnowballStemmer
from nltk.stem.wordnet import WordNetLemmatize... | Natural Language Processing with Disaster Tweets |
10,165,272 | model = RandomForestClassifier(max_depth=200, random_state=1)
model.fit(train2_x, train2_y)
fatalities = model.predict(test2_x )<load_from_csv> | train = pd.read_csv(r'/kaggle/input/nlp-getting-started/train.csv')
test = pd.read_csv(r'/kaggle/input/nlp-getting-started/test.csv' ) | Natural Language Processing with Disaster Tweets |
10,165,272 | Sub = pd.read_csv('.. /input/covid19-global-forecasting-week-1/submission.csv')
output = pd.DataFrame({
'ForecastId': Sub['ForecastId'],
'ConfirmedCases': conf_cases,
'Fatalities': fatalities
} )<save_to_csv> | def remove_shortforms(phrase):
phrase = re.sub(r"won't", "will not", phrase)
phrase = re.sub(r"can't", "can not", phrase)
phrase = re.sub(r"n't", " not", phrase)
phrase = re.sub(r"'re", " are", phrase)
phrase = re.sub(r"'s", " is", phrase)
phrase = re.sub(r"'d", " would", phrase)
phrase = re.sub(r"'ll", " will", ... | Natural Language Processing with Disaster Tweets |
10,165,272 | output.to_csv('submission.csv', index=False )<import_modules> | Y = train['target']
train = train.drop('target',axis=1)
data = pd.concat([train,test],axis=0 ).reset_index(drop=True)
data.head() | Natural Language Processing with Disaster Tweets |
10,165,272 | import numpy as np
import pandas as pd
import xgboost as xgb
from xgboost import plot_importance, plot_tree
from sklearn.metrics import mean_squared_error, mean_absolute_error
from sklearn.ensemble import RandomForestRegressor<load_from_csv> | for i in range(len(data['text'])) :
data['text'][i] = str(data['text'][i] ) | Natural Language Processing with Disaster Tweets |
10,165,272 | train = pd.read_csv(".. /input/covid19-global-forecasting-week-1/train.csv")
test = pd.read_csv(".. /input/covid19-global-forecasting-week-1/test.csv" )<drop_column> | for i in range(len(data['text'])) :
data['text'][i] = remove_shortforms(data['text'][i])
data['text'][i] = remove_special_char(data['text'][i])
data['text'][i] = remove_wordswithnum(data['text'][i])
data['text'][i] = lowercase(data['text'][i])
data['text'][i] = remove_stop_words(data['text'][i])
text = data['text'... | Natural Language Processing with Disaster Tweets |
10,165,272 | X_train = train.drop(["Fatalities", "ConfirmedCases"], axis=1 )<define_variables> | cv = CountVectorizer(ngram_range=(1,3))
text_bow = cv.fit_transform(data['text'])
print(text_bow.shape ) | Natural Language Processing with Disaster Tweets |
10,165,272 | countries = X_train["Country/Region"]<drop_column> | train_text = text_bow[:train.shape[0]]
test_text = text_bow[train.shape[0]:] | Natural Language Processing with Disaster Tweets |
10,165,272 | X_train = X_train.drop(["Id"], axis=1)
X_test = test.drop(["ForecastId"], axis=1 )<data_type_conversions> | X_train,X_test,Y_train,Y_test = train_test_split(train_text,Y,test_size=0.2)
print(X_train.shape)
print(X_test.shape)
print(Y_train.shape)
print(Y_test.shape ) | Natural Language Processing with Disaster Tweets |
10,165,272 | X_train['Date']= pd.to_datetime(X_train['Date'])
X_test['Date']= pd.to_datetime(X_test['Date'] )<rename_columns> | lr = LogisticRegression(C=10,penalty='l2')
lr.fit(X_train,Y_train)
pred = lr.predict(X_test)
print("F1 score :",f1_score(Y_test,pred))
print("Classification Report
:",classification_report(Y_test,pred)) | Natural Language Processing with Disaster Tweets |
10,165,272 | X_train = X_train.set_index(['Date'])
X_test = X_test.set_index(['Date'] )<feature_engineering> | lr = LogisticRegression(C=10,penalty='l2',max_iter=2000)
lr.fit(train_text,Y)
pred = lr.predict(test_text)
submit = pd.DataFrame(test['id'],columns=['id'])
print(len(pred))
submit.head() | Natural Language Processing with Disaster Tweets |
10,165,272 | def create_time_features(df):
df['date'] = df.index
df['hour'] = df['date'].dt.hour
df['dayofweek'] = df['date'].dt.dayofweek
df['quarter'] = df['date'].dt.quarter
df['month'] = df['date'].dt.month
df['year'] = df['date'].dt.year
df['dayofyear'] = df['date'].dt.dayofyear
df['dayofmonth'] = df['date'].dt.day
df['weeko... | submit['target'] = pred
submit.to_csv("realnlp.csv",index=False ) | Natural Language Processing with Disaster Tweets |
10,165,272 | create_time_features(X_train)
create_time_features(X_test )<drop_column> | tfidf = TfidfVectorizer(ngram_range=(1,3))
text_tfidf = tfidf.fit_transform(data['text'])
print(text_tfidf.shape ) | Natural Language Processing with Disaster Tweets |
10,165,272 | X_train.drop("date", axis=1, inplace=True)
X_test.drop("date", axis=1, inplace=True )<categorify> | X_train,X_test,Y_train,Y_test = train_test_split(train_text,Y,test_size=0.2)
print(X_train.shape)
print(X_test.shape)
print(Y_train.shape)
print(Y_test.shape ) | Natural Language Processing with Disaster Tweets |
10,165,272 | X_train = pd.concat([X_train,pd.get_dummies(X_train['Province/State'], prefix='ps')],axis=1)
X_train.drop(['Province/State'],axis=1, inplace=True)
X_test = pd.concat([X_test,pd.get_dummies(X_test['Province/State'], prefix='ps')],axis=1)
X_test.drop(['Province/State'],axis=1, inplace=True )<categorify> | lr = LogisticRegression(C=100,penalty='l2',max_iter=2000)
lr.fit(X_train,Y_train)
pred = lr.predict(X_test)
print("F1 score :",f1_score(Y_test,pred))
print("Classification Report :",classification_report(Y_test,pred)) | Natural Language Processing with Disaster Tweets |
10,165,272 | X_train = pd.concat([X_train,pd.get_dummies(X_train['Country/Region'], prefix='cr')],axis=1)
X_train.drop(['Country/Region'],axis=1, inplace=True)
X_test = pd.concat([X_test,pd.get_dummies(X_test['Country/Region'], prefix='cr')],axis=1)
X_test.drop(['Country/Region'],axis=1, inplace=True )<prepare_x_and_y> | print("Number of null values in data keywords column : ",data['keyword'].isnull().sum() ) | Natural Language Processing with Disaster Tweets |
10,165,272 | y_train = train["Fatalities"]<load_from_csv> | data['keyword'] = data['keyword'].fillna("unknown")
data.head() | Natural Language Processing with Disaster Tweets |
10,165,272 | submissionOrig = pd.read_csv(".. /input/covid19-global-forecasting-week-1/submission.csv" )<predict_on_test> | combined_text = [None] * len(data['text'])
for i in range(len(data['text'])) :
if data['keyword'][i] == 'unknown':
combined_text[i] = data['text'][i]
else:
combined_text[i] = data['text'][i] + " " + data['keyword'][i] + " " + data['keyword'][i] + " " + data['keyword'][i]
data['combined_text'] = combined_text | Natural Language Processing with Disaster Tweets |
10,165,272 | y_train = train["ConfirmedCases"]
confirmed_reg = RandomForestRegressor(max_depth=100,n_jobs=-1,n_estimators=100)
confirmed_reg.fit(X_train, y_train)
preds = confirmed_reg.predict(X_test)
preds = np.array(preds)
preds[preds < 0] = 0
preds = np.round(preds, 0)
preds = np.array(preds)
submissionOrig["ConfirmedCases... | for i in range(len(data['combined_text'])) :
data['combined_text'][i] = str(data['combined_text'][i] ) | Natural Language Processing with Disaster Tweets |
10,165,272 | y_train = train["Fatalities"]
confirmed_reg = RandomForestRegressor(max_depth=100,n_jobs=-1,n_estimators=100)
confirmed_reg.fit(X_train, y_train)
preds = confirmed_reg.predict(X_test)
preds = np.array(preds)
preds[preds < 0] = 0
preds = np.round(preds, 0)
submissionOrig["Fatalities"]=pd.Series(preds)
<save_to_csv> | for i in range(len(data['combined_text'])) :
data['combined_text'][i] = remove_shortforms(data['combined_text'][i])
data['combined_text'][i] = remove_special_char(data['combined_text'][i])
data['combined_text'][i] = remove_wordswithnum(data['combined_text'][i])
data['combined_text'][i] = lowercase(data['combined_tex... | Natural Language Processing with Disaster Tweets |
10,165,272 | submissionOrig.to_csv('submission.csv',index=False )<load_from_csv> | cv = CountVectorizer(ngram_range=(1,3))
text_bow = cv.fit_transform(data['combined_text'])
print(text_bow.shape ) | Natural Language Processing with Disaster Tweets |
10,165,272 | path = '.. /input/covid19-global-forecasting-week-1/'
train = pd.read_csv(path + 'train.csv')
test = pd.read_csv(path + 'test.csv')
sub = pd.read_csv(path + 'submission.csv')
train['Date'] = train['Date'].apply(lambda x:(datetime.datetime.strptime(x, '%Y-%m-%d')))
test['Date'] = test['Date'].apply(lambda x:(datetim... | train_text = text_bow[:train.shape[0]]
test_text = text_bow[train.shape[0]:] | Natural Language Processing with Disaster Tweets |
10,165,272 | train_p_c = train.pivot(index='Area', columns='days', values='ConfirmedCases' ).sort_index()
train_p_f = train.pivot(index='Area', columns='days', values='Fatalities' ).sort_index()
train_p_c = np.maximum.accumulate(train_p_c, axis=1)
train_p_f = np.maximum.accumulate(train_p_f, axis=1)
f_rate =(train_p_f / train_p_c... | X_train,X_test,Y_train,Y_test = train_test_split(train_text,Y,test_size=0.2)
print(X_train.shape)
print(X_test.shape)
print(Y_train.shape)
print(Y_test.shape ) | Natural Language Processing with Disaster Tweets |
10,165,272 | def eval1(y, p):
val_len = y.shape[1] - TRAIN_N
return np.sqrt(mean_squared_error(y[:, TRAIN_N:TRAIN_N+val_len].flatten() , p[:, TRAIN_N:TRAIN_N+val_len].flatten()))
def run_c(params, X, test_size=50):
gr_base = []
for i in range(X_c.shape[0]):
temp = X[i,:]
threshold = np.log(1+params['min cases for growth rate'])
nu... | lr = LogisticRegression(C=1,penalty='l2',max_iter=2000)
lr.fit(X_train,Y_train)
pred = lr.predict(X_test)
print("F1 score :",f1_score(Y_test,pred))
print("Classification Report :",classification_report(Y_test,pred)) | Natural Language Processing with Disaster Tweets |
10,165,272 | def run_f(params, X_c, X_f, X_f_r, test_size=50):
X_f_r = np.array(np.ma.mean(np.ma.masked_outside(X_f_r, 0.06, 0.4)[:,:], axis=1))
X_f_r = np.clip(X_f_r, params['fatality_rate_lower'], params['fatality_rate_upper'])
X_c = np.clip(np.exp(X_c)-1, 0, None)
preds = X_f.copy()
train_size = X_f.shape[1] - 1
for i in range... | tfidf = TfidfVectorizer(ngram_range=(1,3))
text_tfidf = tfidf.fit_transform(data['combined_text'])
print(text_tfidf.shape ) | Natural Language Processing with Disaster Tweets |
10,165,272 | if False:
val_len = train_p_c.values.shape[1] - TRAIN_N
for i in range(val_len):
d = i + TRAIN_N
m1 = np.sqrt(mean_squared_error(np.log(1 + train_p_c.values[:, d]), preds_c[:, d]))
m2 = np.sqrt(mean_squared_error(np.log(1 + train_p_f.values[:, d]), preds_f[:, d]))
print(f"{d}: {(m1 + m2)/2:8.5f} [{m1:8.5f} {m2:8.5f}]")... | train_text = text_tfidf[:train.shape[0]]
test_text = text_tfidf[train.shape[0]:] | Natural Language Processing with Disaster Tweets |
10,165,272 | temp = pd.DataFrame(np.clip(np.exp(preds_c)- 1, 0, None))
temp['Area'] = AREAS
temp = temp.melt(id_vars='Area', var_name='days', value_name="ConfirmedCases")
test = test.merge(temp, how='left', left_on=['Area', 'days'], right_on=['Area', 'days'])
temp = pd.DataFrame(np.clip(np.exp(preds_f)- 1, 0, None))
temp['Area'] ... | X_train,X_test,Y_train,Y_test = train_test_split(train_text,Y,test_size=0.2)
print(X_train.shape)
print(X_test.shape)
print(Y_train.shape)
print(Y_test.shape ) | Natural Language Processing with Disaster Tweets |
10,165,272 | test.to_csv("submission.csv", index=False, columns=["ForecastId", "ConfirmedCases", "Fatalities"] )<sort_values> | lr = LogisticRegression(C=2,penalty='l2',max_iter=2000)
lr.fit(X_train,Y_train)
pred = lr.predict(X_test)
print("F1 score :",f1_score(Y_test,pred))
print("Classification Report :",classification_report(Y_test,pred)) | Natural Language Processing with Disaster Tweets |
10,165,272 | for i, rec in test.groupby('Area' ).last().sort_values("ConfirmedCases", ascending=False ).iterrows() :
print(f"{rec['ConfirmedCases']:10.1f} {rec['Fatalities']:10.1f} {rec['Country/Region']}, {rec['Province/State']}")
<set_options> | print('Loading word vectors...')
word2vec = {}
with open(os.path.join('.. /input/glove-global-vectors-for-word-representation/glove.6B.200d.txt'), encoding = "utf-8")as f:
for line in f:
values = line.split()
word = values[0]
vec = np.asarray(values[1:], dtype='float32')
word2vec[word] = vec
print('Found %s word vect... | Natural Language Processing with Disaster Tweets |
10,165,272 | %matplotlib inline
InteractiveShell.ast_node_interactivity = "all"
pd.set_option('display.max_columns', 99)
pd.set_option('display.max_rows', 99)
<set_options> | train = pd.read_csv(r'/kaggle/input/nlp-getting-started/train.csv')
test = pd.read_csv(r'/kaggle/input/nlp-getting-started/test.csv' ) | Natural Language Processing with Disaster Tweets |
10,165,272 | plt.rcParams['figure.figsize'] = [16, 10]
plt.rcParams['font.size'] = 14
sns.set_palette(sns.color_palette('tab20', 20))<define_variables> | Y = train['target']
train = train.drop('target',axis=1)
data = pd.concat([train,test],axis=0 ).reset_index(drop=True)
text_data = data['text'] | Natural Language Processing with Disaster Tweets |
10,165,272 | DATEFORMAT = '%Y-%m-%d'<define_variables> | tokenizer = Tokenizer()
tokenizer.fit_on_texts(text_data)
sequences = tokenizer.texts_to_sequences(text_data ) | Natural Language Processing with Disaster Tweets |
10,165,272 | COMP = 'covid19-global-forecasting-week-1'<load_from_csv> | word2index = tokenizer.word_index
print("Number of unique tokens : ",len(word2index)) | Natural Language Processing with Disaster Tweets |
10,165,272 | train = pd.read_csv(f'.. /input/{COMP}/train.csv')
test = pd.read_csv(f'.. /input/{COMP}/test.csv')
submission = pd.read_csv(f'.. /input/{COMP}/submission.csv')
train.shape, test.shape, submission.shape<feature_engineering> | train_pad = data_padded[:train.shape[0]]
test_pad = data_padded[train.shape[0]:] | Natural Language Processing with Disaster Tweets |
10,165,272 | def to_log(x):
return np.log(x + 1)
def to_exp(x):
return np.exp(x)- 1<prepare_output> | embedding_matrix = np.zeros(( len(word2index)+1,200))
embedding_vec=[]
for word, i in tqdm(word2index.items()):
embedding_vec = word2vec.get(word)
if embedding_vec is not None:
embedding_matrix[i] = embedding_vec | Natural Language Processing with Disaster Tweets |
10,165,272 | np.arange(10)
to_exp(to_log(np.arange(10)) )<feature_engineering> | model1 = keras.models.Sequential([
keras.layers.Embedding(len(word2index)+1,200,weights=[embedding_matrix],input_length=100,trainable=False),
keras.layers.LSTM(100,return_sequences=True),
keras.layers.LSTM(200),
keras.layers.Dropout(0.5),
keras.layers.Dense(1,activation='sigmoid')
] ) | Natural Language Processing with Disaster Tweets |
10,165,272 | train['Location'] = train['Country/Region'] + '-' + train['Province/State'].fillna('')
train['Location'] = train['Location'].str.replace(',', '')
test['Location'] = test['Country/Region'] + '-' + test['Province/State'].fillna('')
test['Location'] = test['Location'].str.replace(',', '')
train['LogConfirmed'] = to_lo... | model1.compile(
loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'],
) | Natural Language Processing with Disaster Tweets |
10,165,272 | dfs = []
for loc, df in tqdm(train.groupby('Location')) :
df = df.sort_values(by='Date')
df['LogFatalities'] = df['LogFatalities'].cummax()
df['LogConfirmed'] = df['LogConfirmed'].cummax()
df['LogConfirmedNextDay'] = df['LogConfirmed'].shift(-1)
df['DateNextDay'] = df['Date'].shift(-1)
df['LogFatalitiesNextDay'] = d... | history1 = model1.fit(train_pad,Y,
batch_size=64,
epochs=10,
validation_split=0.2
) | Natural Language Processing with Disaster Tweets |
10,165,272 | deltas = dfs[np.logical_and(
dfs.LogConfirmed > 0,
~dfs.Location.str.startswith('China')
)].dropna().sort_values(by='LogConfirmedDelta', ascending=False)
deltas['start'] = deltas['LogConfirmed'].round(1)
confirmed_deltas = pd.concat([
deltas.groupby('start')[['LogConfirmedDelta']].mean() ,
deltas.groupby('start')[['... | model2 = keras.models.Sequential([
keras.layers.Embedding(len(word2index)+1,200,weights=[embedding_matrix],input_length=100,trainable=False),
keras.layers.GRU(100,return_sequences=True),
keras.layers.GRU(200),
keras.layers.Dropout(0.5),
keras.layers.Dense(1,activation='sigmoid')
] ) | Natural Language Processing with Disaster Tweets |
10,165,272 | DECAY = 0.93
DECAY ** 14, DECAY ** 27<feature_engineering> | model2.compile(
loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'],
) | Natural Language Processing with Disaster Tweets |
10,165,272 | confirmed_deltas = train.groupby('Location')[['Id']].count()
confirmed_deltas['DELTA'] = 0.18
confirmed_deltas.loc[confirmed_deltas.index.str.startswith('China'), 'DELTA'] = 0.02
confirmed_deltas.loc[confirmed_deltas.index.str.startswith('US'), 'DELTA'] = 0.24
confirmed_deltas.loc[confirmed_deltas.index=='Turkey-', 'DE... | history2 = model2.fit(train_pad,Y,
batch_size=64,
epochs=10,
validation_split=0.2
) | Natural Language Processing with Disaster Tweets |
10,165,272 | daily_log_confirmed = dfs.pivot('Location', 'Date', 'LogConfirmed' ).reset_index()
daily_log_confirmed = daily_log_confirmed.sort_values('2020-03-24', ascending=False)
daily_log_confirmed.to_csv('daily_log_confirmed.csv', index=False)
for i, d in tqdm(enumerate(pd.date_range('2020-03-25', '2020-04-24'))):
new_day = s... | model3 = keras.models.Sequential([
keras.layers.Embedding(len(word2index)+1,200,weights=[embedding_matrix],input_length=100,trainable=False),
keras.layers.Bidirectional(keras.layers.LSTM(100,return_sequences=True)) ,
keras.layers.Bidirectional(keras.layers.LSTM(200)) ,
keras.layers.Dropout(0.5),
keras.layers.Dense(1,ac... | Natural Language Processing with Disaster Tweets |
10,165,272 | confirmed_deltas = train.groupby('Location')[['Id']].count()
confirmed_deltas['DELTA'] = 0.18
confirmed_deltas.loc[confirmed_deltas.index.str.startswith('China'), 'DELTA'] = 0.02
confirmed_deltas.loc[confirmed_deltas.index.str.startswith('US'), 'DELTA'] = 0.2
confirmed_deltas.loc[confirmed_deltas.index=='Turkey-', 'DEL... | model3.compile(
loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'],
) | Natural Language Processing with Disaster Tweets |
10,165,272 | death_deltas = dfs[np.logical_and(
dfs.Fatalities > 0,
~dfs.Location.str.startswith('China')
)].dropna().sort_values(by='LogFatalitiesDelta', ascending=False )<save_to_csv> | history3 = model3.fit(train_pad,Y,
batch_size=64,
epochs=10,
validation_split=0.2
) | Natural Language Processing with Disaster Tweets |
10,165,272 | loc_confirmed_death_deltas = pd.concat([
death_deltas.groupby('Location')[['LogFatalitiesDelta']].mean() ,
death_deltas.groupby('Location')[['LogFatalitiesDelta']].std() ,
death_deltas.groupby('Location')[['LogFatalitiesDelta']].count() ,
death_deltas.groupby('Location')[['LogFatalities']].max()
], axis=1)
loc_confirm... | es = tf.keras.callbacks.EarlyStopping(monitor='val_accuracy',mode='max',verbose=1,patience=3 ) | Natural Language Processing with Disaster Tweets |
10,165,272 | death_deltas = train.groupby('Location')[['Id']].count()
death_deltas['DELTA'] = 0.17
death_deltas.loc[death_deltas.index.str.startswith('China'), 'DELTA'] = 0.01
death_deltas.loc[death_deltas.index.str.startswith('US'), 'DELTA'] = 0.15
death_deltas.loc[death_deltas.index=='Turkey-', 'DELTA'] = 0.23
death_deltas.loc[de... | history = model3.fit(train_pad,Y,
batch_size=64,
epochs=30,
validation_split=0.2,
callbacks=[es]
) | Natural Language Processing with Disaster Tweets |
10,165,272 | daily_log_deaths = dfs.pivot('Location', 'Date', 'LogFatalities' ).reset_index()
daily_log_deaths = daily_log_deaths.sort_values('2020-03-24', ascending=False)
daily_log_deaths.to_csv('daily_log_deaths.csv', index=False)
for i, d in tqdm(enumerate(pd.date_range('2020-03-25', '2020-04-24'))):
new_day = str(d ).split('... | submit = pd.DataFrame(test['id'],columns=['id'])
predictions = model3.predict(test_pad)
submit['target_prob'] = predictions
submit.head() | Natural Language Processing with Disaster Tweets |
10,165,272 | confirmed = []
fatalities = []
for id, d, loc in tqdm(test.values):
c = to_exp(daily_log_confirmed.loc[daily_log_confirmed.Location == loc, d].values[0])
f = to_exp(daily_log_deaths.loc[daily_log_deaths.Location == loc, d].values[0])
confirmed.append(c)
fatalities.append(f )<prepare_output> | target = [None]*len(submit)
for i in range(len(submit)) :
target[i] = np.round(submit['target_prob'][i] ).astype(int)
submit['target'] = target
submit.head() | Natural Language Processing with Disaster Tweets |
10,165,272 | my_submission = test.copy()
my_submission['ConfirmedCases'] = confirmed
my_submission['Fatalities'] = fatalities
my_submission.head()
my_submission.shape
<save_to_csv> | submit = submit.drop('target_prob',axis=1)
submit.to_csv('real-nlp_lstm.csv',index=False ) | Natural Language Processing with Disaster Tweets |
10,165,272 | my_submission[[
'ForecastId', 'ConfirmedCases', 'Fatalities'
]].to_csv('submission.csv', index=False)
print(DECAY)
my_submission.head()
my_submission.tail()
my_submission.shape<load_from_csv> | train = pd.read_csv(r'/kaggle/input/nlp-getting-started/train.csv')
test = pd.read_csv(r'/kaggle/input/nlp-getting-started/test.csv' ) | Natural Language Processing with Disaster Tweets |
10,165,272 |
<load_from_csv> | Y = train['target']
train = train.drop('target',axis=1)
text_data_train = train['text']
text_data_test = test['text'] | Natural Language Processing with Disaster Tweets |
10,165,272 | df = pd.read_csv("/kaggle/input/covid19-global-forecasting-week-1/train.csv",index_col='Id')
test = pd.read_csv("/kaggle/input/covid19-global-forecasting-week-1/test.csv")
e2= set(df['Country/Region'])
df['ConfirmedCases']=df['ConfirmedCases'].astype(int)
df['Fatalities']=df['Fatalities'].astype(int)
df["Date"] = ... | Y.value_counts() | Natural Language Processing with Disaster Tweets |
10,165,272 | df['ConfirmedCases']=df['ConfirmedCases'].astype(int)
df['Fatalities']=df['Fatalities'].astype(int)
df["Date"] = pd.to_datetime(df["Date"])
df['Weekday']= df.apply(lambda row: row["Date"].weekday() ,axis=1)
df["Weekday"] =(df["Weekday"] < 5 ).astype(int )<count_missing_values> | tokenizer = transformers.BertTokenizer.from_pretrained('bert-large-uncased', do_lower_case=True)
bert_model = transformers.TFBertModel.from_pretrained('bert-large-uncased' ) | Natural Language Processing with Disaster Tweets |
10,165,272 | df.isnull().sum()<groupby> | def bert_encode(data,maximum_length):
input_ids = []
attention_masks = []
for i in range(len(data)) :
encoded = tokenizer.encode_plus(
data[i],
add_special_tokens=True,
max_length=maximum_length,
pad_to_max_length=True,
return_attention_mask=True,
)
input_ids.append(encoded['input_ids'])
attention_masks.append(enco... | Natural Language Processing with Disaster Tweets |
10,165,272 | df.groupby(['Date','Country/Region'] ).first()<groupby> | train_input_ids,train_attention_masks = bert_encode(text_data_train,100)
test_input_ids,test_attention_masks = bert_encode(text_data_test,100 ) | Natural Language Processing with Disaster Tweets |
10,165,272 | df_public = df[df["Date"]<"2020-03-12"]
df_public.groupby(['Date','Lat','Long'], as_index=False ).agg({'ConfirmedCases': 'sum', 'Fatalities': 'sum', 'Weekday': 'first'} )<prepare_x_and_y> | def create_model(bert_model):
input_ids = tf.keras.Input(shape=(100,),dtype='int32')
attention_masks = tf.keras.Input(shape=(100,),dtype='int32')
output = bert_model([input_ids,attention_masks])
output = output[1]
output = tf.keras.layers.Dense(1,activation='sigmoid' )(output)
model = tf.keras.models.Model(inputs =... | Natural Language Processing with Disaster Tweets |
10,165,272 | def preprocessing(dataframe):
z=dataframe['Date']-df['Date'].min()
for i in z.index:
z[i]=int(str(z[i] ).split() [0])
data=dataframe
x =data[['Lat', 'Long', 'Date','Weekday']]
y1 = data[['ConfirmedCases']]
y2 = data[['Fatalities']]
x_test = test[['Lat', 'Long', 'Date']]
x_test["Date"] = pd.to_datetime(x_test["Date"])
... | history = model.fit([train_input_ids,train_attention_masks],Y,
validation_split=0.2,
epochs=3,
batch_size=5 ) | Natural Language Processing with Disaster Tweets |
10,165,272 | z=df_public['Date']-df_public['Date'].min()
for i in z.index:
z[i]=int(str(z[i] ).split() [0] )<prepare_x_and_y> | result = model.predict([test_input_ids,test_attention_masks])
result = np.round(result ).astype(int)
submit = pd.DataFrame(test['id'],columns=['id'])
submit['target'] = result
submit.head() | Natural Language Processing with Disaster Tweets |
10,165,272 | <data_type_conversions><EOS> | submit.to_csv('real_nlp_bert.csv',index=False ) | Natural Language Processing with Disaster Tweets |
8,341,073 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<feature_engineering> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib.pyplot import xticks
from nltk.corpus import stopwords
import nltk
import re
from nltk.stem import WordNetLemmatizer
import string
from nltk.tokenize import word_tokenize
from nltk.util import ngrams
from collec... | Natural Language Processing with Disaster Tweets |
8,341,073 | c=z.max() +1
y=x_test['Date']-x_test['Date'].min()
for i in y.index:
y[i]=int(str(y[i] ).split() [0])+c<feature_engineering> | train= pd.read_csv('.. /input/nlp-getting-started/train.csv')
test=pd.read_csv('.. /input/nlp-getting-started/test.csv' ) | Natural Language Processing with Disaster Tweets |
8,341,073 | x['Date']=z
x_test['Date']=y<drop_column> | train.isnull().sum().sort_values(ascending = False ) | Natural Language Processing with Disaster Tweets |
8,341,073 | x_test2=x_test.drop(['Weekday'],axis=1)
x2=x.drop(['Weekday'],axis=1 )<import_modules> | print("No.of Real Disaster Tweets(Target = 1):",len(train[train["target"]==1]))
print("No.of Fake Disaster Tweets(Target = 0):",len(train[train["target"]==0])) | Natural Language Processing with Disaster Tweets |
8,341,073 | from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import KFold, cross_val_score, train_test_split<train_model> | def length(text):
return len(text)
train["length"]= train.text.apply(length ) | Natural Language Processing with Disaster Tweets |
8,341,073 | scaler = StandardScaler()
X_scaled = scaler.fit_transform(x)
x_test_scaled = scaler.transform(x_test)
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y1, test_size=0.2, random_state=44 )<choose_model_class> | train.drop("length",1,inplace=True ) | Natural Language Processing with Disaster Tweets |
8,341,073 | models = []
models.append(( "RF",RandomForestClassifier()))
models.append(( "Dtree",DecisionTreeClassifier()))
models.append(( "KNN",KNeighborsClassifier()))<compute_train_metric> | stop = list(stopwords.words("english")) | Natural Language Processing with Disaster Tweets |
8,341,073 | for name,model in models:
kfold = KFold(n_splits=2, random_state=22)
cv_result = cross_val_score(model,X_train,y_train, cv = kfold,scoring = "accuracy")
print(name, cv_result )<split> | sw = []
for message in train.text:
for word in message.split() :
if word in stop:
sw.append(word)
wordlist = nltk.FreqDist(sw)
top10 = wordlist.most_common(10 ) | Natural Language Processing with Disaster Tweets |
8,341,073 | X_train, X_test, y_train, y_test = train_test_split(X_scaled, y2, test_size=0.2, random_state=44 )<compute_train_metric> | punctuation = list(string.punctuation ) | Natural Language Processing with Disaster Tweets |
8,341,073 | for name,model in models:
kfold = KFold(n_splits=2, random_state=22)
cv_result = cross_val_score(model,X_train,y_train, cv = kfold,scoring = "accuracy")
print(name, cv_result )<prepare_x_and_y> | pun = []
for message in train.text:
for word in message.split() :
if word in punctuation:
pun.append(word)
wordlist = nltk.FreqDist(pun)
top10 = wordlist.most_common(10 ) | Natural Language Processing with Disaster Tweets |
8,341,073 | z,x,y1,y2 = preprocessing(df )<feature_engineering> | stop_real = []
pun_real = []
for message in train[train.target==1]["text"]:
for word in message.split() :
if word in stop:
stop_real.append(word)
if word in punctuation:
pun_real.append(word)
stop_real_wordlist = nltk.FreqDist(stop_real)
pun_real_wordlist = nltk.FreqDist(pun_real)
stop_real_top10 = stop_real_wordli... | Natural Language Processing with Disaster Tweets |
8,341,073 | x['Date']=z<categorify> | stop_fake = []
pun_fake = []
for message in train[train.target==0]["text"]:
for word in message.split() :
if word in stop:
stop_fake.append(word)
if word in punctuation:
pun_fake.append(word)
stop_fake_wordlist = nltk.FreqDist(stop_fake)
pun_fake_wordlist = nltk.FreqDist(pun_fake)
stop_fake_top10 = stop_fake_wordli... | Natural Language Processing with Disaster Tweets |
8,341,073 | print("-----------Confirmed------
")
do_your_thing(x,y1)
print("-----------Fatality------
")
do_your_thing(x,y2 )<split> | lemma = WordNetLemmatizer() | Natural Language Processing with Disaster Tweets |
8,341,073 | kfold = KFold(n_splits=2, shuffle = True, random_state = 0)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(x)
X_train1, X_test1, y_train1, y_test1 = train_test_split(X_scaled, y1, test_size=0.2, random_state=44)
best_score = 0
for n_estimators in [90, 100, 110, 120, 200]:
for max_features in [0.6, 0.7, 0.... | sw_pun = stop + punctuation | Natural Language Processing with Disaster Tweets |
8,341,073 | print("Params: ", best_parameters )<normalization> | def preprocess(tweet):
tweet = re.sub(r"https?:\/\/t.co\/[A-Za-z0-9]+", "", tweet)
tweet = re.sub('[^\w]',' ',tweet)
tweet = re.sub('[\d]','',tweet)
tweet = tweet.lower()
words = tweet.split()
sentence = ""
for word in words:
if word not in(sw_pun):
word = lemma.lemmatize(word,pos = 'v')
if len(word)> 3:
sentence =... | Natural Language Processing with Disaster Tweets |
8,341,073 | scaler = StandardScaler()
X_scaled = scaler.fit_transform(x)
<train_model> | train['text'] = train['text'].apply(lambda s : preprocess(s))
test ['text'] = test ['text'].apply(lambda s : preprocess(s)) | 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.