kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
12,513,336 | model.compile(loss='categorical_crossentropy',optimizer=Adadelta(learning_rate=1.0, rho=0.95),metrics=['accuracy'] )<train_model> | train['text'] = train['text'].apply(lambda x:
re.sub(r'[^\w\s]','', x))
test['text'] = test['text'].apply(lambda x:
re.sub(r'[^\w\s]','', x)) | Natural Language Processing with Disaster Tweets |
12,513,336 | history = model.fit(X_train, y_train, batch_size = 256, epochs = 10, validation_data =(X_val, y_val), verbose = 2 )<train_model> | w_tokenizer = nltk.tokenize.WhitespaceTokenizer()
lemmatizer = nltk.stem.WordNetLemmatizer()
def lemmatize_text(text):
return ' '.join([lemmatizer.lemmatize(w)for w in w_tokenizer.tokenize(text)])
train['text'] = train.text.apply(lambda x: lemmatize_text(x))
test['text'] = test.text.apply(lambda x: lemmatize_text(x)) | Natural Language Processing with Disaster Tweets |
12,513,336 | datagen = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range = 10,
horizontal_flip = False,
zoom_range = 0.15)
datagen.fit(X_train )<define_variables> | all_stopwords = set(stopwords.words('english')) | Natural Language Processing with Disaster Tweets |
12,513,336 | BATCH_SIZE = 512
EPOCHS = 50<train_model> | def stopword_count(data, column):
count_dict = dict.fromkeys(all_stopwords, 0)
def row_count(row):
for word in row.split() :
if word in all_stopwords:
count_dict[str(word)] += 1
data[column].apply(lambda x: row_count(x))
return count_dict | Natural Language Processing with Disaster Tweets |
12,513,336 | history = model.fit_generator(datagen.flow(X_train,y_train, batch_size=BATCH_SIZE),
epochs = EPOCHS,
shuffle=True,
validation_data =(X_val,y_val),
verbose = 1,
steps_per_epoch=X_train.shape[0] // BATCH_SIZE )<predict_on_test> | stopwords = stopword_count(train, 'text')
stopwords = pd.Series(stopwords, index=stopwords.keys())
stopwords = stopwords[stopwords > 0]
stopwords = stopwords.sort_values(ascending=False ) | Natural Language Processing with Disaster Tweets |
12,513,336 | y_pre_test=model.predict(X_val)
y_pre_test=np.argmax(y_pre_test,axis=1)
y_test=np.argmax(y_val,axis=1 )<compute_test_metric> | train['text'] = train['text'].apply(lambda x: ' '.join([word for word in x.split() if word not in(all_stopwords)]))
test['text'] = test['text'].apply(lambda x: ' '.join([word for word in x.split() if word not in(all_stopwords)])) | Natural Language Processing with Disaster Tweets |
12,513,336 | conf=confusion_matrix(y_test,y_pre_test)
conf=pd.DataFrame(conf,index=range(0,10),columns=range(0,10))<define_variables> | eng_words = set(nltk.corpus.words.words())
train['text'] = train['text'].apply(lambda x: ' '.join(w for w in x.split() if not any(j.isdigit() for j in w)))
test['text'] = test['text'].apply(lambda x: ' '.join(w for w in x.split() if not any(j.isdigit() for j in w)) ) | Natural Language Processing with Disaster Tweets |
12,513,336 | x=(y_pre_test-y_test!=0 ).tolist()
x=[i for i,l in enumerate(x)if l!=False]<predict_on_test> | vect = CountVectorizer(min_df=3, ngram_range=(1,1))
enc = OneHotEncoder()
full_data = pd.concat(( train, test))
enc.fit(full_data[['location', 'keyword']])
vect.fit(full_data['text'])
print(len(vect.get_feature_names()))
print(len(enc.get_feature_names())) | Natural Language Processing with Disaster Tweets |
12,513,336 |
results = model.predict(X_test)
results = np.argmax(results,axis = 1 )<save_to_csv> | np.random.seed(15)
shuffled_train = train.iloc[np.random.permutation(len(train)) ]
shuffled_test = test.iloc[np.random.permutation(len(test)) ]
n_estimators = [60, 80, 100]
X_vect = vect.transform(shuffled_train['text'] ).todense()
X_onehot = enc.transform(shuffled_train[['location', 'keyword']] ).todense()
X = np.con... | Natural Language Processing with Disaster Tweets |
12,513,336 | sample_sub =pd.read_csv(os.path.join(dirname,'sample_submission.csv'))
sample_sub['label'] = results
sample_sub.to_csv('submission.csv',index=False )<import_modules> | vect = TfidfVectorizer(min_df=3, ngram_range=(1,1))
enc = OneHotEncoder()
full_data = pd.concat(( train, test))
enc.fit(full_data[['location', 'keyword']])
vect.fit(full_data['text'])
print(len(vect.get_feature_names()))
print(len(enc.get_feature_names())) | Natural Language Processing with Disaster Tweets |
12,513,336 | device = "cuda"<define_search_model> | np.random.seed(15)
shuffled_train = train.iloc[np.random.permutation(len(train)) ]
clf = BernoulliNB(fit_prior = False)
X_vect = vect.transform(shuffled_train['text'] ).todense()
X_onehot = enc.transform(shuffled_train[['location', 'keyword']] ).todense()
X = np.concatenate(( X_vect, X_onehot), axis=1)
Y = shuffled_... | Natural Language Processing with Disaster Tweets |
12,513,336 | class Sq_Ex_Block(nn.Module):
def __init__(self, in_ch, r):
super(Sq_Ex_Block, self ).__init__()
self.se = nn.Sequential(
GlobalAvgPool() ,
nn.Linear(in_ch, in_ch//r),
nn.ReLU(inplace=True),
nn.Linear(in_ch//r, in_ch),
nn.Sigmoid()
)
def forward(self, x):
se_weight = self.se(x ).unsqueeze(-1 ).unsqueeze(-1)
return ... | np.random.seed(15)
shuffled_train = train.iloc[np.random.permutation(len(train)) ]
shuffled_test = test.iloc[np.random.permutation(len(test)) ]
max_iter = 400
X_vect = vect.transform(shuffled_train['text'] ).todense()
X_onehot = enc.transform(shuffled_train[['location', 'keyword']] ).todense()
X = np.concatenate(( X_v... | Natural Language Processing with Disaster Tweets |
12,513,336 | trans = transforms.Compose([
transforms.RandomAffine(degrees=10,translate=(0.15,0.15),scale=[0.9,1.1],shear=5),
transforms.ToTensor() ,
])
trans_val = transforms.Compose([
transforms.ToTensor() ,
])
trans_test = transforms.Compose([
transforms.ToTensor() ,
] )<load_from_csv> | np.random.seed(15)
shuffled_train = train.iloc[np.random.permutation(len(train)) ]
shuffled_test = test.iloc[np.random.permutation(len(test)) ]
max_iter = 70000
X_vect = vect.transform(shuffled_train['text'] ).todense()
X_onehot = enc.transform(shuffled_train[['location', 'keyword']] ).todense()
X = np.concatenate(( X... | Natural Language Processing with Disaster Tweets |
12,513,336 | global_data = pd.read_csv("/kaggle/input/Kannada-MNIST/train.csv")
global_data_test = pd.read_csv("/kaggle/input/Kannada-MNIST/test.csv")
class KMnistDataset(Dataset):
def __init__(self,data_len=None, is_validate=False,validate_rate=None,indices=None, data=None):
self.is_validate = is_validate
self.data = global_data... | from datetime import datetime | Natural Language Processing with Disaster Tweets |
12,513,336 | batch_size = 1024
num_workers = 8
epochs = 70
lr = 1e-3
val_period = 1
val_rate = 0.1<choose_model_class> | vect = CountVectorizer(min_df=3, ngram_range=(1,1))
enc = OneHotEncoder()
full_data = pd.concat(( train, test))
enc.fit(full_data[['location', 'keyword']])
vect.fit(full_data['text'])
print(len(vect.get_feature_names()))
print(len(enc.get_feature_names())) | Natural Language Processing with Disaster Tweets |
12,513,336 | model = SE_Net(in_channels=1)
if device == "cuda":
model.cuda()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters() ,lr=lr,betas=(0.9,0.99))
lr_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, verbose=True, patience=15,factor=0.1 )<create_dataframe> | max_iter = 400
X_vect_train = vect.transform(train['text'] ).todense()
X_onehot_train = enc.transform(train[['location', 'keyword']] ).todense()
X_train = np.concatenate(( X_vect_train, X_onehot_train), axis=1)
Y_train = train['target']
X_vect_test = vect.transform(test['text'] ).todense()
X_onehot_test = enc.transfor... | Natural Language Processing with Disaster Tweets |
12,513,336 | indices_len = len(global_data)
indices = np.arange(indices_len)
train_dataset = KMnistDataset(data_len=None,is_validate=False, validate_rate=val_rate,indices=indices)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
val_dataset = KMnistDataset(data_len=None,is_v... | X_vect_train = vect.transform(train['text'] ).todense()
X_onehot_train = enc.transform(train[['location', 'keyword']] ).todense()
X_train = np.concatenate(( X_vect_train, X_onehot_train), axis=1)
Y_train = train['target']
X_vect_test = vect.transform(test['text'] ).todense()
X_onehot_test = enc.transform(test[['locati... | Natural Language Processing with Disaster Tweets |
12,513,336 | min_loss = 10000
max_acc = 0
best_model_dict = None
print("Start training...")
for ep in range(0,epochs+1):
model.train()
data_num = 0
for idx, data in enumerate(train_loader):
img, target = data
img, target = img.to(device), target.to(device,dtype=torch.long)
pred = model(img)
loss = criterion(pred,target)
data_nu... | max_iter = 70000
X_vect_train = vect.transform(train['text'] ).todense()
X_onehot_train = enc.transform(train[['location', 'keyword']] ).todense()
X_train = np.concatenate(( X_vect_train, X_onehot_train), axis=1)
Y_train = train['target']
X_vect_test = vect.transform(test['text'] ).todense()
X_onehot_test = enc.transf... | Natural Language Processing with Disaster Tweets |
12,513,336 | result = np.array([],dtype=np.int)
test_dataset = TestDataset(data_len=None)
test_loader = DataLoader(test_dataset, batch_size=256, shuffle=False, num_workers=8)
test_model = SE_Net(in_channels=1)
test_model.load_state_dict(best_model_dict)
if device == "cuda":
test_model.cuda()
test_model.eval()
with torch.no_gra... | max_iter = 80
X_vect_train = vect.transform(train['text'] ).todense()
X_onehot_train = enc.transform(train[['location', 'keyword']] ).todense()
X_train = np.concatenate(( X_vect_train, X_onehot_train), axis=1)
Y_train = train['target']
X_vect_test = vect.transform(test['text'] ).todense()
X_onehot_test = enc.transform... | Natural Language Processing with Disaster Tweets |
12,513,336 | sample_sub=pd.read_csv('/kaggle/input/Kannada-MNIST/sample_submission.csv')
sample_sub['label']=result
sample_sub.to_csv('submission.csv',index=False)
sample_sub.head()<import_modules> | predict =(LogReg_predict + NaiveBayes_predict + RF_predict)/ 3 | Natural Language Processing with Disaster Tweets |
12,513,336 | import csv
import numpy as np
import keras
import tensorflow as tf
from keras.models import Sequential
from keras.layers import Dense,Dropout,Activation,BatchNormalization
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.callbacks import ReduceLROnPlateau, EarlyStopping
from ker... | predict[predict >= 0.5] = int(1)
predict[predict < 0.5] = int(0 ) | Natural Language Processing with Disaster Tweets |
12,513,336 | decay=1e-4
xtrain = []
ytrain = []
xtest = []
xval = []
yval = []<load_from_csv> | result_df = pd.DataFrame(test['id'].values, columns=['id'])
result_df['target'] = predict.astype(int)
result_df.to_csv(path_or_buf=r'submission_Ensamble.csv', index=False ) | Natural Language Processing with Disaster Tweets |
12,513,336 | <data_type_conversions><EOS> | for name, predict in [('LogReg', LogReg_predict),
('NaiveBayes', NaiveBayes_predict),('RF', RF_predict),('SVM', SVM_predict)]:
predict[predict >= 0.5] = int(1)
predict[predict < 0.5] = int(0)
result_df = pd.DataFrame(test['id'].values, columns=['id'])
result_df['target'] = predict.astype(int)
result_df.to_csv(path... | Natural Language Processing with Disaster Tweets |
13,991,134 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<choose_model_class> | train = pd.read_csv(".. /input/nlp-getting-started/train.csv")
display(train)
test = pd.read_csv(".. /input/nlp-getting-started/test.csv")
display(test ) | Natural Language Processing with Disaster Tweets |
13,991,134 | model=Sequential()
model.add(layers.Conv2D(64,(3,3), padding='same', input_shape=(28, 28, 1)))
model.add(layers.BatchNormalization(momentum=0.9, epsilon=1e-5, gamma_initializer="uniform"))
model.add(layers.LeakyReLU(alpha=0.1))
model.add(layers.Conv2D(64,(3,3), padding='same'))
model.add(layers.BatchNormalization(mome... | train.drop(
[
6449, 7034, 3589, 3591, 3597, 3600, 3603,
3604, 3610, 3613, 3614, 119, 106, 115,
2666, 2679, 1356, 7609, 3382, 1335, 2655,
2674, 1343, 4291, 4303, 1345, 48, 3374,
7600, 164, 5292, 2352, 4308, 4306, 4310,
1332, 1156, 7610, 2441, 2449, 2454, 2477,
2452, 2456, 3390, 7611, 6656, 1360, 5771,
4351, 5073, 4601,... | Natural Language Processing with Disaster Tweets |
13,991,134 | optimizer = RMSprop(learning_rate=0.002,rho=0.9)
model.compile(optimizer=optimizer,loss='sparse_categorical_crossentropy',metrics=['accuracy'] )<train_model> | train.drop(
[
4290, 4299, 4312, 4221, 4239, 4244, 2830,
2831, 2832, 2833, 4597, 4605, 4618, 4232,
4235, 3240, 3243, 3248, 3251, 3261, 3266,
4285, 4305, 4313, 1214, 1365, 6614, 6616,
1197, 1331, 4379, 4381, 4284, 4286, 4292,
4304, 4309, 4318, 610, 624, 630, 634, 3985,
4013, 4019, 1221, 1349, 6091, 6094,
6103, 6123, 562... | Natural Language Processing with Disaster Tweets |
13,991,134 | datagen = ImageDataGenerator(
rotation_range=11,
zoom_range=0.4,
width_shift_range=0.3,
height_shift_range=0.3,
)
datagen.fit(xtrain )<choose_model_class> | def fix_text_issues(x):
x = x.lower()
x = x.replace("&", "and")
x = x.replace("<", "<")
x = x.replace(">", ">")
x = re.sub("(\W|^)hwy\.( \W)", "\\1highway\\2", x)
x = re.sub("(\W|^)ave.( \W)", "\\1avenue\\2", x)
x = re.sub("(\W|^)fyi(\W)", "\\1for your information\\2", x)
x = re.sub("(\W|^)ain't(\W)", "... | Natural Language Processing with Disaster Tweets |
13,991,134 | learning_rate_reduction = tf.keras.callbacks.ReduceLROnPlateau(
monitor='loss',
factor=0.2,
patience=2,
verbose=1,
mode="auto",
min_delta=0.0001,
cooldown=0,
min_lr=0.00001
)
es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=300, restore_best_weights=True )<train_model> | pipeline = Pipeline([('tfidf', TfidfVectorizer(decode_error="ignore")) ,('clf', SVC(random_state=2020)) ])
parameters = {
'tfidf__ngram_range':(( 1,1),(1,2),(2,2)) ,
'tfidf__use_idf':(True, False),
'tfidf__smooth_idf':(True, False),
'tfidf__sublinear_tf':(True, False),
'clf__C':(1.5, 1.7, 1.9),
}
grid = GridSearchCV(p... | Natural Language Processing with Disaster Tweets |
13,991,134 | history=model.fit_generator(datagen.flow(xtrain, ytrain, batch_size=1024),
steps_per_epoch=len(xtrain)//1024,
epochs=50,
validation_data=(np.array(xval),np.array(yval)) ,
validation_steps=50,
callbacks=[learning_rate_reduction, es])
<save_to_csv> | x_train, x_valid, y_train, y_valid = train_test_split(
train["text"], train["target"], test_size=0.2, random_state=2020
)
vectorizer = TfidfVectorizer(
decode_error="ignore",
ngram_range=(1,2),
smooth_idf=False,
sublinear_tf=True,
use_idf=True
)
x_train_tfidf = vectorizer.fit_transform(x_train)
x_valid_tfidf = v... | Natural Language Processing with Disaster Tweets |
13,991,134 | ytest = model.predict_classes(xtest)
id_col = np.arange(ytest.shape[0])
submission = pd.DataFrame({'id': id_col, 'label': ytest})
submission.to_csv('submission.csv', index = False )<define_variables> | vectorizer = TfidfVectorizer(
decode_error="ignore",
ngram_range=(1,2),
smooth_idf=False,
sublinear_tf=True,
use_idf=True
)
train_tfidf = vectorizer.fit_transform(train["text"])
model = SVC(random_state=2020, C=1.7)
model.fit(train_tfidf, train["target"] ) | Natural Language Processing with Disaster Tweets |
13,991,134 | <import_modules><EOS> | clean_text(test)
test_tfidf = vectorizer.transform(test["text"])
predictions = model.predict(test_tfidf)
submission = pd.DataFrame({"id": test["id"], "target": predictions})
submission.to_csv("submission.csv", index=False ) | Natural Language Processing with Disaster Tweets |
13,518,520 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<import_modules> | !wget --quiet https://raw.githubusercontent.com/tensorflow/models/master/official/nlp/bert/tokenization.py | Natural Language Processing with Disaster Tweets |
13,518,520 | from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix<import_modules> | import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras.layers import Dense, Input
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.models import Model
from tensorflow.keras.callbacks import ModelCheckpoint
import tensorflow_hub as hub
import tokenization | Natural Language Processing with Disaster Tweets |
13,518,520 | from keras.utils import to_categorical
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.callbacks import EarlyStopping<load_from_csv> | def bert_encode(texts, tokenizer, max_len=512):
all_tokens = []
all_masks = []
all_segments = []
for text in texts:
text = tokenizer.tokenize(text)
text = text[:max_len-2]
input_sequence = ["[CLS]"] + text + ["[SEP]"]
pad_len = max_len - len(input_sequence)
tokens = tokenizer.convert_tokens_to_ids(input_sequence)
to... | Natural Language Processing with Disaster Tweets |
13,518,520 | train_data = pd.read_csv(path + 'train.csv')
train_data<count_values> | def build_model(bert_layer, max_len=512):
input_word_ids = Input(shape=(max_len,), dtype=tf.int32, name="input_word_ids")
input_mask = Input(shape=(max_len,), dtype=tf.int32, name="input_mask")
segment_ids = Input(shape=(max_len,), dtype=tf.int32, name="segment_ids")
_, sequence_output = bert_layer([input_word_ids, ... | Natural Language Processing with Disaster Tweets |
13,518,520 | train_data.label.value_counts()<load_from_csv> | %%time
module_url = "https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/1"
bert_layer = hub.KerasLayer(module_url, trainable=True ) | Natural Language Processing with Disaster Tweets |
13,518,520 | dig_data = pd.read_csv(path + 'Dig-MNIST.csv')
dig_data<count_values> | train = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv")
submission = pd.read_csv("/kaggle/input/nlp-getting-started/sample_submission.csv" ) | Natural Language Processing with Disaster Tweets |
13,518,520 | dig_data.label.value_counts()<categorify> | vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = tokenization.FullTokenizer(vocab_file, do_lower_case ) | Natural Language Processing with Disaster Tweets |
13,518,520 | train_labels = to_categorical(train_data.label)
train_labels<statistical_test> | train_input = bert_encode(train.text.values, tokenizer, max_len=160)
test_input = bert_encode(test.text.values, tokenizer, max_len=160)
train_labels = train.target.values | Natural Language Processing with Disaster Tweets |
13,518,520 | show_random_image(train_images_2D )<data_type_conversions> | checkpoint = ModelCheckpoint('model.h5', monitor='val_loss', save_best_only=True)
train_history = model.fit(
train_input, train_labels,
validation_split=0.2,
epochs=3,
callbacks=[checkpoint],
batch_size=16
) | Natural Language Processing with Disaster Tweets |
13,518,520 | train_images_2D = train_images_2D.astype('float')
train_images_2D /= 255<categorify> | model.load_weights('model.h5')
test_pred = model.predict(test_input ) | Natural Language Processing with Disaster Tweets |
13,518,520 | dig_labels = to_categorical(dig_data.label)
dig_labels<statistical_test> | submission['target'] = test_pred.round().astype(int)
submission.to_csv('submission.csv', index=False ) | Natural Language Processing with Disaster Tweets |
13,081,318 | show_random_image(dig_images_2D )<data_type_conversions> | train_df = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test_df = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv")
sub_df = pd.read_csv("/kaggle/input/nlp-getting-started/sample_submission.csv" ) | Natural Language Processing with Disaster Tweets |
13,081,318 | dig_images_2D = dig_images_2D.astype('float')
dig_images_2D /= 255<split> | train_df.count() | Natural Language Processing with Disaster Tweets |
13,081,318 | images_train,imames_val,labels_train,labels_val = train_test_split(train_images_2D, train_labels,
random_state=42,test_size=0.15 )<init_hyperparams> | test_df.count() | Natural Language Processing with Disaster Tweets |
13,081,318 | datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(ima... | from nltk.corpus import stopwords
import nltk
import re
import string
from sklearn import feature_extraction, linear_model, model_selection, preprocessing | Natural Language Processing with Disaster Tweets |
13,081,318 | test_data = pd.read_csv(path + 'test.csv', index_col='id')
test_data<load_from_csv> | def change_text(text):
text = re.sub(r"n't", " not", text)
text = re.sub(r"'re", " are", text)
text = re.sub(r"'s", " is", text)
text = re.sub(r"'d", " would", text)
text = re.sub(r"'ll", " will", text)
text = re.sub(r"'t", " not", text)
text = re.sub(r"'ve", " have", text)
text = re.sub(r"'m", " am", text)
tex... | Natural Language Processing with Disaster Tweets |
13,081,318 | submission = pd.read_csv(path + 'sample_submission.csv', index_col='id')
submission<data_type_conversions> | def clean_preprocessor(text):
text = text.lower()
text = re.sub('\[.*?\]', '', text)
text = re.sub("\\W"," ",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*... | Natural Language Processing with Disaster Tweets |
13,081,318 | test_images_2D = test_images_2D.astype('float')
test_images_2D /= 255<define_variables> | 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)
train_df['text'] = train_df['text'].apply(lambda x : ... | Natural Language Processing with Disaster Tweets |
13,081,318 | input_shape =(dim, dim, 1)
num_classes = 10<choose_model_class> | from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer
from sklearn.linear_model import LogisticRegression | Natural Language Processing with Disaster Tweets |
13,081,318 | optimizer = 'rmsprop'
loss = 'categorical_crossentropy'
metrics = ['accuracy']<choose_model_class> | stopwords = stopwords.words('english')
count_vectorizer = CountVectorizer(token_pattern=r'\w{1,}', ngram_range=(1, 2), stop_words = stopwords)
train_vector = count_vectorizer.fit_transform(train_df['text'])
test_vector = count_vectorizer.transform(test_df['text'] ) | Natural Language Processing with Disaster Tweets |
13,081,318 | epochs = 100
batch_size = 1024
early_stop = EarlyStopping(monitor='val_loss',
min_delta=0,
patience=3,
verbose=True,
mode='auto',
baseline=None,
restore_best_weights=False)
callbacks = [early_stop]<choose_model_class> | clf = LogisticRegression(C=0.9,max_iter=1000,penalty='l2')
scores = model_selection.cross_val_score(clf, train_vector, train_df["target"], cv=7, scoring="f1")
print(scores ) | Natural Language Processing with Disaster Tweets |
13,081,318 | model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(Conv2D(64,(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(... | clf.fit(train_vector, train_df["target"] ) | Natural Language Processing with Disaster Tweets |
13,081,318 | kernel_size =(5, 5)
model = Sequential()
model.add(Conv2D(32, kernel_size=kernel_size, activation='relu',
input_shape=input_shape))
model.add(Conv2D(64, kernel_size=kernel_size, activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation... | sub_df["target"] = clf.predict(test_vector)
sub_df.to_csv("sample_submission.csv", index=False ) | Natural Language Processing with Disaster Tweets |
11,400,002 | kernel_size =(5, 5)
model = Sequential()
model.add(Conv2D(32, kernel_size=kernel_size, activation='relu',
input_shape=input_shape))
model.add(Conv2D(32, kernel_size=kernel_size, activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, kernel_size=kernel_size, activat... | if torch.cuda.is_available() :
device = torch.device("cuda")
print('We will use the GPU:', torch.cuda.get_device_name(0))
else:
print('No GPU available, using the CPU instead.')
device = torch.device("cpu" ) | Natural Language Processing with Disaster Tweets |
11,400,002 | kernel_size_1 =(7, 7)
kernel_size_2 =(5, 5)
model = Sequential()
model.add(Conv2D(32, kernel_size=kernel_size_1, activation='relu', padding='same',
input_shape=input_shape))
model.add(Conv2D(32, kernel_size=kernel_size_1, activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout... | df_train=pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
df_test=pd.read_csv("/kaggle/input/nlp-getting-started/test.csv" ) | Natural Language Processing with Disaster Tweets |
11,400,002 | kernel_size_1 =(7, 7)
kernel_size_2 =(5, 5)
model = Sequential()
model.add(Conv2D(32, kernel_size=kernel_size_1, activation='relu', padding='same',
input_shape=input_shape))
model.add(Conv2D(32, kernel_size=kernel_size_1, activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout... | def preprocess(text):
text=text.lower()
text = re.sub(r'https?:\/\/.*[\r
]*', '', text)
text = re.sub(r'http?:\/\/.*[\r
]*', '', text)
text=text.replace(r'&?',r'and')
text=text.replace(r'<',r'<')
text=text.replace(r'>',r'>')
text = re.sub(r"(?:\@)\w+", '', text)
text=text.encode("ascii",errors="ignore" ... | Natural Language Processing with Disaster Tweets |
11,400,002 | kernel_size_1 =(7, 7)
kernel_size_2 =(5, 5)
model = Sequential()
model.add(Conv2D(32, kernel_size=kernel_size_1, activation='relu', padding='same',
input_shape=input_shape))
model.add(Conv2D(32, kernel_size=kernel_size_1, activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout... | df_train["target"].value_counts() | Natural Language Processing with Disaster Tweets |
11,400,002 | kernel_size_1 =(7, 7)
kernel_size_2 =(5, 5)
model = Sequential()
model.add(Conv2D(32, kernel_size=kernel_size_1, activation='relu', padding='same',
input_shape=input_shape))
model.add(Conv2D(32, kernel_size=kernel_size_1, activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout... | texts = df_train.text.values
labels = df_train.target.values | Natural Language Processing with Disaster Tweets |
11,400,002 | model.compile(optimizer=optimizer, loss=loss, metrics=metrics )<train_model> | tokenizer = ElectraTokenizer.from_pretrained('google/electra-base-discriminator')
model = ElectraForSequenceClassification.from_pretrained('google/electra-base-discriminator',num_labels=2)
model.cuda() | Natural Language Processing with Disaster Tweets |
11,400,002 | model.fit_generator(datagen.flow(images_train, labels_train,
batch_size=batch_size),
epochs=epochs,
verbose=True,
callbacks=callbacks,
validation_data=(imames_val, labels_val))<predict_on_test> | indices=tokenizer.batch_encode_plus(texts,max_length=64,add_special_tokens=True, return_attention_mask=True,pad_to_max_length=True,truncation=True)
input_ids=indices["input_ids"]
attention_masks=indices["attention_mask"] | Natural Language Processing with Disaster Tweets |
11,400,002 | pred_train = model.predict_classes(train_images_2D)
pred_train.shape<compute_test_metric> | train_inputs, validation_inputs, train_labels, validation_labels = train_test_split(input_ids, labels,
random_state=42, test_size=0.2)
train_masks, validation_masks, _, _ = train_test_split(attention_masks, labels,
random_state=42, test_size=0.2 ) | Natural Language Processing with Disaster Tweets |
11,400,002 | hits =(pred_train == train_data.label)
print('Hits: {}, i.e.{:.2f}%'.format(hits.sum() , hits.sum() / pred_train.shape[0] * 100))<compute_test_metric> | train_inputs = torch.tensor(train_inputs)
validation_inputs = torch.tensor(validation_inputs)
train_labels = torch.tensor(train_labels, dtype=torch.long)
validation_labels = torch.tensor(validation_labels, dtype=torch.long)
train_masks = torch.tensor(train_masks, dtype=torch.long)
validation_masks = torch.tensor(v... | Natural Language Processing with Disaster Tweets |
11,400,002 | miss =(pred_train != train_data.label)
print('Misses: {}, i.e.{:.2f}%'.format(miss.sum() , miss.sum() / pred_train.shape[0] * 100))<create_dataframe> | batch_size = 32
train_data = TensorDataset(train_inputs, train_masks, train_labels)
train_sampler = RandomSampler(train_data)
train_dataloader = DataLoader(train_data, sampler=train_sampler, batch_size=batch_size)
validation_data = TensorDataset(validation_inputs, validation_masks, validation_labels)
validation_sam... | Natural Language Processing with Disaster Tweets |
11,400,002 | cm = confusion_matrix(y_true=train_data.label, y_pred=pred_train)
cm = pd.DataFrame(cm, index=range(num_classes), columns=range(num_classes))
cm<create_dataframe> | def flat_accuracy(preds, labels):
pred_flat = np.argmax(preds, axis=1 ).flatten()
labels_flat = labels.flatten()
return np.sum(pred_flat == labels_flat)/ len(labels_flat ) | Natural Language Processing with Disaster Tweets |
11,400,002 | eval_metrics = model.evaluate(x=train_images_2D, y=train_labels,
batch_size=batch_size, verbose=True, callbacks=callbacks)
pd.DataFrame(eval_metrics, index=model.metrics_names, columns=['metric'] )<predict_on_test> | def format_time(elapsed):
elapsed_rounded = int(round(( elapsed)))
return str(datetime.timedelta(seconds=elapsed_rounded)) | Natural Language Processing with Disaster Tweets |
11,400,002 | pred_Dig = model.predict_classes(dig_images_2D)
pred_Dig.shape<compute_test_metric> | seed_val = 42
random.seed(seed_val)
np.random.seed(seed_val)
torch.manual_seed(seed_val)
torch.cuda.manual_seed_all(seed_val)
loss_values = []
for epoch_i in range(0, epochs):
print("")
print('======== Epoch {:} / {:} ========'.format(epoch_i + 1, epochs))
print('Training...')
t0 = time.time()
total_loss = 0
mode... | Natural Language Processing with Disaster Tweets |
11,400,002 | hits =(pred_Dig == dig_data.label)
print('Hits: {}, i.e.{:.2f}%'.format(hits.sum() , hits.sum() / pred_Dig.shape[0] * 100))<compute_test_metric> | print("")
print("Running Validation...")
t0 = time.time()
model.eval()
preds=[]
true=[]
eval_loss, eval_accuracy = 0, 0
nb_eval_steps, nb_eval_examples = 0, 0
for batch in validation_dataloader:
batch = tuple(t.to(device)for t in batch)
b_input_ids, b_input_mask, b_labels = batch
with torch.no_grad() :
outputs = mod... | Natural Language Processing with Disaster Tweets |
11,400,002 | miss =(pred_Dig != dig_data.label)
print('Misses: {}, i.e.{:.2f}%'.format(miss.sum() , miss.sum() / pred_Dig.shape[0] * 100))<create_dataframe> | flat_predictions = [item for sublist in preds for item in sublist]
flat_predictions = np.argmax(flat_predictions, axis=1 ).flatten()
flat_true_labels = [item for sublist in true for item in sublist] | Natural Language Processing with Disaster Tweets |
11,400,002 | cm = confusion_matrix(y_true=dig_data.label, y_pred=pred_Dig)
cm = pd.DataFrame(cm, index=range(num_classes), columns=range(num_classes))
cm<create_dataframe> | print(classification_report(flat_predictions,flat_true_labels)) | Natural Language Processing with Disaster Tweets |
11,400,002 | eval_metrics = model.evaluate(x=dig_images_2D, y=dig_labels,
batch_size=batch_size, verbose=True, callbacks=callbacks)
pd.DataFrame(eval_metrics, index=model.metrics_names, columns=['metric'] )<train_model> | comments1 = df_test.text.values
indices1=tokenizer.batch_encode_plus(comments1,max_length=128,add_special_tokens=True, return_attention_mask=True,pad_to_max_length=True,truncation=True)
input_ids1=indices1["input_ids"]
attention_masks1=indices1["attention_mask"]
prediction_inputs1= torch.tensor(input_ids1)
prediction... | Natural Language Processing with Disaster Tweets |
11,400,002 | epochs = early_stop.stopped_epoch + 1
model.fit(train_images_2D, train_labels,
batch_size=batch_size, epochs=epochs,
verbose=True )<predict_on_test> | print('Predicting labels for {:,} test sentences...'.format(len(prediction_inputs1)))
model.eval()
predictions = []
for batch in prediction_dataloader1:
batch = tuple(t.to(device)for t in batch)
b_input_ids1, b_input_mask1 = batch
with torch.no_grad() :
outputs1 = model(b_input_ids1, token_type_ids=None,
attention_ma... | Natural Language Processing with Disaster Tweets |
11,400,002 | pred_test = model.predict_classes(test_images_2D )<save_to_csv> | sample_sub=pd.read_csv('.. /input/nlp-getting-started/sample_submission.csv')
submit=pd.DataFrame({'id':sample_sub['id'].values.tolist() ,'target':flat_predictions})
| Natural Language Processing with Disaster Tweets |
11,400,002 | <set_options><EOS> | df_leak = pd.read_csv('/kaggle/input/disasters-on-social-media/socialmedia-disaster-tweets-DFE.csv', encoding ='ISO-8859-1')[['choose_one', 'text']]
df_leak['target'] =(df_leak['choose_one'] == 'Relevant' ).astype(np.int8)
df_leak['id'] = df_leak.index.astype(np.int16)
df_leak.drop(columns=['choose_one', 'text'], inp... | Natural Language Processing with Disaster Tweets |
11,309,718 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<load_from_csv> | import pandas as pd
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import transformers as trfo
import sklearn.model_selection as ms
import sklearn.metrics as m
from functools import partial
import hyperopt as ho
import pickle
import re
import string
import it... | Natural Language Processing with Disaster Tweets |
11,309,718 | train = pd.read_csv("/kaggle/input/Kannada-MNIST/train.csv")
test = pd.read_csv("/kaggle/input/Kannada-MNIST/test.csv")
validation = pd.read_csv("/kaggle/input/Kannada-MNIST/Dig-MNIST.csv")
<groupby> | train_df = pd.read_csv('.. /input/nlp-getting-started/train.csv' ) | Natural Language Processing with Disaster Tweets |
11,309,718 | train.groupby(train["label"] ).size()
<groupby> | tokenizer = trfo.BertTokenizer.from_pretrained('bert-large-uncased' ) | Natural Language Processing with Disaster Tweets |
11,309,718 | validation.groupby(validation["label"] ).size()<prepare_x_and_y> | tokenizer.encode('London!' ) | Natural Language Processing with Disaster Tweets |
11,309,718 | train_labels = to_categorical(train.iloc[:,0])
train = train.iloc[:, 1:].values
X_validation = validation.iloc[:, 1:].values
y_validation = to_categorical(validation.iloc[:,0])
test_id = test.iloc[:, 0]
test = test.iloc[:, 1:].values<categorify> | tokenizer.decode(101), tokenizer.decode(2414), tokenizer.decode(999), tokenizer.decode(102 ) | Natural Language Processing with Disaster Tweets |
11,309,718 | train = train/255
X_validation = X_validation/255
test = test/255<choose_model_class> | def build_vocab(sentences):
vocab = {}
for sentence in tqdm.tqdm(sentences):
for word in sentence:
try:
vocab[word] += 1
except KeyError:
vocab[word] = 1
return vocab | Natural Language Processing with Disaster Tweets |
11,309,718 | train_datagen = ImageDataGenerator(
rotation_range=12,
width_shift_range=0.25,
height_shift_range=0.25,
shear_range=12,
zoom_range=0.25
)
valid_datagen = ImageDataGenerator(
rotation_range=12,
width_shift_range=0.25,
height_shift_range=0.25,
shear_range=12,
zoom_range=0.25)
valid_datagen_simple = ImageDataGenerato... | def check_coverage(vocab, embeddings_index):
a = {}
oov = {}
k = 0
i = 0
for word in tqdm.tqdm(vocab):
try:
a[word] = embeddings_index[word]
k += vocab[word]
except:
oov[word] = vocab[word]
i += vocab[word]
pass
print('Found embeddings for {:.2%} of vocab'.format(len(a)/ len(vocab)))
print('Found embeddings for {:.2%}... | Natural Language Processing with Disaster Tweets |
11,309,718 | X_train, X_test, y_train, y_test = train_test_split(train, train_labels, test_size = 0.2, random_state = 84)
<choose_model_class> | vocab = build_vocab(train_df['text'].apply(lambda x: x.split() ).values)
check_coverage(vocab, tokenizer.get_vocab() ) | Natural Language Processing with Disaster Tweets |
11,309,718 | def build_model() :
model = Sequential()
model.add(Conv2D(32,(3,3), activation = "relu", input_shape =(28,28,1), padding = "same"))
model.add(BatchNormalization())
model.add(Conv2D(32,(5,5), strides =(2,2),activation = "relu", padding = "same"))
model.add(BatchNormalization())
model.add(Dropout(0.2))
model.add(Conv2D... | train_df['text'] = train_df['text'].apply(lambda x: x.lower())
vocab = build_vocab(train_df['text'].apply(lambda x: x.split() ).values)
check_coverage(vocab, tokenizer.get_vocab() ) | Natural Language Processing with Disaster Tweets |
11,309,718 | model = build_model()<train_model> | def remove_url(text):
return re.sub(r'https?:\/\/t.co\/[A-Za-z0-9]+', '', text ) | Natural Language Processing with Disaster Tweets |
11,309,718 | history = model.fit_generator(
train_datagen.flow(X_train, y_train, batch_size = 1024),
epochs = 50,
steps_per_epoch=50,
validation_data =(X_test, y_test))<define_variables> | def remove_user(text):
text = re.sub(r'\@[A-Za-z0-9]+', '', text)
return text | Natural Language Processing with Disaster Tweets |
11,309,718 | y_test_labels = []
for i in y_test:
for j, val in enumerate(i):
if val == 0.:
pass
else:
y_test_labels.append(j )<predict_on_test> | train_df['text'] = train_df['text'].apply(lambda x: remove_url(x))
train_df['text'] = train_df['text'].apply(lambda x: remove_user(x))
vocab = build_vocab(train_df['text'].apply(lambda x: x.split() ).values)
check_coverage(vocab, tokenizer.get_vocab() ) | Natural Language Processing with Disaster Tweets |
11,309,718 | preds = history.model.predict_classes(X_test )<compute_test_metric> | abbreviations_mapping = {
"$" : " dollar ",
"€" : " euro ",
"4ao" : "for adults only",
"a.m" : "before midday",
"a3" : "anytime anywhere anyplace",
"aamof" : "as a matter of fact",
"acct" : "account",
"adih" : "another day in hell",
"afaic" : "as far as i am concerned",
"afaict" : "as far as i can tell",
"afaik" : "as ... | Natural Language Processing with Disaster Tweets |
11,309,718 | accuracy_score(preds, np.array(y_test_labels))<train_model> | contraction_mapping = {"ain't": "is not", "aren't": "are not","can't": "cannot", "'cause": "because", "could've": "could have", "couldn't": "could not", "didn't": "did not", "doesn't": "does not",
"don't": "do not", "hadn't": "had not", "hasn't": "has not", "haven't": "have not", "he'd": "he would","he'll": "he will", ... | Natural Language Processing with Disaster Tweets |
11,309,718 | model = build_model()<train_model> | synonyms_mapping = {
"&": "&",
"retweet": "response to",
"wildfire": "flame",
"reddit": "social network",
"legionnaires": "disease",
"thunderstorm": "storm",
"sinkhole": "crater",
"derailment": "runs off its rails",
"windstorm": "storm",
"twister": "tornado",
"rescuers": "people who rescue",
"whirlwind": "hurricane... | Natural Language Processing with Disaster Tweets |
11,309,718 | history_full = model.fit_generator(
train_datagen.flow(train, train_labels, batch_size = 1024),
epochs = 50,
steps_per_epoch=train.shape[0]//1024,
validation_data = valid_datagen.flow(X_validation, y_validation))<predict_on_test> | def translate_with_mapping(text, dictionary):
text = ' '.join([dictionary[t] if t in dictionary else t for t in text.split(' ')])
return text | Natural Language Processing with Disaster Tweets |
11,309,718 | preds = history_full.model.predict_classes(X_validation)
<compute_test_metric> | train_df['text'] = train_df['text'].apply(lambda x: translate_with_mapping(x, synonyms_mapping))
train_df['text'] = train_df['text'].apply(lambda x: translate_with_mapping(x, abbreviations_mapping))
train_df['text'] = train_df['text'].apply(lambda x: translate_with_mapping(x, contraction_mapping))
vocab = build_vocab(t... | Natural Language Processing with Disaster Tweets |
11,309,718 | accuracy_score(preds, np.argmax(y_validation, axis = 1))
<concatenate> | def remove_punct_dup(text):
punc = set(string.punctuation)
newtext = []
for k, g in itertools.groupby(text):
if k in punc:
newtext.append(k)
else:
newtext.extend(g)
return ''.join(newtext ) | Natural Language Processing with Disaster Tweets |
11,309,718 | X_train_total = np.concatenate(( train, X_validation))
y_train_total = np.concatenate(( train_labels, y_validation))
<train_model> | train_df['text'] = train_df['text'].apply(lambda x: remove_punct_dup(x))
vocab = build_vocab(train_df['text'].apply(lambda x: x.split() ).values)
check_coverage(vocab, tokenizer.get_vocab() ) | Natural Language Processing with Disaster Tweets |
11,309,718 | model = build_model()<train_model> | def init_tpu(tpu):
tf.tpu.experimental.initialize_tpu_system(tpu ) | Natural Language Processing with Disaster Tweets |
11,309,718 | history_final = model.fit_generator(train_datagen.flow(
X_train_total, y_train_total, batch_size=1024),
epochs = 50,
steps_per_epoch = X_train_total.shape[0]//1024,
validation_data = valid_datagen.flow(X_validation, y_validation))<predict_on_test> | tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
tf.config.experimental_connect_to_cluster(tpu)
init_tpu(tpu)
tpu_strategy = tf.distribute.experimental.TPUStrategy(tpu ) | Natural Language Processing with Disaster Tweets |
11,309,718 | preds = history_final.model.predict_classes(test)
<create_dataframe> | def load_trials(name, remove_last=True):
trials = pickle.load(open(name, 'rb'))
if remove_last:
trials = remove_last_trial(trials)
return trials | Natural Language Processing with Disaster Tweets |
11,309,718 | submission = pd.DataFrame(data = [pd.Series(test_id, name = "id"), pd.Series(preds, name = "label")], ).T<save_to_csv> | def remove_last_trial(old_trials):
trials = ho.Trials()
for trial in old_trials.trials[:-1]:
hyperopt_trial = ho.Trials().new_trial_docs(
tids=[None],
specs=[None],
results=[None],
miscs=[None])
hyperopt_trial[0] = trial
trials.insert_trial_docs(hyperopt_trial)
trials.refresh()
return trials | Natural Language Processing with Disaster Tweets |
11,309,718 | submission.to_csv("submission.csv", index = False)
<import_modules> | def save_trials(trials):
pickle.dump(trials, open(f'trials_{len(trials.trials)}.p', 'wb')) | Natural Language Processing with Disaster Tweets |
11,309,718 | import matplotlib.pyplot as plt<load_from_csv> | def save_trials_and_call_objective(hparams, objective, trials, df, kf):
print(f'save this len of trials: {len(trials.trials)}')
save_trials(trials)
loss = objective(df, kf, hparams)
return loss | Natural Language Processing with Disaster Tweets |
11,309,718 | dataset = pd.read_csv('/kaggle/input/Kannada-MNIST/train.csv' )<prepare_x_and_y> | trials_file_name = '.. /input/ntrialsanneal17/anneal_trials_132.p' | 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.