kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,394,678 | !pip install -U tf-models-official==2.3<import_modules> | def get_net() :
net = efficientnet_pytorch.EfficientNet.from_pretrained('efficientnet-b7')
net._fc = nn.Linear(in_features=2560, out_features=10, bias=True)
return net
net = get_net().to(DEVICE ) | Digit Recognizer |
10,394,678 | print("TF version: ", tf.__version__ )<load_from_csv> | fitter = Fitter(
model=net,
device=DEVICE,
criterion=TrainConfig.criterion,
n_epochs=TrainConfig.n_epochs,
lr=TrainConfig.lr,
sheduler=TrainConfig.scheduler,
scheduler_params=TrainConfig.scheduler_params
) | Digit Recognizer |
10,394,678 | train_df = pd.read_csv(".. /input/nlp-getting-started/train.csv")
train_df.info()
train_df.head(6 )<load_from_csv> | fitter.fit(train_loader, valid_loader ) | Digit Recognizer |
10,394,678 | test_df = pd.read_csv(".. /input/nlp-getting-started/test.csv")
test_df.info()
test_df.head(6 )<categorify> | checkpoint = torch.load('.. /working/best-checkpoint.bin')
net.load_state_dict(checkpoint['model_state_dict']);
net.eval() ; | Digit Recognizer |
10,394,678 | for df in [train_df, test_df]:
for col in ['keyword', 'location']:
df[col] = df[col].fillna(f'no_{col}' )<sort_values> | df = pd.read_csv('.. /input/digit-recognizer/test.csv')
print(df.shape)
df.head() | Digit Recognizer |
10,394,678 | mislabeledData = train_df.groupby(['text'] ).nunique().sort_values(by='target', ascending=False)
mislabeledData = mislabeledData[mislabeledData['target'] > 1]['target']
print(f"Total {mislabeledData.shape[0]} mislabled data" )<feature_engineering> | X = df.values | Digit Recognizer |
10,394,678 | train_df['target_relabeled'] = train_df['target'].copy()
train_df.loc[train_df['text'] == 'like for the music video I want some real action shit like burning buildings and police chases not some weak ben winston shit', 'target_relabeled'] = 0
train_df.loc[train_df['text'] == 'Hellfire is surrounded by desires so be car... | class DatasetRetriever(Dataset):
def __init__(self, X, transforms=None):
super().__init__()
self.X = X.reshape(-1, 28, 28 ).astype(np.float32)
self.transforms = transforms
def __getitem__(self, index):
image = self.X[index]
image = np.stack([image] * 3, axis=-1)
image /= 255.
if self.transforms:
image = self.transfo... | Digit Recognizer |
10,394,678 | def clean_special_characters(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", "let... | test_dataset = DatasetRetriever(
X = X,
transforms=get_valid_transforms() ,
) | Digit Recognizer |
10,394,678 | def restore_contractions(tweet):
tweet = re.sub(r"he's", "he is", tweet)
tweet = re.sub(r"there's", "there is", tweet)
tweet = re.sub(r"We're", "We are", tweet)
tweet = re.sub(r"That's", "That is", tweet)
tweet = re.sub(r"won't", "will not", tweet)
tweet = re.sub(r"they're", "they are", tweet)
tweet = re.sub(r"Ca... | test_loader = DataLoader(
test_dataset,
batch_size=DataLoaderConfig.batch_size,
shuffle=False,
num_workers=DataLoaderConfig.num_workers
) | Digit Recognizer |
10,394,678 | def restore_character_entity_references(tweet):
tweet = re.sub(r">", ">", tweet)
tweet = re.sub(r"<", "<", tweet)
tweet = re.sub(r"&", "&", tweet)
return tweet<categorify> | result = []
for step, images in enumerate(test_loader):
print(step, end='\r')
y_pred = net(images.to(DEVICE)).detach().cpu().numpy().argmax(axis=1 ).astype(int)
result.extend(y_pred ) | Digit Recognizer |
10,394,678 | def restore_typos_slang_and_informal_abbreviations(tweet):
tweet = re.sub(r"w/e", "whatever", tweet)
tweet = re.sub(r"w/", "with", tweet)
tweet = re.sub(r"USAgov", "USA government", tweet)
tweet = re.sub(r"recentlu", "recently", tweet)
tweet = re.sub(r"Ph0tos", "Photos", tweet)
tweet = re.sub(r"amirite", "am I rig... | sub = pd.read_csv('.. /input/digit-recognizer/sample_submission.csv', index_col=0)
sub.head() | Digit Recognizer |
10,394,678 | def restore_hashtags_usernames(tweet):
tweet = re.sub(r"IranDeal", "Iran Deal", tweet)
tweet = re.sub(r"ArianaGrande", "Ariana Grande", tweet)
tweet = re.sub(r"camilacabello97", "camila cabello", tweet)
tweet = re.sub(r"RondaRousey", "Ronda Rousey", tweet)
tweet = re.sub(r"MTVHottest", "MTV Hottest", tweet)
tweet ... | sub['Label'] = result | Digit Recognizer |
10,394,678 | def restore_acronyms(tweet):
tweet = re.sub(r"MH370", "Malaysia Airlines Flight 370", tweet)
tweet = re.sub(r"m̼sica", "music", tweet)
tweet = re.sub(r"okwx", "Oklahoma City Weather", tweet)
tweet = re.sub(r"arwx", "Arkansas Weather", tweet)
tweet = re.sub(r"gawx", "Georgia Weather", tweet)
tweet = re.sub(r"scwx"... | sub.to_csv('submission.csv', index=True ) | Digit Recognizer |
9,946,831 | def restore_grouping_same_words_without_embeddings(tweet):
tweet = re.sub(r"Bestnaijamade", "bestnaijamade", tweet)
tweet = re.sub(r"SOUDELOR", "Soudelor", tweet)
return tweet<define_variables> | %matplotlib inline
np.random.seed(0 ) | Digit Recognizer |
9,946,831 | def remove_urls(tweet):
tweet = re.sub("https?:\/\/t.co\/[A-Za-z0-9]*", '', tweet)
return tweet<drop_column> | train = pd.read_csv(r'/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv(r'/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
9,946,831 | def remove_emojis(tweet):
emoji_pattern = re.compile("["
u"\U0001F600-\U0001F64F"
u"\U0001F300-\U0001F5FF"
u"\U0001F680-\U0001F6FF"
u"\U0001F1E0-\U0001F1FF"
u"\U00002702-\U000027B0"
u"\U000024C2-\U0001F251"
"]+", flags=re.UNICODE)
tweet = emoji_pattern.sub(r'', tweet)
return tweet<categorify> | Y = train['label']
X = train.drop('label',axis=1 ) | Digit Recognizer |
9,946,831 | def remove_punctuations(tweet):
tweet = tweet.translate(str.maketrans('', '', string.punctuation))
return tweet<drop_column> | X = X / 255.0
test = test / 255.0 | Digit Recognizer |
9,946,831 | %%time
def clean(tweet):
tweet = clean_special_characters(tweet)
tweet = restore_contractions(tweet)
tweet = restore_character_entity_references(tweet)
tweet = restore_typos_slang_and_informal_abbreviations(tweet)
tweet = restore_hashtags_usernames(tweet)
tweet = restore_acronyms(tweet)
tweet = restore_grouping_s... | Y = to_categorical(Y,10 ) | Digit Recognizer |
9,946,831 | concat_df = pd.concat([train_df, test_df], axis = 0 ).reset_index(drop = True)
MAX_SEQ_LEN = len(max(concat_df.text_cleaned, key = len))
print('The maximum length of each sequence is:', MAX_SEQ_LEN )<define_variables> | X_train,X_test,Y_train,Y_test = train_test_split(X,Y,test_size=0.2 ) | Digit Recognizer |
9,946,831 | AUTOTUNE = tf.data.experimental.AUTOTUNE
BATCH_SIZE = 32
SEED = 42<count_unique_values> | model = keras.models.Sequential([
keras.layers.Conv2D(32,(5,5),input_shape=(28,28,1),activation='relu',padding='same'),
keras.layers.BatchNormalization(axis=1),
keras.layers.MaxPooling2D(2,2),
keras.layers.Conv2D(32,(5,5),activation='relu',padding='same'),
keras.layers.BatchNormalization() ,
keras.layers.MaxPooling2D(2... | Digit Recognizer |
9,946,831 | K = 2
skf = StratifiedKFold(n_splits=K, random_state=SEED, shuffle=True)
DISASTER = train_df['target_relabeled'] == 1
print('Whole Training Set Shape = {}'.format(train_df.shape[0]))
print('Whole Training Set Unique keyword Count = {}'.format(train_df['keyword'].nunique()))
print('Whole Training Set Target Rate(Disast... | model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'] ) | Digit Recognizer |
9,946,831 | test_ds_raw = tf.data.Dataset.from_tensor_slices(test_df['text_cleaned'].values)
for text in test_ds_raw.take(5):
print(f'Review: {text}' )<train_model> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
9,946,831 | BERT_MODEL = 'https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3'
PREPROCESS_MODEL = 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2'
print(f'BERT model selected : {BERT_MODEL}')
print(f'Preprocess model auto-selected: {PREPROCESS_MODEL}' )<choose_model_class> | datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(X_t... | Digit Recognizer |
9,946,831 | def make_bert_preprocess_model(sentence_features, seq_length=128):
input_segments = [
tf.keras.layers.Input(shape=() , dtype=tf.string, name=ft)
for ft in sentence_features]
bert_preprocess = hub.load(PREPROCESS_MODEL)
tokenizer = hub.KerasLayer(bert_preprocess.tokenize, name='tokenizer')
segments = [tokenizer(s)f... | epochs = 250
batch_size=64
history = model.fit_generator(datagen.flow(X_train,Y_train, batch_size=batch_size),
epochs = epochs, validation_data =(X_test,Y_test),
verbose = 2, steps_per_epoch=X_train.shape[0] // batch_size
,callbacks=[learning_rate_reduction] ) | Digit Recognizer |
9,946,831 | def build_classifier_model() :
inputs = dict(
input_word_ids=tf.keras.layers.Input(shape=(None,), dtype=tf.int32, name='word_ids'),
input_mask=tf.keras.layers.Input(shape=(None,), dtype=tf.int32, name='mask'),
input_type_ids=tf.keras.layers.Input(shape=(None,), dtype=tf.int32, name='type_ids'),
)
encoder = hub.Keras... | predictions = model.predict(test)
predictions = np.argmax(predictions,axis = 1)
predictions = pd.Series(predictions,name="Label" ) | Digit Recognizer |
9,946,831 | def build_classifier_model_em_proc() :
text_input = tf.keras.layers.Input(shape=() , dtype=tf.string, name='text')
preprocessing_layer = hub.KerasLayer(PREPROCESS_MODEL, name='preprocessing')
encoder_inputs = preprocessing_layer(text_input)
encoder = hub.KerasLayer(BERT_MODEL, trainable=True, name='BERT_encoder')
o... | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),predictions],axis = 1)
submission.to_csv("submissions_mnist.csv",index=False)
print("Your file is saved." ) | Digit Recognizer |
9,946,831 | train_ds = train_ds_list[0]
train_ds = train_ds.shuffle(SEED ).batch(BATCH_SIZE)
train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)
valid_ds = valid_ds_list[0]
valid_ds = valid_ds.batch(BATCH_SIZE)
valid_ds = valid_ds.cache().prefetch(buffer_size=AUTOTUNE )<choose_model_class> | %matplotlib inline
np.random.seed(0 ) | Digit Recognizer |
9,946,831 | loss = tf.keras.losses.BinaryCrossentropy(from_logits=True)
metrics = tf.metrics.BinaryAccuracy()<choose_model_class> | train = pd.read_csv(r'/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv(r'/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
9,946,831 | EPOCHS = 10
INIT_LR = 3e-5
steps_per_epoch = tf.data.experimental.cardinality(train_ds ).numpy()
num_train_steps = steps_per_epoch * EPOCHS
num_warmup_steps = int(0.1 * num_train_steps)
optimizer = optimization.create_optimizer(init_lr = INIT_LR,
num_train_steps = num_train_steps,
num_warmup_steps = num_warmup_steps,
... | Y = train['label']
X = train.drop('label',axis=1 ) | Digit Recognizer |
9,946,831 | model_em_proc.compile(optimizer=optimizer,
loss=loss,
metrics=metrics )<train_model> | X = X / 255.0
test = test / 255.0 | Digit Recognizer |
9,946,831 | print('Training model with embedded preprocess model')
history_em_proc = model_em_proc.fit(x=train_ds,
validation_data=valid_ds,
epochs = EPOCHS )<predict_on_test> | Y = to_categorical(Y,10 ) | Digit Recognizer |
9,946,831 | test_ds = test_ds_raw.batch(BATCH_SIZE ).cache().prefetch(buffer_size=AUTOTUNE)
predict_result_em_proc = tf.sigmoid(model_em_proc.predict(test_ds))
print(predict_result_em_proc )<categorify> | X_train,X_test,Y_train,Y_test = train_test_split(X,Y,test_size=0.2 ) | Digit Recognizer |
9,946,831 | train_ds = train_ds_list[1]
train_ds = train_ds.shuffle(SEED ).batch(BATCH_SIZE)
train_ds = train_ds.map(lambda x, y:(preprocess_model(x), y))
train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)
valid_ds = valid_ds_list[1]
valid_ds = valid_ds.batch(BATCH_SIZE)
valid_ds = valid_ds.map(lambda x, y:(preprocess_m... | model = keras.models.Sequential([
keras.layers.Conv2D(32,(5,5),input_shape=(28,28,1),activation='relu',padding='same'),
keras.layers.BatchNormalization(axis=1),
keras.layers.MaxPooling2D(2,2),
keras.layers.Conv2D(32,(5,5),activation='relu',padding='same'),
keras.layers.BatchNormalization() ,
keras.layers.MaxPooling2D(2... | Digit Recognizer |
9,946,831 | steps_per_epoch = tf.data.experimental.cardinality(train_ds ).numpy()
num_train_steps = steps_per_epoch * EPOCHS
num_warmup_steps = int(0.1 * num_train_steps)
optimizer = optimization.create_optimizer(init_lr = INIT_LR,
num_train_steps = num_train_steps,
num_warmup_steps = num_warmup_steps,
optimizer_type = 'adamw' )<... | model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'] ) | Digit Recognizer |
9,946,831 | model.compile(optimizer=optimizer,
loss=loss,
metrics=metrics )<train_model> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
9,946,831 | print('Training model without embedded preprocess model')
history_model = model.fit(x=train_ds,
validation_data=valid_ds,
epochs = EPOCHS )<predict_on_test> | datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(X_t... | Digit Recognizer |
9,946,831 | test_ds = test_ds_raw.batch(BATCH_SIZE ).cache().prefetch(buffer_size=AUTOTUNE)
test_ds = test_ds.map(lambda x: preprocess_model(x))
predict_result = tf.sigmoid(model.predict(test_ds))
print(predict_result )<save_to_csv> | epochs = 250
batch_size=64
history = model.fit_generator(datagen.flow(X_train,Y_train, batch_size=batch_size),
epochs = epochs, validation_data =(X_test,Y_test),
verbose = 2, steps_per_epoch=X_train.shape[0] // batch_size
,callbacks=[learning_rate_reduction] ) | Digit Recognizer |
9,946,831 | result_1 = predict_result_em_proc.numpy()
result_2 = predict_result.numpy()
result = []
for i in range(len(result_1)) :
result.append(( result_1[i] + result_2[i])/2)
result = np.round(result)
sample_submission = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
ids = sample_submission.id
final_submi... | predictions = model.predict(test)
predictions = np.argmax(predictions,axis = 1)
predictions = pd.Series(predictions,name="Label" ) | Digit Recognizer |
9,946,831 | <load_from_csv><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),predictions],axis = 1)
submission.to_csv("submissions_mnist.csv",index=False)
print("Your file is saved." ) | Digit Recognizer |
9,895,998 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<count_missing_values> | import pandas as pd
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.optim import lr_scheduler
from torch.autograd import Variable
from torch.utils.data import DataLoader, Dataset
from torchvision import transforms
from torchvision.utils import... | Digit Recognizer |
9,895,998 | train.isnull().sum()<remove_duplicates> | INPUT_DIR = '.. /input/digit-recognizer'
BATCH_SIZE = 64
N_EPOCHS = 50 | Digit Recognizer |
9,895,998 | train=train.drop_duplicates(subset=['text', 'target'], keep='first')
train.shape<count_values> | train_df = pd.read_csv(INPUT_DIR + '/train.csv')
n_train = len(train_df)
n_pixels = len(train_df.columns)- 1
n_class = len(set(train_df['label']))
print('Number of training samples: {0}'.format(n_train))
print('Number of training pixels: {0}'.format(n_pixels))
print('Number of classes: {0}'.format(n_class)) | Digit Recognizer |
9,895,998 | train.target.value_counts()<feature_engineering> | test_df = pd.read_csv(INPUT_DIR + '/test.csv')
n_test = len(test_df)
n_pixels = len(test_df.columns)
print('Number of train samples: {0}'.format(n_test))
print('Number of test pixels: {0}'.format(n_pixels)) | Digit Recognizer |
9,895,998 | train['text_length'] = train.text.apply(lambda x: len(x.split()))
test['text_length'] = test.text.apply(lambda x: len(x.split()))<string_transform> | class MNIST_data(Dataset):
def __init__(self, file_path,
transform = transforms.Compose([transforms.ToPILImage() , transforms.ToTensor() ,
transforms.Normalize(mean=(0.5,), std=(0.5,)) ])
):
df = pd.read_csv(file_path)
if len(df.columns)== n_pixels:
self.X = df.values.reshape(( -1,28,28)).astype(np.uint8)[:,:,:,None]
... | Digit Recognizer |
9,895,998 | list_= []
for i in train.text:
list_ += i
list_= ''.join(list_)
allWords=list_.split()
vocabulary= set(allWords )<string_transform> | class RandomRotation(object):
def __init__(self, degrees, resample=False, expand=False, center=None):
if isinstance(degrees, numbers.Number):
if degrees < 0:
raise ValueError("If degrees is a single number, it must be positive.")
self.degrees =(-degrees, degrees)
else:
if len(degrees)!= 2:
raise ValueError("If degree... | Digit Recognizer |
9,895,998 | def create_corpus(df,target):
corpus=[]
for x in df[df['target']==target]['text'].str.split() :
for i in x:
corpus.append(i)
return corpus<import_modules> | class RandomShift(object):
def __init__(self, shift):
self.shift = shift
@staticmethod
def get_params(shift):
hshift, vshift = np.random.uniform(-shift, shift, size=2)
return hshift, vshift
def __call__(self, img):
hshift, vshift = self.get_params(self.shift)
return img.transform(img.size, Image.AFFINE,(1,0,hshift,0,... | Digit Recognizer |
9,895,998 | string.punctuation<string_transform> | train_dataset = MNIST_data(INPUT_DIR + '/train.csv', transform=transforms.Compose(
[transforms.ToPILImage() , RandomRotation(degrees=20), RandomShift(3),
transforms.ToTensor() , transforms.Normalize(mean=(0.5,), std=(0.5,)) ]))
test_dataset = MNIST_data(INPUT_DIR + '/test.csv')
train_loader = torch.utils.data.DataLoa... | Digit Recognizer |
9,895,998 | stopwords.words('english' )<string_transform> | class Net(nn.Module):
def __init__(self):
super(Net, self ).__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(32),
nn.ReLU(inplace=True),
nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(32),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_si... | Digit Recognizer |
9,895,998 | text='hey this is me and I am here to help you '
tokens = word_tokenize(text)
tokens=[word for word in tokens if word not in stopwords.words('english')]
' '.join(tokens )<string_transform> | model = Net()
optimizer = optim.Adam(model.parameters() , lr=0.003)
criterion = nn.CrossEntropyLoss()
exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)
if torch.cuda.is_available() :
model = model.cuda()
criterion = criterion.cuda() | Digit Recognizer |
9,895,998 | pstem = PorterStemmer()
def clean_text(text):
text= text.lower()
text= re.sub('[0-9]', '', text)
text = "".join([char for char in text if char not in string.punctuation])
tokens = word_tokenize(text)
tokens=[pstem.stem(word)for word in tokens]
text = ' '.join(tokens)
return text<feature_engineering> | def train(epoch):
model.train()
optimizer.step()
exp_lr_scheduler.step()
for batch_idx,(data, target)in enumerate(train_loader):
data, target = Variable(data), Variable(target)
if torch.cuda.is_available() :
data = data.cuda()
target = target.cuda()
optimizer.zero_grad()
output = model(data)
loss = criterion(output, ... | Digit Recognizer |
9,895,998 | train["clean"]=train["text"].apply(clean_text)
test["clean"]=test["text"].apply(clean_text )<string_transform> | def evaluate(data_loader):
model.eval()
loss = 0
correct = 0
with torch.no_grad() :
for data, target in data_loader:
data, target = Variable(data), Variable(target)
if torch.cuda.is_available() :
data = data.cuda()
target = target.cuda()
output = model(data)
loss += F.cross_entropy(output, target, reduction='sum' ).i... | Digit Recognizer |
9,895,998 | list_= []
for i in train.clean:
list_ += i
list_= ''.join(list_)
allWords=list_.split()
vocabulary= set(allWords)
len(vocabulary )<categorify> | for epoch in range(N_EPOCHS):
train(epoch)
evaluate(train_loader ) | Digit Recognizer |
9,895,998 | tfidf = TfidfVectorizer(sublinear_tf=True,max_features=60000, min_df=1, norm='l2', ngram_range=(1,2))
features = tfidf.fit_transform(train.clean ).toarray()
features.shape<categorify> | def prediciton(data_loader):
model.eval()
test_pred = torch.LongTensor()
with torch.no_grad() :
for i, data in enumerate(data_loader):
data = Variable(data)
if torch.cuda.is_available() :
data = data.cuda()
output = model(data)
pred = output.cpu().data.max(1, keepdim=True)[1]
test_pred = torch.cat(( test_pred, pred),... | Digit Recognizer |
9,895,998 | features_test = tfidf.transform(test.clean ).toarray()<prepare_x_and_y> | test_pred = prediciton(test_loader ) | Digit Recognizer |
9,895,998 | skf = StratifiedKFold(n_splits=4, random_state=48, shuffle=True)
accuracy=[]
n=1
y=train['target']<choose_model_class> | out_df = pd.DataFrame(np.c_[np.arange(1, len(test_dataset)+1)[:,None], test_pred.numpy() ], columns=['ImageId', 'Label'] ) | Digit Recognizer |
9,895,998 | for trn_idx, test_idx in skf.split(features, y):
start_time = time()
X_tr,X_val=features[trn_idx],features[test_idx]
y_tr,y_val=y.iloc[trn_idx],y.iloc[test_idx]
model= LogisticRegression(max_iter=1000,C=3)
model.fit(X_tr,y_tr)
s = model.predict(X_val)
sub[str(n)]= model.predict(features_test)
accuracy.append(accura... | out_df.to_csv('submission.csv', index=False ) | Digit Recognizer |
9,671,849 | np.mean(accuracy)*100<import_modules> | %matplotlib inline
np.random.seed(2)
sns.set(style='white', context='notebook', palette='deep' ) | Digit Recognizer |
9,671,849 | from sklearn.metrics import confusion_matrix, classification_report<predict_on_test> | df_train=pd.read_csv('.. /input/digit-recognizer/train.csv')
test=pd.read_csv('.. /input/digit-recognizer/test.csv' ) | Digit Recognizer |
9,671,849 | pred_valid_y = model.predict(X_val)
print(classification_report(y_val, pred_valid_y))<compute_test_metric> | X_train = X_train.values.reshape(-1,28,28,1)
test = test.values.reshape(-1,28,28,1 ) | Digit Recognizer |
9,671,849 | print(confusion_matrix(y_val, pred_valid_y))<feature_engineering> | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
9,671,849 | df=sub[['1','2','3','4']].mode(axis=1)
sub['target']=df[0]
sub=sub[['id','target']]
sub['target']=sub['target'].apply(lambda x : int(x))<save_to_csv> | Y_train = to_categorical(Y_train, num_classes = 10)
print(Y_train[0] ) | Digit Recognizer |
9,671,849 | sub.to_csv('submission.csv',index=False )<load_from_csv> | random_seed=2
X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.1, random_state=random_seed ) | Digit Recognizer |
9,671,849 | train_df = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test_df = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv" )<remove_duplicates> | model = Sequential() | Digit Recognizer |
9,671,849 | print(len(train_df))
train_df = train_df.drop_duplicates('text', keep='last')
print(len(train_df))<count_values> | model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(filters = 64, k... | Digit Recognizer |
9,671,849 | train_df['target'].value_counts()<choose_model_class> | optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0 ) | Digit Recognizer |
9,671,849 | wordLemm = WordNetLemmatizer()<string_transform> | model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
9,671,849 | def preprocess_text(text):
text = re.sub(r"http\S+", "", text)
text = re.sub(URLPATTERN,' URL',text)
for emoji in EMOJIS.keys() :
text = text.replace(emoji, "EMOJI" + EMOJIS[emoji])
text = re.sub(USERPATTERN,' URL',text)
text = re.sub('[^a-zA-z]'," ",text)
text = re.sub(SEQPATTERN,SEQREPLACE,text)
text = text.spl... | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001)
epochs = 30
batch_size = 86 | Digit Recognizer |
9,671,849 | train_df['text_cleaned'] = train_df['text'].apply(lambda s : clean(s))
test_df['text_cleaned'] = test_df['text'].apply(lambda s : clean(s))<install_modules> | datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(X_t... | Digit Recognizer |
9,671,849 | !pip install -U tensorflow_text==2.3<install_modules> | history = model.fit_generator(datagen.flow(X_train,Y_train, batch_size=batch_size),
epochs = epochs, validation_data =(X_val,Y_val),
verbose = 2, steps_per_epoch=X_train.shape[0] // batch_size
, callbacks=[learning_rate_reduction] ) | Digit Recognizer |
9,671,849 | !pip install -q tf-models-official==2.3<import_modules> | accuracy = model.evaluate(X_train, Y_train)
print(f'Train results - Accuracy: {accuracy[1]*100}%' ) | Digit Recognizer |
9,671,849 | import tensorflow as tf
import tensorflow_hub as hub
import tensorflow_text as text
from official.nlp import optimization<split> | accuracy = model.evaluate(X_val, Y_val)
print(f'validation test results - Accuracy: {accuracy[1]*100}%' ) | Digit Recognizer |
9,671,849 | X_train, X_valid, y_train, y_valid = train_test_split(train_df['text'].tolist() ,\
train_df['target'].tolist() ,\
test_size=0.15,\
stratify = train_df['target'].tolist() ,\
random_state=0)
<prepare_x_and_y> | predict_val = model.predict(X_val)
y_val_pred=(np.argmax(predict_val,axis=1))
y_true = np.argmax(Y_val,axis = 1 ) | Digit Recognizer |
9,671,849 | batch_size = 26
seed = 42
train_ds = tf.data.Dataset.from_tensor_slices(( train_df['text'].tolist() ,train_df['target'].tolist())).batch(batch_size)
valid_ds = tf.data.Dataset.from_tensor_slices(( X_valid,y_valid)).batch(batch_size)
<define_variables> | results = confusion_matrix(y_true,y_val_pred)
print('Confusion Matrix :')
print(results)
print('Accuracy Score :',accuracy_score(y_true,y_val_pred))
print('Report : ')
print(classification_report(y_true,y_val_pred)) | Digit Recognizer |
9,671,849 | bert_model_name = 'bert_en_uncased_L-12_H-768_A-12'
map_name_to_handle = {
'bert_en_uncased_L-12_H-768_A-12':
'https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3',
}
map_model_to_preprocess = {
'bert_en_uncased_L-12_H-768_A-12':
'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
}
tfhub_handle_enc... | val_lr_probs = model.predict_proba(X_val)
val_lr_auc =(roc_auc_score(y_true, val_lr_probs, multi_class="ovr",average="macro")) *100
print("AUC :%.2f%%"%(val_lr_auc)) | Digit Recognizer |
9,671,849 | def build_classifier_model() :
text_input = tf.keras.layers.Input(shape=() , dtype=tf.string, name='text')
preprocessing_layer = hub.KerasLayer(tfhub_handle_preprocess, name='preprocessing')
encoder_inputs = preprocessing_layer(text_input)
encoder = hub.KerasLayer(tfhub_handle_encoder, trainable=True, name='BERT_enc... | predictions = model.predict(test)
y_pred= np.argmax(predictions,axis=1 ) | Digit Recognizer |
9,671,849 | <choose_model_class><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("submission.csv",index=False ) | Digit Recognizer |
9,581,031 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | %matplotlib inline
np.random.seed(2)
dense_regularizer = L1L2(l2=0.0001)
sns.set(style='white', context='notebook', palette='deep' ) | Digit Recognizer |
9,581,031 | classifier_model.compile(optimizer=optimizer,
loss=loss,
metrics=metrics )<train_model> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
9,581,031 | print(f'Training model with {tfhub_handle_encoder}')
history = classifier_model.fit(x=train_ds, epochs=epochs,validation_data=valid_ds)
<save_model> | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
9,581,031 | classifier_model.save("./model.h5" )<predict_on_test> | Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
9,581,031 | probs = classifier_model.predict(test_df["text"])
threshold = 0.40
preds = np.where(probs[:,] > threshold, 1, 0 )<load_from_csv> | random_seed = 2 | Digit Recognizer |
9,581,031 | submission=pd.read_csv('/kaggle/input/nlp-getting-started/sample_submission.csv' )<prepare_output> | X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.1, random_state=random_seed ) | Digit Recognizer |
9,581,031 | submission["target"]=preds<save_to_csv> | def Model_1(x=None):
model = Sequential()
model.add(Conv2D(64,(5, 5), input_shape=(28,28,1), padding='same', kernel_regularizer=dense_regularizer,kernel_initializer="he_normal"))
model.add(BatchNormalization())
model.add(Activation('elu'))
model.add(Conv2D(64,(5, 5), padding='same', kernel_regularizer=dense_regularize... | Digit Recognizer |
9,581,031 | submission.to_csv('submission.csv', index=False, header=True )<load_from_csv> | optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0 ) | Digit Recognizer |
9,581,031 | df = pd.read_csv('.. /input/nlp-getting-started/train.csv',index_col=0)
df_test = pd.read_csv('.. /input/nlp-getting-started/test.csv',index_col=0)
temp = [(x,y)for x,y in zip(list(df['text']),list(df['target'])) ]
random.shuffle(temp)
tweets = [t[0] for t in temp]
y = [t[1] for t in temp]
y = np.array(y ).astype('f... | model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
9,581,031 | print('Observations in training set')
print(df['target'].count())
print()
print('Label proportion in training set')
print(df['target'].value_counts() /(sum(df['target'].value_counts())))
print()
print('Observations in test set')
print(df_test['text'].count() )<import_modules> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_accuracy',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
9,581,031 | import tensorflow as tf
from transformers import RobertaTokenizerFast, TFRobertaForSequenceClassification<load_pretrained> | epochs = 100
batch_size = 86 | Digit Recognizer |
9,581,031 | model_name = 'roberta-large'
roberta_tokenizer = RobertaTokenizerFast.from_pretrained(model_name)
roberta_seq = TFRobertaForSequenceClassification.from_pretrained(model_name )<define_variables> | Digit Recognizer | |
9,581,031 | for t in tweets:
if '&' in re.sub(r'(&|>|<)','',t):
print(t )<define_variables> | datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(X_t... | Digit Recognizer |
9,581,031 | for t in tweets:
if any([x in t for x in [' btw ',' omg ',' lol ',' thx ']]):
print(t )<categorify> | history = model.fit_generator(datagen.flow(X_train,Y_train, batch_size=batch_size),
epochs = epochs, validation_data =(X_val,Y_val),
verbose = 1, steps_per_epoch=X_train.shape[0] // batch_size
, callbacks=[learning_rate_reduction] ) | Digit Recognizer |
9,581,031 | def process_tweets(tweets):
r = tweets
r = [re.sub(r'https?://t.co/\w+','',t)for t in r]
r = [re.sub('&','&',t)for t in r]
r = [re.sub('>','gt',t)for t in r]
r = [re.sub('<','lt',t)for t in r]
return r
tweets = process_tweets(tweets )<string_transform> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
9,581,031 | temp = roberta_tokenizer(tweets[:5],padding='max_length',max_length=50)
temp.keys()<categorify> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("cnn_mnist_datagen_MMA.csv",index=False ) | Digit Recognizer |
9,309,487 | print('Original tweet:')
print(tweets[0])
print('Encoded tweet:')
print(temp['input_ids'][0])
print('Decoded tweet:')
print(roberta_tokenizer.decode(temp['input_ids'][0]))<string_transform> | train= pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test= pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
9,309,487 | all_tweets = list(pd.concat([df,df_test],axis=0)['text'])
all_tweets = process_tweets(all_tweets)
max_len = max([len(t)for t in roberta_tokenizer(all_tweets)['input_ids']])
print(max_len )<split> | Ytrain= train['label'].astype('float32')
| Digit Recognizer |
9,309,487 | X_train, X_test, y_train, y_test = train_test_split(tweets,y,test_size=0.30)
X_train = roberta_tokenizer(X_train,padding='max_length',max_length=max_len,return_tensors='tf')
X_test = roberta_tokenizer(X_test,padding='max_length',max_length=max_len,return_tensors='tf' )<define_variables> | train= train.drop('label',axis=1 ) | Digit Recognizer |
9,309,487 | batch_size = 8
train_dataset = tf.data.Dataset.from_tensor_slices(( dict(X_train),y_train))
train_dataset = train_dataset.batch(batch_size)
test_dataset = tf.data.Dataset.from_tensor_slices(( dict(X_test),y_test))
test_dataset = test_dataset.batch(batch_size )<concatenate> | train= train.values.reshape(-1,28,28,1 ).astype('float32')
test= test.values.reshape(-1,28,28,1 ).astype('float32')
train =train / 255.0
test = test / 255.0
| Digit Recognizer |
9,309,487 | temp_x, temp_y = next(iter(test_dataset))
temp = roberta_seq(temp_x,temp_y)
temp<choose_model_class> | Ytrain=to_categorical(Ytrain,num_classes=10)
x_train,x_test,y_train,y_test=train_test_split(train,Ytrain,test_size=0.25 ) | Digit Recognizer |
9,309,487 | optimizer = tf.keras.optimizers.Adam(learning_rate=5e-6)
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
roberta_seq.compile(optimizer=optimizer,loss=loss,metrics=['accuracy'] )<train_model> | from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D,BatchNormalization
from keras.preprocessing.image import ImageDataGenerator
| Digit Recognizer |
9,309,487 | history = roberta_seq.fit(train_dataset,epochs=3,
validation_data=test_dataset,
callbacks=[callback_chkpt] )<load_pretrained> | model = Sequential() | Digit Recognizer |
9,309,487 | roberta_seq.load_weights(chkpt )<predict_on_test> | model.add(Conv2D(32,(3,3),padding='same',activation= 'relu',input_shape=(28,28,1)))
model.add(BatchNormalization())
model.add(Conv2D(32,(3,3),padding='same',activation= 'relu',input_shape=(28,28,1)))
model.add(BatchNormalization())
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.2)) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.