kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,958,924 | import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from keras.preprocessing.image import ImageDataGenerator
from keras.utils import to_categorical
from keras.models import Sequential, load_model
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, Ma... | CFG = {
'fold_num': 5,
'seed': 719,
'model_arch': 'tf_efficientnet_b4_ns',
'img_size': 512,
'epochs': 10,
'train_bs': 32,
'valid_bs': 32,
'lr': 1e-4,
'num_workers': 4,
'accum_iter': 1,
'verbose_step': 1,
'device': 'cuda:0',
'tta': 3,
'used_epochs': [9,1,5],
'weights': [1,1,1]
} | Cassava Leaf Disease Classification |
13,958,924 | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv')
df = train.copy()
df_test = test.copy()<count_missing_values> | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head() | Cassava Leaf Disease Classification |
13,958,924 | df.isnull().any().sum()<count_missing_values> | train.label.value_counts() | Cassava Leaf Disease Classification |
13,958,924 | df_test.isnull().any().sum()<define_variables> | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head() | Cassava Leaf Disease Classification |
13,958,924 | seed = 3141
np.random.seed(seed )<split> | class CassavaDataset(Dataset):
def __init__(
self, df, data_root, transforms=None, output_label=True
):
super().__init__()
self.df = df.reset_index(drop=True ).copy()
self.transforms = transforms
self.data_root = data_root
self.output_label = output_label
def __len__(self):
return self.df.shape[0]
def __getitem__(sel... | Cassava Leaf Disease Classification |
13,958,924 | X = train.iloc[:,1:]
Y = train.iloc[:,0]
x_train , x_test , y_train , y_test = train_test_split(X, Y , test_size=0.1, random_state=seed )<categorify> | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | Cassava Leaf Disease Classification |
13,958,924 | x_train = x_train.values.reshape(-1, 28, 28, 1)
x_test = x_test.values.reshape(-1, 28, 28, 1)
df_test=df_test.values.reshape(-1,28,28,1 )<define_variables> | class CassvaImgClassifier(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
self.model = timm.create_model(model_arch, pretrained=pretrained)
n_features = self.model.classifier.in_features
self.model.classifier = nn.Linear(n_features, n_class)
def forward(self, x):
x = self.mod... | Cassava Leaf Disease Classification |
13,958,924 | 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 )<data_type_conve... | test = pd.DataFrame()
test['image_id'] = list(os.listdir('.. /input/cassava-leaf-disease-classification/test_images/'))
test_ds = CassavaDataset(test, '.. /input/cassava-leaf-disease-classification/test_images/', transforms=get_inference_transforms() , output_label=False)
tst_loader = torch.utils.data.DataLoader(
tes... | Cassava Leaf Disease Classification |
13,958,924 | x_train = x_train.astype("float32")/255
x_test = x_test.astype("float32")/255
df_test = df_test.astype("float32")/255<train_model> | tst_preds = []
model_name = ['net1_fold0_epoch0','tf_efficientnet_b4_ns_fold_0_4','tf_efficientnet_b4_ns_fold_3_5']
for i in range(len(model_name)) :
model.load_state_dict(torch.load('.. /input/model903/{}'.format(model_name[i])))
with torch.no_grad() :
for _ in range(CFG['tta']):
tst_preds += [CFG['weights'][i]/sum(C... | Cassava Leaf Disease Classification |
13,958,924 | datagen.fit(x_train )<categorify> | test['label'] = np.argmax(tst_preds, axis=1)
test.head() | Cassava Leaf Disease Classification |
13,958,924 | y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)
print(y_train[0] )<choose_model_class> | test['label'] = np.argmax(tst_preds, axis=1)
test.head() | Cassava Leaf Disease Classification |
13,958,924 | <choose_model_class><EOS> | test.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
14,040,094 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<choose_model_class> | %matplotlib inline | Cassava Leaf Disease Classification |
14,040,094 | model.compile(optimizer=optimizer, loss="categorical_crossentropy", metrics=["accuracy"] )<choose_model_class> | import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import CosineAnnealingLR, CosineAnnealingWarmRestarts
import torch.utils.data as data
from torch.utils.data import DataLoader
import torchvision
from torchvision import transforms
from torch.cuda.amp import autocast, GradScaler | Cassava Leaf Disease Classification |
14,040,094 | reduce_lr = LearningRateScheduler(lambda x: 1e-3 * 0.9 ** x )<train_model> | !pip install '.. /input/efficientnet-pytorch-07/efficientnet_pytorch-0.7.0'
| Cassava Leaf Disease Classification |
14,040,094 | decays = [(lambda x: 1e-3 * 0.9 ** x )(x)for x in range(10)]
i=1
for lr in decays:
print("Epoch " + str(i)+" Learning Rate: " + str(lr))
i+=1<choose_model_class> | DEBUG = False
INFERENCE = True
def seed_everything(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = True
device = torch.device('cuda' if torch.cuda.i... | Cassava Leaf Disease Classification |
14,040,094 | early_stopping = EarlyStopping(
min_delta=0.001,
patience=20,
restore_best_weights=True,
)<define_variables> | if INFERENCE:
test_df = pd.DataFrame()
test_df['image_id'] = list(os.listdir(TEST_IMGS + '/'))
test_df.loc[:, 'img_path'] = TEST_IMGS + '/' + test_df.image_id
if DEBUG:
test_df = pd.read_csv(TRAIN ).head(128)
test_df.loc[:, 'img_path'] = TRAIN_IMGS + '/' + test_df.image_id
else:
train_df = pd.read_csv(TRAIN)
train_df... | Cassava Leaf Disease Classification |
14,040,094 | batch_size = 64
epochs = 50<train_model> | if(DEBUG)&(not INFERENCE):
num_labels = len(train_df.loc[:, 'label'].unique())
print('train ds', train_df.loc[:, 'label'].value_counts(normalize=True ).values)
print('val ds', val_df.loc[:, 'label'].value_counts(normalize=True ).values ) | Cassava Leaf Disease Classification |
14,040,094 | history = model.fit_generator(datagen.flow(x_train, y_train, batch_size = batch_size), epochs = epochs,
validation_data =(x_test, y_test), verbose=1,
steps_per_epoch=x_train.shape[0] // batch_size,
callbacks = [reduce_lr] )<import_modules> | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | Cassava Leaf Disease Classification |
14,040,094 | import matplotlib.pyplot as plt<save_to_csv> | class CassavaDataset(data.Dataset):
def __init__(self, df, transform=None, phase='train'):
self.transform = transform
self.phase= phase
self.df = df
def __len__(self):
return len(self.df)
def __getitem__(self, index):
img_path = self.df.iloc[index].loc['img_path']
img = cv2.imread(img_path)
img = cv2.cvtColor(img, cv... | Cassava Leaf Disease Classification |
14,040,094 | pred_digits_test = np.argmax(model.predict(df_test),axis=1)
image_id_test = []
for i in range(len(pred_digits_test)) :
image_id_test.append(i+1)
d = {'ImageId':image_id_test,'Label':pred_digits_test}
answer = pd.DataFrame(d)
answer.to_csv('answer.csv',index=False )<set_options> | transform = AlbumTransform()
if INFERENCE:
if cfg['test']['TTA']:
test_ds = CassavaDataset(test_df, transform=transform, phase='test_tta')
else:
test_ds = CassavaDataset(test_df, transform=transform, phase='test')
test_dl = DataLoader(test_ds, batch_size=cfg['test']['batch_size'],
shuffle=cfg['test']['shuffle'], num_... | Cassava Leaf Disease Classification |
14,040,094 | %matplotlib inline
%load_ext autoreload
%autoreload 2
<load_from_csv> | class CassavaNet(nn.Module):
def __init__(self):
super().__init__()
if INFERENCE:
self.model = EfficientNet.from_name(cfg['model']['arch'], in_channels=3)
else:
self.model = EfficientNet.from_pretrained(cfg['model']['arch'], in_channels=3)
num_in_features = self.model._fc.in_features
self.model._fc = nn.Linear(num_in... | Cassava Leaf Disease Classification |
14,040,094 | train_data = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test_data = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" )<train_model> | model = CassavaNet() | Cassava Leaf Disease Classification |
14,040,094 | print("Training Data : ")
train_data.head(3 ).iloc[:,:17]<feature_engineering> | criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(params = model.parameters() , lr=cfg['optim']['lr'] ) | Cassava Leaf Disease Classification |
14,040,094 | train_data_norm = train_data.iloc[:, 1:] / 255.0
test_data_norm = test_data / 255.0<define_variables> | class RunOneEpoch() :
def __init__(self, model, dataloaders, criterion, optimizer, scheduler=None):
self.model = model
self.dataloaders = dataloaders
self.criterion = criterion.to(device)
self.optimizer = optimizer
self.scheduler = scheduler
def train(self, phase='train'):
batch_loss = 0.0
batch_corrects = 0
epoch_los... | Cassava Leaf Disease Classification |
14,040,094 | num_examples_train = train_data.shape[0]
num_examples_test = test_data.shape[0]
n_h = 32
n_w = 32
n_c = 3<define_variables> | def get_checkpoint(folder, checkpoint_name):
checkpoint_path = os.path.join(folder, checkpoint_name)
checkpoint = torch.load(checkpoint_path, map_location=device)
return checkpoint | Cassava Leaf Disease Classification |
14,040,094 | <categorify><EOS> | %%time
if INFERENCE:
if cfg['test']['TTA']:
outputs = []
model = CassavaNet().to(device)
try:
checkpoint = get_checkpoint(cfg['test']['checkpoint'], f'checkpoint.pth')
model.load_state_dict(checkpoint['model'])
except:
print('No checkpoint.')
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(params = model.p... | Cassava Leaf Disease Classification |
13,978,606 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<train_model> | import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
import cv2
import tensorflow as tf
from tensorflow import keras | Cassava Leaf Disease Classification |
13,978,606 | for example in range(num_examples_train):
Train_input_images[example] = cv2.resize(Train_input_images[example],(n_h, n_w))
for example in range(num_examples_test):
Test_input_images[example] = cv2.resize(Test_input_images[example],(n_h, n_w))<define_variables> | test_batch_size = 8
image_size = 512 | Cassava Leaf Disease Classification |
13,978,606 | Train_labels = np.array(train_data.iloc[:, 0] )<choose_model_class> | PATH = '.. /input/cassava-leaf-disease-classification/'
sub_df = pd.read_csv(PATH + 'sample_submission.csv' ) | Cassava Leaf Disease Classification |
13,978,606 | image_generator = ImageDataGenerator(
rotation_range=27,
width_shift_range=0.3,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=False,
samplewise_center=True,
samplewise_std_normalization=True
)
validation_datagen = ImageDataGenerator()<choose_model_class> | sub_df["path"] = PATH + 'test_images/' + sub_df["image_id"] | Cassava Leaf Disease Classification |
13,978,606 | pretrained_model = keras.applications.resnet50.ResNet50(input_shape=(n_h, n_w, n_c),
include_top=False, weights='imagenet')
model = keras.Sequential([
pretrained_model,
keras.layers.Flatten() ,
keras.layers.Dense(units=60, activation='relu'),
keras.layers.Dense(units=10, activation='softmax')
] )<choose_model_class> | test_ds = tf.data.Dataset.from_tensor_slices(( sub_df.path.values, sub_df.label.values)) | Cassava Leaf Disease Classification |
13,978,606 | Optimizer = 'RMSprop'
model.compile(optimizer=Optimizer,
loss='sparse_categorical_crossentropy',
metrics=['accuracy'] )<split> | AUTOTUNE = tf.data.experimental.AUTOTUNE | Cassava Leaf Disease Classification |
13,978,606 | train_images, dev_images, train_labels, dev_labels = train_test_split(Train_input_images,
Train_labels,
test_size=0.1, train_size=0.9,
shuffle=True,
random_state=44)
test_images = Test_input_images<define_search_model> | def test_aug(image):
data = {"image":image}
aug_data = test_transforms(**data)
aug_img = aug_data["image"]
aug_img = tf.cast(aug_img, tf.float32)
return aug_img | Cassava Leaf Disease Classification |
13,978,606 | train_datagen = ImageDataGenerator(
rotation_range=27,
width_shift_range=0.3,
height_shift_range=0.2,
shear_range=0.3,
zoom_range=0.2,
horizontal_flip=False)
validation_datagen = ImageDataGenerator()<train_model> | def process_data(image_path, label, func_aug):
image = tf.io.read_file(image_path)
image = tf.image.decode_jpeg(image)
image = tf.image.convert_image_dtype(image, tf.float32)
aug_img = tf.numpy_function(func=func_aug, inp=[image], Tout=tf.float32)
return aug_img, label | Cassava Leaf Disease Classification |
13,978,606 | class myCallback(keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs={}):
if(logs.get('accuracy')> 0.999999):
print("Stop training!")
self.model.stop_training = True<train_model> | test_ds_alb = test_ds.map(partial(process_data, func_aug=test_aug), num_parallel_calls=AUTOTUNE ).prefetch(AUTOTUNE ) | Cassava Leaf Disease Classification |
13,978,606 | EPOCHS = 5
batch_size = 212
history = model.fit_generator(train_datagen.flow(train_images,train_labels, batch_size=batch_size),
steps_per_epoch=train_images.shape[0] / batch_size,
epochs=EPOCHS,
validation_data=validation_datagen.flow(dev_images,dev_labels,
batch_size=batch_size),
validation_steps=dev_images.shape[0] /... | test_ds_alb = test_ds_alb.map(set_shapes, num_parallel_calls=AUTOTUNE ).batch(8 ) | Cassava Leaf Disease Classification |
13,978,606 | submission = pd.read_csv('.. /input/digit-recognizer-submission/submission.csv')
submission.to_csv('digit_submission.csv', index=False )<load_from_csv> | os.system('pip install /kaggle/input/kerasapplications -q')
os.system('pip install /kaggle/input/efficientnet-keras-source-code/ -q --no-deps' ) | Cassava Leaf Disease Classification |
13,978,606 | mnist_train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
mnist_test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" )<categorify> | efficientnet = efn.EfficientNetB4(weights=None, include_top=False,
drop_connect_rate=0.3, input_shape=(image_size, image_size, 3))
inputs = Input(shape=(image_size, image_size, 3))
efficientnet = efficientnet(inputs)
pooling = GlobalAveragePooling2D()(efficientnet)
dropout = Dropout(0.3 )(pooling)
outputs = Dense(5,... | Cassava Leaf Disease Classification |
13,978,606 | mnist_train_data = mnist_train.loc[:, "pixel0":]
mnist_train_label = mnist_train.loc[:, "label"]
mnist_train_data = mnist_train_data/255.0
mnist_test = mnist_test/255.0<normalization> | preds = []
for fold in [2,3]:
model.load_weights('.. /input/effnetb45128weights/EffNetB4_512_8_weights_fold_{}.h5'.format(fold+1))
preds.append(model.predict(test_ds_alb, workers=4, verbose=1)) | Cassava Leaf Disease Classification |
13,978,606 | standardized_scalar = StandardScaler()
standardized_data = standardized_scalar.fit_transform(mnist_train_data)
standardized_data.shape<train_model> | preds = []
for fold in [2,3]:
model.load_weights('.. /input/effnetb45128weights/EffNetB4_512_8_weights_fold_{}.h5'.format(fold+1))
fold_preds = []
for i in range(5):
fold_preds.append(model.predict(test_ds_alb, workers=4, verbose=1))
preds.append(np.mean(fold_preds, axis=0)) | Cassava Leaf Disease Classification |
13,978,606 | cov_matrix = np.matmul(standardized_data.T, standardized_data)
cov_matrix.shape<compute_train_metric> | preds_avg = np.mean(preds, axis=0 ) | Cassava Leaf Disease Classification |
13,978,606 | lambdas, vectors = eigh(cov_matrix, eigvals=(782, 783))
vectors.shape<concatenate> | y_pred = np.argmax(preds_avg, axis=-1 ) | Cassava Leaf Disease Classification |
13,978,606 | new_coordinates = np.matmul(vectors, standardized_data.T)
print(new_coordinates.shape)
new_coordinates = np.vstack(( new_coordinates, mnist_train_label)).T<prepare_output> | sub_df['label'] = y_pred | Cassava Leaf Disease Classification |
13,978,606 | df_new = pd.DataFrame(new_coordinates, columns=["f1", "f2", "labels"])
df_new.head()<normalization> | sub_df.drop(['path'], axis=1, inplace=True ) | Cassava Leaf Disease Classification |
13,978,606 | <concatenate><EOS> | sub_df.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
23,000,148 | def Classifier(shape_):
inp = Input(shape=(shape_))
x = Bidirectional(GRU(128,return_sequences=True))(inp)
x = Bidirectional(GRU(128,return_sequences=True))(x)
x = Bidirectional(GRU(128,return_sequences=True))(x)
out = Dense(11, activation='softmax', name='out' )(x)
model = models.Model(inputs=inp, outputs=out)
op... | pip install cleantext | Natural Language Processing with Disaster Tweets |
23,000,148 | class MacroF1(Callback):
def __init__(self, model, inputs, targets):
self.model = model
self.inputs = inputs
self.targets = np.argmax(targets, axis=2 ).reshape(-1)
def on_epoch_end(self, epoch, logs):
pred = np.argmax(self.model.predict(self.inputs), axis=2 ).reshape(-1)
score = f1_score(self.targets, pred, average="... | pip install ktrain | Natural Language Processing with Disaster Tweets |
23,000,148 | def normalize(train, test):
train_input_mean = train.signal.mean()
train_input_sigma = train.signal.std()
train['signal'] =(train.signal-train_input_mean)/train_input_sigma
test['signal'] =(test.signal-train_input_mean)/train_input_sigma
return train, test<load_pretrained> | warnings.filterwarnings("ignore" ) | Natural Language Processing with Disaster Tweets |
23,000,148 | def run_everything(fe_config : List)-> NoReturn:
not_feats_cols = ['time']
target_col = ['open_channels']
init_logger()
with timer(f'Reading Data'):
logger.info('Reading Data Started...')
base = os.path.abspath('/kaggle/input/liverpool-ion-switching/')
train, test, sample_submission = read_data(base)
logger.info('Re... | df = pd.read_csv(".. /input/nlp-getting-started/train.csv")
display(df.head())
display(df.shape ) | Natural Language Processing with Disaster Tweets |
23,000,148 | warnings.filterwarnings('ignore' )<load_from_csv> | l=len(df)
display(l)
cleanlist=[]
textlength=[]
for i in range(l):
ct=cleantext.clean(df.iloc[i,3], clean_all= True)
cleanlist.append(ct)
lct=len(ct)
textlength.append(lct)
| Natural Language Processing with Disaster Tweets |
23,000,148 | %%time
df_train = pd.read_feather('.. /input/ashrae-feather/train.ft')
building = pd.read_feather('.. /input/ashrae-feather/building.ft')
le = LabelEncoder()
building.primary_use = le.fit_transform(building.primary_use)
DATA_PATH = ".. /input/ashrae-energy-prediction/"
weather_train = pd.read_csv(DATA_PATH + 'weathe... | df_clean=pd.DataFrame(cleanlist)
df_clean.columns=['cleantext']
frames=[df,df_clean]
newdf=pd.concat(frames, axis=1)
display(newdf ) | Natural Language Processing with Disaster Tweets |
23,000,148 | %%time
df_train = df_train.query('not(building_id <= 104 & meter == 0 & timestamp <= "2016-05-20 18")')
df_train = df_train.query('not(building_id == 681 & meter == 0 & timestamp <= "2016-04-27")')
df_train = df_train.query('not(building_id == 761 & meter == 0 & timestamp <= "2016-09-02")')
df_train = df_train.query... | ( x_train, y_train),(x_test, y_test), preproc=text.texts_from_df(newdf, 'cleantext',label_columns=['target'],
maxlen=127,max_features=100000,
preprocess_mode='bert', val_pct=.1 ) | Natural Language Processing with Disaster Tweets |
23,000,148 |
<data_type_conversions> | model=text.text_classifier('bert',(x_train, y_train), preproc=preproc)
learner=ktrain.get_learner(model, train_data=(x_train, y_train),
val_data=(x_test, y_test),
batch_size=32 ) | Natural Language Processing with Disaster Tweets |
23,000,148 | def fill_weather_dataset(weather_df):
time_format = "%Y-%m-%d %H:%M:%S"
start_date = datetime.datetime.strptime(weather_df['timestamp'].min() ,time_format)
end_date = datetime.datetime.strptime(weather_df['timestamp'].max() ,time_format)
total_hours = int(((end_date - start_date ).total_seconds() + 3600)/ 3600)
hour... | learner.fit_onecycle(2e-5, 3)
predictor=ktrain.get_predictor(learner.model, preproc ) | Natural Language Processing with Disaster Tweets |
23,000,148 | def rmse(ytrue, ypred):
return np.sqrt(np.mean(np.square(ypred - ytrue), axis=0))
def rmsle(ytrue, ypred):
return np.sqrt(np.mean(np.square(np.log1p(ypred)- np.log1p(ytrue)) , axis=0))<create_dataframe> | predictor.predict(['calm','earthquake'] ) | Natural Language Processing with Disaster Tweets |
23,000,148 | weather_train = fill_weather_dataset(weather_train )<categorify> | df1 = pd.read_csv(".. /input/nlp-getting-started/test.csv")
display(df1.head())
display(df1.shape ) | Natural Language Processing with Disaster Tweets |
23,000,148 | df_train = reduce_mem_usage(df_train,use_float16=True)
building = reduce_mem_usage(building,use_float16=True)
weather_train = reduce_mem_usage(weather_train,use_float16=True )<merge> | l=len(df1)
display(l)
predlist=[]
for i in range(l):
ct=cleantext.clean(df1.iloc[i,3], clean_all= True)
new=predictor.predict(ct)
predlist.append(new ) | Natural Language Processing with Disaster Tweets |
23,000,148 | df_train = df_train.merge(building, left_on='building_id',right_on='building_id',how='left')
df_train = df_train.merge(weather_train,how='left',left_on=['site_id','timestamp'],right_on=['site_id','timestamp'])
del weather_train
gc.collect()<feature_engineering> | df_pred=pd.DataFrame(predlist)
df_pred.columns=['target']
frames=[df1,df_pred]
df2=pd.concat(frames, axis=1)
display(df2.head() ) | Natural Language Processing with Disaster Tweets |
23,000,148 | %%time
df_train = features_engineering(df_train )<prepare_x_and_y> | df2.loc[df2['target']=='target','target']=1
df2.loc[df2['target']=='not_target','target']=0
display(df2['target'].mean())
df2=df2[['id','target']]
display(df2.shape)
display(df2.head() ) | Natural Language Processing with Disaster Tweets |
23,000,148 | <split><EOS> | df2.to_csv("submission.csv", index=False ) | Natural Language Processing with Disaster Tweets |
23,121,360 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<set_options> | !wget --quiet https://raw.githubusercontent.com/tensorflow/models/master/official/nlp/bert/tokenization.py | Natural Language Processing with Disaster Tweets |
23,121,360 | del X_train, y_train
gc.collect()<load_from_disk> | import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras import layers, models, optimizers
from tensorflow.keras.callbacks import ModelCheckpoint | Natural Language Processing with Disaster Tweets |
23,121,360 | df_test = pd.read_feather('.. /input/ashrae-feather/test.ft')
row_ids = df_test["row_id"]
df_test.drop("row_id", axis=1, inplace=True)
df_test = reduce_mem_usage(df_test )<feature_engineering> | 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 |
23,121,360 |
<merge> | def bert_encode(texts, tokenizer, max_len):
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)
tokens... | Natural Language Processing with Disaster Tweets |
23,121,360 | df_test = df_test.merge(building,left_on='building_id',right_on='building_id',how='left')
del building
gc.collect()<drop_column> | train = train.fillna(' ')
test = test.fillna(' ' ) | Natural Language Processing with Disaster Tweets |
23,121,360 | weather_test = fill_weather_dataset(weather_test)
weather_test = reduce_mem_usage(weather_test )<merge> | max_len = 60
module_url = "https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/1"
bert_layer = hub.KerasLayer(module_url, trainable=True)
vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = tokenization.FullTokeniz... | Natural Language Processing with Disaster Tweets |
23,121,360 | df_test = df_test.merge(weather_test,how='left',on=['timestamp','site_id'])
del weather_test
gc.collect()<feature_engineering> | input_word_ids = layers.Input(shape=(max_len,), dtype=tf.int32, name="input_word_ids")
input_mask = layers.Input(shape=(max_len,), dtype=tf.int32, name="input_mask")
segment_ids = layers.Input(shape=(max_len,), dtype=tf.int32, name="segment_ids")
_, sequence_output = bert_layer([input_word_ids, input_mask, segment_i... | Natural Language Processing with Disaster Tweets |
23,121,360 | df_test = features_engineering(df_test )<predict_on_test> | 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 |
23,121,360 | %%time
pred = []
for model in tqdm(models):
if pred == []:
pred = np.expm1(model.predict(df_test, num_iteration=model.best_iteration)) / len(models)
else:
pred += np.expm1(model.predict(df_test, num_iteration=model.best_iteration)) / len(models)
del model
gc.collect()<load_pretrained> | model.load_weights('model.h5')
test_pred = model.predict(test_input ) | Natural Language Processing with Disaster Tweets |
23,121,360 | <set_options><EOS> | submission['target'] = test_pred.round().astype(int)
submission.to_csv('submission.csv', index=False ) | Natural Language Processing with Disaster Tweets |
22,626,888 | <save_to_csv><EOS> | import pandas as pd | Natural Language Processing with Disaster Tweets |
22,626,888 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<load_from_disk> | import pandas as pd | Natural Language Processing with Disaster Tweets |
22,626,888 | site0 = pd.read_feather('.. /input/ucf-building-meter-reading/site0.ft')
df_test = pd.read_feather('.. /input/ashrae-feather/test.ft' )<merge> | train_df = pd.read_csv(".. /input/nlp-getting-started/train.csv")
test_df = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv')
gt_df = pd.read_csv(".. /input/disasters-on-social-media/socialmedia-disaster-tweets-DFE.csv" ) | Natural Language Processing with Disaster Tweets |
22,626,888 | merged = df_test.merge(site0, left_on=['building_id', 'meter', 'timestamp'],
right_on=['building_id', 'meter', 'timestamp'], how='left' )<prepare_x_and_y> | gt_df = gt_df[['choose_one', 'text']]
gt_df['target'] =(gt_df['choose_one']=='Relevant' ).astype(int)
gt_df['id'] = gt_df.index
gt_df | Natural Language Processing with Disaster Tweets |
22,626,888 | ytrue = merged[~merged['meter_reading'].isna() ]['meter_reading']
pred = submission[~merged['meter_reading'].isna() ]['meter_reading']<compute_test_metric> | merged_df = pd.merge(test_df, gt_df, on='id')
merged_df | Natural Language Processing with Disaster Tweets |
22,626,888 | <load_from_disk><EOS> | subm_df.to_csv('submission.csv', index=False ) | Natural Language Processing with Disaster Tweets |
22,263,006 | <SOS> metric: meanfscore Kaggle data source: natural-language-processing-with-disaster-tweets<merge> | ! pip install tf-models-official==2.4.0 -q
! pip install tensorflow-gpu==2.4.1 -q
! pip install tensorflow-text==2.4.1 -q
! python -m spacy download en_core_web_sm -q
! pip install dataprep | grep -v 'already satisfied' | Natural Language Processing with Disaster Tweets |
22,263,006 | merged = df_test.merge(site1, left_on=['building_id', 'meter', 'timestamp'],
right_on=['building_id', 'meter', 'timestamp'], how='left' )<prepare_x_and_y> | np.set_printoptions(precision=4)
warnings.filterwarnings('ignore' ) | Natural Language Processing with Disaster Tweets |
22,263,006 | ytrue = merged[~merged['meter_reading'].isna() ]['meter_reading']
pred = submission[~merged['meter_reading'].isna() ]['meter_reading']<compute_test_metric> | tf.__version__ | Natural Language Processing with Disaster Tweets |
22,263,006 | del site1, merged
print(f'RMSLE of buildings 105-155: {rmsle(ytrue, pred):.4f}' )<load_from_disk> | random.seed(319)
np.random.seed(319)
tf.random.set_seed(319 ) | Natural Language Processing with Disaster Tweets |
22,263,006 | site2 = pd.read_feather('.. /input/asu-feather/site2.ft')
site2 = site2.query('timestamp >= 2017' )<merge> | train_full = pd.read_csv('/kaggle/input/nlp-getting-started/train.csv')
test_full = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv')
print('Training Set Shape = {}'.format(train_full.shape))
print('Training Set Memory Usage = {:.2f}MB'.format(train_full.memory_usage().sum() /2**20))
print('Test Set Shape = {... | Natural Language Processing with Disaster Tweets |
22,263,006 | merged = df_test.merge(site2, left_on=['building_id', 'meter', 'timestamp'],
right_on=['building_id', 'meter', 'timestamp'], how='left' )<prepare_x_and_y> | df_train = pd.read_csv("/kaggle/input/disastertweet-prepared2/train_prepared.csv")
df_test = pd.read_csv("/kaggle/input/disastertweet-prepared2/test_prepared.csv" ) | Natural Language Processing with Disaster Tweets |
22,263,006 | ytrue = merged[~merged['meter_reading'].isna() ]['meter_reading']
pred = submission[~merged['meter_reading'].isna() ]['meter_reading']<compute_test_metric> | train_full = clean_text(train_full,'keyword')
test_full = clean_text(test_full, 'keyword' ) | Natural Language Processing with Disaster Tweets |
22,263,006 | del site2, merged
print(f'RMSLE of buildings 156-290: {rmsle(ytrue, pred):.4f}' )<load_from_disk> | df_train['keyword'] = train_full['keyword']
df_test['keyword'] = test_full['keyword'] | Natural Language Processing with Disaster Tweets |
22,263,006 | site4 = pd.read_feather('.. /input/ucb-feather/site4.ft')
site4 = site4.query('timestamp >= 2017' )<merge> | nlp_spacy = spacy.load('en_core_web_sm')
sentence_enc = hub.load('https://tfhub.dev/google/universal-sentence-encoder/4' ) | Natural Language Processing with Disaster Tweets |
22,263,006 | merged = df_test.merge(site4, left_on=['building_id', 'timestamp'],
right_on=['building_id', 'timestamp'], how='left' )<prepare_x_and_y> | def extract_keywords(text):
potential_keywords = []
TOP_KEYWORD = -1
pos_tag = ['ADJ', 'NOUN', 'PROPN']
doc = nlp_spacy(text)
for i in doc:
if i.pos_ in pos_tag:
potential_keywords.append(i.text)
document_embed = sentence_enc([text])
potential_embed = sentence_enc(potential_keywords)
vector_distances = cosine_simil... | Natural Language Processing with Disaster Tweets |
22,263,006 | ytrue = merged[~merged['meter_reading'].isna() ]['meter_reading']
pred = submission[~merged['meter_reading'].isna() ]['meter_reading']<compute_test_metric> | df_train.keyword = pd.DataFrame(list(map(keyword_filler, df_train.keyword, df_train.text)) ).astype(str)
df_test.keyword = pd.DataFrame(list(map(keyword_filler, df_test.keyword, df_test.text)) ).astype(str)
print('Null Training Keywords => ', df_train['keyword'].isnull().any())
print('Null Test Keywords => ', df_tes... | Natural Language Processing with Disaster Tweets |
22,263,006 | del site4, merged
print(f'RMSLE of 74/91 buildings : {rmsle(ytrue, pred):.4f}' )<load_from_disk> | X_train, X_val, y_train, y_val = train_test_split(df_train[['text','keyword']],
df_train.target,
test_size=0.2,
random_state=42)
X_train.shape, X_val.shape | Natural Language Processing with Disaster Tweets |
22,263,006 | site15 = pd.read_feather('.. /input/cornell-feather/site15.ft')
site15 = site15.query('timestamp >= 2017')
site15 = site15.drop_duplicates()<merge> | train_ds = tf.data.Dataset.from_tensor_slices(( dict(X_train), y_train))
val_ds = tf.data.Dataset.from_tensor_slices(( dict(X_val), y_val))
test_ds = tf.data.Dataset.from_tensor_slices(dict(df_test[['text','keyword']])) | Natural Language Processing with Disaster Tweets |
22,263,006 | merged = df_test.merge(site15, left_on=['building_id', 'meter', 'timestamp'],
right_on=['building_id', 'meter', 'timestamp'], how='left' )<prepare_x_and_y> | AUTOTUNE = tf.data.experimental.AUTOTUNE
BUFFER_SIZE = 1000
BATCH_SIZE = 32
RANDOM_SEED = 319
def configure_dataset(dataset, shuffle=False, test=False):
if shuffle:
dataset = dataset.cache() \
.shuffle(BUFFER_SIZE, seed=RANDOM_SEED, reshuffle_each_iteration=True)\
.batch(BATCH_SIZE, drop_remainder=True)\
.prefetch(A... | Natural Language Processing with Disaster Tweets |
22,263,006 | ytrue = merged[~merged['meter_reading'].isna() ]['meter_reading']
pred = submission[~merged['meter_reading'].isna() ]['meter_reading']<compute_test_metric> | a3 = configure_dataset(train_ds, shuffle=True)
dict3 = []
for elem in a3:
dict3.append(elem[0]['text'][0])
dict3[:10] | Natural Language Processing with Disaster Tweets |
22,263,006 | del site15, merged
print(f'RMSLE of buildings 1325-1448: {rmsle(ytrue, pred):.4f}' )<load_from_disk> | train_ds = configure_dataset(train_ds, shuffle=True)
val_ds = configure_dataset(val_ds)
test_ds = configure_dataset(test_ds, test=True ) | Natural Language Processing with Disaster Tweets |
22,263,006 | site012 = pd.read_feather('.. /input/comb-leaked-dataset/site012.ft')
site012 = site012.query('timestamp >= 2017' )<merge> | del X_train, X_val, y_train, y_val, df_train, df_test, train_full, test_full | Natural Language Processing with Disaster Tweets |
22,263,006 | merged = df_test.merge(site012, left_on=['building_id', 'meter', 'timestamp'],
right_on=['building_id', 'meter', 'timestamp'], how='left' )<prepare_x_and_y> | bert_encoder_path = "https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/4"
bert_preprocessor_path = "https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3"
keyword_embedding_path = "https://tfhub.dev/google/nnlm-en-dim128-with-normalization/2" | Natural Language Processing with Disaster Tweets |
22,263,006 | ytrue = merged[~merged['meter_reading'].isna() ]['meter_reading']
pred = submission[~merged['meter_reading'].isna() ]['meter_reading']<compute_test_metric> | bert_encoder = hub.KerasLayer(bert_encoder_path, trainable=True, name="BERT_Encoder")
bert_preprocessor = hub.KerasLayer(bert_preprocessor_path, name="BERT_Preprocessor")
nnlm_embed = hub.KerasLayer(keyword_embedding_path, name="NNLM_Embedding" ) | Natural Language Processing with Disaster Tweets |
22,263,006 | del site012, merged
gc.collect()
print(f'RMSLE of buildings 0-290: {rmsle(ytrue, pred):.4f}' )<define_variables> | kernel_initializer = tf.keras.initializers.GlorotNormal(seed=319)
def create_model() :
text_input = Input(shape=() , dtype=tf.string, name="text")
encoder_inputs = bert_preprocessor(text_input)
encoder_outputs = bert_encoder(encoder_inputs)
pooled_output = encoder_outputs["pooled_output"]
bert_branch = Dropout(0.1,... | Natural Language Processing with Disaster Tweets |
22,263,006 | path_data = "/kaggle/input/ashrae-energy-prediction/"
path_train = path_data + "train.csv"
path_test = path_data + "test.csv"
path_building = path_data + "building_metadata.csv"
path_weather_train = path_data + "weather_train.csv"
path_weather_test = path_data + "weather_test.csv"
path_drops = path_data + ".. /lier-lis... | EPOCHS = 3
LEARNING_RATE = 5e-5
STEPS_PER_EPOCH = int(train_ds.unbatch().cardinality().numpy() / BATCH_SIZE)
VAL_STEPS = int(val_ds.unbatch().cardinality().numpy() / BATCH_SIZE)
TRAIN_STEPS = STEPS_PER_EPOCH * EPOCHS
WARMUP_STEPS = int(TRAIN_STEPS * 0.1)
adamw_optimizer = create_optimizer(
init_lr=LEARNING_RATE,
nu... | Natural Language Processing with Disaster Tweets |
22,263,006 | df_train = pd.read_csv(path_train)
building = pd.read_csv(path_building)
le = LabelEncoder()
building.primary_use = le.fit_transform(building.primary_use)
weather_train = pd.read_csv(path_weather_train)
bad_rows = pd.read_csv(path_drops)
df_train = df_train.drop(index=bad_rows["0"] )<set_options> | bert_classifier.compile(loss=BinaryCrossentropy(from_logits=True),
optimizer=adamw_optimizer,
metrics=[BinaryAccuracy(name="accuracy")]
)
history = bert_classifier.fit(train_ds,
epochs=EPOCHS,
steps_per_epoch=STEPS_PER_EPOCH,
validation_data=val_ds,
validation_steps=VAL_STEPS
) | Natural Language Processing with Disaster Tweets |
22,263,006 | def reduce_mem_usage(df, use_float16=False):
start_mem = df.memory_usage().sum() / 1024**2
print("Memory usage of dataframe is {:.2f} MB".format(start_mem))
for col in df.columns:
if is_datetime(df[col])or is_categorical_dtype(df[col]):
continue
col_type = df[col].dtype
if col_type != object:
c_min = df[col].min()
c_... | def submission(model, test):
sample_sub = pd.read_csv('/kaggle/input/nlp-getting-started/sample_submission.csv')
predictions = model.predict(test)
y_preds = [ int(i)for i in np.rint(predictions)]
sub = pd.DataFrame({'id':sample_sub['id'].values.tolist() ,'target':y_preds})
sub.to_csv('submission.csv', index=False ) | 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.