kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,988,485 | params = {
"C": [1e-3, 1e-2, 1e-1, 1],
"max_iter": [30000]
}
classifier = LinearSVC
classifier_df = trainClassifier(X_train, y_train, "LinearSVC", classifier, params, accuracy_score)
results = results.append(classifier_df )<train_model> | sns.set(style = 'white' , context = 'notebook' , palette = 'deep')
rcParams['figure.figsize'] = 10,6 | Digit Recognizer |
9,988,485 | params = {
"kernel" : ["rbf"],
"C": [1e-4, 1e-3, 1e-2, 1e-1, 1, 10],
"gamma": [1e-3, 1e-2, 1e-1, 1, 10]
}
classifier = SVC
classifier_df = trainClassifier(X_train, y_train, "SVC", classifier, params, accuracy_score)
results = results.append(classifier_df )<choose_model_class> | data_path = ".. /input/digit-recognizer/"
train = pd.read_csv(join(data_path,"train.csv"))
test = pd.read_csv(join(data_path,"test.csv")) | Digit Recognizer |
9,988,485 | params = {
"C": [1e-3, 1e-2, 1e-1, 1, 10]
}
classifier = LogisticRegression
classifier_df = trainClassifier(X_train, y_train, "LogisticRegression", classifier, params, accuracy_score)
results = results.append(classifier_df )<choose_model_class> | def process_data(data):
data = data/255.0
data = data.values.reshape(-1,28,28,1)
return data
X_train = process_data(X_train)
Y_train = to_categorical(Y_train,num_classes = 10 ) | Digit Recognizer |
9,988,485 | params = {"max_depth": [3, 5, 7, 10, None],
"n_estimators":[3, 5,10, 25, 50],
"max_features": [1, 2, "auto"]}
classifier = RandomForestClassifier
classifier_df = trainClassifier(X_train, y_train, "RandomForests", classifier, params, accuracy_score)
results = results.append(classifier_df )<prepare_output> | num = 5
model = [0]*num
for i in range(num):
model[i] = Sequential()
model[i].add(Conv2D(filters = 32, kernel_size =(5,5), padding = "same", activation = "relu", input_shape =(28,28,1)))
model[i].add(BatchNormalization())
model[i].add(Conv2D(filters = 32, kernel_size =(5,5), padding = "same", activation = "relu"))
mo... | Digit Recognizer |
9,988,485 | results = results.set_index("model_name")
results<save_to_csv> | 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... | Digit Recognizer |
9,988,485 | classifier = RandomForestClassifier
best_params = results.loc["RandomForests"]["parameters"]
submission_model = classifier(**best_params)
submission_model.fit(X_train, y_train)
X_test = pd.get_dummies(test_data[features])
X_test = imputer.transform(X_test)
X_test = scaler.transform(X_test)
y_hat = submission_model... | epochs = 32
batch_size = 256
history = [0]*num
for i in range(num):
random_seed = i
X_train_, X_val_, Y_train_, Y_val_ = train_test_split(X_train, Y_train, test_size = 0.2, random_state=random_seed)
learning_rate_reduction = ReduceLROnPlateau(monitor='val_accuracy',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001)
... | Digit Recognizer |
9,988,485 | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head()<load_from_csv> | def predict(X_data):
results = np.zeros(( X_data.shape[0],10))
for j in range(num):
results = results + model[j].predict(X_data)
return results | Digit Recognizer |
9,988,485 | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head()<create_dataframe> | test = process_data(test)
results = predict(test)
results = np.argmax(results,axis = 1 ) | Digit Recognizer |
9,988,485 | <define_variables><EOS> | results = pd.Series(results,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("keras_cnn_mnist_aug_ensemble2.csv",index=False ) | Digit Recognizer |
10,514,367 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | mnist_test = pd.read_csv(".. /input/mnist-in-csv/mnist_test.csv")
mnist_train = pd.read_csv(".. /input/mnist-in-csv/mnist_train.csv" ) | Digit Recognizer |
10,514,367 | num_pipeline = Pipeline([
("imputer", SimpleImputer(strategy = "median")) ,
("scaler", StandardScaler()),
] )<categorify> | sample_submission = pd.read_csv(".. /input/digit-recognizer/sample_submission.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv")
train = pd.read_csv(".. /input/digit-recognizer/train.csv" ) | Digit Recognizer |
10,514,367 | cat_pipeline = Pipeline([
("imputer", SimpleImputer(strategy = "most_frequent")) ,
("cat_encoder", OneHotEncoder(sparse = False)) ,
] )<feature_engineering> | test['dataset'] = 'test' | Digit Recognizer |
10,514,367 | preprocess_pipeline = ColumnTransformer([
("num", num_pipeline, num_attribs),
("cat", cat_pipeline, cat_attribs),
] )<normalization> | train['dataset'] = 'train' | Digit Recognizer |
10,514,367 | X_train = preprocess_pipeline.fit_transform(train_data[num_attribs + cat_attribs])
X_train<prepare_x_and_y> | dataset = pd.concat([train.drop('label', axis=1), test] ).reset_index() | Digit Recognizer |
10,514,367 | y_train = train_data["Survived"]<train_model> | mnist = pd.concat([mnist_train, mnist_test] ).reset_index(drop=True)
labels = mnist['label'].values
mnist.drop('label', axis=1, inplace=True)
mnist.columns = cols | Digit Recognizer |
10,514,367 | forest_clf = RandomForestClassifier(n_estimators = 100, random_state = 42)
forest_clf.fit(X_train, y_train )<predict_on_test> | idx_mnist = mnist.sort_values(by=list(mnist.columns)).index
dataset_from = dataset.sort_values(by=list(mnist.columns)) ['dataset'].values
original_idx = dataset.sort_values(by=list(mnist.columns)) ['index'].values | Digit Recognizer |
10,514,367 | X_test = preprocess_pipeline.fit_transform(test_data[num_attribs + cat_attribs])
y_pred = forest_clf.predict(X_test )<compute_train_metric> | for i in range(len(idx_mnist)) :
if dataset_from[i] == 'test':
sample_submission.loc[original_idx[i], 'Label'] = labels[idx_mnist[i]] | Digit Recognizer |
10,514,367 | forest_scores = cross_val_score(forest_clf, X_train, y_train, cv = 10)
forest_scores.mean()<compute_train_metric> | sample_submission.to_csv('submission.csv', index=False ) | Digit Recognizer |
9,959,337 | svm_clf = SVC(gamma = "auto")
svm_scores = cross_val_score(svm_clf, X_train, y_train, cv = 10)
svm_scores.mean()<predict_on_test> | %matplotlib inline | Digit Recognizer |
9,959,337 | svm_clf.fit(X_train, y_train)
y_pred = svm_clf.predict(X_test )<save_to_csv> | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv' ) | Digit Recognizer |
9,959,337 | output = pd.DataFrame({'PassengerId': test_data.index, 'Survived': y_pred})
output.to_csv('submission.csv', index = False)
print("Your submission was successfully saved!" )<install_modules> | X = train.drop('label', axis = 1)
y = train['label']
del train | Digit Recognizer |
9,959,337 | !pip install tensorflow_hub
!pip install bert-for-tf2
!pip install tensorflow
!pip install sentencepiece
!pip install transformers<feature_engineering> | X = X / 255.0
test = test / 255.0 | Digit Recognizer |
9,959,337 | BertTokenizer = bert.bert_tokenization.FullTokenizer
bert_layer = hub.KerasLayer("https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/1", trainable=False)
vocabulary_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
to_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = Ber... | labels = pd.get_dummies(y)
labels = labels.values | Digit Recognizer |
9,959,337 | stopwrds = set(stopwords.words('english'))
TAG_RE = re.compile(r'<[^>]+>')
def remove_tags(text):
return TAG_RE.sub('', text)
def preprocess_text(sen):
sentence = emoji.demojize(sen)
sentence = re.sub(r"http:\S+",'',sentence)
sentence = ' '.join([x for x in nltk.word_tokenize(sentence)if x not in stopwrds])
senten... | X_train, X_val, y_train, y_val = train_test_split(X, labels, test_size = 0.1,random_state=42 ) | Digit Recognizer |
9,959,337 | def tokenize_bert(data):
tokenized = data.apply(( lambda x: tokenizer.convert_tokens_to_ids(['[CLS]'])+ tokenizer.convert_tokens_to_ids(tokenizer.tokenize(x))))
return tokenized
def pad_mask(data_tokenized,max_len):
padded = tf.keras.preprocessing.sequence.pad_sequences(data_tokenized, maxlen=max_len, dtype='int32', pa... | from keras.preprocessing.image import ImageDataGenerator | Digit Recognizer |
9,959,337 | def encode(df):
tweet = tf.ragged.constant([tokenizer.convert_tokens_to_ids(tokenizer.tokenize(s)) for s in df])
cls1 = [tokenizer.convert_tokens_to_ids(['[CLS]'])]*tweet.shape[0]
input_word_ids = tf.concat([cls1, tweet], axis=-1)
input_mask = tf.ones_like(input_word_ids ).to_tensor()
type_cls = tf.zeros_like(cls1)
... | datagen = ImageDataGenerator(shear_range= 0.2, zoom_range= 0.2)
datagen.fit(X_train ) | Digit Recognizer |
9,959,337 | finetune_train = pd.read_csv('/kaggle/input/twitter-sentiment-analysis-hatred-speech/train.csv',encoding="utf-8")
finetune_test = pd.read_csv('/kaggle/input/twitter-sentiment-analysis-hatred-speech/test.csv',encoding="utf-8")
finetune_train["hashtags"]=finetune_train["tweet"].apply(lambda x:re.findall(r"
finetune_tes... | from keras.layers import Dropout, Conv2D, MaxPool2D, Dense, Flatten
from keras.models import Sequential | Digit Recognizer |
9,959,337 | train = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv",encoding="utf-8")
test = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv",encoding="utf-8")
train["hashtags"]=train["text"].apply(lambda x:re.findall(r"
test["hashtags"]=test["text"].apply(lambda x:re.findall(r"
train["hashtags"]=train["hashtag... | model = Sequential()
model.add(Conv2D(filters = 64, kernel_size = 5,activation ='relu', input_shape =(28,28,1)))
model.add(Conv2D(filters = 64, kernel_size = 5,activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.2))
model.add(Conv2D(filters = 32, kernel_size = 3,activation ='relu'))
model.a... | Digit Recognizer |
9,959,337 | finetune_train["clean"] = finetune_train["tweet"].apply(lambda x: preprocess_text(x.lower()))
finetune_test["clean"] = finetune_test["tweet"].apply(lambda x: preprocess_text(x.lower()))
print("length of finetune train set:",len(finetune_train))
print("length of finetune test set:",len(finetune_test))<data_type_conversi... | model.compile(optimizer= 'adam', loss= 'categorical_crossentropy', metrics= ['accuracy'] ) | Digit Recognizer |
9,959,337 | train["clean"] = train["text"].apply(lambda x: preprocess_text(x.lower()))
test["clean"] = test["text"].apply(lambda x: preprocess_text(x.lower()))
print("length of train set:",len(train))
print("length of test set:",len(test))<string_transform> | performance = model.fit_generator(datagen.flow(X_train,y_train, batch_size=64), epochs = 30,
validation_data =(X_val,y_val), verbose = 3 ) | Digit Recognizer |
9,959,337 | def extract_features(df,test_df):
txt=' '.join(df[df["target"]==1]["clean"])
disaster_unigram=nltk.FreqDist(nltk.word_tokenize(txt))
txt=' '.join(df[df["target"]==0]["clean"])
nondisaster_unigram=nltk.FreqDist(nltk.word_tokenize(txt))
txt=' '.join(df[df["target"]==1]["clean"])
disaster_bigram=nltk.FreqDist(nltk.bigr... | from sklearn.metrics import confusion_matrix, classification_report | Digit Recognizer |
9,959,337 | finetune_train,finetune_test = extract_features(finetune_train,finetune_test)
finetune_train.head(2 )<feature_engineering> | pred = model.predict(X_val ) | Digit Recognizer |
9,959,337 | train,test = extract_features(train,test)
train.head(2 )<categorify> | pred_classes = np.argmax(pred,axis = 1)
y_true = np.argmax(y_val,axis = 1 ) | Digit Recognizer |
9,959,337 | def build_bert(max_len):
input_ids = keras.layers.Input(shape=(max_len,), name="input_ids", dtype=tf.int32)
input_typ = keras.layers.Input(shape=(max_len,), name="input_type_ids", dtype=tf.int32)
input_mask = keras.layers.Input(shape=(max_len,), name="input_mask", dtype=tf.int32)
input_features = keras.layers.Input(... | print(classification_report(y_true, pred_classes)) | Digit Recognizer |
9,959,337 | all_df = pd.concat([finetune_train,finetune_test])
max_len = get_max_len(all_df["clean"])+ 1
encode_ds_all = encode(all_df["clean"] )<categorify> | test_preds = model.predict(test)
test_preds = np.argmax(test_preds,axis = 1)
test_preds = pd.Series(test_preds,name="Label" ) | Digit Recognizer |
9,959,337 | encode_ds_tr = {'input_ids':encode_ds_all["input_ids"][0:31962,:],
'input_mask':encode_ds_all["input_mask"][0:31962,:],
'input_type_ids':encode_ds_all["input_type_ids"][0:31962,:]}<categorify> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),test_preds],axis = 1)
submission.to_csv("cnn_mnist.csv",index=False ) | Digit Recognizer |
8,773,240 | features = ['unigram_disas','unigram_nondisas','unigram_disas_hash','unigram_nondisas_hash','bigram_disas','bigram_nondisas']
encode_features_tr = all_df[features].iloc[0:31962,:]<train_on_grid> | from keras.utils.np_utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D, BatchNormalization
from keras.optimizers import Adam
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import LearningRateScheduler | Digit Recognizer |
8,773,240 | y_enc = finetune_train["target"]
loss = tf.keras.losses.BinaryCrossentropy(from_logits=False)
optimizer = keras.optimizers.Adam(lr=1e-3,decay=1e-3/64)
model.compile(optimizer=optimizer, loss=[loss, loss],metrics=["accuracy"])
checkpoint = tf.keras.callbacks.ModelCheckpoint('model.h5', monitor='val_accuracy', save_be... | train_file = ".. /input/digit-recognizer/train.csv"
test_file = ".. /input/digit-recognizer/test.csv"
sample_submission = pd.read_csv('.. /input/digit-recognizer/sample_submission.csv' ) | Digit Recognizer |
8,773,240 | all_df = pd.concat([train,test])
max_len = get_max_len(train["clean"])+ 1
encode_ds_all = encode(all_df["clean"] )<categorify> | raw_data = np.loadtxt(train_file, skiprows=1, dtype='int', delimiter=',')
x_train, x_val, y_train, y_val = train_test_split(
raw_data[:,1:], raw_data[:,0], test_size=0.1 ) | Digit Recognizer |
8,773,240 | encode_ds_tr = {'input_ids':encode_ds_all["input_ids"][0:7613,:],
'input_mask':encode_ds_all["input_mask"][0:7613,:],
'input_type_ids':encode_ds_all["input_type_ids"][0:7613,:]}
encode_ds_tr<categorify> | x_train = x_train.astype("float32")/255.
x_val = x_val.astype("float32")/255 . | Digit Recognizer |
8,773,240 | encode_features_tr = all_df[features].iloc[0:7613,:]<train_on_grid> | y_train = to_categorical(y_train)
y_val = to_categorical(y_val)
print(y_train[0] ) | Digit Recognizer |
8,773,240 | y_enc = train["target"]
loss = tf.keras.losses.BinaryCrossentropy(from_logits=False)
optimizer = keras.optimizers.Adam(lr=1e-5,decay=1e-5/64)
model.compile(optimizer=optimizer, loss=[loss, loss],metrics=["accuracy"])
checkpoint = tf.keras.callbacks.ModelCheckpoint('model.h5', monitor='val_accuracy', save_best_only=T... | model = Sequential()
model.add(Conv2D(filters = 16, kernel_size =(3, 3), activation='relu',
input_shape =(28, 28, 1)))
model.add(BatchNormalization())
model.add(Conv2D(filters = 16, kernel_size =(3, 3), activation='relu'))
model.add(BatchNormalization())
model.add(MaxPool2D(strides=(2,2)))
model.add(Dropout(0.25))
... | Digit Recognizer |
8,773,240 | y_pred=model.predict([encode_ds_tr,encode_features_tr])
y_pred = y_pred.round()
print(classification_report(y_enc,y_pred))<categorify> | datagen = ImageDataGenerator(zoom_range = 0.1,
height_shift_range = 0.1,
width_shift_range = 0.1,
rotation_range = 10 ) | Digit Recognizer |
8,773,240 | encode_ds_ts = {'input_ids':encode_ds_all["input_ids"][7613:,:],
'input_mask':encode_ds_all["input_mask"][7613:,:],
'input_type_ids':encode_ds_all["input_type_ids"][7613:,:]}
encode_ds_ts<define_variables> | model.compile(loss='categorical_crossentropy', optimizer = Adam(lr=1e-4), metrics=["accuracy"] ) | Digit Recognizer |
8,773,240 | encode_features_ts = all_df[features].iloc[7613:,:]<load_from_csv> | annealer = LearningRateScheduler(lambda x: 1e-3 * 0.9 ** x ) | Digit Recognizer |
8,773,240 | y_pred=model.predict([encode_ds_ts,encode_features_ts])
y_pred= y_pred.round()
submission=pd.read_csv('/kaggle/input/nlp-getting-started/sample_submission.csv')
submission['id']=test['id']
submission['target']=y_pred
submission['target']=submission['target'].astype(int)
submission.head(10)
<save_to_csv> | hist = model.fit_generator(datagen.flow(x_train, y_train, batch_size=16),
steps_per_epoch=500,
epochs=20,
verbose=2,
validation_data=(x_val[:400,:], y_val[:400,:]),
callbacks=[annealer] ) | Digit Recognizer |
8,773,240 | submission.to_csv('sample_submission.csv',index=False )<set_options> | final_loss, final_acc = model.evaluate(x_val, y_val, verbose=0)
print("Final loss: {0:.4f}, final accuracy: {1:.4f}".format(final_loss, final_acc)) | Digit Recognizer |
8,773,240 | pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', 20)
pd.set_option('display.max_colwidth', -1 )<load_from_csv> | y_hat = model.predict(x_val)
y_pred = np.argmax(y_hat, axis=1)
y_true = np.argmax(y_val, axis=1)
cm = confusion_matrix(y_true, y_pred)
print(cm ) | Digit Recognizer |
8,773,240 | df = pd.read_csv('.. /input/nlp-getting-started/train.csv')
print(len(df))
print(df.columns)
df<categorify> | mnist_testset = np.loadtxt(test_file, skiprows=1, dtype='int', delimiter=',')
x_test = mnist_testset.astype("float32")
x_test = x_test.reshape(-1, 28, 28, 1)/255 . | Digit Recognizer |
8,773,240 | def clean_text(text):
text = re.sub(r'http\S+', '', text)
text = re.sub(r"(?:\@)\w+", '', text)
text = re.sub(r'[^a-zA-Z0-9'.,?$&\s]', '', text)
text = text.lower()
return text
for i in range(10):
index = np.random.randint(low=0, high=len(df))
print('Raw text:', df['text'][index])
print('Cleaned text:', clean_text(... | y_hat = model.predict(x_test, batch_size=64 ) | Digit Recognizer |
8,773,240 | def convert_to_features(data, tokenizer, max_len=None):
data = data.replace('
', '')
if max_len is not None:
tokenized = tokenizer.encode_plus(
data,
padding ='max_length',
max_length=max_len,
truncation=True,
return_tensors='np',
return_attention_mask=True,
return_token_type_ids=True,
)
else:
tokenized = tokenizer... | y_pred = np.argmax(y_hat,axis=1 ) | Digit Recognizer |
8,773,240 | base_model = 'bert-base-uncased'
bert_tokenizer = transformers.BertTokenizer.from_pretrained(base_model)
max_len = 80<prepare_x_and_y> | solution = pd.DataFrame({'ImageId': sample_submission['ImageId'], 'Label': y_pred})
solution[["ImageId","Label"]].to_csv("CNNPrediction.csv", index=False)
solution.head() | Digit Recognizer |
12,327,863 | validation_data_indices = df.sample(frac=0.2 ).index
validation_df = df.loc[validation_data_indices, :].reset_index(drop=True)
train_df = df.drop(validation_data_indices, axis=0 ).reset_index(drop=True)
test_df = pd.read_csv('.. /input/nlp-getting-started/test.csv')
x_train, y_train = create_inputs_with_targets(list... | %matplotlib inline | Digit Recognizer |
12,327,863 | def create_model(model_name, max_len=128):
seed = 500
my_init = tf.keras.initializers.glorot_uniform(seed)
max_len = max_len
encoder = transformers.TFAutoModel.from_pretrained(model_name)
encoder.trainable = True
input_ids = keras.layers.Input(shape=(max_len,), dtype=tf.int32)
attention_mask = keras.layers.Input(sha... | train_df = pd.read_csv(".. /input/digit-recognizer/train.csv")
test_df = pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
12,327,863 | epochs = 20
lr = 2e-4
use_tpu = True
if use_tpu:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.experimental.initialize_tpu_system(tpu)
strategy = tf.distribute.experimental.TPUStrategy(tpu)
with strategy.scope() :
model = create_model(base_model, max_... | train_df['label'].value_counts(normalize=True)
| Digit Recognizer |
12,327,863 | my_callbacks = [keras.callbacks.EarlyStopping(monitor='val_binary_accuracy', patience=2, mode='max', restore_best_weights=True)]
hist = model.fit(x_train,
y_train,
validation_data =(x_val, y_val),
epochs= epochs,
batch_size= 128,
callbacks = my_callbacks,
verbose= 1 )<save_to_csv> | x_train = train_df.drop(labels = ["label"],axis = 1)
y_train = train_df['label']
del train_df | Digit Recognizer |
12,327,863 | predictions = model.predict(x_test)
ids = list(test_df['id'])
target = [round(i[0])for i in predictions]
sub = pd.DataFrame({'id':ids, 'target':target}, index=None)
sub.to_csv('submission.csv', index=False)
sub<load_from_csv> | y_train = to_categorical(y_train, num_classes=10)
y_train[:2,:] | Digit Recognizer |
12,327,863 |
<install_modules> | random_seed = 121
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,327,863 | !pip install transformers==3.5.1
!pip install pyspellchecker<import_modules> | model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(3,3),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model.add(Conv2D(filters = 32, kernel_size =(3,3),padding = 'Same',
activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(BatchNormalization())
model.add(Dropout(0.2))
... | Digit Recognizer |
12,327,863 | 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
<load_fr... | optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0 ) | Digit Recognizer |
12,327,863 | 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> | model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
12,327,863 | 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> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001)
epochs = 50
batch_size = 86 | Digit Recognizer |
12,327,863 | print(train_val_df)
print(test_df.head())
original_df = train_val_df.copy()<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 |
12,327,863 | 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" : ... | 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 |
12,327,863 | 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> | results = model.predict(test_df)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
12,327,863 | <load_pretrained><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("cnn_mnist_datagen.csv",index=False ) | Digit Recognizer |
12,305,349 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<load_from_csv> | sns.set()
| Digit Recognizer |
12,305,349 | 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> | digits_PATH = '/kaggle/input/digit-recognizer/'
digits_train = pd.read_csv(digits_PATH+'train.csv' ) | Digit Recognizer |
12,305,349 | 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, y = digits_train.iloc[:,1:].values/255, digits_train.iloc[:,0].values
X = X.reshape(-1,28, 28, 1 ) | Digit Recognizer |
12,305,349 | print(tokenizer.convert_ids_to_tokens(item.Text.tolist()))
print(int(item.Label))<define_variables> | X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.9, random_state=0 ) | Digit Recognizer |
12,305,349 | 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 =... | class MultiCNN() :
def __init__(self, model_generator, num_models=1):
self.models = []
self.create_models(model_generator, num_models)
def create_models(self, model_generator, num_models=1):
for i in range(0,num_models):
m = keras.models.Sequential(model_generator())
m.compile(loss='sparse_categorical_crossentropy', ... | Digit Recognizer |
12,305,349 | model = BertModel.from_pretrained('bert-base-cased' )<set_options> | def make_CNN() :
return [
keras.layers.Conv2D(filters=32, kernel_size=(3,3), activation="relu", input_shape=(28, 28, 1)) ,
keras.layers.MaxPooling2D(pool_size =(2,2), strides = 2),
keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation="relu"),
keras.layers.MaxPooling2D(pool_size =(2,2), strides = 2),
keras.laye... | Digit Recognizer |
12,305,349 | 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... | def make_CNN() :
return [
keras.layers.Conv2D(filters=32, kernel_size=(3,3), activation="relu", input_shape=(28, 28, 1)) ,
keras.layers.MaxPooling2D(pool_size =(2,2), strides = 2),
keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation="relu"),
keras.layers.MaxPooling2D(pool_size =(2,2), strides = 2),
keras.laye... | Digit Recognizer |
12,305,349 | net = BertForTwitter()
net.train()
print('ネットワーク設定完了' )<categorify> | def make_CNN() :
return [
keras.layers.Conv2D(filters=32, kernel_size=(3,3), activation="relu", input_shape=(28, 28, 1)) ,
keras.layers.AveragePooling2D(pool_size =(2,2), strides = 2),
keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation="relu"),
keras.layers.AveragePooling2D(pool_size =(2,2), strides = 2),
ke... | Digit Recognizer |
12,305,349 | 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> | def make_CNN() :
return [
keras.layers.Conv2D(filters=32, kernel_size=(3,3), activation="relu", input_shape=(28, 28, 1)) ,
keras.layers.MaxPooling2D(pool_size =(2,2), strides = 2),
keras.layers.BatchNormalization() ,
keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation="relu"),
keras.layers.MaxPooling2D(pool_s... | Digit Recognizer |
12,305,349 | 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> | def make_CNN() :
return [
keras.layers.Conv2D(filters=32, kernel_size=(3,3), activation="relu", input_shape=(28, 28, 1)) ,
keras.layers.MaxPooling2D(pool_size =(2,2), strides = 2),
keras.layers.BatchNormalization() ,
keras.layers.Dropout(0.2),
keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation="relu"),
keras... | Digit Recognizer |
12,305,349 | 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... | def make_CNN() :
return [
keras.layers.Conv2D(filters=32, kernel_size=(3,3), activation="relu", input_shape=(28, 28, 1)) ,
keras.layers.MaxPooling2D(pool_size =(2,2), strides = 2),
keras.layers.BatchNormalization() ,
keras.layers.Dropout(0.2),
keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation="relu"),
keras... | Digit Recognizer |
12,305,349 | num_epochs = 50
net_trained = train_model(net, dataloaders_dict,
criterion, optimizer, num_epochs=num_epochs )<load_from_csv> | def make_CNN() :
return [
keras.layers.Conv2D(filters=32, kernel_size=(5,5), activation="relu", input_shape=(28, 28, 1)) ,
keras.layers.MaxPooling2D(pool_size =(2,2), strides = 2),
keras.layers.BatchNormalization() ,
keras.layers.Dropout(0.2),
keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation="relu"),
keras... | Digit Recognizer |
12,305,349 | sample_submission = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
sample_submission["target"] = ans_list
sample_submission<save_to_csv> | def make_CNN() :
return [
keras.layers.Conv2D(filters=32, kernel_size=(5,5), activation="relu", input_shape=(28, 28, 1)) ,
keras.layers.MaxPooling2D(pool_size =(2,2), strides = 2),
keras.layers.BatchNormalization() ,
keras.layers.Dropout(0.2),
keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation="relu"),
keras... | Digit Recognizer |
12,305,349 | sample_submission.to_csv("submission_plus.csv", index=False )<import_modules> | datagen = keras.preprocessing.image.ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
zca_epsilon=1e-06,
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
brightness_range=None,
zoom_range... | Digit Recognizer |
12,305,349 | import torch
import pandas as pd
import numpy as np
from transformers import AutoModelForSequenceClassification, AutoTokenizer<string_transform> | def make_CNN() :
return [
keras.layers.Conv2D(filters=32, kernel_size=(5,5), activation="relu", input_shape=(28, 28, 1)) ,
keras.layers.MaxPooling2D(pool_size =(2,2), strides = 2),
keras.layers.BatchNormalization() ,
keras.layers.Dropout(0.2),
keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation="relu"),
keras... | Digit Recognizer |
12,305,349 | class Dataset:
def __init__(self, text, tokenizer, max_len):
self.text = text
self.tokenizer = tokenizer
self.max_len = max_len
def __len__(self):
return len(self.text)
def __getitem__(self, item):
text = str(self.text[item])
inputs = self.tokenizer(
text,
max_length=self.max_len,
padding="max_length",
truncation=Tr... | def make_CNN() :
return [
keras.layers.Conv2D(filters=32, kernel_size=(5,5), activation="relu", input_shape=(28, 28, 1)) ,
keras.layers.MaxPooling2D(pool_size =(2,2), strides = 2),
keras.layers.BatchNormalization() ,
keras.layers.Dropout(0.2),
keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation="relu"),
keras... | Digit Recognizer |
12,305,349 | def generate_predictions(model_path, max_len):
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.to("cuda")
model.eval()
df = pd.read_csv(".. /input/nlp-getting-started/test.csv")
dataset = Dataset(text=df.text.values, tokenizer=tokeni... | multiCNN_final.acuracia(X_test, y_test ) | Digit Recognizer |
12,305,349 | preds = generate_predictions("abhishek/autonlp-fred2-2682064", max_len=64 )<save_to_csv> | submission = pd.read_csv(digits_PATH+'sample_submission.csv', index_col=0)
test = pd.read_csv(digits_PATH+'test.csv')/255
test = test.values.reshape(-1,28, 28, 1 ) | Digit Recognizer |
12,305,349 | sample = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
sample.target = preds
sample.to_csv("submission.csv", index=False )<count_values> | submission['Label'] = np.argmax(multiCNN_final.predict(test), axis=1 ) | Digit Recognizer |
12,305,349 | sample.target.value_counts()<import_modules> | submission.Label.value_counts() | Digit Recognizer |
12,305,349 | <load_from_csv><EOS> | submission.to_csv('submission.csv' ) | Digit Recognizer |
12,242,884 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<load_from_csv> | import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt | Digit Recognizer |
12,242,884 | test_csv = pd.read_csv(".. /input/nlp-getting-started/test.csv")
test_csv.head()<count_values> | train = pd.read_csv(".. /input/digit-recognizer/train.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
12,242,884 | training_csv['target'].value_counts()<count_values> | train.isnull().sum().any() | Digit Recognizer |
12,242,884 | training_csv['keyword'].value_counts()<count_missing_values> | labels = list(range(10)) | Digit Recognizer |
12,242,884 | training_csv['keyword'].isnull().sum()<count_values> | X = train.drop("label", axis=1 ).values
y = train["label"].values | Digit Recognizer |
12,242,884 | training_csv['location'].value_counts()<count_missing_values> | from sklearn.model_selection import train_test_split | Digit Recognizer |
12,242,884 | training_csv['location'].isnull().sum()<categorify> | from sklearn.model_selection import train_test_split | Digit Recognizer |
12,242,884 | def clean(title):
title = re.sub(r"\-"," ",title)
title = re.sub(r"\+"," ",title)
title = re.sub(r"&","and",title)
title = re.sub(r"\|"," ",title)
title = re.sub(r"\"," ",title)
title = re.sub(r"\W"," ",title)
title = title.lower()
for p in string.punctuation :
title = re.sub(r"f{p}"," ",title)
title = re.sub(... | X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.1, random_state=10 ) | Digit Recognizer |
12,242,884 | training_csv["cleaned_text"] = training_csv["text"].map(clean)
training_csv.head()<load_pretrained> | X_test = test.values | Digit Recognizer |
12,242,884 | tokenizer = BertTokenizer.from_pretrained('.. /input/bert-base-uncased')
<split> | from keras.utils import to_categorical | Digit Recognizer |
12,242,884 | X_train,X_test,y_train,y_test = train_test_split(training_csv["cleaned_text"].values,training_csv["target"].values, random_state=0,test_size=0.1,shuffle=True )<categorify> | y_train = to_categorical(y_train)
y_val_true = y_val.copy()
y_val = to_categorical(y_val ) | Digit Recognizer |
12,242,884 | class CreateDataset(Dataset):
def __init__(self, X, y, tokenizer, max_len):
self.X = X
self.y = y
self.tokenizer = tokenizer
self.max_len = max_len
def __len__(self):
return len(self.y)
def __getitem__(self, index):
text = self.X[index]
inputs = self.tokenizer.encode_plus(
text,
add_special_tokens=True,
max_length=se... | X_train = X_train/255
X_val = X_val/255
X_test = X_test/255 | Digit Recognizer |
12,242,884 | max_len = 45
dataset_train = CreateDataset(X_train, y_train, tokenizer, max_len)
dataset_valid = CreateDataset(X_test, y_test, tokenizer, max_len)
<load_pretrained> | X_train = X_train.reshape(-1, 28, 28, 1)
X_val = X_val.reshape(-1, 28, 28, 1)
X_test = X_test.reshape(-1, 28, 28, 1 ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.