kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
8,341,073 | rf = RandomForestClassifier(**best_parameters)
rf.fit(X_scaled,y1 )<normalization> | 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 ) | Natural Language Processing with Disaster Tweets |
8,341,073 | test_scaled = scaler.transform(x_test )<predict_on_test> | train['text'] = train['text'].apply(lambda s : remove_emoji(s))
test ['text'] = test ['text'].apply(lambda s : remove_emoji(s))
| Natural Language Processing with Disaster Tweets |
8,341,073 | y_pred_confirmed = rf.predict(test_scaled )<prepare_output> | def create_vocab(df):
vocab = Counter()
for i in range(df.shape[0]):
vocab.update(df.text[i].split())
return(vocab)
| Natural Language Processing with Disaster Tweets |
8,341,073 | predictions = pd.DataFrame({'ForecastId':test['ForecastId'],'ConfirmedCases':y_pred_confirmed})
predictions.head()<train_model> | master=pd.concat(( train,test)).reset_index(drop=True)
vocab = create_vocab(master)
len(vocab ) | Natural Language Processing with Disaster Tweets |
8,341,073 | print("Params: ", best_parameters )<train_model> | vocab.most_common(50)
| Natural Language Processing with Disaster Tweets |
8,341,073 | scaler = StandardScaler()
X_scaled = scaler.fit_transform(x)
rf = RandomForestClassifier(**best_parameters)
rf.fit(X_scaled,y2 )<normalization> | final_vocab = []
min_occur = 2
for k,v in vocab.items() :
if v >= min_occur:
final_vocab.append(k ) | Natural Language Processing with Disaster Tweets |
8,341,073 | test_scaled = scaler.transform(x_test )<predict_on_test> | def filter(tweet):
sentence = ""
for word in tweet.split() :
if word in final_vocab:
sentence = sentence + word + ' '
return(sentence ) | Natural Language Processing with Disaster Tweets |
8,341,073 | y_pred_fatal = rf.predict(test_scaled )<prepare_output> | train['text'] = train['text'].apply(lambda s : filter(s))
test ['text'] = test ['text'].apply(lambda s : filter(s)) | Natural Language Processing with Disaster Tweets |
8,341,073 | predictions = pd.DataFrame({'ForecastId':test['ForecastId'],'ConfirmedCases':y_pred_confirmed,'Fatalities':y_pred_fatal})
predictions.head()<train_model> | real = train[train.target==1].reset_index()
fake = train[train.target==0].reset_index() | Natural Language Processing with Disaster Tweets |
8,341,073 | ')
')
<predict_on_test> | def get_ngrams(data,n):
all_words = []
for i in range(len(data)) :
temp = data["text"][i].split()
for word in temp:
all_words.append(word)
tokenized = all_words
esBigrams = ngrams(tokenized, n)
esBigram_wordlist = nltk.FreqDist(esBigrams)
top100 = esBigram_wordlist.most_common(100)
top100 = dict(top100)
df_ngrams ... | Natural Language Processing with Disaster Tweets |
8,341,073 |
<save_to_csv> | real_unigrams = get_ngrams(real,1)
fake_unigrams = get_ngrams(fake,1 ) | Natural Language Processing with Disaster Tweets |
8,341,073 | predictions.to_csv('submission.csv', header=True, index=False )<import_modules> | real_bigrams = get_ngrams(real,2)
fake_bigrams = get_ngrams(fake,2 ) | Natural Language Processing with Disaster Tweets |
8,341,073 | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
data_dir = Path('.. /input/covid19-global-forecasting-week-1')
pio.templates.default = 'ggplot2'<categorify> | real_trigrams = get_ngrams(real,3)
fake_trigrams = get_ngrams(fake,3 ) | Natural Language Processing with Disaster Tweets |
8,341,073 |
<load_from_csv> | def word_cloud(df):
comment_words = ''
stopwords = set(STOPWORDS)
for val in df.text:
val = str(val)
tokens = val.split()
for i in range(len(tokens)) :
tokens[i] = tokens[i].lower()
comment_words += " ".join(tokens)+" "
wordcloud = WordCloud(width = 800, height = 800,
background_color ='white',
stopwords = stopwords,... | Natural Language Processing with Disaster Tweets |
8,341,073 | data = pd.read_csv(data_dir/'train.csv')
data_test = pd.read_csv(data_dir/'test.csv')
<feature_engineering> | def get_f1(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
precision = true_positives /(predicted_positives + K.epsilon())
recall = true_positives /(possible_positives... | Natural Language Processing with Disaster Tweets |
8,341,073 | day_min = pd.to_datetime(data['Date'].min() ,format='%Y-%m-%d')
t =(pd.DatetimeIndex(data['Date'])- day_min ).days
pd.DatetimeIndex(data['Date'] ).dayofweek<data_type_conversions> | def create_tokenizer(lines):
tokenizer = Tokenizer()
tokenizer.fit_on_texts(lines)
return tokenizer | Natural Language Processing with Disaster Tweets |
8,341,073 | l_use_date_int = True
l_use_days_num = True
methods = ['use_date_int','use_days_num','use_converter']
c_method = methods[1]
if c_method == methods[0]:
data["Date"] = data["Date"].apply(lambda x: x.replace("-",""))
data["Date"] = data["Date"].astype(int)
data_test["Date"] = data_test["Date"].apply(lambda x: x.replace("... | X = train.text
y = train.target
test_id = test.id
test.drop(["id","location","keyword"],1,inplace = True ) | Natural Language Processing with Disaster Tweets |
8,341,073 | categorical_cols = [cname for cname in data.columns if
data[cname].nunique() < 10 and
data[cname].dtype == "object"]
numerical_cols = [cname for cname in X.columns if
X[cname].dtype in ['int64', 'float64']]
print(categorical_cols, numerical_cols )<count_unique_values> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42 ) | Natural Language Processing with Disaster Tweets |
8,341,073 | [cname for cname in data.columns]
for cname in data.columns:
print(cname, data[cname].nunique() < 10, data[cname].dtype == "object" )<choose_model_class> | tokenizer = create_tokenizer(X_train)
X_train_set = tokenizer.texts_to_matrix(X_train, mode = 'freq')
| Natural Language Processing with Disaster Tweets |
8,341,073 | model0 = RandomForestRegressor(n_estimators=110, random_state=0)
model1 = RandomForestRegressor(n_estimators=50, random_state=0)
model0 = DecisionTreeClassifier(criterion='entropy')
model1 = DecisionTreeClassifier(criterion='entropy')
model0 = DecisionTreeRegressor(random_state = 0)
model1 = DecisionTreeRegressor(... | def define_model(n_words):
model = Sequential()
model.add(Dense(128, input_shape=(n_words,), activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics = [get_f1])
model.summary()
plot_model(model, to_file='model.png', show_shapes=True)
return mod... | Natural Language Processing with Disaster Tweets |
8,341,073 | scores = -1 * cross_val_score(my_pipeline0, X, y,
cv=5,
scoring='neg_mean_absolute_error')
print("Average MAE score:", scores.mean() )<compute_train_metric> | model.fit(X_train_set,y_train,epochs=10,verbose=2 ) | Natural Language Processing with Disaster Tweets |
8,341,073 | scores = -1 * cross_val_score(my_pipeline1, X, y1,
cv=5,
scoring='neg_mean_absolute_error')
print("Average MAE score:", scores.mean() )<compute_train_metric> | X_test_set = tokenizer.texts_to_matrix(X_test, mode = 'freq')
y_pred = model.predict_classes(X_test_set ) | Natural Language Processing with Disaster Tweets |
8,341,073 | def get_score(yy, n_estimators):
my_pipeline = Pipeline(steps=[
('preprocessor', SimpleImputer()),
('model',RandomForestRegressor(n_estimators=n_estimators,random_state=0))
])
score_cross_valids = -1 * cross_val_score(my_pipeline, X, yy,
cv=3,
scoring='neg_mean_absolute_error')
return score_cross_valids.mean()
<... | print(classification_report(y_test, y_pred)) | Natural Language Processing with Disaster Tweets |
8,341,073 | my_pipeline0.fit(X, y)
my_pipeline1.fit(X, y1)
<predict_on_test> | test_set = tokenizer.texts_to_matrix(test.text, mode = 'freq' ) | Natural Language Processing with Disaster Tweets |
8,341,073 | rf_predictions = my_pipeline0.predict(X_valid)
rf_val_mae = mean_absolute_error(rf_predictions, y_valid)
print("Validation MAE for Random Forest Model: {}".format(rf_val_mae))
<predict_on_test> | y_test_pred = model.predict_classes(test_set ) | Natural Language Processing with Disaster Tweets |
8,341,073 | test_preds0 = my_pipeline0.predict(X_test)
test_preds1 = my_pipeline1.predict(X_test)
t0 = np.round(test_preds0 ).astype(int)
t1 = np.round(test_preds1 ).astype(int)
<save_to_csv> | sub = pd.DataFrame()
sub['Id'] = test_id
sub['target'] = y_test_pred
sub.to_csv('submission_1.csv',index=False ) | Natural Language Processing with Disaster Tweets |
8,341,073 | output = pd.DataFrame({'ForecastId': data_test.ForecastId,
'ConfirmedCases':t0,
'Fatalities': t1})
output.to_csv('submission.csv', index=False )<feature_engineering> | t = Tokenizer()
t.fit_on_texts(X_train.tolist() ) | Natural Language Processing with Disaster Tweets |
8,341,073 | data['log_ConfirmedCases'] = np.log(data['ConfirmedCases']+1)
data['log_Fatalities'] = np.log(data['Fatalities']+1)
y_pred2 = data['log_ConfirmedCases']
y1_pred2 = data['log_Fatalities']
day_min = pd.to_datetime(data['Date'].min() ,format='%Y-%m-%d')
t = data['days'] < data_test['days'].min()
X_train = X[t]
X_valid ... | vocab_size = len(t.word_index)+ 1 | Natural Language Processing with Disaster Tweets |
8,341,073 | model0 = RandomForestRegressor(n_estimators=300, random_state=0,verbose=True)
model1 = RandomForestRegressor(n_estimators=100, random_state=0)
my_pipeline0 = Pipeline(steps=[
('preprocessor', SimpleImputer()),
('model', model0)
])
my_pipeline1 = Pipeline(steps=[
('preprocessor', SimpleImputer()),
('model', mode... | embeddings_index = dict()
f = open('.. /input/glove6b100dtxt/glove.6B.100d.txt', mode='rt', encoding='utf-8')
for line in f:
values = line.split()
word = values[0]
coefs = asarray(values[1:], dtype='float32')
embeddings_index[word] = coefs
f.close()
print('Loaded %s word vectors.' % len(embeddings_index)) | Natural Language Processing with Disaster Tweets |
8,341,073 | my_pipeline0.fit(X_train, y_train )<predict_on_test> | encoded_docs = t.texts_to_sequences(X_train.tolist())
max_length = 100
padded_docs = pad_sequences(encoded_docs, maxlen=max_length, padding='post')
print(padded_docs ) | Natural Language Processing with Disaster Tweets |
8,341,073 | rf_predictions = my_pipeline0.predict(X_valid)
rf_val_mae = mean_absolute_error(rf_predictions, y_valid)
print("Validation MAE for Random Forest Model: {}".format(rf_val_mae))<compute_train_metric> | mis_spelled = []
embedding_matrix = zeros(( vocab_size, 100))
for word, i in t.word_index.items() :
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None:
embedding_matrix[i] = embedding_vector
else:
mis_spelled.append(word ) | Natural Language Processing with Disaster Tweets |
8,341,073 | def get_score1(n_est):
model = RandomForestRegressor(n_estimators=n_est, random_state=0)
my_pipeline = Pipeline(steps=[
('preprocessor', SimpleImputer()),
('model', model)
])
score_cross_valids = -1 * cross_val_score(my_pipeline0, X_train, y_train,
cv=5,
scoring='neg_mean_absolute_error')
return score_cross_valid... | model = Sequential()
e = Embedding(vocab_size, 100, weights=[embedding_matrix], input_length=100, trainable=False)
model.add(e)
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=[get_f1])
model.summary()
model.fit(padded_docs, y_train,... | Natural Language Processing with Disaster Tweets |
8,341,073 | my_pipeline0.fit(X, y_pred2)
my_pipeline1.fit(X, y1_pred2)
<predict_on_test> | loss, accuracy = model.evaluate(padded_docs, y_train, verbose=0 ) | Natural Language Processing with Disaster Tweets |
8,341,073 | test_preds2 = my_pipeline0.predict(X_test)
test_preds3 = my_pipeline1.predict(X_test)
t0 = np.round(np.exp(test_preds2)-1 ).astype(int)
t1 = np.round(np.exp(test_preds3)-1 ).astype(int)
<save_to_csv> | encoded_docs = t.texts_to_sequences(X_test.tolist())
padded_docs = pad_sequences(encoded_docs, maxlen=max_length, padding='post' ) | Natural Language Processing with Disaster Tweets |
8,341,073 | output = pd.DataFrame({'ForecastId': data_test.ForecastId,
'ConfirmedCases':t0,
'Fatalities': t1})
output.to_csv('submission.csv', index=False )<compute_test_metric> | y_pred = model.predict_classes(padded_docs ) | Natural Language Processing with Disaster Tweets |
8,341,073 | %matplotlib inline
def sigmoid_sqrt_func(x, a, b, c, d, e):
return c + d /(1.0 + np.exp(-a*x+b)) + e*x**0.5
def sigmoid_linear_func(x, a, b, c, d, e):
return c + d /(1.0 + np.exp(-a*x+b)) + e*0.1*x
def sigmoid_quad_func(x, a, b, c, d, e, f):
return c + d /(1.0 + np.exp(-a*x+b)) + e*0.1*x + f*0.001*x*x
def sigmoid_func(... | encoded_docs = t.texts_to_sequences(test.text.tolist())
padded_docs = pad_sequences(encoded_docs, maxlen=max_length, padding='post' ) | Natural Language Processing with Disaster Tweets |
8,341,073 | train_data = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-1/train.csv')
test_data = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-1/test.csv')
pred_data = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-1/submission.csv')
train_data = train_data.fillna(value='NULL')
test_data =... | y_test_pred = model.predict_classes(padded_docs ) | Natural Language Processing with Disaster Tweets |
8,341,073 | train_date_list = train_data.iloc[:, 5].unique()
print(len(train_date_list))
print(train_date_list)
test_date_list = test_data.iloc[:, 5].unique()
print(len(test_date_list))
print(test_date_list)
len(train_data.groupby(['Province/State', 'Country/Region']))
len(test_data.groupby(['Province/State', 'Country/Region']))... | sub = pd.DataFrame()
sub['Id'] = test_id
sub['target'] = y_test_pred
sub.to_csv('submission_2.csv',index=False ) | Natural Language Processing with Disaster Tweets |
8,341,073 | start_date = '01/22/2020'
test_date_list = test_data.iloc[:, 5].unique()
test_data_filled = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-1/test.csv')
test_data_filled = test_data_filled.fillna(value='NULL')
test_data_filled['ConfirmedCases'] = pred_data['ConfirmedCases']
test_data_filled['Fatalities'] =... | Natural Language Processing with Disaster Tweets | |
8,341,073 | submission = test_data_filled.loc[:,['ForecastId', 'ConfirmedCases', 'Fatalities']]<save_to_csv> | encoded_docs = t.texts_to_sequences(X_train.tolist())
padded_docs = pad_sequences(encoded_docs, maxlen=max_length, padding='post')
print(padded_docs ) | Natural Language Processing with Disaster Tweets |
8,341,073 | submission.to_csv("submission.csv", index=False)
submission.head(500 )<feature_engineering> | vocab_size | Natural Language Processing with Disaster Tweets |
8,341,073 | np.log10(80000 )<load_from_csv> | def define_model(vocab_size, max_length):
model = Sequential()
model.add(Embedding(vocab_size, 100, input_length=max_length))
model.add(Conv1D(filters=32, kernel_size=8, activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(Flatten())
model.add(Dense(10, activation='relu'))
model.add(Dense(1, activation='... | Natural Language Processing with Disaster Tweets |
8,341,073 | %matplotlib inline
for dirname, _, filenames in os.walk('/kaggle/input'):
print(dirname)
data_path = Path('/kaggle/input/covid19-global-forecasting-week-1/')
train = pd.read_csv(data_path / 'train.csv')
test = pd.read_csv(data_path / 'test.csv')
data_path = Path('/kaggle/input/covid19-global-forecasting-week-2/')
... | model = define_model(vocab_size, max_length)
model.fit(padded_docs, y_train, epochs=10, verbose=2 ) | Natural Language Processing with Disaster Tweets |
8,341,073 |
<feature_engineering> | loss, accuracy = model.evaluate(padded_docs, y_train, verbose=0 ) | Natural Language Processing with Disaster Tweets |
8,341,073 | train['country+province'] = train['Country/Region'].fillna('')+ '-' + train['Province/State'].fillna('')
train_2['country+province'] = train_2['Country_Region'].fillna('')+ '-' + train_2['Province_State'].fillna('')
df = train.groupby('country+province')[['Lat', 'Long']].mean()
df.loc['United Kingdom-'] = df.loc['Uni... | encoded_docs = t.texts_to_sequences(X_test.tolist())
padded_docs = pad_sequences(encoded_docs, maxlen=max_length, padding='post' ) | Natural Language Processing with Disaster Tweets |
8,341,073 | train_2.to_csv("train2_latlong.csv",index=False )<feature_engineering> | y_pred = model.predict_classes(padded_docs ) | Natural Language Processing with Disaster Tweets |
8,341,073 | test_2['country+province'] = test_2['Country_Region'].fillna('')+ '-' + test_2['Province_State'].fillna('')
test_2['Lat'] = test_2['country+province'].apply(lambda x: df.loc[x, 'Lat'])
test_2['Long'] = test_2['country+province'].apply(lambda x: df.loc[x, 'Long'])
test_2.head()<save_to_csv> | encoded_docs = t.texts_to_sequences(test.text.tolist())
padded_docs = pad_sequences(encoded_docs, maxlen=max_length, padding='post' ) | Natural Language Processing with Disaster Tweets |
8,341,073 | test_2.to_csv("test2_latlong.csv",index=False )<feature_engineering> | y_test_pred = model.predict_classes(padded_docs ) | Natural Language Processing with Disaster Tweets |
8,341,073 |
<import_modules> | sub = pd.DataFrame()
sub['Id'] = test_id
sub['target'] = y_test_pred
sub.to_csv('submission_cnn.csv',index=False ) | Natural Language Processing with Disaster Tweets |
8,341,073 | import lightgbm as lgb
from fastai.tabular import *
from sklearn import preprocessing
import datetime<load_from_csv> | model.save('model.h5' ) | Natural Language Processing with Disaster Tweets |
8,341,073 | train = pd.read_csv("train2_latlong.csv")
test = pd.read_csv("test2_latlong.csv")
sub = pd.read_csv(".. /input/covid19-global-forecasting-week-2/submission.csv" )<concatenate> | def define_model(length, vocab_size):
inputs1 = Input(shape=(length,))
embedding1 = Embedding(vocab_size, 100 )(inputs1)
conv1 = Conv1D(32, 4, activation='relu' )(embedding1)
drop1 = Dropout(0.5 )(conv1)
pool1 = MaxPooling1D()(drop1)
flat1 = Flatten()(pool1)
inputs2 = Input(shape=(length,))
embedding2 = Embedding(... | Natural Language Processing with Disaster Tweets |
8,341,073 | train = train.append(test[test['Date']>'2020-03-26'] )<compute_test_metric> | encoded_docs = t.texts_to_sequences(X_train.tolist())
padded_docs = pad_sequences(encoded_docs, maxlen=max_length, padding='post')
| Natural Language Processing with Disaster Tweets |
8,341,073 | def rmsle(y_true, y_pred):
return np.sqrt(np.mean(np.power(np.log1p(y_pred)- np.log1p(y_true), 2)))
def mape(y_true, y_pred):
return np.mean(np.abs(y_pred -y_true)*100/(y_true+1))<data_type_conversions> | model = define_model(max_length,vocab_size)
model.fit([padded_docs,padded_docs,padded_docs], array(y_train), epochs=7, batch_size=16 ) | Natural Language Processing with Disaster Tweets |
8,341,073 | train['Date'] = pd.to_datetime(train['Date'], format='%Y-%m-%d' )<feature_engineering> | loss, accuracy = model.evaluate([padded_docs,padded_docs,padded_docs], y_train, verbose=0 ) | Natural Language Processing with Disaster Tweets |
8,341,073 | train['day_dist'] = train['Date']-train['Date'].min()
train['day_dist'] = train['day_dist'].dt.days
cat_cols = train.dtypes[train.dtypes=='object'].keys()
cat_cols<categorify> | encoded_docs = t.texts_to_sequences(X_test.tolist())
padded_docs = pad_sequences(encoded_docs, maxlen=max_length, padding='post' ) | Natural Language Processing with Disaster Tweets |
8,341,073 | for cat_col in cat_cols:
train[cat_col].fillna('no_value', inplace = True)
train['place'] = train['Province_State']+'_'+train['Country_Region']
for cat_col in ['place']:
le = preprocessing.LabelEncoder()
le.fit(train[cat_col])
train[cat_col]=le.transform(train[cat_col] )<feature_engineering> | _, acc = model.evaluate([padded_docs,padded_docs,padded_docs], array(y_test), verbose=0)
print('Train Accuracy: %.2f' %(acc*100)) | Natural Language Processing with Disaster Tweets |
8,341,073 |
<filter> | encoded_docs = t.texts_to_sequences(test.text.tolist())
padded_docs = pad_sequences(encoded_docs, maxlen=max_length, padding='post' ) | Natural Language Processing with Disaster Tweets |
8,341,073 | val = train[(train['Date']>='2020-03-19')&(train['Id'].isnull() ==False)]<prepare_x_and_y> | y_test_pred = model.predict([padded_docs,padded_docs,padded_docs] ) | Natural Language Processing with Disaster Tweets |
8,341,073 | y_ft = train["Fatalities"]
y_val_ft = val["Fatalities"]
y_cc = train["ConfirmedCases"]
y_val_cc = val["ConfirmedCases"]<init_hyperparams> | sub = pd.DataFrame()
sub['Id'] = test_id
sub['target'] = y_test_pred
sub.to_csv('submission_multi-cnn.csv',index=False ) | Natural Language Processing with Disaster Tweets |
8,341,073 | params = {
"objective": "regression",
"boosting": 'gbdt',
"num_leaves": 1280,
"learning_rate": 0.05,
"feature_fraction": 0.9,
"reg_lambda": 2,
"metric": "rmse",
'min_data_in_leaf':20
}<filter> | !wget --quiet https://raw.githubusercontent.com/tensorflow/models/master/official/nlp/bert/tokenization.py | Natural Language Processing with Disaster Tweets |
8,341,073 | dates = dates[dates>'2020-03-26']
len(dates )<define_variables> | from tensorflow.keras.layers import Dense, Input
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.models import Model
from tensorflow.keras.callbacks import ModelCheckpoint
import tensorflow_hub as hub
import tokenization | Natural Language Processing with Disaster Tweets |
8,341,073 | drop_cols = ['Id', 'ConfirmedCases', 'Fatalities','day_dist', 'Province_State', 'Country_Region', 'Date', 'country+province']<count_unique_values> | 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 | places = train["country+province"].unique()
len(places )<define_variables> | 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 |
8,341,073 |
<feature_engineering> | 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 |
8,341,073 | places_dict={}
for place in places:
initdate = min(train.loc[(train["country+province"]==place)&(train["ConfirmedCases"]>0)]["Date"])
places_dict[place] = initdate.date()
places_dict<feature_engineering> | %%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 |
8,341,073 | days_from_first_case = []
for i in range(len(train)) :
row = train.iloc[i]
row = row.to_dict()
initdate = places_dict[row["country+province"]]
currdate = row["Date"].date()
days =(currdate - initdate ).days
days_from_first_case.append(max(0,days))<feature_engineering> | vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
do_lower_case = bert_layer.resolved_object.do_lower_case.numpy() | Natural Language Processing with Disaster Tweets |
8,341,073 | train['Days_from_first_case'] = days_from_first_case<save_to_csv> | tokenizer = tokenization.FullTokenizer(vocab_file, do_lower_case)
| Natural Language Processing with Disaster Tweets |
8,341,073 | train.to_csv("finaltrain.csv",index=False )<filter> | 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 |
8,341,073 | test[test['Country_Region']=='India']<load_from_csv> | train_history = model.fit(
train_input, train_labels,
validation_split=0.2,
epochs=3,
batch_size=16
) | Natural Language Processing with Disaster Tweets |
8,341,073 | train_sub = pd.read_csv(".. /input/covid19-global-forecasting-week-2/train.csv" )<merge> | test_pred = model.predict(test_input ) | Natural Language Processing with Disaster Tweets |
8,341,073 | <feature_engineering><EOS> | submission=pd.DataFrame()
submission['Id']=test_id
submission['target'] = test_pred.round().astype(int)
submission.to_csv('submission_3.csv', index=False)
| Natural Language Processing with Disaster Tweets |
9,132,740 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<feature_engineering> | np.random.seed(1)
nltk.download('stopwords')
tf.random.set_seed(1)
pd.set_option('display.max_colwidth', 500)
warnings.filterwarnings('ignore' ) | Natural Language Processing with Disaster Tweets |
9,132,740 | test.loc[test['Fatalities_x'].isnull() ==True, 'Fatalities_x'] = test.loc[test['Fatalities_x'].isnull() ==True, 'Fatalities_y']<filter> | train = pd.read_csv(".. /input/nlp-getting-started/train.csv")
test = pd.read_csv(".. /input/nlp-getting-started/test.csv")
print("Train Shape :", train.shape)
print("Test Shape :", test.shape ) | Natural Language Processing with Disaster Tweets |
9,132,740 | last_amount = test.loc[(test['Country_Region']=='Italy')&(test['Date']=='2020-03-26'),'ConfirmedCases_x']<filter> | train.isnull().sum() | Natural Language Processing with Disaster Tweets |
9,132,740 | last_fat = test.loc[(test['Country_Region']=='Italy')&(test['Date']=='2020-03-24'),'Fatalities_x']<feature_engineering> | train.isnull().sum() | Natural Language Processing with Disaster Tweets |
9,132,740 | i, k = 0, 35
for date in dates:
k = k-1
i = i + 1
test.loc[(test['Country_Region']=='Italy')&(test['Date']==date),'ConfirmedCases_x'] = last_amount.values[0]+i*(5000-(100*i))
test.loc[(test['Country_Region']=='Italy')&(test['Date']==date),'Fatalities_x'] = last_fat.values[0]+i*(800-(10*i))<filter> | train['target'].value_counts(normalize = True ) | Natural Language Processing with Disaster Tweets |
9,132,740 | test.loc[(test['Country_Region']=='Italy')]<rename_columns> | train.keyword.value_counts() | Natural Language Processing with Disaster Tweets |
9,132,740 | sub = test[['ForecastId', 'ConfirmedCases_x','Fatalities_x']]
sub.columns = ['ForecastId', 'ConfirmedCases', 'Fatalities']<feature_engineering> | train.location.value_counts() | Natural Language Processing with Disaster Tweets |
9,132,740 | sub.loc[sub['ConfirmedCases']<0, 'ConfirmedCases'] = 0<feature_engineering> | real_tweets = train[train['target']==1]['text']
real_tweets.values[0:5] | Natural Language Processing with Disaster Tweets |
9,132,740 | sub.loc[sub['Fatalities']<0, 'Fatalities'] = 0<save_to_csv> | fake_tweets = train[train['target']==0]['text']
fake_tweets.values[0:5] | Natural Language Processing with Disaster Tweets |
9,132,740 | sub.to_csv('submission.csv',index=False )<load_from_csv> | def clean_text(text):
text = text.lower()
text = re.sub('\[.*?\]', '', text)
text = re.sub('https?://\S+|www\.\S+', '', text)
text = re.sub('<.*?>+', '', text)
text = re.sub('[%s]' % re.escape(string.punctuation), '', text)
text = re.sub('
', '', text)
text = re.sub('\w*\d\w*', '', text)
return text | Natural Language Processing with Disaster Tweets |
9,132,740 | train = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-1/train.csv')
test = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-1/test.csv')
submission = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-1/submission.csv' )<data_type_conversions> | train['cleaned_text'] = train['text'].apply(lambda x: clean_text(x))
test['cleaned_text'] = test['text'].apply(lambda x: clean_text(x))
train['cleaned_text'].head() | Natural Language Processing with Disaster Tweets |
9,132,740 | test['Date']=test.Date.astype('datetime64[ns]' )<data_type_conversions> | !pip install nlppreprocess
nlp = NLP()
train['stopwords_cleaned'] = train['cleaned_text'].apply(nlp.process)
test['stopwords_cleaned'] = test['cleaned_text'].apply(nlp.process ) | Natural Language Processing with Disaster Tweets |
9,132,740 | train['key']=train['Province/State'].astype('str')+ " " + train['Country/Region'].astype('str')+ " " +train['Lat'].astype('str')+ " " +train['Long'].astype('str' )<data_type_conversions> | en_model = spacy.load('en', disable=['parser', 'ner'])
def lemmatization(texts):
output = []
for i in texts:
s = [token.lemma_ for token in en_model(i)]
output.append(' '.join(s))
return output | Natural Language Processing with Disaster Tweets |
9,132,740 | test['key']=test['Province/State'].astype('str')+ " " + test['Country/Region'].astype('str')+ " " +test['Lat'].astype('str')+ " " +test['Long'].astype('str' )<groupby> | train['lemmatized_text'] = lemmatization(train['stopwords_cleaned'])
test['lemmatized_text'] = lemmatization(test['stopwords_cleaned'] ) | Natural Language Processing with Disaster Tweets |
9,132,740 | daily_analysis=train.groupby(['Date'] ).sum()<compute_test_metric> | x_train, x_test, y_train, y_test = train_test_split(train['stopwords_cleaned'], train['target'],
test_size = 0.2, random_state = 1 ) | Natural Language Processing with Disaster Tweets |
9,132,740 | def RMSLE(pred,actual):
return np.sqrt(np.mean(np.power(( np.log(pred+1)-np.log(actual+1)) ,2)) )<feature_engineering> | hub_layer = hub.KerasLayer('https://tfhub.dev/google/universal-sentence-encoder/4',
input_shape = [],
output_shape = [512],
dtype = tf.string,
trainable = True)
model = tf.keras.models.Sequential()
model.add(hub_layer)
model.add(tf.keras.layers.Dense(128, activation = 'relu'))
model.add(tf.keras.layers.Dense(32, acti... | Natural Language Processing with Disaster Tweets |
9,132,740 | train_lag_1=train.groupby(['key'] ).shift(periods=1)
train_lag_2=train.groupby(['key'] ).shift(periods=2)
train_lag_3=train.groupby(['key'] ).shift(periods=3)
train_lag_4=train.groupby(['key'] ).shift(periods=4)
train['lag_1_ConfirmedCases']=train_lag_1['ConfirmedCases']
train['lag_1_Fatalities']=train_lag_1['Fatal... | model.compile(optimizer = 'adam',
loss = 'binary_crossentropy',
metrics = ['accuracy'] ) | Natural Language Processing with Disaster Tweets |
9,132,740 | def pred_ets(fcastperiod,fcastperiod1,actual,ffcast,type_ck='ConfirmedCases',verbose=False):
actual=actual[actual[type_ck]>0]
index=pd.date_range(start=ffcast.index[0], end=ffcast.index[-1], freq='D')
data=ffcast[type_ck].values
ffcast1 = pd.Series(data, index)
index=pd.date_range(start=actual.index[0], end=actual.in... | model.fit(x_train,
y_train,
epochs = 1,
validation_data =(x_test, y_test)) | Natural Language Processing with Disaster Tweets |
9,132,740 | Fatalities_all_result_final=pd.DataFrame()
ConfirmedCases_all_result_Final=pd.DataFrame()
for keys in train['key'].unique() :
chk=train[train['key']==keys]
chk.index=chk.Date
fcastperiod=0
fcastperiod1=35
actual=chk[:chk.shape[0]-fcastperiod]
ffcast=chk[chk.shape[0]-fcastperiod-1:]
ffcast
try:
Fatalities_all_result_1=p... | pred = model.predict_classes(test['stopwords_cleaned'] ) | Natural Language Processing with Disaster Tweets |
9,132,740 | ConfirmedCases_all_result_Final.rename(columns={'index':'Date'},inplace=True)
Fatalities_all_result_final.rename(columns={'index':'Date'},inplace=True)
ConfirmedCases_all_result_Final['best_pred']=np.where(ConfirmedCases_all_result_Final['best_pred'] is np.nan , 0, ConfirmedCases_all_result_Final['best_pred'])
Fatal... | submission = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
submission['target'] = pred
submission.to_csv('submission.csv', index=False ) | Natural Language Processing with Disaster Tweets |
9,132,740 | <merge><EOS> | submission.to_csv("submission.csv", index = False ) | Natural Language Processing with Disaster Tweets |
9,077,550 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<merge> | np.random.seed(0)
plt.style.use('ggplot')
stop=set(stopwords.words('english'))
np.random.seed(1)
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Natural Language Processing with Disaster Tweets |
9,077,550 | eval2 = Fatalities_all_result_final[['key','Date','best_pred','best_pred_1']].merge(test, how='right', on=['key','Date'])
eval2.rename(columns={'best_pred':'Fatalities'},inplace=True)
eval2['Fatalities']=eval2['Fatalities'].fillna(0)
eval2<merge> | train= pd.read_csv('.. /input/nlp-getting-started/train.csv')
test=pd.read_csv('.. /input/nlp-getting-started/test.csv')
train.head() | Natural Language Processing with Disaster Tweets |
9,077,550 | sub_prep = eval1[['ForecastId','ConfirmedCases','key']].merge(eval2[['ForecastId','Fatalities']], on=['ForecastId'], how='left')
sub_prep<merge> | train.isnull().sum(axis=0 ) | Natural Language Processing with Disaster Tweets |
9,077,550 | sub = sub_prep.merge(submission['ForecastId'], on=['ForecastId'], how='right')
sub<sort_values> | test.isnull().sum(axis=0 ) | Natural Language Processing with Disaster Tweets |
9,077,550 | sub=sub[['ForecastId','ConfirmedCases','Fatalities']]
sub=sub.sort_values('ForecastId')
sub<save_to_csv> | keyword_cnt = train.keyword.value_counts()
keyword_cnt | Natural Language Processing with Disaster Tweets |
9,077,550 | sub.to_csv('submission.csv',header=['ForecastId','ConfirmedCases','Fatalities'],index=False)
sub<merge> | train_fake = train[train['target'] == 1]
keyword_cnt_fake = train_fake.keyword.value_counts()
keyword_cnt_fake | Natural Language Processing with Disaster Tweets |
9,077,550 | train['Date']=train.Date.astype('datetime64[ns]')
verify=train[['key','Date','ConfirmedCases','Fatalities']].merge(test[['key','Date','ForecastId']], how='inner', on=['key','Date'])
pred=verify[['ForecastId']].merge(sub, how='inner', on=['ForecastId'] )<compute_test_metric> | n_corpus=[]
for text in tqdm(train['text']):
text = re.sub(r'https?://\S+|www\.\S+', '', text)
text = re.sub(r'<.*?>', '', text)
text = re.sub(r'[^a-zA-Z0-9]+', ' ', text)
text = re.sub(r'[0-9]', '', text)
text = text.lower()
text = nltk.word_tokenize(text)
ps = PorterStemmer()
text = [ps.stem(word)for word in tex... | Natural Language Processing with Disaster Tweets |
9,077,550 | RMSLE(pred['Fatalities'].values,verify['Fatalities'].values )<compute_test_metric> | train['text_n']=n_corpus
train.drop('text',axis=1 ) | 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.