kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
12,242,884 | class BERTClass(torch.nn.Module):
def __init__(self, drop_rate, otuput_size):
super().__init__()
model_config = BertConfig.from_pretrained('.. /input/bert-base-uncased', output_hidden_states=True)
self.bert = BertModel.from_pretrained('.. /input/bert-base-uncased', config=model_config)
self.drop = torch.nn.Dropout(dr... | from tensorflow.keras.preprocessing.image import ImageDataGenerator | Digit Recognizer |
12,242,884 | def calculate_loss_and_accuracy(model, criterion, loader, device):
model.eval()
loss = 0.0
total = 0
correct = 0
with torch.no_grad() :
for data in loader:
ids = data['ids'].to(device)
mask = data['mask'].to(device)
labels = data['labels'].to(device)
outputs = model(ids, mask)
loss += criterion(outputs, labels ).... | image_gen = ImageDataGenerator(rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.1,
zoom_range=0.1,
horizontal_flip=False,
vertical_flip=False,
) | Digit Recognizer |
12,242,884 | DROP_RATE = 0.4
OUTPUT_SIZE = 1
BATCH_SIZE = 32
NUM_EPOCHS = 2
LEARNING_RATE = 2e-5
model = BERTClass(DROP_RATE, OUTPUT_SIZE)
criterion = torch.nn.BCEWithLogitsLoss()
optimizer = torch.optim.AdamW(params=model.parameters() , lr=LEARNING_RATE)
device = 'cuda' if cuda.is_available() else 'cpu'
log = train_model(dataset... | from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPool2D, Flatten, Dense, Dropout, BatchNormalization | Digit Recognizer |
12,242,884 | test_csv["cleaned_text"] = test_csv["text"].map(clean)
test_csv.head()<categorify> | model = Sequential()
model.add(Conv2D(filters=32, kernel_size=(5,5), input_shape=(28, 28, 1), padding="same", activation="relu"))
model.add(BatchNormalization())
model.add(Conv2D(filters=32, kernel_size=(5,5), input_shape=(28, 28, 1), padding="same", activation="relu"))
model.add(BatchNormalization())
model.add(MaxPo... | Digit Recognizer |
12,242,884 | class TestDataset(Dataset):
def __init__(self, X, tokenizer, max_len):
self.X = X
self.tokenizer = tokenizer
self.max_len = max_len
def __len__(self):
return len(self.X)
def __getitem__(self, index):
text = self.X[index]
inputs = self.tokenizer.encode_plus(
text,
add_special_tokens=True,
max_length=self.max_len,
trun... | from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau | Digit Recognizer |
12,242,884 | max_len = 45
dataset_test = TestDataset(test_csv["cleaned_text"].values, tokenizer, max_len )<categorify> | check_point = ModelCheckpoint("best_model.h5", monitor="val_accuracy", verbose=1, save_best_only=True ) | Digit Recognizer |
12,242,884 | loader = DataLoader(dataset_test, batch_size=len(dataset_test), shuffle=False)
model.eval()
with torch.no_grad() :
for data in loader:
ids = data['ids'].to(device)
mask = data['mask'].to(device)
outputs = model.forward(ids, mask)
pred = torch.round(torch.sigmoid(outputs)).cpu().numpy()<load_from_csv> | reduce_lr = ReduceLROnPlateau(monitor="val_accuracy", patience=3, verbose=1, factor=0.5, min_lr=0.0001 ) | Digit Recognizer |
12,242,884 | submit_csv =pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
submit_csv.head()<data_type_conversions> | Digit Recognizer | |
12,242,884 | submit_csv['target'] = pred.astype('int64')
submit_csv.head(10 )<save_to_csv> | history = model.fit_generator(image_gen.flow(X_train,y_train, batch_size=64),
epochs = 50, validation_data =(X_val,y_val),
verbose = 1,
callbacks=[check_point, reduce_lr] ) | Digit Recognizer |
12,242,884 | submit_csv.to_csv("submission2.csv",index = False )<install_modules> | losses = pd.DataFrame(model.history.history ) | Digit Recognizer |
12,242,884 | !pip install transformers==3.5.1
!pip install pyspellchecker
!pip install -U joblib textblob
!python -m textblob.download_corpora|<import_modules> | print("Accuracy on validation data: {:.4f}".format(losses["val_accuracy"].max())) | Digit Recognizer |
12,242,884 | import pandas as pd
import torchtext
from transformers import BertTokenizer, BertForMaskedLM, BertConfig
import transformers
import torch
from torch.utils.data import Dataset, DataLoader
from torch import optim
from torch import cuda
from sklearn.model_selection import train_test_split
import re
import string
from jobl... | from keras.models import load_model | Digit Recognizer |
12,242,884 | train_val_df = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test_df = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv" )<feature_engineering> | saved_model = load_model('best_model.h5' ) | Digit Recognizer |
12,242,884 | train_val_df = train_val_df.loc[:,["text","target"]]
test_df = test_df.loc[:,["text"]]
test_df["target"] = [0]*len(test_df["text"] )<prepare_output> | predictions = saved_model.predict_classes(X_test ) | Digit Recognizer |
12,242,884 | print(train_val_df)
print(test_df.head())
original_df = train_val_df.copy()<define_variables> | submission = pd.concat([pd.Series(range(1,28001), name ="ImageId"), submission], axis = 1 ) | Digit Recognizer |
12,242,884 | mispell_dict = {"aren't" : "are not",
"can't" : "cannot",
"couldn't" : "could not",
"couldnt" : "could not",
"didn't" : "did not",
"doesn't" : "does not",
"doesnt" : "does not",
"don't" : "do not",
"hadn't" : "had not",
"hasn't" : "has not",
"haven't" : "have not",
"havent" : "have not",
"he'd" : "he would",
"he'll" : ... | submission.to_csv("submission.csv", index=False ) | Digit Recognizer |
12,242,884 | print(train_val_df.loc[31])
print(original_df.loc[31] )<save_to_csv> | submission.to_csv("submission.csv", index=False ) | Digit Recognizer |
12,233,077 | test_df.to_csv("test.tsv", sep='\t', index=False, header=None)
print(test_df.shape)
train_val_df.to_csv("train_eval.tsv", sep='\t', index=False, header=None)
print(train_val_df.shape )<categorify> | import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt | Digit Recognizer |
12,233,077 | max_length = 50
def tokenizer_50(input_text):
return tokenizer.encode(input_text, max_length=50, return_tensors='pt')[0]
TEXT = torchtext.data.Field(sequential=True, tokenize=tokenizer_50, use_vocab=False, lower=False,
include_lengths=True, batch_first=True, fix_length=max_length, pad_token=0)
LABEL = torchtext.data... | test_data=pd.read_csv('.. /input/digit-recognizer/test.csv')
train_data=pd.read_csv('.. /input/digit-recognizer/train.csv' ) | Digit Recognizer |
12,233,077 | tokenizer = BertTokenizer.from_pretrained('bert-base-cased' )<load_from_csv> | training=np.array(train_data,dtype='float32')
testing=np.array(test_data,dtype='float32' ) | Digit Recognizer |
12,233,077 | dataset_train_eval, dataset_test = torchtext.data.TabularDataset.splits(path='.', train='./train_eval.tsv', test='./test.tsv', format='tsv', fields=[('Text', TEXT),('Label', LABEL)] )<split> | x_train=training[:,1:]/255
y_train=training[:,0] | Digit Recognizer |
12,233,077 | dataset_train, dataset_eval = dataset_train_eval.split(
split_ratio=1.0 - 1800/7613, random_state=random.seed(1234))
print(dataset_train.__len__())
print(dataset_eval.__len__())
print(dataset_test.__len__() )<data_type_conversions> | x_test=testing[:,0:]/255 | Digit Recognizer |
12,233,077 | print(tokenizer.convert_ids_to_tokens(item.Text.tolist()))
print(int(item.Label))<define_variables> | y_train_cat=to_categorical(y_train ) | Digit Recognizer |
12,233,077 | batch_size = 32
dl_train = torchtext.data.Iterator(
dataset_train, batch_size=batch_size, train=True)
dl_eval = torchtext.data.Iterator(
dataset_eval, batch_size=batch_size, train=False, sort=False)
dl_test = torchtext.data.Iterator(
dataset_test, batch_size=batch_size, train=False, sort=False)
dataloaders_dict =... | model =Sequential()
model.add(Conv2D(64,kernel_size=(3, 3),activation='relu',input_shape=(28, 28, 1)))
model.add(Conv2D(64,kernel_size=(3, 3),activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(BatchNormalization())
model.add(Dropout(0.25))
model.add(Conv2D(filters = 128, kernel_size =(3,3),activ... | Digit Recognizer |
12,233,077 | model = BertModel.from_pretrained('bert-base-cased' )<set_options> | model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.RMSprop() ,
metrics=['accuracy'])
learning_rate_reduction = ReduceLROnPlateau(monitor='accuracy',
patience=3,
verbose=1,
factor=0.3,
min_lr=0.0001 ) | Digit Recognizer |
12,233,077 | class BertForTwitter(nn.Module):
def __init__(self):
super(BertForTwitter, self ).__init__()
self.bert = model
self.cls = nn.Linear(in_features=768, out_features=2)
nn.init.normal_(self.cls.weight, std=0.02)
nn.init.normal_(self.cls.bias, 0)
def forward(self, input_ids):
result = self.bert(input_ids)
vec_0 = resu... | epochs_range = 60
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train,y_train_cat,batch_size=256,epochs=epochs_range ) | Digit Recognizer |
12,233,077 | net = BertForTwitter()
net.train()
print('ネットワーク設定完了' )<categorify> | y_pred=model.predict_classes(X_test ) | Digit Recognizer |
12,233,077 | for param in net.parameters() :
param.requires_grad = False
for param in net.bert.encoder.layer[-1].parameters() :
param.requires_grad = True
for param in net.cls.parameters() :
param.requires_grad = True<choose_model_class> | sample=pd.read_csv('.. /input/digit-recognizer/sample_submission.csv' ) | Digit Recognizer |
12,233,077 | optimizer = optim.Adam([
{'params': net.bert.encoder.layer[-1].parameters() , 'lr': 5e-5},
{'params': net.cls.parameters() , 'lr': 1e-4}
])
criterion = nn.CrossEntropyLoss()
<train_model> | temp=pd.DataFrame({'ImageId':sample['ImageId'],'Label':y_pred} ) | Digit Recognizer |
12,233,077 | def train_model(net, dataloaders_dict, criterion, optimizer, num_epochs):
max_acc = 0
Stop_flag = False
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("使用デバイス：", device)
print('-----start-------')
net.to(device)
torch.backends.cudnn.benchmark = True
batch_size = dataloaders_dict["trai... | csv_data=temp.to_csv('pred.csv',index=False ) | Digit Recognizer |
12,216,311 | num_epochs = 50
net_trained = train_model(net, dataloaders_dict,
criterion, optimizer, num_epochs=num_epochs )<load_from_csv> | %matplotlib inline
| Digit Recognizer |
12,216,311 | sample_submission = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
sample_submission["target"] = ans_list
sample_submission<save_to_csv> | train = pd.read_csv(".. /input/digit-recognizer/train.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
12,216,311 | sample_submission.to_csv("submission_plus.csv", index=False )<import_modules> | Y_train = train['label']
X_train = train.drop(labels=['label'], axis=1)
del train | Digit Recognizer |
12,216,311 | import pandas as pd
import numpy as np
import spacy
import re
import string<load_from_csv> | X_train = X_train / 255
test = test / 255 | Digit Recognizer |
12,216,311 | 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" )<categorify> | X_train = X_train.values.reshape(-1, 28, 28, 1)
test = test.values.reshape(-1, 28, 28, 1)
Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
12,216,311 | def clean_text(text):
text = str(text ).lower()
text = re.sub('[%s]' % re.escape(string.punctuation), '', text)
text = re.sub('
', '', text)
return text<feature_engineering> | model = Sequential()
model.add(Conv2D(input_shape=(28,28,1), kernel_size=(5,5),
filters=20, activation = "relu"))
model.add(MaxPooling2D(pool_size=(2,2), strides=2, padding='same'))
model.add(Conv2D(kernel_size=(5,5), filters=50, activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2), strides=2, padding='same'))
mo... | Digit Recognizer |
12,216,311 | train["text"] = train["text"].apply(lambda x:clean_text(x))
test["text"] = test["text"].apply(lambda x:clean_text(x))<count_unique_values> | model.compile(optimizer='adam', loss='categorical_crossentropy',
metrics=['accuracy'] ) | Digit Recognizer |
12,216,311 | len(train["keyword"].unique() )<count_unique_values> | history = model.fit(X_train, Y_train, validation_split=0.1,
epochs=100, batch_size=64 ) | Digit Recognizer |
12,216,311 | len(train["location"].unique() )<load_pretrained> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
12,216,311 | <define_variables><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),
results],axis = 1)
submission.to_csv("cnn_mnist_datagen20210209.csv",index=False ) | Digit Recognizer |
12,099,647 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<concatenate> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Conv2D, MaxPool2D, Flatten, Dropout, BatchNormalization
from keras.callbacks import EarlyStopping, ReduceLROnPlateau
fro... | Digit Recognizer |
12,099,647 | def concat_keyword_text(row):
return(str(row["text"])+ " " + str(row["keyword"]))<feature_engineering> | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
12,099,647 | train_samples = train.apply(concat_keyword_text, axis = 1)
train_samples.head()<init_hyperparams> | X_train = train.iloc[:,1:]
y_train = train.iloc[:,0] | Digit Recognizer |
12,099,647 | vectorizer = TextVectorization()
text_ds = tf.data.Dataset.from_tensor_slices(train_samples ).batch(128)
vectorizer.adapt(text_ds )<feature_engineering> | X_train = X_train.values.reshape(-1, 28, 28, 1)/255.
test = test.values.reshape(-1, 28, 28, 1)/255.
y_train = to_categorical(y_train, 10 ) | Digit Recognizer |
12,099,647 | voc = vectorizer.get_vocabulary()<define_variables> | datagen = ImageDataGenerator(
rotation_range=15,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1,
shear_range=0.2
) | Digit Recognizer |
12,099,647 | num_tokens = len(voc)
embedding_dim = len(nlp('The' ).vector)
embedding_matrix = np.zeros(( num_tokens, embedding_dim))<feature_engineering> | def create_model() :
model = Sequential()
model.add(Conv2D(32,(3,3), padding='same', input_shape=X_train.shape[1:], activation='relu'))
model.add(Conv2D(32,(3,3), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPool2D(2,2))
model.add(Dropout(0.2))
model.add(Conv2D(64,(3,3), padding='sa... | Digit Recognizer |
12,099,647 | for i, word in enumerate(voc):
embedding_matrix[i] = nlp(word ).vector<feature_engineering> | EPOCHS = 30
BATCH_SIZE = 50
ENSEMBLES = 5
result_list = []
histories = []
results = np.zeros(( test.shape[0],10))
callback_list = [
ReduceLROnPlateau(monitor='val_loss', factor=0.25, patience=2),
EarlyStopping(monitor='val_loss', min_delta=0.0005, patience=4)
]
for i in range(ENSEMBLES):
X_train_tmp, X_val, y_train_tm... | Digit Recognizer |
12,099,647 | <categorify><EOS> | 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 |
11,964,083 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<randomize_order> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Conv2D, MaxPool2D, Flatten, BatchNormalization, Dropout
from keras.callbacks import EarlyStopping, ReduceLROnPlateau
from keras.preprocessing.... | Digit Recognizer |
11,964,083 | df_train = train.sample(frac=0.7, random_state=0)
df_valid = train.drop(df_train.index )<prepare_x_and_y> | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
11,964,083 | X_train = df_train.drop(['target'], axis=1)
X_valid = df_valid.drop(['target'], axis=1)
y_train = df_train['target']
y_valid = df_valid['target']<data_type_conversions> | X_train = train.iloc[:,1:]
y_train = train.iloc[:,0] | Digit Recognizer |
11,964,083 | x_train = vectorizer(np.array([[s] for s in X_train["text"]])).numpy()
x_valid = vectorizer(np.array([[s] for s in X_valid["text"]])).numpy()<categorify> | X_train = X_train.values.reshape(-1, 28, 28, 1)/255.
test = test.values.reshape(-1, 28, 28, 1)/255.
y_train = to_categorical(y_train, 10 ) | Digit Recognizer |
11,964,083 | y_train_ = np_utils.to_categorical(y_train.values)
y_valid_ = np_utils.to_categorical(y_valid.values )<choose_model_class> | random_seed = 0
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.2, random_state=random_seed ) | Digit Recognizer |
11,964,083 | int_sequences_input = keras.Input(shape=(None,), dtype="int64")
embedded_sequences = embedding_layer(int_sequences_input)
x = layers.Conv1D(64, 5, activation="relu",padding='same' )(embedded_sequences)
x = layers.MaxPooling1D(3 )(x)
x = layers.Conv1D(32, 5, activation="relu",padding='same' )(x)
x = layers.MaxPooli... | datagen = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1
) | Digit Recognizer |
11,964,083 | early_stopping = callbacks.EarlyStopping(
min_delta=0.001,
patience=20,
restore_best_weights=True,
)
model.compile(
optimizer='adam',
loss='categorical_crossentropy',
metrics ='accuracy'
)
history = model.fit(
x_train, y_train_,
validation_data=(x_valid, y_valid_),
batch_size=128,
epochs=500,
callbacks=[early_st... | model = Sequential()
model.add(Conv2D(32,(5,5), padding='same', input_shape=X_train.shape[1:], activation='relu'))
model.add(Conv2D(32,(5,5), padding='same', activation='relu'))
model.add(MaxPool2D(2,2))
model.add(Conv2D(64,(3,3), padding='same', activation='relu'))
model.add(Conv2D(64,(3,3), padding='same', activation... | Digit Recognizer |
11,964,083 | x_test = vectorizer(np.array([[s] for s in test["text"]])).numpy()<predict_on_test> | model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'] ) | Digit Recognizer |
11,964,083 | predictions = model.predict(x_test )<load_from_csv> | EPOCHS = 30
BATCH_SIZE = 20
callback_list = [
ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=1),
EarlyStopping(monitor='val_loss', min_delta=0.0005, patience=4)
]
history = model.fit(datagen.flow(X_train, y_train, batch_size=BATCH_SIZE),
epochs=EPOCHS,
callbacks=callback_list,
validation_data=(X_val, y_val... | Digit Recognizer |
11,964,083 | sub = pd.read_csv('.. /input/nlp-getting-started/sample_submission.csv')
sub.head()<save_to_csv> | 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 |
8,042,252 | submission = pd.DataFrame({"id": test.iloc[:,0].values,"target": np.argmax(predictions,axis=1)})
submission.to_csv("submission.csv", index=False)
submission.head()<install_modules> | %%script false --no-raise-error
print(device_lib.list_local_devices())
| Digit Recognizer |
8,042,252 | !pip install transformers==3.5.1
!pip install pyspellchecker
!pip install -U joblib textblob
!python -m textblob.download_corpora<import_modules> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import time
from sklearn.model_selection import train_test_split, StratifiedKFold
from keras import backend as K
from keras.preprocessing.image import ImageDataGenerator
from keras.utils import to_categorical
from keras.models import Sequential, loa... | Digit Recognizer |
8,042,252 | import pandas as pd
import torchtext
from transformers import BertTokenizer, BertForMaskedLM, BertConfig
import transformers
import torch
from torch.utils.data import Dataset, DataLoader
from torch import optim
from torch import cuda
from sklearn.model_selection import train_test_split
import re
import string
from jobl... | gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
tf.config.experimental.set_visible_devices(gpus[0], 'GPU')
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
logical_gpus = tf.config.experimental.list_logical_devices('GPU')
print(len(gpus), "Physical GPUs,", len(logical_gp... | Digit Recognizer |
8,042,252 | train_val_df = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test_df = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv" )<feature_engineering> | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer//test.csv' ) | Digit Recognizer |
8,042,252 | train_val_df = train_val_df.loc[:,["text","target"]]
test_df = test_df.loc[:,["text"]]
test_df["target"] = [0]*len(test_df["text"] )<define_variables> | y = train.pop('label')
train_y = to_categorical(y)
train_X = train/255
test_X = test/255
train_X = train_X.to_numpy()
test_X = test_X.to_numpy() | Digit Recognizer |
8,042,252 | check_df = train_val_df<define_variables> | sub_test_X, sub_train_X, sub_test_y, sub_train_y = train_test_split(train_X, train_y,
train_size=0.2, stratify=train_y ) | Digit Recognizer |
8,042,252 | languages = ["de"]
parallel = Parallel(n_jobs=-1, backend="threading", verbose=5 )<categorify> | img_gen = ImageDataGenerator(rotation_range = 12, width_shift_range=.12, height_shift_range=.12,
zoom_range=.12 ) | Digit Recognizer |
8,042,252 | def translate_text(comment, language):
if hasattr(comment, "decode"):
comment = comment.decode("utf-8")
text = TextBlob(comment)
try:
text = text.translate(to=language)
sleep(2.0)
text = text.translate(to="en")
sleep(2.0)
except NotTranslated:
pass
return str(text )<save_to_csv> | def build_model(save = False):
model = Sequential()
model.add(Conv2D(32, kernel_size = 3, activation = 'relu', input_shape =(28,28,1)))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size = 3, activation = 'relu'))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size = 3, activation = 'relu'... | Digit Recognizer |
8,042,252 | comments_list = check_df["text"]
for language in languages:
print('Translate comments using "{0}" language'.format(language))
translated_data = parallel(delayed(translate_text )(comment, language)for comment in comments_list)
check_df['text'] = translated_data
result_path = os.path.join("train_val_" + language + ".csv... | num_models = 3
models = [0]*num_models
for i in range(num_models):
models[i] = build_model()
train_model(models[i],train_X, train_y)
| Digit Recognizer |
8,042,252 | train_val_de_df = pd.read_csv("./train_val_de.csv")
train_concat_df = train_val_de_df<concatenate> | prediction = np.zeros(( test_X.shape[0],10))
for i in range(len(models)) :
prediction += models[i].predict(test_X ) | Digit Recognizer |
8,042,252 | print(train_concat_df )<concatenate> | predict = np.argmax(prediction, axis =1)
predict = np.vstack(( np.arange(predict.shape[0])+1, predict)).T | Digit Recognizer |
8,042,252 | train_val_df = pd.concat([train_val_df,train_concat_df] )<load_pretrained> | submission = pd.DataFrame(data=predict, columns=['imageid', 'label'] ) | Digit Recognizer |
8,042,252 | tokenizer = BertTokenizer.from_pretrained('bert-base-cased' )<import_modules> | submission.to_csv('submit.csv',index=False ) | Digit Recognizer |
11,813,917 | print(torch.__version__ )<feature_engineering> | %matplotlib inline
| Digit Recognizer |
11,813,917 | def remove_URL(text):
url = re.compile(r'https?://\S+|www\.\S+')
return url.sub(r'', text)
train_val_df['text'] = train_val_df['text'].apply(lambda x : remove_URL(x))
test_df['text'] = test_df['text'].apply(lambda x : remove_URL(x))
def remove_html(text):
html = re.compile(r'<.*?>')
return html.sub(r'',text)
train_... | print("Tensorflow version " + tf.__version__)
np.random.seed(42 ) | Digit Recognizer |
11,813,917 | test_df.to_csv("test.tsv", sep='\t', index=False, header=None)
print(test_df.shape)
train_val_df.to_csv("train_eval.tsv", sep='\t', index=False, header=None)
print(train_val_df.shape)
<categorify> | try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
print('Running on TPU ', tpu.master())
except ValueError:
tpu = None
if tpu:
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.experimental.initialize_tpu_system(tpu)
strategy = tf.distribute.experimental.TPUStrategy(tpu)
else:
strategy = tf.distrib... | Digit Recognizer |
11,813,917 | max_length = 100
def tokenizer_100(input_text):
return tokenizer.encode(input_text, max_length=100, return_tensors='pt')[0]
TEXT = torchtext.data.Field(sequential=True, tokenize=tokenizer_100, use_vocab=False, lower=False,
include_lengths=True, batch_first=True, fix_length=max_length, pad_token=0)
LABEL = torchtext.... | train_data=pd.read_csv(".. /input/digit-recognizer/train.csv")
test_data=pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
11,813,917 | dataset_train_eval, dataset_test = torchtext.data.TabularDataset.splits(
path='.', train='./train_eval.tsv', test='./test.tsv', format='tsv', fields=[('Text', TEXT),('Label', LABEL)] )<data_type_conversions> | Y_train=train_data['label']
X_train=train_data.drop('label', axis=1 ) | Digit Recognizer |
11,813,917 | print(tokenizer.convert_ids_to_tokens(item.Text.tolist()))
print(int(item.Label))<define_variables> | ( x_train0, y_train0),(x_test0, y_test0)= mnist.load_data()
x_train1 = np.concatenate([x_train0, x_test0], axis=0)
y_train1 = np.concatenate([y_train0, y_test0], axis=0)
X_train_keras = x_train1.reshape(-1, 28*28)
Y_train_keras = y_train1 | Digit Recognizer |
11,813,917 | batch_size = 32
dl_train = torchtext.data.Iterator(
dataset_train, batch_size=batch_size, train=True)
dl_eval = torchtext.data.Iterator(
dataset_eval, batch_size=batch_size, train=False, sort=False)
dl_test = torchtext.data.Iterator(
dataset_test, batch_size=batch_size, train=False, sort=False)
dataloaders_dict =... | X_train = np.concatenate(( X_train.values, X_train_keras))
Y_train = np.concatenate(( Y_train, Y_train_keras)) | Digit Recognizer |
11,813,917 | print(transformers.__version__ )<load_pretrained> | unique, counts = np.unique(Y_train, return_counts=True)
dict(zip(unique, counts)) | Digit Recognizer |
11,813,917 | model = BertModel.from_pretrained('bert-base-cased' )<set_options> | X_train = X_train.astype('float32')
Y_train = Y_train.astype('float32')
test_data=test_data.astype('float32')
X_train = X_train / 255.0
test_data = test_data / 255.0 | Digit Recognizer |
11,813,917 | class BertForTwitter(nn.Module):
def __init__(self):
super(BertForTwitter, self ).__init__()
self.bert = model
self.cls = nn.Linear(in_features=768, out_features=9)
nn.init.normal_(self.cls.weight, std=0.02)
nn.init.normal_(self.cls.bias, 0)
def forward(self, input_ids):
result = self.bert(input_ids)
vec_0 = resu... | Y_train=to_categorical(Y_train, num_classes=10)
print(f"Label size {Y_train.shape}" ) | Digit Recognizer |
11,813,917 | net = BertForTwitter()
net.train()
print('ネットワーク設定完了' )<categorify> | X_train, X_val, Y_train, Y_val=train_test_split(X_train, Y_train, test_size=0.3, random_state=42)
| Digit Recognizer |
11,813,917 | for param in net.parameters() :
param.requires_grad = False
for param in net.bert.encoder.layer[-1].parameters() :
param.requires_grad = True
for param in net.cls.parameters() :
param.requires_grad = True<choose_model_class> | model= Sequential()
model.add(Conv2D(input_shape=(28,28,1), filters=32, kernel_size=(5,5), padding='Same', activation='relu'))
model.add(BatchNormalization())
model.add(Dropout(0.10))
model.add(Conv2D(filters=32, kernel_size=(5,5), padding='Same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPool2... | Digit Recognizer |
11,813,917 | optimizer = optim.Adam([
{'params': net.bert.encoder.layer[-1].parameters() , 'lr': 5e-5},
{'params': net.cls.parameters() , 'lr': 1e-4}
])
criterion = nn.CrossEntropyLoss()
<train_model> | optimizer=Adam(lr=0.001,decay=0.0 ) | Digit Recognizer |
11,813,917 | def train_model(net, dataloaders_dict, criterion, optimizer, num_epochs):
max_acc = 0
Stop_flag = False
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("使用デバイス：", device)
print('-----start-------')
net.to(device)
torch.backends.cudnn.benchmark = True
batch_size = dataloaders_dict["trai... | model.compile(optimizer= optimizer, loss='categorical_crossentropy', metrics=['accuracy'] ) | Digit Recognizer |
11,813,917 | num_epochs = 100
net_trained = train_model(net, dataloaders_dict,
criterion, optimizer, num_epochs=num_epochs )<load_from_csv> | learning_rate_redcuing=ReduceLROnPlateau(monitor='val_accuracy',
patience=5,
verbose=1,
factor=0.5,
min_lr=0.0001 ) | Digit Recognizer |
11,813,917 | sample_submission = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
sample_submission["target"] = ans_list
sample_submission<save_to_csv> | epochs = 30
batch_size = 32 | Digit Recognizer |
11,813,917 | sample_submission.to_csv("submission_plus.csv", index=False )<install_modules> | imagegen=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)
imagegen.fit(X_tra... | Digit Recognizer |
11,813,917 | !pip install nlpaug<load_pretrained> | history=model.fit_generator(imagegen.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_redcuing] ) | Digit Recognizer |
11,813,917 | !kaggle datasets download -d rtatman/glove-global-vectors-for-word-representation<install_modules> | model.save("MNIST_CNN_Model.h5")
model.save_weights("MNIST_CNN_Model_weights.h5" ) | Digit Recognizer |
11,813,917 | !pip install nltk
!pip install gensim<load_pretrained> | results = model.predict(test_data)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
11,813,917 | <load_from_url><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("sample_submission.csv",index=False)
submission.head() | Digit Recognizer |
12,714,797 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<set_options> | np.random.seed(2)
sns.set(style='white', context='notebook', palette='deep' ) | Digit Recognizer |
12,714,797 | plt.style.use('ggplot')
stop=set(stopwords.words('english'))
pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 1000)
plt.style.use('ggplot')
stop=set(stopwords.words('english'))
warnings.filterwarnings("ignore")
nltk.download('brown', quiet=True)
nltk... | train = pd.read_csv(".. /input/digit-recognizer/train.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
12,714,797 | df_train = pd.read_csv('.. /input/nlp-getting-started/train.csv', dtype={'id': np.int16, 'target': np.int8})
df_test = pd.read_csv('.. /input/nlp-getting-started/test.csv', dtype={'id': np.int16})
print('Training Set Shape = {}'.format(df_train.shape))
print('Training Set Memory Usage = {:.2f} MB'.format(df_train.mem... | Y_train = train["label"]
X_train = train.drop(labels = ["label"],axis = 1 ) | Digit Recognizer |
12,714,797 | print(f'Number of unique values in keyword = {df_train["keyword"].nunique() }(Training)- {df_test["keyword"].nunique() }(Test)')
print(f'Number of unique values in location = {df_train["location"].nunique() }(Training)- {df_test["location"].nunique() }(Test)' )<string_transform> | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
12,714,797 | def create_corpus(target):
corpus=[]
for x in df_train[df_train['target']==target]['text'].str.split() :
for i in x:
corpus.append(i)
return corpus<count_values> | Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
12,714,797 | counter=Counter(corpus)
most=counter.most_common()
x=[]
y=[]
for word,count in most[:40]:
if(word not in stop):
x.append(word)
y.append(count )<feature_engineering> | random_seed = 2 | Digit Recognizer |
12,714,797 | def get_top_tweet_bigrams(corpus, n=None):
vec = CountVectorizer(ngram_range=(2, 2)).fit(corpus)
bag_of_words = vec.transform(corpus)
sum_words = bag_of_words.sum(axis=0)
words_freq = [(word, sum_words[0, idx])for word, idx in vec.vocabulary_.items() ]
words_freq =sorted(words_freq, key = lambda x: x[1], reverse=Tru... | X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.15, random_state=random_seed ) | Digit Recognizer |
12,714,797 | df_train['word_count'] = df_train['text'].apply(lambda x: len(str(x ).split()))
df_test['word_count'] = df_test['text'].apply(lambda x: len(str(x ).split()))
df_train['unique_word_count'] = df_train['text'].apply(lambda x: len(set(str(x ).split())))
df_test['unique_word_count'] = df_test['text'].apply(lambda x: len(se... | model = Sequential()
DefaultConv2D = partial(keras.layers.Conv2D, kernel_size =(3,3),padding = 'Same', activation ='relu')
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 ='r... | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.