kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,296,992 | y = "revenue"
x = h2o_df.columns
x.remove(y )<choose_model_class> | callback_lrs = LearningRateScheduler(lambda x: 1e-3 * 0.95 ** x)
epochs = 40
history = [0]*10
for j in range(10):
X_train1, X_valid1, y_train1, y_valid1 = train_test_split(X_train, y_train, test_size = 0.1)
history[j] = model[j].fit_generator(datagen.flow(X_train1, y_train1, batch_size = batch_size), epochs = epochs,... | Digit Recognizer |
10,296,992 | <train_model><EOS> | results = np.zeros(( X_test.shape[0],10))
for j in range(10):
results = results + model[j].predict(X_test)
y_test_class = np.argmax(results, axis = 1)
submission = pd.DataFrame({'ImageId': list(range(1, len(y_test_class)+1)) , 'Label': np.array(y_test_class)})
submission.to_csv('submission.csv', index=False)
print(... | Digit Recognizer |
7,206,401 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<predict_on_test> | %matplotlib inline
| Digit Recognizer |
7,206,401 | pred = aml.predict(h2o_valid)
pred.head()<save_model> | data = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
print(data.shape ) | Digit Recognizer |
7,206,401 | h2o.save_model(aml.leader, path="./model_bin" )<train_model> | test_data = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
print(test_data.shape ) | Digit Recognizer |
7,206,401 | params = {'objective': 'reg:linear',
'eta': 0.01,
'max_depth': 6,
'min_child_weight': 3,
'subsample': 0.8,
'colsample_bytree': 0.8,
'colsample_bylevel': 0.50,
'gamma': 1.45,
'eval_metric': 'rmse',
'seed': 12,
'silent': True}
xgb_data = [(xgb.DMatrix(X_train, y_train), 'train'),(xgb.DMatrix(X_valid, y_valid), 'valid')]
... | sample_submission = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv')
print(sample_submission.shape ) | Digit Recognizer |
7,206,401 | xgb_pred = xgb_model.predict(xgb.DMatrix(X_valid))<drop_column> | encoder = OneHotEncoder(sparse=False,categories='auto')
yy = [[0],[1],[2],[3],[4],[5],[6],[7],[8],[9]]
encoder.fit(yy)
train_label = train_label.reshape(-1,1)
val_label = val_label.reshape(-1,1)
train_label = encoder.transform(train_label)
val_label = encoder.transform(val_label)
print('train_label shape: %s'%str... | Digit Recognizer |
7,206,401 | X_test = test.drop('revenue',axis=1 )<prepare_x_and_y> | import numpy as np
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.optimizers import SGD
from keras.layers.normalization import BatchNormalization
from keras.layers import LeakyReLU
| Digit Recognizer |
7,206,401 | X_test[X_test==np.inf]=np.nan
X_test.fillna(X_test.mean() , inplace=True )<predict_on_test> | model = Sequential()
model.add(Conv2D(32,(3, 3), activation='relu', input_shape=(28, 28, 1),padding='same'))
model.add(BatchNormalization(momentum=0.9, epsilon=1e-5, gamma_initializer="uniform"))
model.add(LeakyReLU(alpha=0.1))
model.add(Conv2D(32,(3, 3), activation='relu',padding='same'))
model.add(BatchNormalization(... | Digit Recognizer |
7,206,401 | test_pred_xgb = xgb_model.predict(xgb.DMatrix(( X_test)) , ntree_limit=xgb_model.best_ntree_limit )<choose_model_class> | datagen = ImageDataGenerator(
rotation_range=15,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range = 15,
horizontal_flip = False,
zoom_range = 0.20 ) | Digit Recognizer |
7,206,401 | model = CatBoostRegressor(iterations=100000,
learning_rate=0.005,
depth=5,
eval_metric='RMSE',
colsample_bylevel=0.8,
random_seed = 21,
bagging_temperature = 0.2,
metric_period = None,
early_stopping_rounds=200
)
model.fit(X_train, y_train,eval_set=(X_valid, y_valid),use_best_model=True,verbose=500)
val_pred = model... | model.compile(loss='categorical_crossentropy',optimizer=Adam() ,metrics=['accuracy'])
datagen.fit(train_image)
history = model.fit_generator(datagen.flow(train_image,train_label, batch_size=32),
epochs = 75,
shuffle=True,
validation_data =(val_image,val_label),
verbose = 1,
steps_per_epoch=train_image.shape[0] // 32 ... | Digit Recognizer |
7,206,401 | params = {'objective':'regression',
'num_leaves' : 30,
'min_data_in_leaf' : 20,
'max_depth' : 9,
'learning_rate': 0.004,
'feature_fraction':0.9,
"bagging_freq": 1,
"bagging_fraction": 0.9,
'lambda_l1': 0.2,
"bagging_seed": 11,
"metric": 'rmse',
"random_state" : 11,
"verbosity": -1}
record = dict()
model = lgb.train(par... | intermediate_output = intermediate_layer_model.predict(train_image)
intermediate_output = pd.DataFrame(data=intermediate_output ) | Digit Recognizer |
7,206,401 | sub = pd.read_csv('.. /input/tmdb-box-office-prediction/sample_submission.csv')
df_sub = pd.DataFrame()
df_sub['id'] = sub['id']
final_pred = 0.3*test_pred_xgb + 0.7*test_pred_cat
df_sub['revenue'] = np.expm1(final_pred)
print(df_sub['revenue'])
df_sub.to_csv("submission.csv", index=False )<import_modules> | val_data = intermediate_output[40000:] | Digit Recognizer |
7,206,401 | confusion_matrix)
<define_variables> | submission_cnn = model.predict(test_image ) | Digit Recognizer |
7,206,401 | PRETRAINED_MODEL_NAME = 'bert-base-uncased'
LABELS_NUMBER = 2
MAX_LENGHT = 512
BATCH_SIZE = 6
LEARNING_RATE = 2e-5
EPOCHS_NUMBER = 1
N_PREDICTIONS_TO_SHOW = 10<load_from_csv> | intermediate_test_output = intermediate_layer_model.predict(test_image)
intermediate_test_output = pd.DataFrame(data=intermediate_test_output ) | Digit Recognizer |
7,206,401 | train_data = pd.read_csv('.. /input/nlp-getting-started/train.csv')
print(train_data.shape)
train_data.head(3 )<load_from_csv> | xgbmodel = XGBClassifier(objective='multi:softprob',
num_class= 10)
xgbmodel.fit(intermediate_output, train_label1)
xgbmodel.score(val_data, val_label1 ) | Digit Recognizer |
7,206,401 | test_data = pd.read_csv('.. /input/nlp-getting-started/test.csv')
print(test_data.shape)
test_data.head(3 )<load_pretrained> | submission_xgb = xgbmodel.predict(intermediate_test_output ) | Digit Recognizer |
7,206,401 | tokenizer = BertTokenizer.from_pretrained(PRETRAINED_MODEL_NAME,
do_lower_case=True )<string_transform> | submission_cnn = submission_cnn.astype(int)
submission_xgb = submission_xgb.astype(int)
| Digit Recognizer |
7,206,401 | vocabulary = tokenizer.get_vocab()
print(f'Size of the vocabulary: {len(vocabulary)}')
print(f'Some tokens of the vocabulary: {list(vocabulary.keys())[5000:5010]}' )<categorify> | submission_cnn
label = np.argmax(submission_cnn,1)
id_ = np.arange(0,label.shape[0])
label | Digit Recognizer |
7,206,401 | def prepare_sequence(text):
prepared_sequence = tokenizer.encode_plus(
text,
add_special_tokens = True,
max_length = MAX_LENGHT,
padding = 'max_length',
return_attention_mask = True
)
return prepared_sequence<categorify> | final_sub = submission_xgb | Digit Recognizer |
7,206,401 | test_sentence = 'Is this jacksonville?'
test_sentence_encoded = prepare_sequence(test_sentence)
token_ids = test_sentence_encoded["input_ids"]
print(f'Test sentence: {test_sentence}')
print(f'Keys: {test_sentence_encoded.keys() }')
print(f'Tokens: {tokenizer.convert_ids_to_tokens(token_ids)[:12]}')
print(f'Token ID... | save = pd.DataFrame({'ImageId':sample_submission.ImageId,'label':final_sub})
print(save.head(10))
save.to_csv('submission.csv',index=False ) | Digit Recognizer |
231,224 | def map_example_to_dict(input_ids, attention_masks, token_type_ids, label):
mapped_example = {
"input_ids": input_ids,
"token_type_ids": token_type_ids,
"attention_mask": attention_masks,
}
return mapped_example, label
def encode_examples(texts_and_labels):
input_ids_list = []
token_type_ids_list = []
attention_mas... | train = pd.read_csv(".. /input/train.csv")
print(train.shape)
train.head() | Digit Recognizer |
231,224 | X = train_data["text"]
y = train_data["target"]<split> | z_train = Counter(train['label'])
z_train | Digit Recognizer |
231,224 | X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.10,
random_state=1 )<count_values> | test= pd.read_csv(".. /input/test.csv")
print(test.shape)
test.head() | Digit Recognizer |
231,224 | n_training_examples = X_train.shape[0]
n_positive_training_examples = y_train.value_counts() [1]
n_negative_training_examples = y_train.value_counts() [0]
print(f'Number examples in training dataset: {n_training_examples}')
print(f'Number of positive examples in training dataset: {n_positive_training_examples}')
prin... | x_train =(train.ix[:,1:].values ).astype('float32')
y_train = train.ix[:,0].values.astype('int32')
x_test = test.values.astype('float32' ) | Digit Recognizer |
231,224 | train_dataset = list(zip(X_train, y_train))
val_dataset = list(zip(X_val, y_val))<categorify> | x_train = x_train/255.0
x_test = x_test/255.0 | Digit Recognizer |
231,224 | ds_train_encoded = encode_examples(train_dataset ).shuffle(10000 ).batch(BATCH_SIZE)
ds_val_encoded = encode_examples(val_dataset ).batch(BATCH_SIZE )<load_pretrained> | batch_size = 64
num_classes = 10
epochs = 20
input_shape =(28, 28, 1 ) | Digit Recognizer |
231,224 | def get_model() :
config = AutoConfig.from_pretrained(PRETRAINED_MODEL_NAME,
hidden_dropout_prob=0.2,
num_labels=LABELS_NUMBER)
model = TFBertForSequenceClassification.from_pretrained(PRETRAINED_MODEL_NAME,
config=config)
return model<choose_model_class> | y_train = keras.utils.to_categorical(y_train, num_classes)
X_train, X_val, Y_train, Y_val = train_test_split(X_train, y_train, test_size = 0.1, random_state=42 ) | Digit Recognizer |
231,224 | model = get_model()
optimizer = tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE)
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
metric = tf.keras.metrics.SparseCategoricalAccuracy('accuracy')
model.compile(optimizer=optimizer, loss=loss, metrics=[metric] )<train_model> | model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',kernel_initializer='he_normal',input_shape=input_shape))
model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',kernel_initializer='he_normal'))
model.add(MaxPool2D(( 2, 2)))
model.add(Dropout(0.20))
model.add(Conv2D(64,(3, 3), activatio... | Digit Recognizer |
231,224 | weight_for_0 =(1 / n_negative_training_examples)*(n_training_examples)/2.0
weight_for_1 =(1 / n_positive_training_examples)*(n_training_examples)/2.0
class_weight = {0: weight_for_0, 1: weight_for_1}
print('Weight for class 0: {:.2f}'.format(weight_for_0))
print('Weight for class 1: {:.2f}'.format(weight_for_1))<train_... | datagen.fit(X_train)
h = model.fit_generator(datagen.flow(X_train,Y_train, batch_size=batch_size),
epochs = epochs, validation_data =(X_val,Y_val),
verbose = 1, steps_per_epoch=X_train.shape[0] // batch_size
, callbacks=[learning_rate_reduction], ) | Digit Recognizer |
231,224 | model.fit(ds_train_encoded, epochs=EPOCHS_NUMBER, validation_data=ds_val_encoded,
class_weight = class_weight )<predict_on_test> | final_loss, final_acc = model.evaluate(X_val, Y_val, verbose=0)
print("Final loss: {0:.6f}, final accuracy: {1:.6f}".format(final_loss, final_acc)) | Digit Recognizer |
231,224 | val_predictions = model.predict(ds_val_encoded)
val_probabilities = softmax(val_predictions[0], axis=1)
y_val_predictions = np.argmax(val_probabilities, axis=1 ).flatten()<categorify> | layer_outputs = [layer.output for layer in model.layers[:8]]
activation_model = models.Model(input=model.input, output=layer_outputs)
activations = activation_model.predict(test_im.reshape(1,28,28,1))
first_layer_activation = activations[0]
plt.matshow(first_layer_activation[0, :, :, 4], cmap='viridis' ) | Digit Recognizer |
231,224 | def encode_test_examples(texts):
input_ids_list = []
token_type_ids_list = []
attention_mask_list = []
for text in texts:
bert_input = prepare_sequence(text)
input_ids_list.append(bert_input['input_ids'])
token_type_ids_list.append(bert_input['token_type_ids'])
attention_mask_list.append(bert_input['attention_mask... | model.layers[:-1] | Digit Recognizer |
231,224 | X_test = test_data["text"]
test_dataset = list(X_test)
ds_test_encoded = encode_test_examples(test_dataset ).batch(BATCH_SIZE )<predict_on_test> | layer_names = []
for layer in model.layers[:-1]:
layer_names.append(layer.name)
images_per_row = 16
for layer_name, layer_activation in zip(layer_names, activations):
if layer_name.startswith('conv'):
n_features = layer_activation.shape[-1]
size = layer_activation.shape[1]
n_cols = n_features // images_per_row
display... | Digit Recognizer |
231,224 | test_predictions = model.predict(ds_test_encoded)
test_probabilities = softmax(test_predictions[0], axis=1)
y_test_predictions = np.argmax(test_probabilities, axis=1 ).flatten()<save_to_csv> | layer_names = []
for layer in model.layers[:-1]:
layer_names.append(layer.name)
images_per_row = 16
for layer_name, layer_activation in zip(layer_names, activations):
if layer_name.startswith('max'):
n_features = layer_activation.shape[-1]
size = layer_activation.shape[1]
n_cols = n_features // images_per_row
display_... | Digit Recognizer |
231,224 | final_submission = pd.DataFrame(data={"id":test_data["id"], "target":y_test_predictions})
final_submission.to_csv("submissionTweets.csv", index=False )<set_options> | layer_names = []
for layer in model.layers[:-1]:
layer_names.append(layer.name)
images_per_row = 16
for layer_name, layer_activation in zip(layer_names, activations):
if layer_name.startswith('drop'):
n_features = layer_activation.shape[-1]
size = layer_activation.shape[1]
n_cols = n_features // images_per_row
display... | Digit Recognizer |
231,224 | warnings.filterwarnings('ignore')
<categorify> | Y_pred = model.predict(X_val)
Y_pred_classes = np.argmax(Y_pred, axis = 1)
Y_true_classes = np.argmax(Y_val, axis = 1 ) | Digit Recognizer |
231,224 | def bert_encode(texts, tokenizer, max_len=512):
all_tokens = []
for text in texts:
text = tokenizer.tokenize(text)
text = text[:max_len-2]
input_sequence = ["[CLS]"] + text + ["[SEP]"]
pad_len = max_len - len(input_sequence)
tokens = tokenizer.convert_tokens_to_ids(input_sequence)
tokens += [0] * pad_len
pad_masks =... | target_names = ["Class {}".format(i)for i in range(num_classes)]
print(classification_report(Y_true_classes, Y_pred_classes, target_names=target_names)) | Digit Recognizer |
231,224 | train = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
test = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv")
submission = pd.read_csv("/kaggle/input/nlp-getting-started/sample_submission.csv" )<choose_model_class> | predicted_classes = model.predict_classes(X_test)
submissions=pd.DataFrame({"ImageId": list(range(1,len(predicted_classes)+1)) ,
"Label": predicted_classes})
submissions.to_csv("asd.csv", index=False, header=True ) | Digit Recognizer |
231,224 | <split><EOS> | model.save('my_model_1.h5')
json_string = model.to_json() | Digit Recognizer |
10,869,544 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<compute_test_metric> | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
X_train =(train.iloc[:,1:].values ).astype('float32')
y_train = train.iloc[:,0].values.astype('int32')
X_test = test.values.astype('float32')
X_train_scaled = X_train.reshape(X_train.shape[... | Digit Recognizer |
10,869,544 | def metrics(y_true, y_pred):
print("
F1-score: ", round(f1_score(y_true, y_pred), 2))
print("Precision: ", round(precision_score(y_true, y_pred), 2))
print("Recall: ", round(recall_score(y_true, y_pred), 2))<train_model> | def format_predictions(model, test_data=X_test_scaled):
preds = model.predict(test_data)
preds_test = []
for i in preds:
preds_test.append(np.argmax(i))
return preds_test
early_stop = EarlyStopping(monitor='val_loss',
patience=20,
mode='min',
restore_best_weights=True)
def scheduler(epoch, lr):
if epoch < 20:
retur... | Digit Recognizer |
10,869,544 | start_time = time.time()
train_history = model.fit(X_train, y_train, epochs = 3, batch_size = 8)
end_time = time.time()
print("
=>Training time :", round(end_time - start_time, 1), 's' )<predict_on_test> | def conv_block1(In, std):
out = SeparableConv2D(16,(3, 3), kernel_initializer=TruncatedNormal(0, std, 1))(In)
out = BatchNormalization()(out)
out = SeparableConv2D(16,(1, 1), kernel_initializer=TruncatedNormal(0, std-1e-5, 1))(out)
return out
def conv_block2(In, std):
out = SeparableConv2D(16,(3, 1), kernel_initiali... | Digit Recognizer |
10,869,544 | start_time = time.time()
test_pred = model.predict(X_test, verbose=1 ).round().astype(int)
end_time = time.time()
print('
=>Average Inference Time :', round(( end_time - start_time)/ len(test_pred)* 1000, 1), 'ms')
metrics(y_test, test_pred )<save_to_csv> | scaled_input = tf.keras.Input(shape=(28,28,1))
norm_in = BatchNormalization(name='norm_in' )(scaled_input)
out1 = []
for i in range(0, 8):
out1.append(conv_block1(norm_in, 1e3/10**(i)))
out2 = []
for i in range(0, 8, 2):
out2.append(Add()([out1[i], out1[i+1]]))
for i in range(0, len(out2)) :
out2[i] = conv_block2(out... | Digit Recognizer |
10,869,544 | submission['target'] = model.predict(test_input, verbose=1 ).round().astype(int)
submission.to_csv('submission.csv', index=False )<install_modules> | model.count_params() / 1e6 | Digit Recognizer |
10,869,544 | !pip install transformers<import_modules> | model.compile(optimizer=Adam(0.0075),
loss=CategoricalCrossentropy() ,
metrics=['accuracy'] ) | Digit Recognizer |
10,869,544 | import torch
from torch.utils.data import TensorDataset, random_split
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler
from transformers import BertTokenizer, get_linear_schedule_with_warmup
from transformers import BertForSequenceClassification, AdamW, BertConfig
import torch.nn.functional as ... | def scheduler(epoch, lr):
if epoch < 20:
return lr
elif lr > 5e-5:
return lr *(0.95 **(epoch // 10 - 1))
return lr
hist = model.fit(X_train_scaled, y_train, epochs= 2000, batch_size=128,
callbacks=[
LearningRateScheduler(scheduler),
tfdocs.modeling.EpochDots() ,
ReduceLROnPlateau(
monitor='val_accuracy', factor=0.6, p... | Digit Recognizer |
10,869,544 | if torch.cuda.is_available() :
device = torch.device("cuda")
print('There are %d GPU(s)available.{}'.format(torch.cuda.device_count()))
print('We will use the GPU: {}'.format(torch.cuda.get_device_name(0)))
else:
print('No GPU available, using the CPU instead.')
device = torch.device("cpu")
seed_val = 42
random.see... | submission = pd.DataFrame({
"ImageId": [i+1 for i in range(0, 28000)],
"Label": format_predictions(model)
})
submission.to_csv('s.csv', index=False ) | Digit Recognizer |
10,869,544 | train = pd.read_csv('.. /input/nlp-getting-started/train.csv')
test = pd.read_csv('.. /input/nlp-getting-started/test.csv')
pd.set_option('display.max_colwidth', 150)
train.head()<train_model> | try :
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.experimental.initialize_tpu_system(tpu)
tpu_strategy = tf.distribute.experimental.TPUStrategy(tpu)
except:
print('No TPU being used!')
| Digit Recognizer |
10,869,544 | print('Number of training sentences: {:,}
'.format(train.shape[0]))
print('Number of test sentences: {:,}
'.format(test.shape[0]))<categorify> | Digit Recognizer | |
10,869,544 | def clean_text(text):
text = text.lower()
text = re.sub(r'[!]+','!',text)
text = re.sub(r'[?]+','?',text)
text = re.sub(r'[.]+','.',text)
text = re.sub(r"'","",text)
text = re.sub('\s+', '', text ).strip()
text = re.sub(r'&?',r'and', text)
text = re.sub(r"https?:\/\/t.co\/[A-Za-z0-9]+", "", text)
text = re.su... | Digit Recognizer | |
10,869,544 | sentences = train.text.values
labels = train.target.values
sentences_test = test.text.values
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True )<categorify> | Digit Recognizer | |
10,869,544 | print(' Original: ', sentences[0])
print('Tokenized: ', tokenizer.tokenize(sentences[0]))
print('Token IDs: ', tokenizer.convert_tokens_to_ids(tokenizer.tokenize(sentences[0])))
<define_variables> | Digit Recognizer | |
10,869,544 | max_len = 0
for sent in sentences:
input_ids = tokenizer.encode(sent, add_special_tokens=True)
max_len = max(max_len, len(input_ids))
print('Max sentence length: ', max_len)
<categorify> | Digit Recognizer | |
10,427,138 | input_ids = []
attention_masks = []
for sent in sentences:
encoded_dict = tokenizer.encode_plus(
sent,
add_special_tokens = True,
max_length = 64,
pad_to_max_length = True,
return_attention_mask = True,
return_tensors = 'pt',
)
input_ids.append(encoded_dict['input_ids'])
attention_masks.append(encoded_dict['attenti... | %matplotlib inline
| Digit Recognizer |
10,427,138 | dataset = TensorDataset(input_ids, attention_masks, labels)
train_size = int(0.8 * len(dataset))
val_size = len(dataset)- train_size
train_dataset, val_dataset = random_split(dataset, [train_size, val_size])
print('{:>5,} training samples'.format(train_size))
print('{:>5,} validation samples'.format(val_size))<load_p... | train = pd.read_csv(".. /input/digit-recognizer/train.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
10,427,138 | batch_size = 32
train_dataloader = DataLoader(
train_dataset,
sampler = RandomSampler(train_dataset),
batch_size = batch_size
)
validation_dataloader = DataLoader(
val_dataset,
sampler = SequentialSampler(val_dataset),
batch_size = batch_size
)<load_pretrained> | x_train = np.array(x_train)
test = np.array(test ) | Digit Recognizer |
10,427,138 | model = BertForSequenceClassification.from_pretrained(
"bert-base-uncased",
num_labels = 2,
output_attentions = False,
output_hidden_states = False,
)
model.cuda()<choose_model_class> | y_train = to_categorical(y_train,10 ) | Digit Recognizer |
10,427,138 | optimizer = AdamW(model.parameters() ,
lr = 2e-5,
eps = 1e-8
)
epochs = 4
total_steps = len(train_dataloader)* epochs
scheduler = get_linear_schedule_with_warmup(optimizer,
num_warmup_steps = 0,
num_training_steps = total_steps )<compute_test_metric> | x_train, x_val, y_train, y_val=train_test_split(x_train,y_train,test_size=0.1 ) | Digit Recognizer |
10,427,138 | def flat_accuracy(preds, labels):
pred_flat = np.argmax(preds, axis=1 ).flatten()
labels_flat = labels.flatten()
return np.sum(pred_flat == labels_flat)/ len(labels_flat)
def format_time(elapsed):
elapsed_rounded = int(round(( elapsed)))
return str(datetime.timedelta(seconds=elapsed_rounded))<train_model> | model = Sequential() | Digit Recognizer |
10,427,138 | training_stats = []
total_t0 = time.time()
for epoch_i in range(0, epochs):
print("")
print('======== Epoch {:} / {:} ========'.format(epoch_i + 1, epochs))
print('Training...')
t0 = time.time()
total_train_loss = 0
model.train()
for step, batch in enumerate(train_dataloader):
if step % 40 == 0 and not step == 0:
ela... | model.add(Input(shape=(28, 28, 1)))
model.add(Conv2D(filters=64, kernel_size =(3,3),padding = 'Same', activation ='relu'))
model.add(MaxPooling2D(pool_size=(1,1)))
model.add(Conv2D(filters=64, kernel_size =(3,3),padding = 'Same',activation ='relu'))
model.add(MaxPooling2D(pool_size=(1,1)))
model.add(Conv2D(filters=6... | Digit Recognizer |
10,427,138 | print('Number of test sentences: {:,}
'.format(test.shape[0]))
sentences_test = test.text.values
input_ids = []
attention_masks = []
for sent in sentences_test:
encoded_dict = tokenizer.encode_plus(
sent,
add_special_tokens = True,
max_length = 64,
pad_to_max_length = True,
return_attention_mask = True,
return_tensors... | model.compile(loss=keras.losses.categorical_crossentropy,\
optimizer = tf.keras.optimizers.Adam() ,\
metrics=['accuracy'] ) | Digit Recognizer |
10,427,138 | print('Predicting labels for {:,} test sentences...'.format(len(input_ids)))
model.eval()
predictions = []
for batch in prediction_dataloader:
batch = tuple(t.to(device)for t in batch)
b_input_ids, b_input_mask = batch
with torch.no_grad() :
outputs = model(b_input_ids, token_type_ids=None,
attention_mask=b_input_mas... | model.fit(x_train,y_train, batch_size = 128, epochs = 30, validation_data=(x_val,y_val)) | Digit Recognizer |
10,427,138 | all_logits = torch.cat(predictions, dim=0)
probs = F.softmax(all_logits, dim=1 ).cpu().numpy()
probs<prepare_output> | y_pred = model.predict(x_val)
y_pred_classes = np.argmax(y_pred,axis = 1)
y_pred_classes
y_true = np.argmax(y_val,axis = 1)
y_true
confusion_mtx = confusion_matrix(y_true, y_pred_classes)
confusion_mtx | Digit Recognizer |
10,427,138 | threshold = 0.5
preds = np.where(probs[:, 1] > threshold, 1, 0)
preds<count_values> | model.evaluate(x_val,y_val,verbose=0 ) | Digit Recognizer |
10,427,138 | print("Number of tweets labeled as true disaster tweet: ", preds.sum() )<prepare_x_and_y> | train_image_generator = ImageDataGenerator() | Digit Recognizer |
10,427,138 | Y_test = preds<save_to_csv> | history = model.fit_generator(train_image_generator.flow(x_train,y_train, batch_size =32),epochs = 3,validation_data =(x_val,y_val)) | Digit Recognizer |
10,427,138 | df_submission = pd.read_csv('.. /input/nlp-getting-started/sample_submission.csv', index_col=0 ).fillna('')
df_submission['target'] = Y_test
df_submission.to_csv('submission.csv')
!head submission.csv<set_options> | y_pred = model.predict(x_val)
y_pred_classes = np.argmax(y_pred,axis = 1)
y_pred_classes | Digit Recognizer |
10,427,138 | warnings.filterwarnings('ignore')
stop = set(stopwords.words('english'))
%matplotlib inline
plt.style.use('ggplot')
<load_from_csv> | y_true = np.argmax(y_val,axis = 1)
y_true | Digit Recognizer |
10,427,138 | 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')
train_sent, test_sent, train_label = train.text.values, test.text.values, train.target.values<train_model> | confusion_mtx = confusion_matrix(y_true, y_pred_classes)
confusion_mtx | Digit Recognizer |
10,427,138 | word_tokenizer = Tokenizer()
word_tokenizer.fit_on_texts(train_sent)
vocab_length = len(word_tokenizer.word_index)+ 1<string_transform> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
10,427,138 | <feature_engineering><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 |
10,403,729 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<split> | import tensorflow.keras as keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten
from tensorflow.keras.layers import Conv2D, MaxPool2D
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt | Digit Recognizer |
10,403,729 | X_train, X_test, y_train, y_test = train_test_split(padded_sentences,
train_label,
test_size=0.25,
random_state=42,
shuffle=True)
<train_model> | training_data = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test_data = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
10,403,729 | def training(model, model_name):
checkpoint = ModelCheckpoint(model_name + '.h5', monitor = 'val_loss', verbose = 1, save_best_only = True)
reduce_lr = ReduceLROnPlateau(monitor = 'val_loss', factor = 0.2, verbose = 1, patience = 5, min_lr = 0.001)
early_stop = EarlyStopping(monitor='val_loss', patience=1)
start_tim... | X_train = training_data.drop('label', axis=1 ).values
y_train = training_data[['label']].values
X_test = test_data.values
test_data.shape | Digit Recognizer |
10,403,729 | def CNN() :
model = Sequential()
model.add(Embedding(input_dim=embedding_matrix.shape[0],
output_dim=embedding_matrix.shape[1],
weights=[embedding_matrix],
input_length=length_long_sentence))
model.add(Conv1D(filters=32, kernel_size=8, activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(Flatten())
model... | batch_size = 128
num_classes = 10
epochs = 12
img_rows, img_cols = 28, 28
input_shape =(1, img_rows, img_cols ) | Digit Recognizer |
10,403,729 | training(model, 'model_cnn' )<choose_model_class> | X_train = X_train.reshape(-1,28,28,1)
X_test = X_test.reshape(-1,28,28,1 ) | Digit Recognizer |
10,403,729 | def RNN() :
model = Sequential()
model.add(Embedding(input_dim=embedding_matrix.shape[0],
output_dim=embedding_matrix.shape[1],
weights=[embedding_matrix],
input_length=length_long_sentence))
model.add(Bidirectional(SimpleRNN(length_long_sentence, return_sequences = True, recurrent_dropout=0.2)))
model.add(GlobalMaxPo... | X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
print('x_train shape:', X_train.shape)
print(X_train.shape[0], 'train samples')
print(X_test.shape[0], 'test samples' ) | Digit Recognizer |
10,403,729 | training(model, 'model_rnn' )<choose_model_class> | X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, stratify=y_train,
test_size=0.15, random_state=42 ) | Digit Recognizer |
10,403,729 | def BiGRU() :
model = Sequential()
model.add(Embedding(input_dim=embedding_matrix.shape[0],
output_dim=embedding_matrix.shape[1],
weights=[embedding_matrix],
input_length=length_long_sentence))
model.add(Bidirectional(GRU(length_long_sentence, return_sequences = True, recurrent_dropout=0.2)))
model.add(GlobalMaxPool1D... | y_train = keras.utils.to_categorical(y_train, num_classes)
y_val = keras.utils.to_categorical(y_val, num_classes)
y_train.shape, y_val.shape | Digit Recognizer |
10,403,729 | training(model, 'model_bigru' )<choose_model_class> | model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(filters = 64, k... | Digit Recognizer |
10,403,729 | def BiLSTM() :
model = Sequential()
model.add(Embedding(input_dim=embedding_matrix.shape[0],
output_dim=embedding_matrix.shape[1],
weights=[embedding_matrix],
input_length=length_long_sentence))
model.add(Bidirectional(LSTM(length_long_sentence, return_sequences = True, recurrent_dropout=0.2)))
model.add(GlobalMaxPool... | optimizer = keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'] ) | Digit Recognizer |
10,403,729 | training(model, 'model_bilstm' )<save_to_csv> | model.fit(X_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(X_val, y_val)) | Digit Recognizer |
10,403,729 | submission.target = model.predict_classes(test_sentences)
submission.to_csv("submission.csv", index=False )<import_modules> | score = model.evaluate(X_val, y_val, verbose=0)
score | Digit Recognizer |
10,403,729 | import tensorflow as tf
from tensorflow import keras
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt<load_from_csv> | results = model.predict(X_test)
results = np.argmax(results, axis = 1)
results = pd.Series(results, name="Label" ) | Digit Recognizer |
10,403,729 | <count_values><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"), results],axis = 1)
submission.to_csv("cnn_mnist.csv",index=False ) | Digit Recognizer |
10,394,678 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<count_values> | !pip install -q efficientnet_pytorch | Digit Recognizer |
10,394,678 | df.keyword.value_counts(dropna=False )<count_values> | import time
import random
import datetime
import os
import numpy as np
import pandas as pd
from sklearn import model_selection
import torch
from torch import nn
from torch.utils.data import Dataset, DataLoader
import efficientnet_pytorch
import cv2
import albumentations as A
from albumentations.pytorch.transforms impor... | Digit Recognizer |
10,394,678 | df.location.value_counts(dropna=False )<feature_engineering> | SEED = 42 | Digit Recognizer |
10,394,678 | glove = {}
with open(".. /input/glove6b/glove.6B.100d.txt")as f:
for line in f:
glove[line.split() [0]] = line.split() [1:]<count_values> | def seed_everything(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = True
seed_everything(SEED ) | Digit Recognizer |
10,394,678 | word_counts = df.text.str.lower().str.split().explode().value_counts()
word_counts.cumsum() [10000] / word_counts.sum()<string_transform> | class DataLoaderConfig:
batch_size = 64
num_workers = 8
class TrainConfig:
criterion = nn.CrossEntropyLoss
n_epochs = 10
lr = 0.001
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau
scheduler_params = dict(
mode='min',
factor=0.5,
patience=1,
verbose=False,
threshold=0.0001,
threshold_mode='abs',
cooldown=0,
min_... | Digit Recognizer |
10,394,678 | NUM_WORDS = 10000
MAXLEN = 30
texts = df.text.str.lower()
tokenizer = keras.preprocessing.text.Tokenizer(num_words=NUM_WORDS)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
word_index = tokenizer.word_index
data = keras.preprocessing.sequence.pad_sequences(sequences, maxlen=MAXLEN )<de... | df = pd.read_csv('.. /input/digit-recognizer/train.csv')
print(df.shape)
df.head() | Digit Recognizer |
10,394,678 | labels = df.target<prepare_x_and_y> | y = df['label'].values
X = df.drop(['label'], axis=1 ).values | Digit Recognizer |
10,394,678 | x_train = data
y_train = labels<define_variables> | X_train, X_valid, y_train, y_valid = model_selection.train_test_split(X, y, test_size=0.2)
X_train.shape, X_valid.shape, y_train.shape, y_valid.shape | Digit Recognizer |
10,394,678 | EMBEDDING_DIM = len(glove["the"])
embedding_matrix = np.zeros(( NUM_WORDS, EMBEDDING_DIM))
for word, i in word_index.items() :
if i < NUM_WORDS:
embedding_vector = glove.get(word)
if embedding_vector is not None:
embedding_matrix[i] = embedding_vector<choose_model_class> | class DatasetRetriever(Dataset):
def __init__(self, X, y, transforms=None):
super().__init__()
self.X = X.reshape(-1, 28, 28 ).astype(np.float32)
self.y = y
self.transforms = transforms
def __getitem__(self, index):
image, target = self.X[index], self.y[index]
image = np.stack([image] * 3, axis=-1)
image /= 255.
if ... | Digit Recognizer |
10,394,678 | model = keras.Sequential([
layers.Embedding(NUM_WORDS, EMBEDDING_DIM, input_length=MAXLEN,
name='embedding'),
layers.Bidirectional(layers.GRU(32,
dropout=.2,
recurrent_dropout=.2,)) ,
layers.Dense(1, activation='sigmoid'),
])
model.get_layer('embedding' ).set_weights([embedding_matrix])
model.get_layer('embedding' ).... | def get_train_transforms() :
return A.Compose(
[
A.Rotate(limit=10, border_mode=cv2.BORDER_REPLICATE, p=0.5),
A.Cutout(num_holes=8, max_h_size=2, max_w_size=2, fill_value=0, p=0.5),
A.Cutout(num_holes=8, max_h_size=1, max_w_size=1, fill_value=1, p=0.5),
A.Resize(32, 32, p=1.) ,
ToTensorV2(p=1.0),
],
p=1.0)
def get_va... | Digit Recognizer |
10,394,678 | early_stopping = keras.callbacks.EarlyStopping(
patience=10,
restore_best_weights=True,
)
lr_decay = keras.callbacks.ReduceLROnPlateau()
history = model.fit(
x_train, y_train,
epochs=50,
batch_size=32,
validation_split=.2,
callbacks=[early_stopping, lr_decay]
)<load_from_csv> | train_dataset = DatasetRetriever(
X = X_train,
y = y_train,
transforms=get_train_transforms() ,
)
valid_dataset = DatasetRetriever(
X = X_valid,
y = y_valid,
transforms=get_valid_transforms() ,
) | Digit Recognizer |
10,394,678 | test_df = pd.read_csv(".. /input/nlp-getting-started/test.csv",
index_col=0)
def preprocess(texts, labels=None, tokenizer=tokenizer):
NUM_WORDS = 10000
MAXLEN = 30
texts = pd.Series(texts ).str.lower()
sequences = tokenizer.texts_to_sequences(texts)
data = keras.preprocessing.sequence.pad_sequences(sequences, maxlen=... | train_loader = DataLoader(
train_dataset,
batch_size=DataLoaderConfig.batch_size,
shuffle=True,
num_workers=DataLoaderConfig.num_workers,
)
valid_loader = DataLoader(
valid_dataset,
batch_size=DataLoaderConfig.batch_size,
shuffle=False,
num_workers=DataLoaderConfig.num_workers,
) | Digit Recognizer |
10,394,678 | answer_df = pd.read_csv(
'.. /input/nlp-getting-started/sample_submission.csv',
index_col=0
)
answer_df['target'] =(preds > 0.5 ).astype('uint8')
answer_df.to_csv('submission.csv')
!head submission.csv<install_modules> | class LossMeter:
def __init__(self):
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
class AccMeter:
def __init__(self):
self.true_count = 0
self.all_count = 0
self.avg = 0
def update(self, y_true, y_pred):
y_true = y_true.cpu().n... | Digit Recognizer |
10,394,678 | !pip install -U tensorflow-text==2.3<install_modules> | class Fitter:
def __init__(
self, model, device, criterion, n_epochs,
lr, sheduler=None, scheduler_params=None
):
self.epoch = 0
self.n_epochs = n_epochs
self.base_dir = './'
self.log_path = f'{self.base_dir}/log.txt'
self.best_summary_loss = np.inf
self.model = model
self.device = device
self.optimizer = torch.optim... | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.