kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,644,856 | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head()<load_from_csv> | NB_bow = MultinomialNB()
scores = model_selection.cross_val_score(NB_bow, train_vectors, train["target"], cv=5, scoring="f1")
scores.mean() | Natural Language Processing with Disaster Tweets |
10,644,856 | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head()<feature_engineering> | NB_tfidf = MultinomialNB()
scores = model_selection.cross_val_score(NB_tfidf, train_tfidf, train["target"], cv=5, scoring="f1")
scores.mean() | Natural Language Processing with Disaster Tweets |
10,644,856 | train_data['FamilySize'] = train_data['SibSp'] + train_data['Parch'] + 1
test_data['FamilySize'] = test_data['SibSp'] + test_data['Parch'] + 1
<feature_engineering> | NB_bow.fit(train_vectors, train["target"] ) | Natural Language Processing with Disaster Tweets |
10,644,856 | train_data['Fare'].fillna(train_data['Fare'].median() , inplace=True)
test_data['Fare'].fillna(test_data['Fare'].median() , inplace=True)
<define_variables> | sample_submission = pd.read_csv('.. /input/nlp-getting-started/sample_submission.csv')
sample_submission["target"] = NB_bow.predict(test_vectors)
os.chdir('/kaggle/working')
sample_submission.to_csv("submission1.csv", index=False ) | Natural Language Processing with Disaster Tweets |
10,644,856 | women = train_data.loc[train_data['Sex']=='female']['Survived']
rate_women = sum(women)/len(women)
print("% of women who survived:", rate_women )<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)
... | Natural Language Processing with Disaster Tweets |
10,644,856 | men = train_data.loc[train_data['Sex']=='male']['Survived']
rate_men = sum(men)/len(men)
print("% of men who survived:", rate_men )<categorify> | 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 |
10,644,856 | train_data.Sex = pd.get_dummies(train_data.Sex)
test_data.Sex = pd.get_dummies(test_data.Sex )<data_type_conversions> | 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 |
10,644,856 | train_data['Age'].fillna(train_data['Age'].median() , inplace=True)
test_data['Age'].fillna(test_data['Age'].median() , inplace=True)
<feature_engineering> | Natural Language Processing with Disaster Tweets | |
10,644,856 | train_data['IsAlone'] = 0
train_data.loc[train_data['FamilySize'] == 1, 'IsAlone'] = 1
test_data['IsAlone'] = 0
test_data.loc[test_data['FamilySize'] == 1, 'IsAlone'] = 1
train_data['Age*Class'] = train_data.Age * train_data.Pclass
test_data['Age*Class'] = test_data.Age * test_data.Pclass<filter> | 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 |
10,644,856 | old = train_data.loc[train_data['Age'] > 45]['Survived']
rate_old = sum(old)/len(old)
print("% of old people who survived:", rate_old )<filter> | 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 |
10,644,856 | mid_age = train_data.loc[(train_data['Age'] <= 45)&(train_data['Age'] >= 15)]['Survived']
rate_mid = sum(mid_age)/len(mid_age)
print("% of middle aged people who survived:", rate_mid )<define_variables> | 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 |
10,644,856 | young = train_data.loc[train_data['Age'] < 15]['Survived']
rate_young = sum(young)/len(young)
print("% of young people who survived:", rate_young )<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 |
10,644,856 | train_data['Age'] = pd.cut(train_data['Age'], bins=[0., 10., 25., 50, 80, np.inf], labels=[0,1,2,3,4] ).astype(int)
test_data['Age'] = pd.cut(test_data['Age'], bins=[0., 10., 25., 50, 80, np.inf], labels=[0,1,2,3,4] ).astype(int)
<count_missing_values> | model.load_weights('model.h5')
test_pred = model.predict(test_input ) | Natural Language Processing with Disaster Tweets |
10,644,856 | <categorify><EOS> | submission['target'] = test_pred.round().astype(int)
os.chdir('/kaggle/working')
submission.to_csv("submission2.csv", index=False ) | Natural Language Processing with Disaster Tweets |
10,556,663 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<prepare_x_and_y> | %ls /kaggle/input/nlp-getting-started/ | Natural Language Processing with Disaster Tweets |
10,556,663 | y = train_data["Survived"]
features = ["Pclass", "Sex", "Fare", "SibSp", "Parch","FamilySize", "Embarked", "IsAlone"]
X = train_data[features]
X_test = test_data[features]
print(X)
scoring_method = "f1"
<train_on_grid> | prefix = '/kaggle/input/nlp-getting-started/' | Natural Language Processing with Disaster Tweets |
10,556,663 | rf_model = RandomForestClassifier()
rf_params ={
'bootstrap': [True, False],
'max_depth': [10, None],
'max_features': ['auto', 'sqrt'],
'min_samples_leaf': [1, 2, 4],
'min_samples_split': [2, 5, 10],
'n_estimators': [100]}
rf_gs = GridSearchCV(rf_model, rf_params, scoring=scoring_method, cv=8, n_jobs=4)
rf_gs.fit(X, y... | train_df = pd.read_csv(prefix + 'train.csv')
| Natural Language Processing with Disaster Tweets |
10,556,663 | cross_val_score(rf_gs, X, y, cv=5 )<save_to_csv> | train_df = pd.DataFrame({
'id':range(len(train_df)) ,
'label':train_df["target"],
'alpha':['a']*train_df.shape[0],
'text': train_df["text"].replace(r'
', ' ', regex=True)
})
train_df.head()
len(train_df ) | Natural Language Processing with Disaster Tweets |
10,556,663 | predictions = random_forest.predict(X_test)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Your pipeline submission was successfully saved!" )<import_modules> | test_df = pd.read_csv(prefix + 'test.csv')
| Natural Language Processing with Disaster Tweets |
10,556,663 | classification_report, f1_score, roc_curve, auc
<load_from_csv> | test_df.isnull().sum() | Natural Language Processing with Disaster Tweets |
10,556,663 | PATH = "/kaggle/input/nlp-getting-started/"
train_df = pd.read_csv(f'{PATH}train.csv', low_memory=False)
train_df.shape<categorify> | test_df = pd.DataFrame({
'id':range(len(test_df)) ,
'label':[0]*test_df.shape[0],
'alpha':['a']*test_df.shape[0],
'text': test_df["text"].replace(r'
', ' ', regex=True)
})
test_df.head()
len(test_df ) | Natural Language Processing with Disaster Tweets |
10,556,663 | def clean_text(text):
cleaned_text = re.sub('<[^>]*>', '', text.lower())
cleaned_text = re.sub('[\W]+', ' ', cleaned_text)
cleaned_text = re.sub(r'^https?:\/\/.*[\r
]*', '', cleaned_text)
emojis = re.compile("["
u"\U0001F600-\U0001F64F"
u"\U0001F300-\U0001F5FF"
u"\U0001F680-\U0001F6FF"
u"\U0001F1E0-\U0001F1FF"
u"\... | !mkdir data
!pip install contractions | Natural Language Processing with Disaster Tweets |
10,556,663 | def extensive_clean_and_format(tweet):
tweet = re.sub(r"\x89Û_", "", tweet)
tweet = re.sub(r"\x89ÛÒ", "", tweet)
tweet = re.sub(r"\x89ÛÓ", "", tweet)
tweet = re.sub(r"\x89ÛÏWhen", "When", tweet)
tweet = re.sub(r"\x89ÛÏ", "", tweet)
tweet = re.sub(r"China\x89Ûªs", "China's", tweet)
tweet = re.sub(r"let\x89Ûªs", ... | def fix_contractions(text):
return contractions.fix(text)
def remove_url(text):
url = re.compile(r'https?://\S+|www\.\S+')
return url.sub(r'',text)
def remove_mark(text):
table=str.maketrans('','',string.punctuation)
return text.translate(table)
print("tweet before contractions fix : ", train_df.iloc[1055]["text"]... | Natural Language Processing with Disaster Tweets |
10,556,663 | %%time
stemmer = PorterStemmer()
lemmatizer = WordNetLemmatizer()
sw = stopwords.words('english')
sw.append('http')
sw.append('https')
sw.append('co')
sw.append('û_')
train_df['cleaned text'] = train_df['text'].apply(preprocess_text,
stopwords=True,
stem=True,
lemmatize=False)
train_df['cleaned text'] = train_df[... | logger = logging.getLogger(__name__)
csv.field_size_limit(2147483647)
class InputExample(object):
def __init__(self, guid, text_a, text_b=None, label=None):
self.guid = guid
self.text_a = text_a
self.text_b = text_b
self.label = label
class InputFeatures(object):
def __init__(self, input_ids, input_mask, segmen... | Natural Language Processing with Disaster Tweets |
10,556,663 | def create_corpus(text_data):
corpus = []
for sentence in text_data:
for word in sentence.split() :
corpus.append(word)
return corpus
def top_words(text_corpus, top_n=25):
def_dict = defaultdict(int)
for word in text_corpus:
def_dict[word] += 1
most_common = sorted(def_dict.items() , key=lambda x : x[1], reverse=... | !pip install pytorch_transformers | Natural Language Processing with Disaster Tweets |
10,556,663 | PATH = "/kaggle/input/nlp-getting-started/"
test_df = pd.read_csv(f'{PATH}test.csv', low_memory=False)
test_df['cleaned_text'] = test_df['text'].apply(preprocess_text,
stopwords=True,
stem=True,
lemmatize=False)
test_df['cleaned_text'] = test_df['cleaned_text'].apply(extensive_clean_and_format)
X_test = test_df['cle... | TensorDataset)
XLMConfig, XLMForSequenceClassification, XLMTokenizer,
XLNetConfig, XLNetForSequenceClassification, XLNetTokenizer,
RobertaConfig, RobertaForSequenceClassification, RobertaTokenizer)
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__ ) | Natural Language Processing with Disaster Tweets |
10,556,663 | X_train, X_val, y_train, y_val = train_test_split(X, y, test_size = 0.2, random_state=0)
print("Shapes of our data:
X_train: {0}
y_train: {1}
X_val: {2}
y_val: {3} ".format(X_train.shape,
y_train.shape,
X_val.shape,
y_val.shape))<feature_engineering> | args = {
'data_dir': './data/',
'model_type': 'bert',
'model_name': 'bert-base-cased',
'task_name': 'binary',
'output_dir': 'outputs/',
'cache_dir': 'cache/',
'do_train': True,
'do_eval': True,
'fp16': False,
'fp16_opt_level': 'O1',
'max_seq_length': 128,
'output_mode': 'classification',
'train_batch_size': 8,
'eval_ba... | Natural Language Processing with Disaster Tweets |
10,556,663 | n_grams =(1,3)
vectorizer = TfidfVectorizer(analyzer='word', ngram_range=n_grams)
X_train_vec = vectorizer.fit_transform(X_train)
X_val_vec = vectorizer.transform(X_val)
X_test_vec = vectorizer.transform(X_test )<compute_train_metric> | MODEL_CLASSES = {
'bert':(BertConfig, BertForSequenceClassification, BertTokenizer),
'xlnet':(XLNetConfig, XLNetForSequenceClassification, XLNetTokenizer),
'xlm':(XLMConfig, XLMForSequenceClassification, XLMTokenizer),
'roberta':(RobertaConfig, RobertaForSequenceClassification, RobertaTokenizer)
}
config_class, model_... | Natural Language Processing with Disaster Tweets |
10,556,663 | def multi_model_cross_validation(clf_tuple_list, X, y, K_folds=10, score_type='accuracy', random_seed=0):
model_names, model_scores = [], []
for name, model in clf_list:
k_fold = StratifiedKFold(n_splits=K_folds, shuffle=True, random_state=random_seed)
cross_val_results = cross_val_score(model, X, y, cv=k_fold, scor... | config = config_class.from_pretrained(args['model_name'], num_labels=2, finetuning_task=args['task_name'])
tokenizer = tokenizer_class.from_pretrained(args['model_name'] ) | Natural Language Processing with Disaster Tweets |
10,556,663 | def test_set_performances(clf_tuple_list, X_train, y_train, X_test,
y_test, score_type='accuracy', print_results=True):
model_names, model_accuracies, model_f1 = [], [], []
if print_results:
print("{0:<30} {1:<10} {2:<10}
{3}".format("Model", "Accuracy",
"F1-Score", "-"*50))
for name, model in clf_list:
model.fit(X_t... | model = model_class.from_pretrained(args['model_name'] ) | Natural Language Processing with Disaster Tweets |
10,556,663 | svc_clf = SVC(kernel='linear', C=1.0, probability=True)
svc_clf.fit(X_train_vec, y_train )<prepare_x_and_y> | model.to(device ) | Natural Language Processing with Disaster Tweets |
10,556,663 | X = train_df['cleaned text'].values
y = train_df['target'].values<feature_engineering> | task = args['task_name']
processor = processors[task]()
label_list = processor.get_labels()
num_labels = len(label_list ) | Natural Language Processing with Disaster Tweets |
10,556,663 | vectorizer = TfidfVectorizer(analyzer='word', ngram_range=n_grams)
X_vec = vectorizer.fit_transform(X)
X_test_vec = vectorizer.transform(X_test )<train_model> | def load_and_cache_examples(task, tokenizer, evaluate=False):
processor = processors[task]()
output_mode = args['output_mode']
mode = 'dev' if evaluate else 'train'
cached_features_file = os.path.join(args['data_dir'], f"cached_{mode}_{args['model_name']}_{args['max_seq_length']}_{task}")
if os.path.exists(cached_feat... | Natural Language Processing with Disaster Tweets |
10,556,663 | svc_clf = SVC(kernel='linear', C=1.0)
svc_clf.fit(X_vec, y )<predict_on_test> | def train(train_dataset, model, tokenizer):
tb_writer = SummaryWriter()
train_sampler = RandomSampler(train_dataset)
train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=args['train_batch_size'])
t_total = len(train_dataloader)// args['gradient_accumulation_steps'] * args['num_train_epochs']... | Natural Language Processing with Disaster Tweets |
10,556,663 | test_preds = svc_clf.predict(X_test_vec)
test_df['target'] = test_preds<save_to_csv> | if args['do_train']:
train_dataset = load_and_cache_examples(task, tokenizer)
global_step, tr_loss = train(train_dataset, model, tokenizer)
logger.info(" global_step = %s, average loss = %s", global_step, tr_loss ) | Natural Language Processing with Disaster Tweets |
10,556,663 | submission = test_df.loc[:, ['id', 'target']]
submission.to_csv('SVC_submission.csv', index=False)
submission.head()<train_model> | def submit(pred_ids):
sub = pd.read_csv(prefix+'sample_submission.csv')
sub['target'] = list(map(int,pred_ids))
sub.to_csv('submission.csv', index=False ) | Natural Language Processing with Disaster Tweets |
10,556,663 | clf_list = [("Logistic Regression", LogisticRegression(C=10.0)) ,
("Support Vector Machine", SVC(kernel='linear', C=1.0, probability=True)) ,
("Random Forest", RandomForestClassifier(n_estimators=500)) ,
("Multinomial Naive Bayes", MultinomialNB())]
ensemble_clf = VotingClassifier(estimators=clf_list, voting='soft')... | def get_mismatched(labels, preds):
mismatched = labels != preds
examples = processor.get_dev_examples(args['data_dir'])
wrong = [i for(i, v)in zip(examples, mismatched)if v]
return wrong
def get_eval_report(labels, preds):
mcc = matthews_corrcoef(labels, preds)
tn, fp, fn, tp = confusion_matrix(labels, preds ).ravel(... | Natural Language Processing with Disaster Tweets |
10,556,663 | <load_from_csv><EOS> | Natural Language Processing with Disaster Tweets | |
10,466,695 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<choose_model_class> | nltk.download('stopwords')
stop_words = stopwords.words('english')
nlp = spacy.load('en' ) | Natural Language Processing with Disaster Tweets |
10,466,695 | PROJECT_ID = 'kaggle-bqml-course'
bucket_name = 'leosuky_kaggle_competitions'
region = 'us-central1'
storage_client = storage.Client(project=PROJECT_ID)
automl_client = automl.AutoMlClient()
<load_pretrained> | !pip install transformers | Natural Language Processing with Disaster Tweets |
10,466,695 | def upload_to_gcs(bucket_name, source_file_name, destination_blob_name):
"Uploads a file to the bucket.https://cloud.google.com/storage/docs/"
bucket = storage_client.get_bucket(bucket_name)
blob = bucket.blob(destination_blob_name)
blob.upload_from_filename(source_file_name)
<define_variables> | from transformers import RobertaModel, RobertaTokenizer
from transformers import RobertaForSequenceClassification, RobertaConfig, AdamW, get_linear_schedule_with_warmup | Natural Language Processing with Disaster Tweets |
10,466,695 | destination_path = 'uploads/kaggle_auto_ml/train.csv'
<define_variables> | print(torch.cuda.is_available() ) | Natural Language Processing with Disaster Tweets |
10,466,695 | dataset_name = 'disaster_tweets_nlp'
model_name = 'disaster_tweets_nlp'
client = automl_client
region = region
project_id = PROJECT_ID
bucket_name = bucket_name<drop_column> | data = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")[["text", "target"]]
test = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv")
data.head() | Natural Language Processing with Disaster Tweets |
10,466,695 | amw = AutoMLWrapper(client=client,
project_id=PROJECT_ID,
bucket_name=bucket_name,
region='us-central1',
dataset_display_name=dataset_name,
model_display_name=model_name )<create_dataframe> | def clean_text(text):
text = re.sub(r"\x89Û_", "", text)
text = re.sub(r"\x89ÛÒ", "", text)
text = re.sub(r"\x89ÛÓ", "", text)
text = re.sub(r"\x89ÛÏWhen", "When", text)
text = re.sub(r"\x89ÛÏ", "", text)
text = re.sub(r"China\x89Ûªs", "China's", text)
text = re.sub(r"let\x89Ûªs", "let's", text)
text = re.sub(r"... | Natural Language Processing with Disaster Tweets |
10,466,695 | def create_dataset(project_id, dataset_name):
client = automl.AutoMlClient()
project_location = client.location_path(project_id, region)
metadata = automl.types.TextSentimentDatasetMetadata(sentiment_max=1)
dataset = automl.types.Dataset(display_name=dataset_name,
text_sentiment_dataset_metadata=metadata)
result = c... | unique_targets = data.groupby('text' ).agg(unique_target=('target', pd.Series.nunique))
controversial_tweets = unique_targets[unique_targets['unique_target'] > 1].index
data = data[~data['text'].isin(controversial_tweets)]
data = data.drop_duplicates(subset='text', keep='first')
data['text'] = data['text'].apply(clean... | Natural Language Processing with Disaster Tweets |
10,466,695 | def import_dataset(project_id, dataset_id, path):
client = automl.AutoMlClient()
dataset_full_id = client.dataset_path(project_id, 'us-central1', dataset_id)
input_uris = path.split(",")
gcs_source = automl.types.GcsSource(input_uris=input_uris)
input_config = automl.types.InputConfig(gcs_source=gcs_source)
result ... | tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaForSequenceClassification.from_pretrained('roberta-base' ) | Natural Language Processing with Disaster Tweets |
10,466,695 | file_path = 'gs://leosuky_kaggle_competitions/uploads/kaggle_auto_ml/train.csv'
dataset_id = 'TST2133943162303938560'
<choose_model_class> | def prepare_features(data_set, labels=None, max_seq_length = 100,
zero_pad = True, include_special_tokens = True):
input_ids = []
attention_masks = []
for sent in data_set:
encoded_dict = tokenizer.encode_plus(
sent,
add_special_tokens = include_special_tokens,
max_length = max_seq_length,
pad_to_max_length = zero_pad... | Natural Language Processing with Disaster Tweets |
10,466,695 | def create_model(project_id, dataset_id, dataset_name):
client = automl.AutoMlClient()
project_location = client.location_path(project_id, 'us-central1')
metadata = automl.types.TextSentimentModelMetadata()
model = automl.types.Model(display_name=dataset_name,
dataset_id=dataset_id,
text_sentiment_model_metadata=metad... | train_input_ids, train_attention_masks, train_labels = prepare_features(
train['text'], train['target'])
val_input_ids, val_attention_masks, val_labels = prepare_features(
val['text'], val['target'])
test_input_ids, test_attention_masks = prepare_features(
test['text'] ) | Natural Language Processing with Disaster Tweets |
10,466,695 | print("model has already been created and trained!" )<train_model> | training_set = TensorDataset(train_input_ids, train_attention_masks, train_labels)
validation_set = TensorDataset(val_input_ids, val_attention_masks, val_labels)
test_set = TensorDataset(test_input_ids, test_attention_masks ) | Natural Language Processing with Disaster Tweets |
10,466,695 | def model_evaluations(project_id, model_id):
client = automl.AutoMlClient()
full_model_id = client.model_path(project_id, 'us-central1', model_id)
print('Model Evaluations:')
for evaluation in client.list_model_evaluations(full_model_id, ""):
print('Model Evaluation Name: {}'.format(evaluation.name))
print('Model Ann... | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device ) | Natural Language Processing with Disaster Tweets |
10,466,695 | model_id = "TST4544356324388896768"
model_evaluations(project_id=project_id, model_id=model_id )<prepare_x_and_y> | torch.cuda.is_available() | Natural Language Processing with Disaster Tweets |
10,466,695 | if not amw.get_dataset_by_display_name(dataset_display_name=dataset_name):
print('dataset not found')
amw.create_dataset()
amw.import_gcs_data(training_gcs_path)
amw.dataset<train_model> | BATCH_SIZE = 32
LEARNING_RATE = 1e-05
EPSILON = 1e-8
MAX_EPOCHS = 10 | Natural Language Processing with Disaster Tweets |
10,466,695 | if not amw.get_model_by_display_name() :
amw.train_model()
amw.deploy_model()
amw.model<find_best_params> | loading_params = {'batch_size': BATCH_SIZE,
'shuffle': True,
'drop_last': False,
'num_workers': 1}
training_loader = DataLoader(training_set, **loading_params)
validation_loader = DataLoader(validation_set, **loading_params)
test_loading_params = {'batch_size': BATCH_SIZE,
'shuffle': False,
'drop_last': False,
'num_w... | Natural Language Processing with Disaster Tweets |
10,466,695 | amw.model_full_path<predict_on_test> | loss_function = nn.CrossEntropyLoss()
optimizer = AdamW(model.parameters() ,
lr = LEARNING_RATE,
eps = EPSILON
)
total_steps = len(training_loader)* MAX_EPOCHS
scheduler = get_linear_schedule_with_warmup(optimizer,
num_warmup_steps = 0,
num_training_steps = total_steps ) | Natural Language Processing with Disaster Tweets |
10,466,695 | def make_predictions(project_id, model_id, content):
prediction_client = automl.PredictionServiceClient()
model_full_id = prediction_client.model_path(project_id, "us-central1", model_id)
text_snippet = automl.types.TextSnippet(content=content, mime_type="text/plain")
payload = automl.types.ExamplePayload(text_snippe... | def format_time(elapsed):
elapsed_rounded = int(round(( elapsed)))
return str(datetime.timedelta(seconds=elapsed_rounded)) | Natural Language Processing with Disaster Tweets |
10,466,695 | make_predictions(project_id=PROJECT_ID, model_id=model_id, content=corpus[1] )<predict_on_test> | def flat_accuracy(preds, labels):
pred_flat = np.argmax(preds, axis=1)
labels_flat = labels
return accuracy_score(labels_flat, pred_flat ) | Natural Language Processing with Disaster Tweets |
10,466,695 | predictions = []
print('Starting predictions...')
print('Predicting 1st batch.....')
for document in corpus[:600]:
predictions.append(
make_predictions(project_id=PROJECT_ID, model_id=model_id, content=document)
)
print('Predicting 2nd batch.....')
for document in corpus[600:1200]:
predictions.append(
make_predic... | for epoch in tqdm_notebook(range(MAX_EPOCHS)) :
t0 = time.time()
total_train_loss = 0
model.train()
print("EPOCH -- {} / {}".format(epoch, MAX_EPOCHS))
for step, batch in enumerate(training_loader):
if step % 30 == 0 and not step == 0:
elapsed = format_time(time.time() - t0)
print(' Batch {} of {}.Elapsed: {:}'.format... | Natural Language Processing with Disaster Tweets |
10,466,695 | sentiment_predictions = pd.DataFrame(predictions, columns=['target'])
sentiment_predictions.head(4 )<concatenate> | model.eval()
predictions = []
for batch in testing_loader:
batch = tuple(t.to(device)for t in batch)
input_ids, input_masks = batch
with torch.no_grad() :
logits = model(input_ids,
token_type_ids=None,
attention_mask=input_masks)[0]
logits = logits.detach().cpu().numpy()
predictions.append(logits ) | Natural Language Processing with Disaster Tweets |
10,466,695 | submission_df = pd.concat([nlp_test['id'], sentiment_predictions['target']], axis=1)
print(submission_df.shape)
submission_df.head()<save_to_csv> | flat_predictions = [item for sublist in predictions for item in sublist]
targets = np.argmax(flat_predictions, axis=1 ).flatten() | Natural Language Processing with Disaster Tweets |
10,466,695 | submission_df.to_csv("submission.csv", index=False, header=True )<import_modules> | test['target'] = targets | Natural Language Processing with Disaster Tweets |
10,466,695 | import numpy as np
import pandas as pd
import spacy
from spacy.matcher import Matcher
from spacy.tokens import Span
from spacy import displacy<load_pretrained> | tokenizer.convert_tokens_to_ids(tokenizer.tokenize('dick')) | Natural Language Processing with Disaster Tweets |
10,466,695 | nlp=spacy.load("en_core_web_sm" )<load_from_csv> | submission = test[['id', 'target']].to_csv("submission_roberta.csv", index=False ) | Natural Language Processing with Disaster Tweets |
10,466,695 | train=pd.read_csv('/kaggle/input/nlp-getting-started/train.csv')
test=pd.read_csv('/kaggle/input/nlp-getting-started/test.csv' )<string_transform> | def preprocess(texts, allowed_postags=['NOUN', "ADJ", "VERB", "ADV", "DET"]):
texts_out = []
for text in texts:
lowered_text = text.lower()
doc = nlp(lowered_text)
tokens = [token for token in doc if not(token.is_punct |
token.is_space |
token.is_digit)]
tokens = [token for token in tokens if token.is_alpha]
lemmas = ... | Natural Language Processing with Disaster Tweets |
10,466,695 | stopwords = list(STOP_WORDS)
punct=string.punctuation
def text_data_cleaning(sentence):
doc = nlp(sentence)
tokens = []
for token in doc:
if token.lemma_ != "-PRON-":
temp = token.lemma_.lower().strip()
else:
temp = token.lower_
tokens.append(temp)
cleaned_tokens = []
for token in tokens:
if token not in stopwords a... | data_pruned = data.copy(deep=True)
data_pruned['text'] = data_pruned['text'].progress_apply(clean_text)
data_pruned['text'] = data_pruned['text'].progress_apply(preprocess ) | Natural Language Processing with Disaster Tweets |
10,466,695 | from sklearn.svm import LinearSVC
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.pipeline import Pipeline
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix<choose_model_class> | test_pruned = test.copy(deep=True)
test_pruned['text'] = test_pruned['text'].apply(clean_text)
test_pruned['text'] = test_pruned['text'].apply(preprocess ) | Natural Language Processing with Disaster Tweets |
10,466,695 | tfidf = TfidfVectorizer(tokenizer = text_data_cleaning)
classifier = LinearSVC()<prepare_x_and_y> | all_text = pd.concat([data_pruned[['text']], test_pruned[['text']]], ignore_index=True ) | Natural Language Processing with Disaster Tweets |
10,466,695 | x = train['text']
y = train['target']<split> | cv = CountVectorizer(ngram_range=(1,2))
tfidf_transformer = TfidfTransformer()
x = cv.fit_transform(all_text['text'])
x_all_tfidf = tfidf_transformer.fit_transform(x ) | Natural Language Processing with Disaster Tweets |
10,466,695 | X_train, X_test, y_train, y_test = train_test_split(x, y, test_size = 0.2, random_state = 42 )<choose_model_class> | training_samples = data_pruned.shape[0]
X_train = x_all_tfidf[:training_samples,:]
X_test = x_all_tfidf[training_samples:,:] | Natural Language Processing with Disaster Tweets |
10,466,695 | clf = Pipeline([('tfidf', tfidf),('clf', classifier)] )<train_model> | y_train = data_pruned['target'] | Natural Language Processing with Disaster Tweets |
10,466,695 | clf.fit(X_train,y_train )<predict_on_test> | mb_classifier = MB().fit(X_train, y_train ) | Natural Language Processing with Disaster Tweets |
10,466,695 | y_pred = clf.predict(X_test )<compute_test_metric> | pred = mb_classifier.predict(X_train)
c = classification_report(y_train,pred ) | Natural Language Processing with Disaster Tweets |
10,466,695 | print(classification_report(y_test, y_pred))<predict_on_test> | skf = StratifiedKFold(n_splits=5, random_state=RANDOM_STATE)
total_accuracy = []
total_precision = []
total_recall = []
for train_index, val_index in skf.split(X_train, y_train):
current_X_train = X_train[train_index]
current_y_train = y_train.iloc[train_index]
current_X_val = X_train[val_index]
current_y_val = y_trai... | Natural Language Processing with Disaster Tweets |
10,466,695 | y_pred=clf.predict(test['text'] )<create_dataframe> | test_pruned['target'] = mb_classifier.predict(x_test ) | Natural Language Processing with Disaster Tweets |
10,466,695 | sub_file=pd.DataFrame({'id':test['id'],'target':y_pred.round().astype(int)} )<load_from_url> | test_pruned[['id', 'target']].to_csv("submission_2.csv", index=False ) | Natural Language Processing with Disaster Tweets |
10,466,695 | !wget --quiet https://raw.githubusercontent.com/tensorflow/models/master/official/nlp/bert/tokenization.py<import_modules> | clf_svm = svm.SVC(C=1.0, kernel='linear', degree=3, gamma='auto' ) | Natural Language Processing with Disaster Tweets |
10,466,695 | 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<categorify> | clf_svm.fit(x_train, y_train)
pred = clf_svm.predict(x_train)
print(classification_report(y_train,pred)) | Natural Language Processing with Disaster Tweets |
10,466,695 | 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... | test_pruned['target'] = clf_svm.predict(x_test)
test_pruned[['id', 'target']].to_csv("submission_svm.csv", index=False ) | Natural Language Processing with Disaster Tweets |
10,466,695 | 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, ... | TRAIN_VAL_SPLIT = 0.8
train = data.sample(frac=TRAIN_VAL_SPLIT, random_state=RANDOM_STATE)
val = data[~data.index.isin(train.index)]
X_train = train['text'].values
y_train = train['target'].values
X_val = val['text'].values
y_val = val['target'].values
X_test = test['text'].values | Natural Language Processing with Disaster Tweets |
10,466,695 | %%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 )<feature_engineering> | def preprocess(texts, allowed_postags=['NOUN', "ADJ", "VERB", "ADV", "PROPN", "DET"]):
texts_out = []
for text in texts:
lowered_text = text.lower()
lowered_text = re.sub(r'https?://\S+|www\.\S+', '', lowered_text)
lowered_text = re.sub(r'<.*?>', '', lowered_text)
doc = nlp(lowered_text)
tokens = [token for token in... | Natural Language Processing with Disaster Tweets |
10,466,695 | 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 )<categorify> | train_corpus = preprocess(X_train)
val_corpus = preprocess(X_val)
test_corpus = preprocess(X_test ) | Natural Language Processing with Disaster Tweets |
10,466,695 | 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<train_model> | corpus = train_corpus + val_corpus + test_corpus | Natural Language Processing with Disaster Tweets |
10,466,695 | train_history = model.fit(
train_input, train_labels,
validation_split=0.2,
epochs=3,
batch_size=16
)<predict_on_test> | tokenizer = Tokenizer()
tokenizer.fit_on_texts(corpus)
train_sequences = tokenizer.texts_to_sequences(train_corpus)
val_sequences = tokenizer.texts_to_sequences(val_corpus)
test_sequences = tokenizer.texts_to_sequences(test_corpus)
word_index = tokenizer.word_index
train_max_length = max([len(x)for x in train_seque... | Natural Language Processing with Disaster Tweets |
10,466,695 | test_pred = model.predict(test_input )<save_to_csv> | EMBEDDING_DIM = 30 | Natural Language Processing with Disaster Tweets |
10,466,695 | submission=pd.DataFrame()
submission['id']=test['id']
submission['target'] = test_pred.round().astype(int)
submission.to_csv('submission.csv', index=False )<import_modules> | model_tuned = Sequential()
model_tuned.add(Embedding(vocab_size, EMBEDDING_DIM, input_length=max_length))
model_tuned.add(GRU(units=30, dropout=0.2, recurrent_dropout=0.2, return_sequences=True))
model_tuned.add(GRU(units=30, dropout=0.2, recurrent_dropout=0.2, return_sequences=True))
model_tuned.add(GRU(units=30, drop... | Natural Language Processing with Disaster Tweets |
10,466,695 | import numpy as np
import pandas as pd
import time
from datetime import datetime<load_from_csv> | history = model_tuned.fit(X_train_pad, y_train, batch_size=128, epochs=25, validation_data=(X_val_pad, y_val), verbose=2 ) | Natural Language Processing with Disaster Tweets |
10,466,695 | train = pd.read_csv('/kaggle/input/nlp-getting-started/train.csv')
test = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv' )<import_modules> | y_pred_tuned = model_tuned.predict(X_test_pad ) | Natural Language Processing with Disaster Tweets |
10,466,695 | from google.cloud import storage, automl_v1beta1 as automl
from google.api_core.gapic_v1.client_info import ClientInfo
from automlwrapper import AutoMLWrapper<choose_model_class> | y_pred_binary = list(map(lambda x: 1 if x >= 0.5 else 0, y_pred_tuned)) | Natural Language Processing with Disaster Tweets |
10,466,695 | PROJECT_ID = 'kaggle-nlp-wdt'
BUCKET_NAME = 'kaggle-nlp-wdt-lcm'
region = 'us-central1'
storage_client = storage.Client(project=PROJECT_ID)
client = automl.AutoMlClient(client_info=ClientInfo())
print(f'Starting AutoML notebook at {datetime.fromtimestamp(time.time() ).strftime("%Y-%m-%d, %H:%M:%S UTC")}' )<define_var... | test['target'] = y_pred_binary | Natural Language Processing with Disaster Tweets |
10,466,695 | VERSION = 'V19'
BUCKET_PATH = 'preprocessing/'+VERSION+'/'
FILE_NAME = 'train_cleaned'+'_'+VERSION
training_gcs_path = BUCKET_PATH+FILE_NAME+'.csv'
dataset_display_name = FILE_NAME
model_display_name = 'model_'+FILE_NAME<save_to_csv> | test[['id', 'target']].to_csv("submission_rnn.csv", index=False ) | Natural Language Processing with Disaster Tweets |
10,466,695 | train.loc[:,['text','target']].drop_duplicates() \
.to_csv('train.csv', index=False, header=False )<prepare_output> | def ConvNet(max_sequence_length, num_words, embedding_dim, labels_index):
embedding_layer = Embedding(num_words,
embedding_dim,
input_length=max_sequence_length)
sequence_input = Input(shape=(max_sequence_length,), dtype='int32')
embedded_sequences = embedding_layer(sequence_input)
convs = []
filter_sizes = [3,4,5,6... | Natural Language Processing with Disaster Tweets |
10,466,695 | bucket = storage.Bucket(storage_client, name=BUCKET_NAME)
if not bucket.exists() :
bucket.create(location=BUCKET_REGION )<load_pretrained> | model = ConvNet(max_length, vocab_size, EMBEDDING_DIM, 1 ) | Natural Language Processing with Disaster Tweets |
10,466,695 | def upload_blob(bucket_name, source_file_name, destination_blob_name):
bucket = storage_client.get_bucket(bucket_name)
blob = bucket.blob(destination_blob_name)
blob.upload_from_filename(source_file_name)
print('File {} uploaded to {}'.format(
source_file_name,
'gs://' + bucket_name + '/' + destination_blob_name)... | hist = model.fit(X_train_pad,
y_train,
epochs=25,
batch_size=128,
validation_data=(X_val_pad, y_val),
verbose=2 ) | Natural Language Processing with Disaster Tweets |
10,466,695 | upload_blob(BUCKET_NAME, 'train.csv', training_gcs_path )<choose_model_class> | y_pred = model.predict(X_test_pad)
y_pred_binary = list(map(lambda x: 1 if x >= 0.5 else 0, y_pred)) | Natural Language Processing with Disaster Tweets |
10,466,695 | amw = AutoMLWrapper(client=client,
project_id=PROJECT_ID,
bucket_name=BUCKET_NAME,
region='us-central1',
dataset_display_name=dataset_display_name,
model_display_name=model_display_name)
<prepare_x_and_y> | test['target'] = y_pred_binary
test[['id', 'target']].to_csv("submission_cnn.csv", index=False ) | Natural Language Processing with Disaster Tweets |
10,466,695 | <train_model><EOS> | data[data['target'] == 0].values | Natural Language Processing with Disaster Tweets |
9,148,670 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<find_best_params> | stop = set(stopwords.words('english'))
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,148,670 | amw.model_full_path<predict_on_test> | train = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv")
target = train['target']
print("Train shape", train.shape)
print("Test shape", test.shape ) | Natural Language Processing with Disaster Tweets |
9,148,670 | print(f'Begin getting predictions at {datetime.fromtimestamp(time.time() ).strftime("%Y-%m-%d, %H:%M:%S UTC")}')
prediction_client = automl.PredictionServiceClient()
amw.set_prediction_client(prediction_client)
predictions_df = amw.get_predictions(test,
input_col_name='text',
limit=None,
threshold=0.5,
verbose=False)... | def create_corpus(target):
corpus = []
for x in train[train['target'] == target]['text'].str.split() :
for i in x:
corpus.append(i)
return corpus
def filter_specific_word(corpus, filters):
dic = defaultdict(int)
for word in corpus:
if word in filters:
dic[word] += 1
return dic | Natural Language Processing with Disaster Tweets |
9,148,670 | submission_df = pd.concat([test['id'], predictions_df['class']], axis=1 )<rename_columns> | def get_top_tweet_bigrams(corpus, n=None):
vec = CountVectorizer(ngram_range=(2, 2)).fit(corpus)
bag_of_words = vec.transform(corpus)
sum_words = bag_of_words.sum(axis=0)
words_freq = [(word, sum_words[0, idx])for word, idx in vec.vocabulary_.items() ]
words_freq = sorted(words_freq, key=lambda x: x[1], reverse=True... | Natural Language Processing with Disaster Tweets |
9,148,670 | submission_df = submission_df.rename(columns={'class':'target'})
submission_df.head()<save_to_csv> | df = pd.concat([train, test], axis=0, sort=False)
df.shape | 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.