kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,077,550 | RMSLE(pred['ConfirmedCases'].values,verify['ConfirmedCases'].values )<groupby> | n_corpus=[]
for text in tqdm(test['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 text... | Natural Language Processing with Disaster Tweets |
9,077,550 | train
train_ck=train.groupby(['Country/Region','Date'] ).sum().reset_index()
train_ck['key']=train_ck['Country/Region']
<create_dataframe> | test['text_n']=n_corpus
test.drop('text',axis=1 ) | Natural Language Processing with Disaster Tweets |
9,077,550 | Fatalities_all_result_final=pd.DataFrame()
ConfirmedCases_all_result_Final=pd.DataFrame()
for keys in train_ck['key'].unique() :
chk=train_ck[train_ck['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_r... | !wget --quiet https://raw.githubusercontent.com/tensorflow/models/master/official/nlp/bert/tokenization.py | Natural Language Processing with Disaster Tweets |
9,077,550 | 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... | import tensorflow as tf
from tensorflow.keras.layers import Dense, Input
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.models import Model
from tensorflow.keras.callbacks import ModelCheckpoint
import tensorflow_hub as hub
import tokenization | Natural Language Processing with Disaster Tweets |
9,077,550 | best_model_key=ConfirmedCases_all_result_Final[['key','best_model']].drop_duplicates()
max_number_current=train_ck.groupby('key' ).max() [['ConfirmedCases','Fatalities']].reset_index()
best_model_key=best_model_key.merge(max_number_current,on='key',how='left')
best_model_key=best_model_key.sort_values('ConfirmedCases'... | 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 |
9,077,550 | train = pd.read_csv('.. /input/covid19-global-forecasting-week-1/train.csv')
test = pd.read_csv('.. /input/covid19-global-forecasting-week-1/test.csv' )<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 |
9,077,550 | train['date_datetime'] = train['Date'].apply(lambda x:(datetime.datetime.strptime(x, '%Y-%m-%d')) )<data_type_conversions> | 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 |
9,077,550 | def days_convert(date):
return(date - datetime.datetime(2020,1,22)).days
train['days_since_start'] = train['date_datetime'].apply(days_convert )<feature_engineering> | vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = tokenization.FullTokenizer(vocab_file, do_lower_case ) | Natural Language Processing with Disaster Tweets |
9,077,550 | def rename_countries(country):
if country == 'US':
country = 'United States'
elif country == 'Gambia, The' or country == 'The Gambia':
country = "Gambia"
elif country == 'The Bahamas':
country = 'Bahamas'
elif country == 'Taiwan*':
country = 'Taiwan'
elif country == 'Republic of the Congo' or country == 'Congo(Kinshasa... | 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 |
9,077,550 | def clean_name(country):
country = country.split('[')[0]
return country
population['country'] = population['Country or area'].apply(clean_name)
population['pop'] = population['Population(1 July 2019)']<filter> | train_history = model.fit(
train_input, train_labels,
validation_split=0.2,
epochs=3,
batch_size=16
)
model.save('model.h5' ) | Natural Language Processing with Disaster Tweets |
9,077,550 | <feature_engineering><EOS> | test_pred = model.predict(test_input)
submission=pd.read_csv('/kaggle/input/nlp-getting-started/sample_submission.csv')
submission['target'] = test_pred.round().astype(int)
submission.to_csv('submission.csv', index=False)
| Natural Language Processing with Disaster Tweets |
8,853,238 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<load_from_csv> | !pip install bert-for-tf2
!pip install sentencepiece | Natural Language Processing with Disaster Tweets |
8,853,238 | life = pd.read_csv('/kaggle/input/world-bank-data-1960-to-2016/life_expectancy.csv')[['Country Name','2016']]
life.head()<feature_engineering> | try:
%tensorflow_version 2.x
except Exception:
pass
| Natural Language Processing with Disaster Tweets |
8,853,238 | def change_countries(country):
if country == 'DR Congo':
country = 'Democratic Republic of the Congo'
elif country == 'Bahamas':
country = 'The Bahamas'
return country
def get_expectancy(country):
try:
return life[life['Country Name'] == country]['2016'].reset_index() ['2016'][0]
except:
if country == 'Brunei':
return ... | def recall_m(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)))
recall = true_positives /(possible_positives + K.epsilon())
return recall
def precision_m(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1... | Natural Language Processing with Disaster Tweets |
8,853,238 | for index in train[train['Country/Region']=='Andorra']['life_expectancy'].index:
train.loc[index,'life_expectancy'] = 82.8
for index in train[train['Country/Region']=='Greenland']['life_expectancy'].index:
train.loc[index,'life_expectancy'] = 72.4
for index in train[train['Country/Region']=='Monaco']['life_expectancy']... | train= pd.read_csv('.. /input/extensive-pre-processing-for-bert/processed train.csv')
train.head(5 ) | Natural Language Processing with Disaster Tweets |
8,853,238 | train[train['life_expectancy'].isna() ==True]<split> | train.loc[4,'processed_text'] | Natural Language Processing with Disaster Tweets |
8,853,238 | X = train[['Lat','Long','days_since_start','population','median_age']]
y = train['ConfirmedCases']
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3 )<train_model> | test=pd.read_csv('.. /input/extensive-pre-processing-for-bert/processed test.csv')
test = test.set_index(test['id'])
test.head(5 ) | Natural Language Processing with Disaster Tweets |
8,853,238 | rf = RandomForestClassifier()
rf.fit(X_train,y_train )<compute_train_metric> | test_actual = pd.read_csv("https://raw.githubusercontent.com/sampath9dasari/GSU/master/true%20submission.csv")
test_labels = test_actual.target.to_numpy() | Natural Language Processing with Disaster Tweets |
8,853,238 | mean_absolute_error(rf.predict(X_test),y_test )<split> | 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,853,238 | X1 = train[['Lat','Long','days_since_start','population','median_age','life_expectancy']]
y1 = train['Fatalities']
X_train1,X_test1,y_train1,y_test1 = train_test_split(X1,y1,test_size=0.3 )<train_model> |
def bert_encode(texts, tokenizer, max_len=50):
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)
t... | Natural Language Processing with Disaster Tweets |
8,853,238 | rf1 = RandomForestClassifier()
rf1.fit(X_train1,y_train1 )<compute_train_metric> | BertTokenizer = bert.bert_tokenization.FullTokenizer
vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = BertTokenizer(vocab_file, do_lower_case ) | Natural Language Processing with Disaster Tweets |
8,853,238 | mean_absolute_error(rf1.predict(X_test1),y_test1 )<load_from_csv> | full_input = bert_encode(train.processed_text.values, tokenizer, max_len=50)
full_labels = train.target.values.copy() | Natural Language Processing with Disaster Tweets |
8,853,238 | test = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-1/test.csv')
test.head()<feature_engineering> | train_data, val_data, train_labels, val_labels = train_test_split(train.processed_text.values, train.target.values, test_size=0.15, random_state=10)
train_input = bert_encode(train_data, tokenizer, max_len=50)
val_input = bert_encode(val_data, tokenizer, max_len=50)
test_input = bert_encode(test.processed_text.value... | Natural Language Processing with Disaster Tweets |
8,853,238 | test['date_datetime'] = test['Date'].apply(lambda x:(datetime.datetime.strptime(x, '%Y-%m-%d')))
def days_convert(date):
return(date - datetime.datetime(2020,1,22)).days
test['days_since_start'] = test['date_datetime'].apply(days_convert)
test['Country/Region'] = test['Country/Region'].apply(rename_countries)
test['... | Natural Language Processing with Disaster Tweets | |
8,853,238 | predictions = rf.predict(test[['Lat','Long','days_since_start','population','median_age']])
predictions1 = rf1.predict(test[['Lat','Long','days_since_start','population','median_age','life_expectancy']] )<load_from_csv> | learning_rate=1e-5
decay=5e-5
max_len=50
lr_schedule = [9e-7,1e-8,5e-8,9e-8,7e-9,1e-9]
K.clear_session() | Natural Language Processing with Disaster Tweets |
8,853,238 | submit = pd.read_csv('/kaggle/input/covid19-global-forecasting-week-1/submission.csv')
submit['ConfirmedCases'] = predictions
submit['ConfirmedCases'] = submit['ConfirmedCases'].apply(int)
submit['Fatalities'] = predictions1
submit['Fatalities'] = submit['Fatalities'].apply(int)
submit.head()<save_to_csv> | 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")
pooled_output, sequence_output = bert_layer([input_word_ids, input_mask, segment_ids])
clf... | Natural Language Processing with Disaster Tweets |
8,853,238 | submit.to_csv('submission.csv',index=False )<save_to_csv> | sBERT = Model(inputs=[input_word_ids, input_mask, segment_ids], outputs=out)
sBERT.compile(Adam(lr=learning_rate, decay=decay), loss='binary_crossentropy', metrics=['accuracy',f1_m])
sBERT.summary() | Natural Language Processing with Disaster Tweets |
8,853,238 | test.to_csv('test.csv')
train.to_csv('train.csv' )<install_modules> | init_weights = sBERT.get_weights() | Natural Language Processing with Disaster Tweets |
8,853,238 | !pip install pyramid-arima<set_options> | checkpoint1 = ModelCheckpoint('best_accuracy.h5',
monitor='val_f1_m',
save_best_only=True)
train_history = sBERT.fit(
full_input, full_labels,
epochs = 1,
batch_size = 16
)
test_pred = sBERT.predict(test_input)
print(" - test_f1_score: {}".format(f1_score(test_labels,test_pred.round())))
print()
sBERT.save_weight... | Natural Language Processing with Disaster Tweets |
8,853,238 | warnings.filterwarnings("ignore")
test = pd.read_csv(".. /input/covid19-global-forecasting-week-1/test.csv")
train = pd.read_csv(".. /input/covid19-global-forecasting-week-1/train.csv")
train.head()<count_unique_values> | K.set_value(sBERT.optimizer.lr, 1e-6)
sBERT.fit(
full_input, full_labels,
epochs = 1,
batch_size = 16
)
test_pred = sBERT.predict(test_input)
epoch_test_accuracy = f1_score(test_labels,test_pred.round())
print(" - test_f1_score: {}".format(epoch_test_accuracy))
print()
if epoch_test_accuracy >= test_accuracy:
sBE... | Natural Language Processing with Disaster Tweets |
8,853,238 | no_countr = train['Country/Region'].nunique()
no_province = train['Province/State'].nunique()
no_countr_with_prov = len(train[train['Province/State'].isna() ==False]['Country/Region'].unique())
total_forecasting_number = no_province + no_countr - no_countr_with_prov+2
no_days = train['Date'].nunique()
print('there are... | K.set_value(sBERT.optimizer.lr, 1e-7)
sBERT.fit(
full_input, full_labels,
epochs = 1,
batch_size = 16
)
test_pred = sBERT.predict(test_input)
epoch_test_accuracy = f1_score(test_labels,test_pred.round())
print(" - test_f1_score: {}".format(epoch_test_accuracy))
print()
if epoch_test_accuracy >= test_accuracy:
sBE... | Natural Language Processing with Disaster Tweets |
8,853,238 | df = confirmed_total_date.copy()
df = pd.DataFrame({'date': [df.index[i] for i in range(len(df)) ] , 'cases': df['ConfirmedCases'].values.reshape(1,-1)[0].tolist() })
dfog = df.copy()
def l_regr(x,y):
model = LinearRegression().fit(x, y)
return model
x = df['cases']
x = x.drop(x.index[-1] ).values.reshape(( -1, 1))
y... | sBERT.layers[3].trainable = False
sBERT.compile(Adam(lr=1e-6, decay=1e-6), loss='binary_crossentropy', metrics=['accuracy',f1_m] ) | Natural Language Processing with Disaster Tweets |
8,853,238 | index = 1
cases_pred= []
fatalities_pred = []
pbar = tqdm(total=total_forecasting_number)
while index < total_forecasting_number+1:
x = train['ConfirmedCases'].iloc[[i for i in range(no_days*(index-1),no_days*index)]].values
z = train['Fatalities'].iloc[[i for i in range(no_days*(index-1),no_days*index)]].values
index... | sBERT.fit(
full_input, full_labels,
validation_data=(test_input, test_labels),
epochs = 10,
batch_size = 16
)
test_pred = sBERT.predict(test_input)
epoch_test_accuracy = f1_score(test_labels,test_pred.round())
print(" - test_f1_score: {}".format(epoch_test_accuracy))
print()
if epoch_test_accuracy >= test_accuracy... | Natural Language Processing with Disaster Tweets |
8,853,238 | submission = pd.DataFrame({'ForecastId': [i for i in range(1,len(cases_pred)+1)] ,'ConfirmedCases': cases_pred, 'Fatalities': fatalities_pred})
filename = 'submission.csv'
submission.to_csv(filename,index=False )<load_from_csv> | Natural Language Processing with Disaster Tweets | |
8,853,238 | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
train=pd.read_csv('/kaggle/input/covid19-global-forecasting-week-1/train.csv',sep=',')
test=pd.read_csv('/kaggle/input/covid19-global-forecasting-week-1/test.csv',sep=',')
submission=pd.read_csv('/... | sBERT.load_weights('best_accuracy.h5' ) | Natural Language Processing with Disaster Tweets |
8,853,238 | print("Training data:
", train.count() , "
Test data:
", test.count())
print("
Training Missing data:
", train.isnull().sum() , "
Test Missing data:
", test.isnull().sum() )<drop_column> | bert_encoder = Model(sBERT.inputs, sBERT.layers[-5].output)
bert_encoder.summary()
| Natural Language Processing with Disaster Tweets |
8,853,238 | train = train.drop(['Province/State'],axis=1)
test = test.drop(['Province/State'],axis=1)
train.dtypes<feature_engineering> | bert_encoder.layers[3].trainable | Natural Language Processing with Disaster Tweets |
8,853,238 | def create_time_features(df):
df['date'] = df.index
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['weekofyear'] = df['date'].dt.weekofye... | %%time
train_embed = bert_encoder.predict(train_input)
test_embed = bert_encoder.predict(test_input ) | Natural Language Processing with Disaster Tweets |
8,853,238 | train["iDate"] = train["Date"].apply(lambda x: x.replace("-",""))
train["iDate"] = train["iDate"].astype(int)
test["iDate"] = test["Date"].apply(lambda x: x.replace("-",""))
test["iDate"] = test["iDate"].astype(int)
train['Date'] = pd.to_datetime(train['Date'])
test['Date']= pd.to_datetime(test['Date'])
train = tra... | with open('Train BERT 1024d Embed', 'ab')as fo:
pickle.dump(train_embed, fo)
with open('Test BERT 1024d Embed', 'ab')as fo:
pickle.dump(test_embed, fo ) | Natural Language Processing with Disaster Tweets |
8,853,238 | create_time_features(train)
create_time_features(test )<feature_engineering> | from sklearn.model_selection import StratifiedKFold, KFold, GridSearchCV
from sklearn.svm import SVC | Natural Language Processing with Disaster Tweets |
8,853,238 | train['ConfirmedCases_today'] = train.groupby(['Country/Region'])['ConfirmedCases'].diff(1)
train['Fatalities_today'] = train.groupby(['Country/Region'])['Fatalities'].diff(1 )<data_type_conversions> | %%time
svc_model = SVC(gamma='scale', kernel='rbf', C=3)
svc_model.fit(train_embed, train_labels ) | Natural Language Processing with Disaster Tweets |
8,853,238 | train['ConfirmedCases_today'] = train['ConfirmedCases_today'].fillna(0)
train['Fatalities_today'] = train['Fatalities_today'].fillna(0)
print(train.groupby(['Country/Region'])['ConfirmedCases_today'].sum())
print(train.groupby(['Country/Region'])['Fatalities_today'].sum())
<count_missing_values> | import xgboost as xgb | Natural Language Processing with Disaster Tweets |
8,853,238 | train.isnull().sum()<count_missing_values> | %%time
clf = xgb.XGBClassifier(max_depth=200, n_estimators=400, subsample=1, learning_rate=0.07, reg_lambda=0.1, reg_alpha=0.1,\
gamma=1)
clf.fit(train_embed, train_labels)
predictions = clf.predict(train_embed)
print("Training set f1_score :", np.round(f1_score(train_labels, predictions),5)) | Natural Language Processing with Disaster Tweets |
8,853,238 | train.isnull().sum()<define_variables> | test_pred1 = clf.predict(test_embed ).round().astype(int)
test_pred2 = svc_model.predict(test_embed ).round().astype(int)
test_pred3 = sBERT.predict(test_input ).round().astype(int)
print("XGBOOST: ", accuracy_score(test_labels, test_pred1), f1_score(test_labels, test_pred1))
print("SVC: ",accuracy_score(test_labels... | Natural Language Processing with Disaster Tweets |
8,853,238 | input_cols = ["Lat","Long", "iDate"]
output_cols = ["ConfirmedCases","Fatalities"]
ids = submission["ForecastId"]
extra_feat = ["ConfirmedCases_today", "Fatalities_today"]<prepare_x_and_y> | sub = pd.read_csv("/kaggle/input/nlp-getting-started/sample_submission.csv")
sub['target'] = test_pred1
sub.to_csv('submission_xgboost.csv', index=False)
sub['target'] = test_pred2
sub.to_csv('submission_svc.csv', index=False)
sub['target'] = test_pred3
sub.to_csv('submission_bertnn.csv', index=False ) | Natural Language Processing with Disaster Tweets |
9,087,560 | X = train[input_cols]
Y1 = train[output_cols[0]]
Y2 = train[output_cols[1]]
X_test = test[input_cols]
E1 = train[extra_feat[0]]
E2 = train[extra_feat[1]]
XE = train[input_cols+extra_feat]<train_model> | import nltk
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.base import Base... | Natural Language Processing with Disaster Tweets |
9,087,560 | model= xgb.XGBRegressor(n_estimators=1000)
model.fit(X,E1)
ep1 = model.predict(X_test)
model.fit(X,E2)
ep2 = model.predict(X_test)
<train_model> | rand_state = random.seed(12 ) | Natural Language Processing with Disaster Tweets |
9,087,560 | model= xgb.XGBRegressor(n_estimators=1000)
model.fit(X,E1)
ep1 = model.predict(X_test)
preds = np.array(ep1)
preds[preds < 0] = 0
preds = np.round(preds, 0)
model.fit(X,E2)
ep2 = model.predict(X_test)
prds = np.array(ep2)
prds[prds < 0] = 0
prds = np.round(prds, 0 )<feature_engineering> | train = pd.read_csv('/kaggle/input/nlp-getting-started/train.csv')
test = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv' ) | Natural Language Processing with Disaster Tweets |
9,087,560 | test['ConfirmedCases_today'] = preds
test['Fatalities_today'] = prds<prepare_x_and_y> | X = train['text'] | Natural Language Processing with Disaster Tweets |
9,087,560 | XE_test = test[input_cols+extra_feat]<save_to_csv> | y = train['target'] | Natural Language Processing with Disaster Tweets |
9,087,560 | tree_reg= xgb.XGBRegressor(n_estimators=1000)
tree_reg.fit(XE,Y1)
prd = tree_reg.predict(XE_test)
tree_reg.fit(XE,Y2)
prd_2 = tree_reg.predict(XE_test)
output_tree_reg = pd.DataFrame({ 'ForecastId' : ids, 'ConfirmedCases': prd,'Fatalities':prd_2 })
output_tree_reg.to_csv('submission.csv', index=False)
<load_fro... | test_x = test['text'] | Natural Language Processing with Disaster Tweets |
9,087,560 | 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' )<set_options> | X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = rand_state, shuffle = True ) | Natural Language Processing with Disaster Tweets |
9,087,560 | pio.templates.default = "plotly_dark"
py.init_notebook_mode(connected=True )<groupby> | count_vectorizer = CountVectorizer(stop_words='english')
count_train = count_vectorizer.fit_transform(X_train)
count_test = count_vectorizer.transform(X_test)
count_train_sub = count_vectorizer.transform(X)
count_sub = count_vectorizer.transform(test_x)
| Natural Language Processing with Disaster Tweets |
9,087,560 | latest_grouped = train.groupby('Country/Region')['ConfirmedCases', 'Fatalities'].sum().reset_index()<drop_column> | count_nb = MultinomialNB()
count_nb.fit(count_train ,y_train)
count_nb_pred = count_nb.predict(count_test)
count_nb_score = accuracy_score(y_test,count_nb_pred)
print('MultinomialNaiveBayes Count Score: ', count_nb_score)
count_nb_cm = confusion_matrix(y_test, count_nb_pred)
count_nb_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | europe = list(['Austria','Belgium','Bulgaria','Croatia','Cyprus','Czechia','Denmark','Estonia','Finland','France','Germany','Greece','Hungary','Ireland',
'Italy', 'Latvia','Luxembourg','Lithuania','Malta','Norway','Netherlands','Poland','Portugal','Romania','Slovakia','Slovenia',
'Spain', 'Sweden', 'United Kingdom', 'I... | count_bnb = BernoulliNB()
count_bnb.fit(count_train ,y_train)
count_bnb_pred = count_bnb.predict(count_test)
count_bnb_score = accuracy_score(y_test,count_bnb_pred)
print('BernoulliNaiveBayes Count Score: ', count_bnb_score)
count_bnb_cm = confusion_matrix(y_test, count_bnb_pred)
count_bnb_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | train['province_encoded'] = train['Province/State'].apply(lambda x: province_encoded[x])
train.head()<feature_engineering> | count_lsvc = LinearSVC()
count_lsvc.fit(count_train ,y_train)
count_lsvc_pred = count_lsvc.predict(count_test)
count_lsvc_score = accuracy_score(y_test,count_lsvc_pred)
print('LinearSVC Count Score: ', count_lsvc_score)
count_lsvc_cm = confusion_matrix(y_test, count_lsvc_pred)
count_lsvc_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | train['country_encoded'] = train['Country/Region'].apply(lambda x: country_encoded[x])
train.head()<import_modules> | count_svc = SVC()
count_svc.fit(count_train ,y_train)
count_svc_pred = count_svc.predict(count_test)
count_svc_score = accuracy_score(y_test,count_svc_pred)
print('SVC Count Score: ', count_svc_score)
count_svc_cm = confusion_matrix(y_test, count_svc_pred)
count_svc_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | from datetime import datetime
import time<feature_engineering> | count_nusvc = NuSVC(0.4)
count_nusvc.fit(count_train ,y_train)
count_nusvc_pred = count_nusvc.predict(count_test)
count_nusvc_score = accuracy_score(y_test,count_nusvc_pred)
print('NuSVC Count Score: ', count_nusvc_score)
count_nusvc_cm = confusion_matrix(y_test, count_nusvc_pred)
count_nusvc_cm | Natural Language Processing with Disaster Tweets |
9,087,560 |
<feature_engineering> | Natural Language Processing with Disaster Tweets | |
9,087,560 |
<feature_engineering> | Natural Language Processing with Disaster Tweets | |
9,087,560 | train['Mon'] = train['Date'].apply(lambda x: int(x.split('-')[1]))
train['Day'] = train['Date'].apply(lambda x: int(x.split('-')[2]))<feature_engineering> | count_sgd = SGDClassifier()
count_sgd.fit(count_train ,y_train)
count_sgd_pred = count_sgd.predict(count_test)
count_sgd_score = accuracy_score(y_test,count_sgd_pred)
print('SGD Count Score: ', count_sgd_score)
count_sgd_cm = confusion_matrix(y_test, count_sgd_pred)
count_sgd_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | train['serial'] = train['Mon'] * 30 + train['Day']
train.head()<feature_engineering> | count_lr = LogisticRegression()
count_lr.fit(count_train ,y_train)
count_lr_pred = count_lr.predict(count_test)
count_lr_score = accuracy_score(y_test,count_lr_pred)
print('LogisticRegression Count Score: ', count_lr_score)
count_lr_cm = confusion_matrix(y_test, count_lr_pred)
count_lr_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | train['serial'] = train['serial'] - train['serial'].min()<load_from_csv> | tfidf_vectorizer = TfidfVectorizer(stop_words='english')
tfidf_train = tfidf_vectorizer.fit_transform(X_train)
tfidf_test = tfidf_vectorizer.transform(X_test)
tfidf_train_sub = tfidf_vectorizer.transform(X)
tfidf_sub = tfidf_vectorizer.transform(test_x ) | Natural Language Processing with Disaster Tweets |
9,087,560 | gdp2020 = pd.read_csv('/kaggle/input/gdp2020/GDP2020.csv')
population2020 = pd.read_csv('/kaggle/input/population2020/population2020.csv' )<define_variables> | tfidf_nb = MultinomialNB()
tfidf_nb.fit(tfidf_train, y_train)
tfidf_nb_pred = tfidf_nb.predict(tfidf_test)
tfidf_nb_score = accuracy_score(y_test,tfidf_nb_pred)
print('MultinomialNaiveBayes Tfidf Score: ', tfidf_nb_score)
tfidf_nb_cm = confusion_matrix(y_test, tfidf_nb_pred)
tfidf_nb_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | gdp2020 = gdp2020.rename(columns={"rank":"rank_gdp"})
gdp2020_numeric_list = [list(gdp2020)[0]] + list(gdp2020)[2:-1]
gdp2020.head()<define_variables> | tfidf_svc = LinearSVC()
tfidf_svc.fit(tfidf_train, y_train)
tfidf_svc_pred = tfidf_svc.predict(tfidf_test)
tfidf_svc_score = accuracy_score(y_test,tfidf_svc_pred)
print("LinearSVC Score: %0.3f" % tfidf_svc_score)
svc_cm = confusion_matrix(y_test, tfidf_svc_pred)
svc_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | map_state = {'US':'United States',
'Korea, South':'South Korea',
'Cote d'Ivoire':'Ivory Coast',
'Czechia':'Czech Republic',
'Eswatini':'Swaziland',
'Holy See':'Vatican City',
'Jersey':'United Kingdom',
'North Macedonia':'Macedonia',
'Taiwan*':'Taiwan',
'occupied Palestinian territory':'Palestine'
}
map_state_rev = {v: ... | tfidf_svc0 = SVC()
tfidf_svc0.fit(tfidf_train, y_train)
tfidf_svc_pred0 = tfidf_svc.predict(tfidf_test)
tfidf_svc_score0 = accuracy_score(y_test,tfidf_svc_pred0)
print("SVC Score: %0.3f" % tfidf_svc_score0)
svc_cm0 = confusion_matrix(y_test, tfidf_svc_pred0)
classification_report(y_test, tfidf_svc_pred0)
svc_cm0 | Natural Language Processing with Disaster Tweets |
9,087,560 | population2020['name'] = population2020['name'].apply(lambda x: map_state_rev[x] if x in map_state_rev else x)
gdp2020['country'] = gdp2020['country'].apply(lambda x: map_state_rev[x] if x in map_state_rev else x )<rename_columns> | tfidf_nusvc = NuSVC()
tfidf_nusvc.fit(tfidf_train, y_train)
tfidf_nusvc_pred = tfidf_nusvc.predict(tfidf_test)
tfidf_nusvc_score = accuracy_score(y_test,tfidf_nusvc_pred)
print("NuSVC Score: %0.3f" % tfidf_nusvc_score)
nusvc_cm = confusion_matrix(y_test, tfidf_nusvc_pred)
classification_report(y_test, tfidf_nusvc_... | Natural Language Processing with Disaster Tweets |
9,087,560 | population2020 = population2020.rename(columns={"rank":"rank_pop"})
population2020_numeric_list = [list(population2020)[0]] + list(gdp2020)[2:]
population2020.head()<merge> | tfidf_bnb = BernoulliNB()
tfidf_bnb.fit(tfidf_train, y_train)
tfidf_bnb_pred = tfidf_bnb.predict(tfidf_test)
tfidf_bnb_score = accuracy_score(y_test,tfidf_bnb_pred)
print('BernoulliNaiveBayes Tfidf Score: %0.3f' % tfidf_bnb_score)
tfidf_bnb_cm = confusion_matrix(y_test, tfidf_bnb_pred)
tfidf_bnb_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | train = pd.merge(train, population2020, how='left', left_on = 'Country/Region', right_on = 'name')
train = pd.merge(train, gdp2020, how='left', left_on = 'Country/Region', right_on = 'country' )<count_missing_values> | tfidf_sgd = SGDClassifier()
tfidf_sgd.fit(tfidf_train, y_train)
tfidf_sgd_pred = tfidf_sgd.predict(tfidf_test)
tfidf_sgd_score = accuracy_score(y_test,tfidf_sgd_pred)
print("SGD Score: %0.3f" % tfidf_sgd_score)
sgd_cm = confusion_matrix(y_test, tfidf_sgd_pred)
sgd_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | train.isnull().sum()<count_missing_values> | tfidf_lr = LogisticRegression()
tfidf_lr.fit(tfidf_train, y_train)
tfidf_lr_pred = tfidf_lr.predict(tfidf_test)
tfidf_lr_score = accuracy_score(y_test,tfidf_lr_pred)
print("LogisticRegression Score: %0.3f" % tfidf_lr_score)
lr_cm = confusion_matrix(y_test, tfidf_lr_pred)
lr_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | train.isnull().sum()<data_type_conversions> | sample_sub=pd.read_csv('/kaggle/input/nlp-getting-started/sample_submission.csv')
| Natural Language Processing with Disaster Tweets |
9,087,560 | train = train.fillna(0 )<prepare_x_and_y> | count_nusvc.fit(count_train_sub ,y)
count_nusvc_sub = count_nusvc.predict(count_sub)
| Natural Language Processing with Disaster Tweets |
9,087,560 | numeric_features_X = ['Lat','Long', 'province_encoded' ,'country_encoded','Mon','Day'] + population2020_numeric_list + gdp2020_numeric_list
numeric_features_Y = ['ConfirmedCases', 'Fatalities']
train_numeric_X = train[numeric_features_X]
train_numeric_Y = train[numeric_features_Y]<feature_engineering> | sub=pd.DataFrame({'id':sample_sub['id'].values.tolist() ,'target':count_nusvc_sub} ) | Natural Language Processing with Disaster Tweets |
9,087,560 | test['province_encoded'] = test['Province/State'].apply(lambda x: province_encoded[x] if x in province_encoded else max(province_encoded.values())+1 )<feature_engineering> | sub.to_csv('submission.csv',index=False ) | Natural Language Processing with Disaster Tweets |
9,087,560 | test['country_encoded'] = test['Country/Region'].apply(lambda x: country_encoded[x] if x in country_encoded else max(country_encoded.values())+1 )<feature_engineering> | import nltk
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.base import Base... | Natural Language Processing with Disaster Tweets |
9,087,560 | test['Mon'] = test['Date'].apply(lambda x: int(x.split('-')[1]))
test['Day'] = test['Date'].apply(lambda x: int(x.split('-')[2]))<feature_engineering> | rand_state = random.seed(12 ) | Natural Language Processing with Disaster Tweets |
9,087,560 | test['serial'] = test['Mon'] * 30 + test['Day']
test['serial'] = test['serial'] - test['serial'].min()<merge> | train = pd.read_csv('/kaggle/input/nlp-getting-started/train.csv')
test = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv' ) | Natural Language Processing with Disaster Tweets |
9,087,560 | test = pd.merge(test, population2020, how='left', left_on = 'Country/Region', right_on = 'name')
test = pd.merge(test, gdp2020, how='left', left_on = 'Country/Region', right_on = 'country' )<feature_engineering> | X = train['text'] | Natural Language Processing with Disaster Tweets |
9,087,560 |
<count_missing_values> | y = train['target'] | Natural Language Processing with Disaster Tweets |
9,087,560 | test_numeric_X = test[numeric_features_X]
test_numeric_X.isnull().sum()<correct_missing_values> | test_x = test['text'] | Natural Language Processing with Disaster Tweets |
9,087,560 | test_numeric_X = test_numeric_X.fillna(-1 )<import_modules> | X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = rand_state, shuffle = True ) | Natural Language Processing with Disaster Tweets |
9,087,560 | from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression<train_model> | count_vectorizer = CountVectorizer(stop_words='english')
count_train = count_vectorizer.fit_transform(X_train)
count_test = count_vectorizer.transform(X_test)
count_train_sub = count_vectorizer.transform(X)
count_sub = count_vectorizer.transform(test_x)
| Natural Language Processing with Disaster Tweets |
9,087,560 | pipeline = Pipeline([('scaler', StandardScaler()),('estimator', LinearRegression())])
pipeline.fit(train_numeric_X, train_numeric_Y )<predict_on_test> | count_nb = MultinomialNB()
count_nb.fit(count_train ,y_train)
count_nb_pred = count_nb.predict(count_test)
count_nb_score = accuracy_score(y_test,count_nb_pred)
print('MultinomialNaiveBayes Count Score: ', count_nb_score)
count_nb_cm = confusion_matrix(y_test, count_nb_pred)
count_nb_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | predicted = pipeline.predict(test_numeric_X )<import_modules> | count_bnb = BernoulliNB()
count_bnb.fit(count_train ,y_train)
count_bnb_pred = count_bnb.predict(count_test)
count_bnb_score = accuracy_score(y_test,count_bnb_pred)
print('BernoulliNaiveBayes Count Score: ', count_bnb_score)
count_bnb_cm = confusion_matrix(y_test, count_bnb_pred)
count_bnb_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | from sklearn.svm import SVR<train_model> | count_lsvc = LinearSVC()
count_lsvc.fit(count_train ,y_train)
count_lsvc_pred = count_lsvc.predict(count_test)
count_lsvc_score = accuracy_score(y_test,count_lsvc_pred)
print('LinearSVC Count Score: ', count_lsvc_score)
count_lsvc_cm = confusion_matrix(y_test, count_lsvc_pred)
count_lsvc_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | pipeline = Pipeline([('scaler', StandardScaler()),('estimator', SVR())])
pipeline.fit(train_numeric_X, train_numeric_Y.values[:,0])
pipeline2 = Pipeline([('scaler', StandardScaler()),('estimator', SVR())])
pipeline2.fit(train_numeric_X, train_numeric_Y.values[:,1])
discovered, fatal = pipeline.predict(test_numeric_... | count_svc = SVC()
count_svc.fit(count_train ,y_train)
count_svc_pred = count_svc.predict(count_test)
count_svc_score = accuracy_score(y_test,count_svc_pred)
print('SVC Count Score: ', count_svc_score)
count_svc_cm = confusion_matrix(y_test, count_svc_pred)
count_svc_cm | Natural Language Processing with Disaster Tweets |
9,087,560 |
<import_modules> | count_nusvc = NuSVC(0.4)
count_nusvc.fit(count_train ,y_train)
count_nusvc_pred = count_nusvc.predict(count_test)
count_nusvc_score = accuracy_score(y_test,count_nusvc_pred)
print('NuSVC Count Score: ', count_nusvc_score)
count_nusvc_cm = confusion_matrix(y_test, count_nusvc_pred)
count_nusvc_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | from sklearn.neighbors import KNeighborsClassifier<import_modules> | Natural Language Processing with Disaster Tweets | |
9,087,560 | from sklearn.neighbors import KNeighborsClassifier<import_modules> | Natural Language Processing with Disaster Tweets | |
9,087,560 | from sklearn.neighbors import KNeighborsClassifier<train_model> | count_sgd = SGDClassifier()
count_sgd.fit(count_train ,y_train)
count_sgd_pred = count_sgd.predict(count_test)
count_sgd_score = accuracy_score(y_test,count_sgd_pred)
print('SGD Count Score: ', count_sgd_score)
count_sgd_cm = confusion_matrix(y_test, count_sgd_pred)
count_sgd_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | pipeline = Pipeline([('scaler', StandardScaler()),('estimator', KNeighborsClassifier(n_jobs=4)) ])
pipeline.fit(train_numeric_X, train_numeric_Y )<import_modules> | count_lr = LogisticRegression()
count_lr.fit(count_train ,y_train)
count_lr_pred = count_lr.predict(count_test)
count_lr_score = accuracy_score(y_test,count_lr_pred)
print('LogisticRegression Count Score: ', count_lr_score)
count_lr_cm = confusion_matrix(y_test, count_lr_pred)
count_lr_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | from sklearn.ensemble import RandomForestClassifier<train_model> | tfidf_vectorizer = TfidfVectorizer(stop_words='english')
tfidf_train = tfidf_vectorizer.fit_transform(X_train)
tfidf_test = tfidf_vectorizer.transform(X_test)
tfidf_train_sub = tfidf_vectorizer.transform(X)
tfidf_sub = tfidf_vectorizer.transform(test_x ) | Natural Language Processing with Disaster Tweets |
9,087,560 | RF_model = RandomForestClassifier(n_estimators=50,n_jobs=4,verbose=True)
RF_model.fit(train_numeric_X, train_numeric_Y )<save_to_csv> | tfidf_nb = MultinomialNB()
tfidf_nb.fit(tfidf_train, y_train)
tfidf_nb_pred = tfidf_nb.predict(tfidf_test)
tfidf_nb_score = accuracy_score(y_test,tfidf_nb_pred)
print('MultinomialNaiveBayes Tfidf Score: ', tfidf_nb_score)
tfidf_nb_cm = confusion_matrix(y_test, tfidf_nb_pred)
tfidf_nb_cm | Natural Language Processing with Disaster Tweets |
9,087,560 |
<import_modules> | tfidf_svc = LinearSVC()
tfidf_svc.fit(tfidf_train, y_train)
tfidf_svc_pred = tfidf_svc.predict(tfidf_test)
tfidf_svc_score = accuracy_score(y_test,tfidf_svc_pred)
print("LinearSVC Score: %0.3f" % tfidf_svc_score)
svc_cm = confusion_matrix(y_test, tfidf_svc_pred)
svc_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | from sklearn.ensemble import AdaBoostClassifier<train_model> | tfidf_svc0 = SVC()
tfidf_svc0.fit(tfidf_train, y_train)
tfidf_svc_pred0 = tfidf_svc.predict(tfidf_test)
tfidf_svc_score0 = accuracy_score(y_test,tfidf_svc_pred0)
print("SVC Score: %0.3f" % tfidf_svc_score0)
svc_cm0 = confusion_matrix(y_test, tfidf_svc_pred0)
classification_report(y_test, tfidf_svc_pred0)
svc_cm0 | Natural Language Processing with Disaster Tweets |
9,087,560 | adaboost_model_for_ConfirmedCases = AdaBoostClassifier(n_estimators=15)
adaboost_model_for_ConfirmedCases.fit(train_numeric_X, train_numeric_Y[numeric_features_Y[0]])
adaboost_model_for_Fatalities = AdaBoostClassifier(n_estimators=15)
adaboost_model_for_Fatalities.fit(train_numeric_X, train_numeric_Y[numeric_feature... | tfidf_nusvc = NuSVC()
tfidf_nusvc.fit(tfidf_train, y_train)
tfidf_nusvc_pred = tfidf_nusvc.predict(tfidf_test)
tfidf_nusvc_score = accuracy_score(y_test,tfidf_nusvc_pred)
print("NuSVC Score: %0.3f" % tfidf_nusvc_score)
nusvc_cm = confusion_matrix(y_test, tfidf_nusvc_pred)
classification_report(y_test, tfidf_nusvc_... | Natural Language Processing with Disaster Tweets |
9,087,560 |
<create_dataframe> | tfidf_bnb = BernoulliNB()
tfidf_bnb.fit(tfidf_train, y_train)
tfidf_bnb_pred = tfidf_bnb.predict(tfidf_test)
tfidf_bnb_score = accuracy_score(y_test,tfidf_bnb_pred)
print('BernoulliNaiveBayes Tfidf Score: %0.3f' % tfidf_bnb_score)
tfidf_bnb_cm = confusion_matrix(y_test, tfidf_bnb_pred)
tfidf_bnb_cm | Natural Language Processing with Disaster Tweets |
9,087,560 |
<import_modules> | tfidf_sgd = SGDClassifier()
tfidf_sgd.fit(tfidf_train, y_train)
tfidf_sgd_pred = tfidf_sgd.predict(tfidf_test)
tfidf_sgd_score = accuracy_score(y_test,tfidf_sgd_pred)
print("SGD Score: %0.3f" % tfidf_sgd_score)
sgd_cm = confusion_matrix(y_test, tfidf_sgd_pred)
sgd_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
from sklearn import model_selection
from mlxtend.classifier import StackingCVClassifier<choose_model_class> | tfidf_lr = LogisticRegression()
tfidf_lr.fit(tfidf_train, y_train)
tfidf_lr_pred = tfidf_lr.predict(tfidf_test)
tfidf_lr_score = accuracy_score(y_test,tfidf_lr_pred)
print("LogisticRegression Score: %0.3f" % tfidf_lr_score)
lr_cm = confusion_matrix(y_test, tfidf_lr_pred)
lr_cm | Natural Language Processing with Disaster Tweets |
9,087,560 | clf1 = KNeighborsClassifier(n_neighbors=100)
clf2 = RandomForestClassifier(n_estimators=10)
clf3 = GaussianNB()
lr = LogisticRegression(solver='lbfgs')
sclf = StackingCVClassifier(classifiers=[clf1, clf2], meta_classifier=lr, use_probas=True, cv=3)
for clf, label in zip([clf1, clf2, clf3, sclf],
['KNN',
'Random For... | sample_sub=pd.read_csv('/kaggle/input/nlp-getting-started/sample_submission.csv')
| 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.