kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
12,714,797 | def generate_ngrams(text, n_gram=1):
token = [token for token in text.lower().split(' ')if token != '' if token not in STOPWORDS]
ngrams = zip(*[token[i:] for i in range(n_gram)])
return [' '.join(ngram)for ngram in ngrams]
N = 100
disaster_unigrams = defaultdict(int)
nondisaster_unigrams = defaultdict(int)
for twee... | model.compile(optimizer = "nadam" , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
12,714,797 | sw = stopwords.words('english')
stw = sw + ['lot','frog','ppl','tldr','time','nan','thing', 'subject', 're', 'edu', 'use','good','really','quite','nice','well','little','need','keep','make','important','take','get','very','course','instructor','example']
ps = PorterStemmer()
lemmatizer = nltk.stem.WordNetLemmatizer()<... | epochs = 100
batch_size = 64
| Digit Recognizer |
12,714,797 | def lower(df):
df['com_token'] = df['text'].str.lower().str.split()
df["com_"] = df["com_token"].apply(' '.join)
return df<feature_engineering> | 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 |
12,714,797 | df_train = lower(df_train)
df_train["Orig_comment"] = df_train["text"]
df_train["text"] = df_train["com_"]<categorify> | early_stopping_cb = keras.callbacks.EarlyStopping(patience=20, restore_best_weights=True)
model_checkpoint_cb = keras.callbacks.ModelCheckpoint("best_mnist_model.h5", save_best_only=True)
learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=5,
verbose=1,
factor=0.5,
min_lr=0.00001)
history = model... | Digit Recognizer |
12,714,797 | def decontracted(tweet):
tweet = re.sub(r"won't", "will not", tweet)
tweet = re.sub(r"can't", "can not", tweet)
tweet = re.sub(r"he\ ’ s", "he is", tweet)
tweet = re.sub(r"i\ ’ m", "he is", tweet)
tweet=re.sub("(<.*?>)","",tweet)
tweet=re.sub("(\\W|\\d)"," ",tweet)
tweet = re.sub(r"n't", " not", tweet)
tweet =... | model = keras.models.load_model("best_mnist_model.h5")
model.evaluate(X_train, Y_train)
| Digit Recognizer |
12,714,797 | def remove_punct(text):
table=str.maketrans('','',string.punctuation)
return text.translate(table )<feature_engineering> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
12,714,797 | df_train['text']=df_train['text'].apply(reduce_lengthening, 0)
df_train['text']=df_train['text'].apply(decontracted, 0)
df_train['text']=df_train['text'].apply(lambda x : remove_punct(x))<drop_column> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("cnn_mnist_with_aug.csv",index=False ) | Digit Recognizer |
11,966,240 | def remove_URL(text):
url = re.compile(r'https?://\S+|www\.\S+')
return url.sub(r'',text )<feature_engineering> | %matplotlib inline
np.random.seed(42)
| Digit Recognizer |
11,966,240 | df_train['text']=df_train['text'].apply(lambda x : remove_URL(x))<choose_model_class> | train_data = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test_data = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
submission=pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv' ) | Digit Recognizer |
11,966,240 | aug_w2v = naw.WordEmbsAug(
model_type='glove', model_path='.. /input/glove-global-vectors-for-word-representation/glove.6B.100d.txt',
action="substitute")
<normalization> | train_data=".. /input/digit-recognizer/train.csv"
test_data = ".. /input/digit-recognizer/test.csv" | Digit Recognizer |
11,966,240 | aug_w2v.aug_p=0.2
print("Augmented Text:")
for ii in range(5):
augmented_text = aug_w2v.augment(text)
print(augmented_text )<split> | Xtrain,Xtest,ytrain,ytest=train_test_split(raw_data[:,1:], raw_data[:,0],test_size=0.2,
stratify=raw_data[:,0],
random_state=42)
| Digit Recognizer |
11,966,240 | train,valid=train_test_split(df_train,test_size=0.15)
print('Shape of train',train.shape)
print("Shape of Validation ",valid.shape )<categorify> | Xtrain=Xtrain/255.
Xtest=Xtest/255 . | Digit Recognizer |
11,966,240 | def augment_text(df,samples=300,pr=0.2):
aug_w2v.aug_p=pr
new_text=[]
df_n=df[df.target==1].reset_index(drop=True)
for i in tqdm(np.random.randint(0,len(df_n),samples)) :
text = df_n.iloc[i]['text']
augmented_text = aug_w2v.augment(text)
new_text.append(augmented_text)
new=pd.DataFrame({'text':new_text,'target':1})
... | ytrain= to_categorical(ytrain, num_classes = 10)
ytest= to_categorical(ytest, num_classes = 10 ) | Digit Recognizer |
11,966,240 | train = augment_text(train,samples=400)
tweet = train.append(valid ).reset_index(drop=True )<concatenate> | Xtrain=Xtrain.astype("float32" ).reshape(-1,28,28,1)
Xtest=Xtest.astype("float32" ).reshape(-1,28,28,1 ) | Digit Recognizer |
11,966,240 | df=pd.concat([tweet,df_test] )<remove_duplicates> | train_gen=ImageDataGenerator(rotation_range=20,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1,
shear_range=0.2
) | Digit Recognizer |
11,966,240 | def create_corpus(df):
corpus=[]
for tweet in tqdm(df['text']):
words=[word.lower() for word in word_tokenize(tweet)if(( word.isalpha() ==1)&(word not in stop)) ]
corpus.append(words)
return corpus
<statistical_test> | def model() :
model=tf.keras.Sequential()
model.add(tf.keras.layers.Conv2D(16,(3,3), activation="relu",padding="SAME",input_shape=(28,28,1)))
model.add(BatchNormalization())
model.add(tf.keras.layers.Conv2D(32,(3,3),activation="relu",padding="SAME"))
model.add(BatchNormalization())
model.add(tf.keras.layers.MaxPool2... | Digit Recognizer |
11,966,240 | corpus=create_corpus(df )<load_from_csv> | annealer = LearningRateScheduler(lambda x: 1e-3 * 0.9 ** x ) | Digit Recognizer |
11,966,240 | embedding_dict={}
with open('.. /input/glove-global-vectors-for-word-representation/glove.6B.100d.txt','r')as f:
for line in f:
values=line.split()
word=values[0]
vectors=np.asarray(values[1:],'float32')
embedding_dict[word]=vectors
f.close()<categorify> | model.compile(optimizer=Adam(lr=1e-4),loss='categorical_crossentropy',
metrics=['accuracy'] ) | Digit Recognizer |
11,966,240 | MAX_LEN=50
tokenizer_obj=Tokenizer()
tokenizer_obj.fit_on_texts(corpus)
sequences=tokenizer_obj.texts_to_sequences(corpus)
tweet_pad=pad_sequences(sequences,maxlen=MAX_LEN,truncating='post',padding='post' )<count_unique_values> | class MyCallback(tf.keras.callbacks.Callback):
def on_epoch_end(self,epochs,logs={}):
if(logs.get('accuracy')>0.99):
print()
print("Stopping Training")
self.model.stop_training=True | Digit Recognizer |
11,966,240 | word_index=tokenizer_obj.word_index
print('Number of unique words:',len(word_index))<define_variables> | history=model.fit_generator(train_gen.flow(Xtrain,ytrain,batch_size=16),
validation_data=(Xtest[:1000,:], ytest[:1000,:]),
epochs=30,callbacks=[annealer], steps_per_epoch=500
) | Digit Recognizer |
11,966,240 | num_words=len(word_index)+1
embedding_matrix=np.zeros(( num_words,100))
for word,i in tqdm(word_index.items()):
if i > num_words:
continue
emb_vec=embedding_dict.get(word)
if emb_vec is not None:
embedding_matrix[i]=emb_vec
<choose_model_class> | model.evaluate(Xtest,ytest ) | Digit Recognizer |
11,966,240 | model = Sequential()
embedding=Embedding(num_words,100,embeddings_initializer=Constant(embedding_matrix),
input_length=MAX_LEN,trainable=False)
model.add(embedding)
model.add(SimpleRNN(100))
model.add(Dense(1, activation='sigmoid'))
optimzer=Adam(learning_rate=1e-5)
model.compile(loss='binary_crossentropy',optimizer... | testing = np.loadtxt(test_data, skiprows=1, dtype='int', delimiter=',')
test = testing.astype("float32")
test = testing.reshape(-1, 28, 28, 1)/255 . | Digit Recognizer |
11,966,240 | train_df=tweet_pad[:tweet.shape[0]]
test_df=tweet_pad[tweet.shape[0]:]<prepare_x_and_y> | ypred=np.argmax(model.predict(test),axis=-1 ) | Digit Recognizer |
11,966,240 | <train_model><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("MNIST_digit_recog.csv",index=False ) | Digit Recognizer |
12,482,444 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<predict_on_test> | %matplotlib inline
np.random.seed(2)
sns.set(style='white', context='notebook', palette='deep')
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Digit Recognizer |
12,482,444 | y_pre=model.predict(X_test)
y_pre=np.round(y_pre ).astype(int ).reshape(1142 )<compute_test_metric> | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv' ) | Digit Recognizer |
12,482,444 | print(roc_auc_score(y_pre,y_test))<define_variables> | y_train = train.label
x_train = train.drop('label', 1 ) | Digit Recognizer |
12,482,444 | scores_model = []<compute_test_metric> | train.isnull().values.any() | Digit Recognizer |
12,482,444 | scores_model.append({'Model': 'SimpleRNN','AUC_Score': roc_auc_score(y_pre,y_test)} )<choose_model_class> | x_train = x_train/255.0
test = test/255.0 | Digit Recognizer |
12,482,444 | model=Sequential()
embedding=Embedding(num_words,100,embeddings_initializer=Constant(embedding_matrix),
input_length=MAX_LEN,trainable=False)
model.add(embedding)
model.add(SpatialDropout1D(0.2))
model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(1, activation='sigmoid'))
optimzer=Adam(learning_... | y_train = to_categorical(y_train, num_classes = 10 ) | Digit Recognizer |
12,482,444 | history=model.fit(X_train,y_train,batch_size=4,epochs=10,validation_data=(X_test,y_test),verbose=2 )<predict_on_test> | x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, test_size = 0.1, random_state=2)
| Digit Recognizer |
12,482,444 | y_pre=model.predict(X_test)
y_pre=np.round(y_pre ).astype(int ).reshape(1142 )<compute_test_metric> | model = Sequential()
model.add(Conv2D(64,kernel_size=5,padding = 'Same',activation='relu',input_shape=(28,28,1)))
model.add(Conv2D(64,kernel_size=5,padding = 'Same',activation='relu'))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))
model.add(Dropout(0.40))
model.add(Conv2D(64,kernel_size=3,padding = 'Same',acti... | Digit Recognizer |
12,482,444 | print(roc_auc_score(y_pre,y_test))<compute_test_metric> | epochs = 30
batch_size = 100 | Digit Recognizer |
12,482,444 | scores_model.append({'Model': 'LSTM','AUC_Score': roc_auc_score(y_pre,y_test)} )<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 |
12,482,444 | model=Sequential()
embedding=Embedding(num_words,100,embeddings_initializer=Constant(embedding_matrix),
input_length=MAX_LEN,trainable=False)
model.add(embedding)
model.add(SpatialDropout1D(0.2))
model.add(GRU(300))
model.add(Dense(1, activation='sigmoid'))
optimzer=Adam(learning_rate=1e-5)
model.compile(loss='binar... | LR_reduction = ReduceLROnPlateau(monitor='val_accuracy',
patience = 2,
verbose = 1,
factor = 0.5,
min_lr = 0.00001 ) | Digit Recognizer |
12,482,444 | history=model.fit(X_train,y_train,batch_size=8,epochs=10,validation_data=(X_test,y_test),verbose=2 )<predict_on_test> | model.fit_generator(datagen.flow(x_train, y_train, batch_size = batch_size),
epochs = epochs, validation_data =(x_val,y_val), steps_per_epoch=x_train.shape[0] // batch_size, callbacks=[LR_reduction] ) | Digit Recognizer |
12,482,444 | <choose_model_class><EOS> | results = model.predict(test)
results = np.argmax(results, axis = 1)
results = pd.Series(results, name="Label")
submission = pd.concat([pd.Series(range(1,28001), name = "ImageId"), results], axis = 1)
submission.to_csv("submission.csv", index=False ) | Digit Recognizer |
12,477,197 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<train_model> | import os
import random
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Adam
from torch.utils.data import DataLoader
from torchvision import transforms
import numpy as np
import matplotlib.pyplot as plt
from torch.nn import CrossEntropyLoss
from tqdm import tqdm
from collectio... | Digit Recognizer |
12,477,197 | history=model.fit(X_train,y_train,batch_size=4,epochs=5,validation_data=(X_test,y_test),verbose=2 )<compute_train_metric> | root = "/kaggle/input/digit-recognizer"
train_data = np.loadtxt(os.path.join(root,"train.csv"),delimiter=",",skiprows=1)
test_data = np.loadtxt(os.path.join(root,"test.csv"),delimiter=",",skiprows=1 ) | Digit Recognizer |
12,477,197 | y_pre=model.predict(X_test)
y_pre=np.round(y_pre ).astype(int ).reshape(1142)
print(roc_auc_score(y_pre,y_test))<compute_test_metric> | !nvidia-smi | Digit Recognizer |
12,477,197 | scores_model.append({'Model': 'Bidirectional-LSTM','AUC_Score': roc_auc_score(y_pre,y_test)} )<load_from_url> | class Dataset:
def __init__(self,data,targets,transform=None):
self.data = data
self.targets = targets
self.transform = transform
def __len__(self):
return len(self.data)
def __getitem__(self,idx):
if self.transform == None:
return self.data[idx],self.targets[idx]
else:
return self.transform(self.data[idx]),self.tar... | Digit Recognizer |
12,477,197 | !wget --quiet https://raw.githubusercontent.com/tensorflow/models/master/official/nlp/bert/tokenization.py<import_modules> | transform = transforms.Compose([transforms.ToPILImage() ,
transforms.RandomResizedCrop(size=28,scale=(0.9,1.0),ratio=(0.9,1,15)) ,
transforms.RandomAffine(degrees=12,translate=(1/7,1/7),shear=12),
transforms.RandomRotation(degrees=12),
transforms.ToTensor() ])
x_train = train_data[:,1:].reshape(-1,28,28 ).astype(np.ui... | Digit Recognizer |
12,477,197 | import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras.layers import Dense, Input
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.models import Model
from tensorflow.keras.callbacks import ModelCheckpoint
import tensorflow_hub as hub
import tokenization<categorify> | class CNN(nn.Module):
def __init__(self):
super(CNN,self ).__init__()
self.layer1 = self.get_conv_block(1,64)
self.layer2 = self.get_conv_block(64,128,paddings=(0,1))
self.layer3 = self.get_conv_block(128,256)
self.fc1 = nn.Linear(256*3*3,2048)
self.fc2 = nn.Linear(2048,512)
self.fc3 = nn.Linear(512,10)
def forwar... | Digit Recognizer |
12,477,197 | 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... | device = torch.device("cuda")if torch.cuda.is_available() else torch.device("cpu")
random.seed(1234)
np.random.seed(1234)
torch.random.manual_seed(1234)
epochs = 80
batch_size = 512
trainloader = DataLoader(train_dataset,batch_size,shuffle=True,pin_memory=True)
def train(dataloader,net,optimizer,loss_fn,epochs=50)... | Digit Recognizer |
12,477,197 | 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, ... | cnn.eval()
train_dataset.transform = transforms.ToTensor()
trainloader = DataLoader(train_dataset,batch_size=512,shuffle=False,pin_memory=True)
train_preds = []
for cnn in models:
train_pred = []
with torch.no_grad() :
for x,_ in trainloader:
out = cnn(x.to(device))
pred = out.max(dim=1)[1]
train_pred.append(pred.deta... | Digit Recognizer |
12,477,197 | %%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 )<load_from_csv> | x_test = test_data.reshape(-1,1,28,28)
x_test = torch.Tensor(x_test)/255.
test_preds = []
for cnn in models:
test_pred = []
with torch.no_grad() :
for i in range(0,len(x_test),batch_size):
out = cnn(x_test[i:i+batch_size].to(device))
pred = out.max(dim=1)[1]
test_pred.append(pred.detach().cpu().numpy())
test_preds.a... | Digit Recognizer |
12,477,197 | train = pd.read_csv(".. /input/nlp-getting-started/train.csv")
test = pd.read_csv(".. /input/nlp-getting-started/test.csv")
submission = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
<feature_engineering> | imageid = pd.Series(np.arange(len(test_pred)))+1
df = pd.DataFrame({"ImageId":imageid,"Label":test_pred})
df.set_index("ImageId")
df.to_csv("/kaggle/working/test_pred.csv",index=False ) | Digit Recognizer |
12,506,433 | vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = tokenization.FullTokenizer(vocab_file, do_lower_case )<categorify> | %matplotlib inline
| Digit Recognizer |
12,506,433 | train_input = bert_encode(train.text.values, tokenizer, max_len=160)
test_input = bert_encode(test.text.values, tokenizer, max_len=160)
train_labels = train.target.values<train_model> | train_data = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
train_data.head() | Digit Recognizer |
12,506,433 | 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
)<predict_on_test> | test_data = pd.read_csv("/kaggle/input/digit-recognizer/test.csv")
test_data.head() | Digit Recognizer |
12,506,433 | model.load_weights('model.h5')
test_pred = model.predict(test_input )<save_to_csv> | from sklearn.model_selection import train_test_split | Digit Recognizer |
12,506,433 | submission['target'] = test_pred.round().astype(int)
submission.to_csv('submission.csv', index=False )<load_from_csv> | from sklearn.model_selection import train_test_split | Digit Recognizer |
12,506,433 | train = pd.read_csv('/kaggle/input/nlp-getting-started/train.csv')
test = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv')
print(train.shape, test.shape)
train.sample(10, random_state=26 )<feature_engineering> | y = train_data['label']
| Digit Recognizer |
12,506,433 | def preprocess(df):
df_new = df.copy(deep=True)
df_new['text'] = df.apply(lambda row: re.sub('@[A-z0-9]', '', row['text'] ).lower() , axis=1)
df_new['text_w_kword'] = df_new.apply(lambda row: 'keyword: ' + str(row['keyword'])+ '.'+ str(row['text']), axis=1)
return df_new
train_prep = preprocess(train)
test_prep = p... | df_train = train_data.drop(['label'], axis=1 ) | Digit Recognizer |
12,506,433 | X_train, X_valid, y_train, y_valid = train_test_split(train_prep['text_w_kword'],
train_prep['target'],
test_size=0.1,
random_state=1 )<load_pretrained> | from sklearn import preprocessing
from sklearn.model_selection import train_test_split
import sklearn.metrics as metrics | Digit Recognizer |
12,506,433 | tokenizer = DistilBertTokenizerFast.from_pretrained('/kaggle/input/huggingface-bert-variants/distilbert-base-uncased/distilbert-base-uncased/')
train_encodings = tokenizer(list(X_train), truncation=True, padding='max_length', max_length=100)
valid_encodings = tokenizer(list(X_valid), truncation=True, padding='max_len... | df_train = df_train/255
df_train[0:5] | Digit Recognizer |
12,506,433 | train_dataset = tf.data.Dataset.from_tensor_slices((
dict(train_encodings),
y_train.values.astype('float32' ).reshape(( -1,1))
))
valid_dataset = tf.data.Dataset.from_tensor_slices((
dict(valid_encodings),
y_valid.values.astype('float32' ).reshape(( -1,1))
))
train_dataset<choose_model_class> | y = to_categorical(y, num_classes = 10)
y.shape | Digit Recognizer |
12,506,433 | es = EarlyStopping(monitor='val_loss',
verbose=1,
patience=4,
restore_best_weights=True )<choose_model_class> | X_train, X_test, y_train, y_test = train_test_split(df_train, y, test_size = 0.1, random_state=42, stratify=y ) | Digit Recognizer |
12,506,433 | batch_size = 64
num_epochs = 15
num_train_steps =(X_train.shape[0] // batch_size)* num_epochs
lr_scheduler = PolynomialDecay(
initial_learning_rate=5e-5,
end_learning_rate=1e-5,
decay_steps=num_train_steps
)
new_opt = Adam(learning_rate=lr_scheduler )<compute_test_metric> | input_shape =(28,28,1)
X_input = Input(input_shape)
x = Conv2D(64,(3,3),strides=(1,1),name='layer_conv1',padding='same' )(X_input)
x = BatchNormalization()(x)
x = Activation('relu' )(x)
x = MaxPooling2D(( 2,2),name='maxPool1' )(x)
x = Conv2D(32,(3,3),strides=(1,1),name='layer_conv2',padding='same' )(x)
x = Batch... | Digit Recognizer |
12,506,433 | def f1_score(true, pred):
ground_positives = K.sum(true, axis=0)+ K.epsilon()
pred_positives = K.sum(pred, axis=0)+ K.epsilon()
true_positives = K.sum(true * pred, axis=0)+ K.epsilon()
precision = true_positives / pred_positives
recall = true_positives / ground_positives
f1 = 2 *(precision * recall)/(precision + recall... | conv_model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])
conv_model.fit(X_train, y_train, epochs=10, batch_size=100, validation_data=(X_test,y_test)) | Digit Recognizer |
12,506,433 | model = TFDistilBertForSequenceClassification.from_pretrained('/kaggle/input/huggingface-bert-variants/distilbert-base-uncased/distilbert-base-uncased/',
num_labels=2)
model.compile(
optimizer=new_opt,
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
)
history = model.fit(train_dataset.batch(batc... | sgd = SGD(lr=0.0005, momentum=0.5, decay=0.0, nesterov=False)
conv_model.compile(optimizer=sgd,loss='categorical_crossentropy',metrics=['accuracy'])
conv_model.fit(X_train, y_train, epochs=30, validation_data=(X_test, y_test)) | Digit Recognizer |
12,506,433 | test_encodings = tokenizer(list(test_prep['text_w_kword']), truncation=True, padding='max_length', max_length=100)
test_dataset = tf.data.Dataset.from_tensor_slices((
dict(test_encodings)
))<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 |
12,506,433 | test_preds = model.predict(test_dataset.batch(1))<prepare_output> | hist = conv_model.fit_generator(datagen.flow(X_train,y_train),
epochs = 1, validation_data =(X_test,y_test),
verbose = 2)
| Digit Recognizer |
12,506,433 | class_preds = np.argmax(test_preds.logits, axis=1)
class_preds<predict_on_test> | data_generator = ImageDataGenerator(rescale=1./255,
rotation_range=1,
zoom_range=0.1,
width_shift_range=0.05,
height_shift_range=0.05)
data_generator.fit(X_train)
| Digit Recognizer |
12,506,433 | valid_preds = model.predict(valid_dataset.batch(batch_size))<prepare_output> | df_test = test_data/255
df_test[0:5] | Digit Recognizer |
12,506,433 | valid_class_preds = np.argmax(valid_preds.logits, axis=1 )<compute_test_metric> | results = conv_model.predict(df_test)
results = np.argmax(results,axis=1)
my_submission = pd.DataFrame({'ImageId': list(range(1, len(results)+1)) , 'Label': results})
my_submission.to_csv('submission.csv', index=False ) | Digit Recognizer |
12,506,433 | <create_dataframe><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("cnn_mnist_datagen.csv",index=False)
print("Your submission was successfully saved!")
| Digit Recognizer |
12,403,998 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<save_to_csv> | import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense, Conv2D , MaxPool2D , Flatten , Dropout , BatchNormalization
from keras.preprocessing.... | Digit Recognizer |
12,403,998 | df_submission.to_csv('submission.csv', index=False )<import_modules> | train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
12,403,998 | print(tf.__version__ )<import_modules> | train_Y = np.array(train["label"])
train_Y = np_utils.to_categorical(train_Y, num_classes = 10 ) | Digit Recognizer |
12,403,998 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from tensorflow import keras
import cv2
import PIL
import os
import pathlib
import shutil
from IPython.display import Image, display
import plotly.graph_objs as go
import plotly.graph_objects as go
from sklearn.metrics import cohen_kappa_score
from ... | train_X = np.array(train.iloc[:, 1:])
test_X = np.array(test ) | Digit Recognizer |
12,403,998 | train_dir = '.. /input/dog-breed-dataset-with-subdirectories-by-class/data/train'
test_dir = '.. /input/dog-breed-dataset-with-subdirectories-by-class/data/test'
train_labels = pd.read_csv('.. /input/dog-breed-identification/labels.csv', index_col = 'id')
submission=pd.read_csv('.. /input/dog-breed-identification/samp... | train_X, valid_X, train_Y, valid_Y = train_test_split(train_X, train_Y, shuffle=True, test_size = 0.1, random_state=2, stratify=train_Y ) | Digit Recognizer |
12,403,998 | target, dog_breeds = pd.factorize(train_labels['breed'], sort = True)
train_labels['target'] = target
print(dog_breeds )<count_values> | 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(tra... | Digit Recognizer |
12,403,998 | train_labels['breed'].value_counts()<define_variables> | nets = 5
model = [0] *nets
for i in range(nets):
model[i] = Sequential()
model[i].add(Conv2D(32, kernel_size = 3, activation='relu', input_shape =(28, 28, 1)))
model[i].add(BatchNormalization())
model[i].add(Conv2D(32, kernel_size = 3, activation='relu'))
model[i].add(BatchNormalization())
model[i].add(Conv2D(32, ke... | Digit Recognizer |
12,403,998 | N_EPOCHS = 50
BATCH_SIZE = 128
IMG_HEIGHT = 331
IMG_WIDTH = 331<create_dataframe> | annealer = LearningRateScheduler(lambda x: 1e-3 * 0.95 ** x)
history = [0] * nets
epochs = 45
for j in range(nets):
print("CNN ",j+1)
history[j] = model[j].fit_generator(datagen.flow(train_X, train_Y, batch_size=64),
epochs = epochs, steps_per_epoch = train_X.shape[0]//64,
validation_data =(valid_X, valid_Y), callbac... | Digit Recognizer |
12,403,998 | train_ds = image_dataset_from_directory(
directory = train_dir,
labels = 'inferred',
label_mode='int',
batch_size=BATCH_SIZE,
image_size=(IMG_HEIGHT, IMG_WIDTH),
shuffle = True,
seed=1234,
validation_split=0.1,
subset="training",
)<define_variables> | results = np.zeros(( test_X.shape[0],10))
for j in range(nets):
results = results + model[j].predict(test_X)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("submission.csv",index=... | Digit Recognizer |
13,307,296 | class_names = train_ds.class_names
print(len(class_names))
print(class_names )<create_dataframe> | df_train=pd.read_csv(".. /input/digit-recognizer/train.csv")
df_train.head() | Digit Recognizer |
13,307,296 | val_ds = image_dataset_from_directory(
directory = train_dir,
labels = 'inferred',
label_mode='int',
batch_size=BATCH_SIZE,
image_size=(IMG_HEIGHT, IMG_WIDTH),
shuffle = True,
seed=1234,
validation_split=0.1,
subset="validation",
)<create_dataframe> | df_train = shuffle(df_train ) | Digit Recognizer |
13,307,296 | test_ds = image_dataset_from_directory(
directory = test_dir,
label_mode= None,
batch_size=BATCH_SIZE,
image_size=(IMG_HEIGHT, IMG_WIDTH),
shuffle = False,
seed=1234
)<drop_column> | X=df_train.drop(["label"],axis=1)
y=df_train["label"] | Digit Recognizer |
13,307,296 | del class_names<data_type_conversions> | y.value_counts(normalize=True ) | Digit Recognizer |
13,307,296 | plt.figure(figsize=(20, 20))
for images, labels in train_ds.take(1):
for i in range(16):
ax = plt.subplot(4, 4, i + 1)
plt.imshow(images[i].numpy().astype("uint8"))
plt.title(dog_breeds[labels[i]])
plt.axis("off" )<data_type_conversions> | from tensorflow.keras.layers import Conv2D,Dense,Reshape,MaxPool2D,Dropout
from tensorflow.keras.models import Sequential | Digit Recognizer |
13,307,296 | plt.figure(figsize=(20, 20))
for images, labels in val_ds.take(1):
for i in range(16):
ax = plt.subplot(4, 4, i + 1)
plt.imshow(images[i].numpy().astype("uint8"))
plt.title(dog_breeds[labels[i]])
plt.axis("off" )<data_type_conversions> | from tensorflow.keras.layers import Flatten | Digit Recognizer |
13,307,296 | plt.figure(figsize=(20, 20))
for images in test_ds.take(1):
for i in range(16):
ax = plt.subplot(4, 4, i + 1)
plt.imshow(images[i].numpy().astype("uint8"))
plt.axis("off" )<load_pretrained> | import tensorflow as tf | Digit Recognizer |
13,307,296 | AUTOTUNE = tf.data.AUTOTUNE
train_ds = train_ds.prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.prefetch(buffer_size=AUTOTUNE)
test_ds = test_ds.prefetch(buffer_size=AUTOTUNE)
<choose_model_class> | model=Sequential()
model.add(Reshape(( 28,28,1),input_shape=(784,)))
model.add(Conv2D(64,(3,3),activation="relu",kernel_initializer="he_uniform"))
model.add(Dropout(0.5))
model.add(MaxPool2D(pool_size=(2,2),strides=2))
model.add(Conv2D(64,(5,5),activation="relu",kernel_initializer="he_uniform"))
model.add(Dropout(0.5)... | Digit Recognizer |
13,307,296 | data_augmentation = Sequential(
[
preprocessing.RandomFlip("horizontal"),
preprocessing.RandomRotation(0.1),
preprocessing.RandomZoom(0.1),
]
)<choose_model_class> | model.fit(tf.cast(X,tf.float32)/255.0,tf.cast(y,tf.float32),validation_split=0.3,batch_size=100,verbose=2,epochs=100)
| Digit Recognizer |
13,307,296 | base_model_1 = xception.Xception(weights='imagenet', include_top=False, input_shape=(IMG_HEIGHT, IMG_WIDTH,3))
base_model_2 = inception_v3.InceptionV3(weights='imagenet', include_top=False, input_shape=(IMG_HEIGHT, IMG_WIDTH,3))
base_model_3 = inception_resnet_v2.InceptionResNetV2(weights='imagenet', include_top=False,... | df_test=pd.read_csv(".. /input/digit-recognizer/test.csv")
df_test.head() | Digit Recognizer |
13,307,296 | optimizer = Adam(learning_rate=0.001)
model.compile(loss="sparse_categorical_crossentropy", metrics=['accuracy'], optimizer=optimizer )<choose_model_class> | submit=pd.DataFrame(columns=["ImageId","Label"] ) | Digit Recognizer |
13,307,296 | EarlyStop_callback = EarlyStopping(min_delta=0.001, patience=10, restore_best_weights=True)
<train_model> | submit["ImageId"]=df_test.index.values
submit["ImageId"]=submit["ImageId"]+1
submit | Digit Recognizer |
13,307,296 | history = model.fit(
train_ds,
epochs=N_EPOCHS,
validation_data=val_ds,
callbacks=[EarlyStop_callback]
)<predict_on_test> | import numpy as np | Digit Recognizer |
13,307,296 | wrong_pred_images = np.array([])
actual_labels = np.array([])
predicted_labels = np.array([])
batch = 1
for images, labels in val_ds:
batch_predictions_probs = model.predict_on_batch(images)
batch_predictions = np.argmax(batch_predictions_probs, axis=1)
mask =(batch_predictions != labels.numpy())
print("No of wro... | output=model.predict(tf.cast(df_test,tf.float32)/255.0)
output | Digit Recognizer |
13,307,296 | predictions = model.predict(
test_ds,
batch_size = BATCH_SIZE,
verbose=1
)<prepare_output> | prediction=np.argmax(output,axis=1)
len(prediction ) | Digit Recognizer |
13,307,296 | submission.loc[:, dog_breeds] = predictions
submission.head()<save_to_csv> | submit["Label"]=prediction
submit | Digit Recognizer |
13,307,296 | submission.to_csv('submission.csv', index=False)
<import_modules> | submit.to_csv("digit_submission",index=False ) | Digit Recognizer |
13,330,495 | import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from tensorflow import keras
from keras.preprocessing.image import ImageDataGenerator as Imgen
from keras.models import Sequential,load_model
from keras.layers import Conv2D,MaxPooling2D,Flatten,Dense,GlobalAveragePooling2D,Dropout
from ke... | import os
import numpy as np
import glob
import shutil
import pandas as pd;
import matplotlib.pyplot as plt | Digit Recognizer |
13,330,495 | labels = pd.read_csv(".. /input/dog-breed-identification/labels.csv")
sample_sub = pd.read_csv(".. /input/dog-breed-identification/sample_submission.csv")
labels.head()<feature_engineering> | import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.callbacks import EarlyStopping
from tensorflow.keras import regularizers
from keras.layers.normalization import BatchNormalization | Digit Recognizer |
13,330,495 | def addjpg(id):
return id+".jpg"<feature_engineering> | train_full = pd.read_csv(".. /input/digit-recognizer/train.csv")
test= pd.read_csv(".. /input/digit-recognizer/test.csv")
train_full.head() | Digit Recognizer |
13,330,495 | labels['id'] = labels['id'].apply(addjpg)
sample_sub['id'] = sample_sub['id'].apply(addjpg )<choose_model_class> | train = train_full.sample(frac=0.8, random_state=0)
val = train_full.drop(train.index ) | Digit Recognizer |
13,330,495 | data = Imgen(preprocessing_function=keras.applications.nasnet.preprocess_input,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
validation_split=0.1
)<prepare_x_and_y> | X_full =(train_full.iloc[:,1:].values ).astype('float32')
y_full = train_full.iloc[:,0].values.astype('int32')
X_train =(train.iloc[:,1:].values ).astype('float32')
y_train = train.iloc[:,0].values.astype('int32')
X_val =(val.iloc[:,1:].values ).astype('float32')
y_val = val.iloc[:,0].values.astype('int32')
X_tes... | Digit Recognizer |
13,330,495 | train_ds = data.flow_from_dataframe(
labels,
directory = '.. /input/dog-breed-identification/train',
x_col = 'id',
y_col = 'breed',
subset="training",
color_mode="rgb",
target_size =(331,331),
class_mode="categorical",
batch_size=32,
shuffle=True,
seed=123,
)
val_ds = data.flow_from_dataframe(
labels,
directory = '... | BATCH_SIZE = 100 | Digit Recognizer |
13,330,495 | x,y = next(train_ds)
x.shape<import_modules> | image_gen_train = ImageDataGenerator(
rescale=1./255,
rotation_range=20,
horizontal_flip=False,
fill_mode='nearest')
train_data_gen = image_gen_train.flow(X_train, y_train, batch_size=BATCH_SIZE,
shuffle=True)
full_data_gen = image_gen_train.flow(X_full, y_full, batch_size=BATCH_SIZE,
shuffle=True ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.