kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,087,560 | train_y_pred = RF_model.predict(train_numeric_X )<compute_train_metric> | count_nusvc.fit(count_train_sub ,y)
count_nusvc_sub = count_nusvc.predict(count_sub)
| Natural Language Processing with Disaster Tweets |
9,087,560 | error = np.sqrt(( train_y_pred - train_numeric_Y)**2)
error = error.cumsum()<compute_test_metric> | sub=pd.DataFrame({'id':sample_sub['id'].values.tolist() ,'target':count_nusvc_sub} ) | Natural Language Processing with Disaster Tweets |
9,087,560 | <choose_model_class><EOS> | sub.to_csv('submission.csv',index=False ) | Natural Language Processing with Disaster Tweets |
8,766,497 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<train_model> | classification_report, f1_score, roc_curve, auc
| Natural Language Processing with Disaster Tweets |
8,766,497 | clf1.fit(train_numeric_X, train_numeric_Y)
clf3.fit(train_numeric_X, train_numeric_Y)
clf5.fit(train_numeric_X, train_numeric_Y)
clf10.fit(train_numeric_X, train_numeric_Y)
clf50.fit(train_numeric_X, train_numeric_Y )<predict_on_test> | PATH = "/kaggle/input/nlp-getting-started/"
train_df = pd.read_csv(f'{PATH}train.csv', low_memory=False)
train_df.shape | Natural Language Processing with Disaster Tweets |
8,766,497 | predicted1 = clf1.predict(train_numeric_X)
predicted3 = clf3.predict(train_numeric_X)
predicted5 = clf5.predict(train_numeric_X)
predicted10 = clf10.predict(train_numeric_X)
predicted50 = clf50.predict(train_numeric_X )<compute_test_metric> | 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"\... | Natural Language Processing with Disaster Tweets |
8,766,497 | a = np.sum(( predicted1)-(train_numeric_Y)) **2 / len(predicted1)
b = np.sum(( predicted3)-(train_numeric_Y)) **2 / len(predicted3)
c = np.sum(( predicted5)-(train_numeric_Y)) **2 / len(predicted5)
d = np.sum(( predicted10)-(train_numeric_Y)) **2 / len(predicted10)
e = np.sum(( predicted50)-(train_numeric_Y)) **2 /... | 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", ... | Natural Language Processing with Disaster Tweets |
8,766,497 | clf1 = RandomForestClassifier(n_estimators=10,n_jobs=4,max_depth=1)
clf2 = RandomForestClassifier(n_estimators=10,n_jobs=4,max_depth=2)
clf3 = RandomForestClassifier(n_estimators=10,n_jobs=4,max_depth=3)
clf4 = RandomForestClassifier(n_estimators=10,n_jobs=4,max_depth=4)
clf5 = RandomForestClassifier(n_estimators=1... | %%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[... | Natural Language Processing with Disaster Tweets |
8,766,497 | clf1.fit(train_numeric_X, train_numeric_Y)
clf2.fit(train_numeric_X, train_numeric_Y)
clf3.fit(train_numeric_X, train_numeric_Y)
clf4.fit(train_numeric_X, train_numeric_Y)
clf5.fit(train_numeric_X, train_numeric_Y)
clf10.fit(train_numeric_X, train_numeric_Y )<predict_on_test> | 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=... | Natural Language Processing with Disaster Tweets |
8,766,497 | predicted1 = clf1.predict(train_numeric_X)
predicted2 = clf2.predict(train_numeric_X)
predicted3 = clf3.predict(train_numeric_X)
predicted4 = clf4.predict(train_numeric_X)
predicted5 = clf5.predict(train_numeric_X)
predicted10 = clf10.predict(train_numeric_X )<compute_test_metric> | 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... | Natural Language Processing with Disaster Tweets |
8,766,497 | a = np.sum(( predicted1)-(train_numeric_Y)) **2 / len(predicted1)
b = np.sum(( predicted2)-(train_numeric_Y)) **2 / len(predicted2)
c = np.sum(( predicted3)-(train_numeric_Y)) **2 / len(predicted3)
d = np.sum(( predicted4)-(train_numeric_Y)) **2 / len(predicted4)
e = np.sum(( predicted5)-(train_numeric_Y)) **2 / le... | 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)) | Natural Language Processing with Disaster Tweets |
8,766,497 | from sklearn.decomposition import PCA
from sklearn.pipeline import Pipeline
from sklearn.naive_bayes import GaussianNB<normalization> | 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 ) | Natural Language Processing with Disaster Tweets |
8,766,497 | pipeline = Pipeline([('scale', StandardScaler()),('pca', PCA(n_components=2)) ])
pca = pipeline.fit(train_numeric_X)
pca_X = pca.transform(train_numeric_X )<import_modules> | 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... | Natural Language Processing with Disaster Tweets |
8,766,497 | from sklearn.manifold import TSNE<feature_engineering> | 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... | Natural Language Processing with Disaster Tweets |
8,766,497 | X_embedded = TSNE(n_components=3 ).fit_transform(train_numeric_X )<import_modules> | svc_clf = SVC(kernel='linear', C=1.0, probability=True)
svc_clf.fit(X_train_vec, y_train ) | Natural Language Processing with Disaster Tweets |
8,766,497 | import pandas as pd
import datetime
import lightgbm as lgb<load_from_csv> | X = train_df['cleaned text'].values
y = train_df['target'].values | Natural Language Processing with Disaster Tweets |
8,766,497 | train = pd.read_csv(".. /input/covid19-global-forecasting-week-1/train.csv")
test = pd.read_csv(".. /input/covid19-global-forecasting-week-1/test.csv")
sub = pd.read_csv(".. /input/covid19-global-forecasting-week-1/submission.csv" )<feature_engineering> | vectorizer = TfidfVectorizer(analyzer='word', ngram_range=n_grams)
X_vec = vectorizer.fit_transform(X)
X_test_vec = vectorizer.transform(X_test ) | Natural Language Processing with Disaster Tweets |
8,766,497 | train.loc[(train['Date']=='2020-03-24')&(train['Country/Region']=='France')&(train['Province/State']=='France'),'ConfirmedCases'] = 22654
train.loc[(train['Date']=='2020-03-24')&(train['Country/Region']=='France')&(train['Province/State']=='France'),'Fatalities'] = 1000<filter> | svc_clf = SVC(kernel='linear', C=1.0)
svc_clf.fit(X_vec, y ) | Natural Language Processing with Disaster Tweets |
8,766,497 | train[(train['Date']=='2020-03-24')&(train['Country/Region']=='France')&(train['Province/State']=='France')]<concatenate> | test_preds = svc_clf.predict(X_test_vec)
test_df['target'] = test_preds | Natural Language Processing with Disaster Tweets |
8,766,497 | train = train.append(test[test['Date']>'2020-03-24'] )<data_type_conversions> | submission = test_df.loc[:, ['id', 'target']]
submission.to_csv('SVC_submission.csv', index=False)
submission.head() | Natural Language Processing with Disaster Tweets |
8,766,497 | train['Date'] = pd.to_datetime(train['Date'], format='%Y-%m-%d')
<feature_engineering> | 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')... | Natural Language Processing with Disaster Tweets |
8,766,497 | train['day_dist'] = train['Date']-train['Date'].min()
<feature_engineering> | test_preds = ensemble_clf.predict(X_test_vec)
test_df['target'] = test_preds
submission = test_df.loc[:, ['id', 'target']]
submission.to_csv('ensemble_submission.csv', index=False)
submission.head() | Natural Language Processing with Disaster Tweets |
7,755,916 | train['day_dist'] = train['day_dist'].dt.days<define_variables> | nlp_train = pd.read_csv('/kaggle/input/nlp-getting-started/train.csv')
nlp_test = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv')
nlp_train.head(2 ) | Natural Language Processing with Disaster Tweets |
7,755,916 | cat_cols = train.dtypes[train.dtypes=='object'].keys()
cat_cols<correct_missing_values> | PROJECT_ID = 'kaggle-bqml-course'
bucket_name = 'leosuky_kaggle_competitions'
region = 'us-central1'
storage_client = storage.Client(project=PROJECT_ID)
automl_client = automl.AutoMlClient()
| Natural Language Processing with Disaster Tweets |
7,755,916 | for cat_col in cat_cols:
train[cat_col].fillna('no_value', inplace = True )<feature_engineering> | 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)
| Natural Language Processing with Disaster Tweets |
7,755,916 | train['place'] = train['Province/State']+'_'+train['Country/Region']
<import_modules> | destination_path = 'uploads/kaggle_auto_ml/train.csv'
| Natural Language Processing with Disaster Tweets |
7,755,916 | from sklearn import preprocessing<define_variables> | dataset_name = 'disaster_tweets_nlp'
model_name = 'disaster_tweets_nlp'
client = automl_client
region = region
project_id = PROJECT_ID
bucket_name = bucket_name | Natural Language Processing with Disaster Tweets |
7,755,916 | cat_cols = train.dtypes[train.dtypes=='object'].keys()
cat_cols<categorify> | 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 ) | Natural Language Processing with Disaster Tweets |
7,755,916 | for cat_col in ['place']:
le = preprocessing.LabelEncoder()
le.fit(train[cat_col])
train[cat_col]=le.transform(train[cat_col] )<define_variables> | 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... | Natural Language Processing with Disaster Tweets |
7,755,916 | drop_cols = ['Id','ForecastId', 'ConfirmedCases','Date', 'Fatalities','day_dist', 'Province/State', 'Country/Region']<filter> | 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 ... | Natural Language Processing with Disaster Tweets |
7,755,916 | val = train[(train['Date']>='2020-03-12')&(train['Id'].isnull() ==False)]
<prepare_x_and_y> | file_path = 'gs://leosuky_kaggle_competitions/uploads/kaggle_auto_ml/train.csv'
dataset_id = 'TST2133943162303938560'
| Natural Language Processing with Disaster Tweets |
7,755,916 | y_ft = train["Fatalities"]
y_val_ft = val["Fatalities"]
y_cc = train["ConfirmedCases"]
y_val_cc = val["ConfirmedCases"]
<compute_test_metric> | 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... | Natural Language Processing with Disaster Tweets |
7,755,916 | def rmsle(y_true, y_pred):
return np.sqrt(np.mean(np.power(np.log1p(y_pred)- np.log1p(y_true), 2)))
<compute_test_metric> | print("model has already been created and trained!" ) | Natural Language Processing with Disaster Tweets |
7,755,916 | def mape(y_true, y_pred):
return np.mean(np.abs(y_pred -y_true)*100/(y_true+1))
<import_modules> | 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... | Natural Language Processing with Disaster Tweets |
7,755,916 | import numpy as np<init_hyperparams> | model_id = "TST4544356324388896768"
model_evaluations(project_id=project_id, model_id=model_id ) | Natural Language Processing with Disaster Tweets |
7,755,916 | params = {
"objective": "regression",
"boosting": 'gbdt',
"num_leaves": 1280,
"learning_rate": 0.05,
"feature_fraction": 0.9,
"reg_lambda": 2,
"metric": "rmse",
'min_data_in_leaf':20
}
<filter> | 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 | Natural Language Processing with Disaster Tweets |
7,755,916 | dates = dates[dates>'2020-03-24']<filter> | if not amw.get_model_by_display_name() :
amw.train_model()
amw.deploy_model()
amw.model | Natural Language Processing with Disaster Tweets |
7,755,916 | test[test['Country/Region']=='Italy']<filter> | amw.model_full_path | Natural Language Processing with Disaster Tweets |
7,755,916 | test[test['Country/Region']=='Italy']<load_from_csv> | 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... | Natural Language Processing with Disaster Tweets |
7,755,916 | train_sub = pd.read_csv(".. /input/covid19-global-forecasting-week-1/train.csv" )<feature_engineering> | make_predictions(project_id=PROJECT_ID, model_id=model_id, content=corpus[1] ) | Natural Language Processing with Disaster Tweets |
7,755,916 | train_sub.loc[(train_sub['Date']=='2020-03-24')&(train_sub['Country/Region']=='France')&(train_sub['Province/State']=='France'),'ConfirmedCases'] = 22654
train_sub.loc[(train_sub['Date']=='2020-03-24')&(train_sub['Country/Region']=='France')&(train_sub['Province/State']=='France'),'Fatalities'] = 1000<merge> | 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... | Natural Language Processing with Disaster Tweets |
7,755,916 | test = pd.merge(test,train_sub[['Province/State','Country/Region','Lat','Long','Date','ConfirmedCases','Fatalities']], on=['Province/State','Country/Region','Lat','Long','Date'], how='left' )<filter> | sentiment_predictions = pd.DataFrame(predictions, columns=['target'])
sentiment_predictions.head(4 ) | Natural Language Processing with Disaster Tweets |
7,755,916 | test.loc[test['ConfirmedCases_x'].isnull() ==True]<feature_engineering> | submission_df = pd.concat([nlp_test['id'], sentiment_predictions['target']], axis=1)
print(submission_df.shape)
submission_df.head() | Natural Language Processing with Disaster Tweets |
7,755,916 | <feature_engineering><EOS> | submission_df.to_csv("submission.csv", index=False, header=True ) | Natural Language Processing with Disaster Tweets |
8,591,963 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<filter> | import numpy as np
import pandas as pd
import spacy
from spacy.matcher import Matcher
from spacy.tokens import Span
from spacy import displacy | Natural Language Processing with Disaster Tweets |
8,591,963 | last_amount = test.loc[(test['Country/Region']=='Italy')&(test['Date']=='2020-03-24'),'ConfirmedCases_x']<filter> | nlp=spacy.load("en_core_web_sm" ) | Natural Language Processing with Disaster Tweets |
8,591,963 | last_fat = test.loc[(test['Country/Region']=='Italy')&(test['Date']=='2020-03-24'),'Fatalities_x']<define_variables> | 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 |
8,591,963 | i = 0
k = 35<feature_engineering> | 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... | Natural Language Processing with Disaster Tweets |
8,591,963 | for date in dates:
k = k-1
i = i + 1
test.loc[(test['Country/Region']=='Italy')&(test['Date']==date),'ConfirmedCases_x'] = last_amount.values[0]+i*(5000-(100*i))
test.loc[(test['Country/Region']=='Italy')&(test['Date']==date),'Fatalities_x'] = last_fat.values[0]+i*(800-(10*i))<filter> | 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 | Natural Language Processing with Disaster Tweets |
8,591,963 | test.loc[(test['Country/Region']=='Italy')]<prepare_output> | tfidf = TfidfVectorizer(tokenizer = text_data_cleaning)
classifier = LinearSVC() | Natural Language Processing with Disaster Tweets |
8,591,963 | sub = test[['ForecastId', 'ConfirmedCases_x','Fatalities_x']]<rename_columns> | x = train['text']
y = train['target'] | Natural Language Processing with Disaster Tweets |
8,591,963 | sub.columns = ['ForecastId', 'ConfirmedCases', 'Fatalities']<feature_engineering> | X_train, X_test, y_train, y_test = train_test_split(x, y, test_size = 0.2, random_state = 42 ) | Natural Language Processing with Disaster Tweets |
8,591,963 | sub.loc[sub['ConfirmedCases']<0, 'ConfirmedCases'] = 0<feature_engineering> | clf = Pipeline([('tfidf', tfidf),('clf', classifier)] ) | Natural Language Processing with Disaster Tweets |
8,591,963 | sub.loc[sub['Fatalities']<0, 'Fatalities'] = 0<save_to_csv> | clf.fit(X_train,y_train ) | Natural Language Processing with Disaster Tweets |
8,591,963 | sub.to_csv('submission.csv',index=False )<set_options> | y_pred = clf.predict(X_test ) | Natural Language Processing with Disaster Tweets |
8,591,963 | warnings.filterwarnings("ignore")
sys.path.append('.. /input/iterative-stratification/iterative-stratification-master')
np.random.seed(42)
tf.random.set_seed(42)
print("Tensorflow version " + tf.__version__)
AUTO = tf.data.experimental.AUTOTUNE<set_options> | print(classification_report(y_test, y_pred)) | Natural Language Processing with Disaster Tweets |
8,591,963 | MIXED_PRECISION = False
XLA_ACCELERATE = True
if MIXED_PRECISION:
if tpu: policy = tf.keras.mixed_precision.experimental.Policy('mixed_bfloat16')
else: policy = tf.keras.mixed_precision.experimental.Policy('mixed_float16')
mixed_precision.set_policy(policy)
print('Mixed precision enabled')
if XLA_ACCELERATE:
tf.con... | y_pred=clf.predict(test['text'] ) | Natural Language Processing with Disaster Tweets |
8,591,963 | train_features = pd.read_csv('.. /input/lish-moa/train_features.csv')
train_targets = pd.read_csv('.. /input/lish-moa/train_targets_scored.csv')
test_features = pd.read_csv('.. /input/lish-moa/test_features.csv')
sub = pd.read_csv('.. /input/lish-moa/sample_submission.csv')
cols = [c for c in sub.columns.values if ... | sub_file=pd.DataFrame({'id':test['id'],'target':y_pred.round().astype(int)} ) | Natural Language Processing with Disaster Tweets |
8,591,963 | def preprocess(df):
df.loc[:, 'cp_type'] = df.loc[:, 'cp_type'].map({'trt_cp': 0, 'ctl_vehicle': 1})
df.loc[:, 'cp_dose'] = df.loc[:, 'cp_dose'].map({'D1': 0, 'D2': 1})
del df['sig_id']
return df
def log_loss_metric(y_true, y_pred):
metrics = []
for _target in train_targets.columns:
metrics.append(log_loss(y_true.loc... | !wget --quiet https://raw.githubusercontent.com/tensorflow/models/master/official/nlp/bert/tokenization.py | Natural Language Processing with Disaster Tweets |
8,591,963 | top_feats = [ 0, 1, 2, 3, 5, 6, 8, 9, 10, 11, 12, 14, 15,
16, 18, 19, 20, 21, 23, 24, 25, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 39, 40, 41, 42, 44, 45, 46,
48, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
63, 64, 65, 66, 68, 69, 70, 71, 72, 73, 74, 75, 76,
78, 79, 80, 81, 82, 83, 84, 86, 87, 88, 89, 90, 92,
93... | 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 |
8,591,963 | def create_model(n_top_feats, learning_rate):
hidden_units = 512
b_size = int(np.ceil(0.6 * n_top_feats))
m_size = int(np.ceil(0.5 * n_top_feats))
s_size = int(np.ceil(0.4 * n_top_feats))
inp1 = tf.keras.layers.Input(shape =(b_size,))
x1 = tf.keras.layers.BatchNormalization()(inp1)
for _ in range(3):
x1 = tfa.layers.W... | def bert_encode(texts, tokenizer, max_len=512):
all_tokens = []
all_masks = []
all_segments = []
for text in texts:
text = tokenizer.tokenize(text)
text = text[:max_len-2]
input_sequence = ["[CLS]"] + text + ["[SEP]"]
pad_len = max_len - len(input_sequence)
tokens = tokenizer.convert_tokens_to_ids(input_sequence)
to... | Natural Language Processing with Disaster Tweets |
8,591,963 | print(f'Split NN OOF Metric: {log_loss_metric(train_targets, res)}')
res.loc[train['cp_type'] == 1, train_targets.columns] = 0
sub.loc[test['cp_type'] == 1, train_targets.columns] = 0
print(f'Split NN OOF Metric with postprocessing: {log_loss_metric(train_targets, res)}' )<save_to_csv> | def build_model(bert_layer, max_len=512):
input_word_ids = Input(shape=(max_len,), dtype=tf.int32, name="input_word_ids")
input_mask = Input(shape=(max_len,), dtype=tf.int32, name="input_mask")
segment_ids = Input(shape=(max_len,), dtype=tf.int32, name="segment_ids")
_, sequence_output = bert_layer([input_word_ids, ... | Natural Language Processing with Disaster Tweets |
8,591,963 | sub.to_csv('submission.csv', index = False )<set_options> | %%time
module_url = "https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/1"
bert_layer = hub.KerasLayer(module_url, trainable=True ) | Natural Language Processing with Disaster Tweets |
8,591,963 | warnings.filterwarnings('ignore' )<load_from_csv> | 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 |
8,591,963 | train_features = pd.read_csv('.. /input/lish-moa/train_features.csv')
train_targets = pd.read_csv('.. /input/lish-moa/train_targets_scored.csv')
test_features = pd.read_csv('.. /input/lish-moa/test_features.csv')
ss = pd.read_csv('.. /input/lish-moa/sample_submission.csv' )<categorify> | train_input = bert_encode(train.text.values, tokenizer, max_len=160)
test_input = bert_encode(test.text.values, tokenizer, max_len=160)
train_labels = train.target.values | Natural Language Processing with Disaster Tweets |
8,591,963 | def preprocess(df):
df = df.copy()
df.loc[:, 'cp_type'] = df.loc[:, 'cp_type'].map({'trt_cp': 0, 'ctl_vehicle': 1})
df.loc[:, 'cp_dose'] = df.loc[:, 'cp_dose'].map({'D1': 0, 'D2': 1})
del df['sig_id']
return df
train = preprocess(train_features)
test = preprocess(test_features)
del train_targets['sig_id']
train_tar... | train_history = model.fit(
train_input, train_labels,
validation_split=0.2,
epochs=3,
batch_size=16
) | Natural Language Processing with Disaster Tweets |
8,591,963 | def set_seed(seed):
torch.manual_seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
np.random.seed(seed )<choose_model_class> | test_pred = model.predict(test_input ) | Natural Language Processing with Disaster Tweets |
8,591,963 | <define_search_model><EOS> | submission=pd.DataFrame()
submission['id']=test['id']
submission['target'] = test_pred.round().astype(int)
submission.to_csv('submission.csv', index=False ) | Natural Language Processing with Disaster Tweets |
8,318,844 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<define_variables> | import numpy as np
import pandas as pd
import time
from datetime import datetime | Natural Language Processing with Disaster Tweets |
8,318,844 | top_feats = [ 1, 2, 3, 4, 5, 6, 7, 9, 11, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31,
32, 33, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 46,
47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 58, 59, 60,
61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
74, 75, 76, 78, 79, 80, 81, 82, 83, 84, 86, 87, 88,
89... | 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 |
8,318,844 | class MoaDataset(Dataset):
def __init__(self, df, targets, feats_idx, mode='train'):
self.mode = mode
self.feats = feats_idx
self.data = df[:, feats_idx]
if mode=='train':
self.targets = targets
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
if self.mode == 'train':
return torch.FloatTensor(self.... | from google.cloud import storage, automl_v1beta1 as automl
from google.api_core.gapic_v1.client_info import ClientInfo
from automlwrapper import AutoMLWrapper | Natural Language Processing with Disaster Tweets |
8,318,844 | train = train.values
test = test.values
train_targets = train_targets.values<prepare_x_and_y> | 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")}' ) | Natural Language Processing with Disaster Tweets |
8,318,844 | for seed in range(nstarts):
print(f'Train seed {seed}')
set_seed(seed)
for n,(tr, te)in enumerate(kfold.split(train_targets, train_targets)) :
print(f'Train fold {n+1}')
xtrain, xval = train[tr], train[te]
ytrain, yval = train_targets[tr], train_targets[te]
train_set = MoaDataset(xtrain, ytrain, top_feats)
val_set ... | 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 | Natural Language Processing with Disaster Tweets |
8,318,844 | oof = np.zeros(( len(train), nstarts, ntargets))
oof_targets = np.zeros(( len(train), ntargets))
preds = np.zeros(( len(test), ntargets))<compute_test_metric> | train.loc[:,['text','target']].drop_duplicates() \
.to_csv('train.csv', index=False, header=False ) | Natural Language Processing with Disaster Tweets |
8,318,844 | def mean_log_loss(y_true, y_pred):
metrics = []
for i, target in enumerate(targets):
metrics.append(log_loss(y_true[:, i], y_pred[:, i].astype(float), labels=[0,1]))
return np.mean(metrics )<prepare_x_and_y> | bucket = storage.Bucket(storage_client, name=BUCKET_NAME)
if not bucket.exists() :
bucket.create(location=BUCKET_REGION ) | Natural Language Processing with Disaster Tweets |
8,318,844 | for seed in range(nstarts):
print(f"Inference for seed {seed}")
seed_targets = []
seed_oof = []
seed_preds = np.zeros(( len(test), ntargets, nfolds))
for n,(tr, te)in enumerate(kfold.split(train_targets, train_targets)) :
xval, yval = train[te], train_targets[te]
fold_preds = []
val_set = MoaDataset(xval, yval, top_fe... | 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)... | Natural Language Processing with Disaster Tweets |
8,318,844 | ss[targets] = preds
ss.loc[test_features['cp_type']=='ctl_vehicle', targets] = 0
ss.to_csv('submission.csv', index=False )<set_options> | upload_blob(BUCKET_NAME, 'train.csv', training_gcs_path ) | Natural Language Processing with Disaster Tweets |
8,318,844 | sys.path.append('.. /input/iterativestratification')
warnings.filterwarnings("ignore")
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu' )<feature_engineering> | 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)
| Natural Language Processing with Disaster Tweets |
8,318,844 | def get_logger(filename='log'):
logger = getLogger(__name__)
logger.setLevel(INFO)
handler1 = StreamHandler()
handler1.setFormatter(Formatter("%(message)s"))
handler2 = FileHandler(filename=f"{filename}.log")
handler2.setFormatter(Formatter("%(message)s"))
logger.addHandler(handler1)
logger.addHandler(handler2)
re... | print(f'Getting dataset ready at {datetime.fromtimestamp(time.time() ).strftime("%Y-%m-%d, %H:%M:%S UTC")}')
if not amw.get_dataset_by_display_name(dataset_display_name):
print('dataset not found')
amw.create_dataset()
amw.import_gcs_data(training_gcs_path)
amw.dataset
print(f'Dataset ready at {datetime.fromtimestam... | Natural Language Processing with Disaster Tweets |
8,318,844 | train_features = pd.read_csv('.. /input/lish-moa/train_features.csv')
train_targets_scored = pd.read_csv('.. /input/lish-moa/train_targets_scored.csv')
train_targets_nonscored = pd.read_csv('.. /input/lish-moa/train_targets_nonscored.csv')
test_features = pd.read_csv('.. /input/lish-moa/test_features.csv')
submissi... | print(f'Getting model trained at {datetime.fromtimestamp(time.time() ).strftime("%Y-%m-%d, %H:%M:%S UTC")}')
if not amw.get_model_by_display_name(model_display_name):
print(f'Training model at {datetime.fromtimestamp(time.time() ).strftime("%Y-%m-%d, %H:%M:%S UTC")}')
amw.train_model()
print(f'Model trained.Ensuring ... | Natural Language Processing with Disaster Tweets |
8,318,844 | folds = train.copy()
Fold = MultilabelStratifiedKFold(n_splits=5, shuffle=True, random_state=42)
for n,(train_index, val_index)in enumerate(Fold.split(folds, folds[target_cols])) :
folds.loc[val_index, 'fold'] = int(n)
folds['fold'] = folds['fold'].astype(int)
print(folds.shape )<prepare_x_and_y> | amw.model_full_path | Natural Language Processing with Disaster Tweets |
8,318,844 | class TrainDataset(Dataset):
def __init__(self, df, num_features, cat_features, labels):
self.cont_values = df[num_features].values
self.cate_values = df[cat_features].values
self.labels = labels
def __len__(self):
return len(self.cont_values)
def __getitem__(self, idx):
cont_x = torch.FloatTensor(self.cont_values[idx... | 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)... | Natural Language Processing with Disaster Tweets |
8,318,844 | class CFG:
max_grad_norm=1000
gradient_accumulation_steps=1
hidden_size=512
dropout=0.45
lr=1e-3
weight_decay=1e-5
batch_size=128
epochs=50
num_features=num_features
cat_features=cat_features
target_cols=target_cols
class TabularNN(nn.Module):
def __init__(self, cfg):
super().__init__()
self.mlp = nn.Sequential(
nn.Li... | submission_df = pd.concat([test['id'], predictions_df['class']], axis=1 ) | Natural Language Processing with Disaster Tweets |
8,318,844 | model_paths = glob.glob('.. /input/moa-model-weights/pth_0908_dr45/*.pth')
predictions = just_predict(CFG, test, model_paths, device)
test[target_cols] = predictions
test<save_to_csv> | submission_df = submission_df.rename(columns={'class':'target'})
submission_df.head() | Natural Language Processing with Disaster Tweets |
8,318,844 | <save_to_csv><EOS> | submission_df.to_csv("submission.csv", index=False, header=True ) | Natural Language Processing with Disaster Tweets |
8,536,043 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<define_variables> | import transformers
import torch.nn as nn
import torch
from tqdm import tqdm
import torch
import torch.nn as nn
import pandas as pd
import torch.nn as nn
import numpy as np
from sklearn import model_selection
from sklearn import metrics
from transformers import AdamW
from transformers import get_linear_schedule_with_wa... | Natural Language Processing with Disaster Tweets |
8,536,043 | my_sub = '.. /input/single-model-7seeds/submission(2 ).csv'<define_variables> | MAX_Len = 512
TRAIN_BATCH_SIZE =8
VALID_BATCH_SIZE = 4
BERT_PATH = '.. /input/bert-base-uncased'
TOKENZIER = transformers.BertTokenizer.from_pretrained(BERT_PATH ,do_lower_case = True ) | Natural Language Processing with Disaster Tweets |
8,536,043 | TARGET_COL = ['5-alpha_reductase_inhibitor', '11-beta-hsd1_inhibitor', 'acat_inhibitor', 'acetylcholine_receptor_agonist', 'acetylcholine_receptor_antagonist', 'acetylcholinesterase_inhibitor', 'adenosine_receptor_agonist', 'adenosine_receptor_antagonist', 'adenylyl_cyclase_activator', 'adrenergic_receptor_agonist', 'a... | class BertBaseUncased(nn.Module):
def __init__(self):
super(BertBaseUncased,self ).__init__()
self.bert = transformers.BertModel.from_pretrained(BERT_PATH)
self.bert_drop = nn.Dropout(0.4)
self.out = nn.Linear(768,1)
def forward(self,ids,mask,token_type_ids):
out1,out2 = self.bert(
ids ,
attention_mask = mask ,
tok... | Natural Language Processing with Disaster Tweets |
8,536,043 | import numpy as np
import pandas as pd
import tensorflow as tf
import tensorflow.keras.backend as K
import tensorflow.keras.layers as L
import tensorflow.keras.models as M
from tensorflow.keras.callbacks import ReduceLROnPlateau, ModelCheckpoint, EarlyStopping
import tensorflow_addons as tfa
from sklearn.model_selectio... | class BERTDataset :
def __init__(self,df):
self.text = df['text'].values
self.target = df['target'].values
self.tokenizer = TOKENZIER
self.max_len = MAX_Len
def __len__(self):
return len(self.text)
def __getitem__(self, item):
text = str(self.text[item])
text = " ".join(text.split())
inputs = self.tokenizer.encode_p... | Natural Language Processing with Disaster Tweets |
8,536,043 | train_features = pd.read_csv('.. /input/lish-moa/train_features.csv')
train_targets = pd.read_csv('.. /input/lish-moa/train_targets_scored.csv')
test_features = pd.read_csv('.. /input/lish-moa/test_features.csv')
ss = pd.read_csv('.. /input/lish-moa/sample_submission.csv' )<categorify> | def loss_fn(outputs, targets):
return nn.BCEWithLogitsLoss()(outputs, targets.view(-1, 1)) | Natural Language Processing with Disaster Tweets |
8,536,043 | def preprocess(df):
df = df.copy()
df.loc[:, 'cp_type'] = df.loc[:, 'cp_type'].map({'trt_cp': 0, 'ctl_vehicle': 1})
df.loc[:, 'cp_dose'] = df.loc[:, 'cp_dose'].map({'D1': 0, 'D2': 1})
del df['sig_id']
return df
train = preprocess(train_features)
test = preprocess(test_features)
del train_targets['sig_id']
train_tar... | def train_fn(data_loader, model, optimizer, scheduler):
model.train()
for bi, d in tqdm(enumerate(data_loader), total=len(data_loader)) :
ids = d["ids"]
token_type_ids = d["token_type_ids"]
mask = d["mask"]
targets = d["targets"]
ids = ids.to(device, dtype=torch.long)
token_type_ids = token_type_ids.to(device, dtype=t... | Natural Language Processing with Disaster Tweets |
8,536,043 | def nn_model(num_columns):
model = tf.keras.Sequential([
tf.keras.layers.Input(num_columns),
tf.keras.layers.BatchNormalization() ,
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(1024),
tf.keras.layers.BatchNormalization() ,
tf.keras.layers.Dropout(0.41),
tf.keras.layers.PReLU() ,
tf.keras.layers.Dense(512),
tf.ke... | def eval_fn(data_loader, model):
model.eval()
fin_targets = []
fin_outputs = []
with torch.no_grad() :
for bi, d in tqdm(enumerate(data_loader), total=len(data_loader)) :
ids = d["ids"]
token_type_ids = d["token_type_ids"]
mask = d["mask"]
targets = d["targets"]
ids = ids.to(device, dtype=torch.long)
token_type_ids = ... | Natural Language Processing with Disaster Tweets |
8,536,043 |
<define_variables> | DEVICE =torch.device("cuda")
device = torch.device("cuda")
def run(model,EPOCHS):
dfx = pd.read_csv('.. /input/nlp-getting-started/train.csv' ).fillna("none")
df_train, df_valid = model_selection.train_test_split(
dfx,
test_size=0.1,
random_state=42,
stratify=dfx.target.values
)
train_dataset = BERTDataset(
df_t... | Natural Language Processing with Disaster Tweets |
8,536,043 | top_feats = [ 0, 1, 2, 3, 5, 6, 8, 9, 10, 11, 12, 14, 15,
16, 18, 19, 20, 21, 23, 24, 25, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 39, 40, 41, 42, 44, 45, 46,
48, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
63, 64, 65, 66, 68, 69, 70, 71, 72, 73, 74, 75, 76,
78, 79, 80, 81, 82, 83, 84, 86, 87, 88, 89, 90, 92,
93... | def sentence_prediction(sentence):
tokenizer = TOKENZIER
max_len = MAX_Len
text = str(sentence)
text = " ".join(text.split())
inputs = tokenizer.encode_plus(
text,
None,
add_special_tokens=True,
max_length=max_len
)
ids = inputs["input_ids"]
mask = inputs["attention_mask"]
token_type_ids = inputs["token_type_ids"]... | Natural Language Processing with Disaster Tweets |
8,536,043 | def metric(y_true, y_pred):
metrics = []
for _target in train_targets.columns:
metrics.append(log_loss(y_true.loc[:, _target], y_pred.loc[:, _target].astype(float), labels=[0,1]))
return np.mean(metrics )<compute_test_metric> | test = pd.read_csv('.. /input/nlp-getting-started/test.csv')
test['target'] = test['text'].apply(sentence_prediction ) | Natural Language Processing with Disaster Tweets |
8,536,043 | print(f'OOF Metric: {metric(train_targets, res)}' )<feature_engineering> | sub = test[['id','target']] | Natural Language Processing with Disaster Tweets |
8,536,043 | ss.loc[test['cp_type']==1, train_targets.columns] = 0<save_to_csv> | sub['target'] = sub['target'].round().astype('int' ) | Natural Language Processing with Disaster Tweets |
8,536,043 | ss.to_csv('submission.csv', index=False )<set_options> | train = pd.read_csv('.. /input/nlp-getting-started/train.csv')
train = train.fillna('None')
ag = train.groupby('keyword' ).agg({'text':np.size, 'target':np.mean} ).rename(columns={'text':'Count', 'target':'Disaster Probability'})
ag.sort_values('Disaster Probability', ascending=False ).head(10 ) | Natural Language Processing with Disaster Tweets |
8,536,043 | warnings.filterwarnings("ignore")
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu' )<feature_engineering> | keyword_list = list(ag[(ag['Count']>2)&(ag['Disaster Probability']>=0.9)].index)
keyword_list | Natural Language Processing with Disaster Tweets |
8,536,043 | def get_logger(filename='log'):
logger = getLogger(__name__)
logger.setLevel(INFO)
handler1 = StreamHandler()
handler1.setFormatter(Formatter("%(message)s"))
handler2 = FileHandler(filename=f"{filename}.log")
handler2.setFormatter(Formatter("%(message)s"))
logger.addHandler(handler1)
logger.addHandler(handler2)
re... | ids = test['id'][test.keyword.isin(keyword_list)].values
sub['target'][sub['id'].isin(ids)] = 1
sub.head() | 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.