kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
8,872,016 | def bert_encode(texts, bert_layer, max_len=128):
vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = tokenization.FullTokenizer(vocab_file, do_lower_case)
all_tokens = []
all_masks = []
all_segments = []
for text in texts:
t... | datagen = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1)
history = datagen.fit(X_train ) | Digit Recognizer |
8,872,016 | %%time
module_url = "https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/1"
bert_layer = hub.KerasLayer(module_url, trainable=True )<load_from_csv> | history = model.fit_generator(datagen.flow(X_train, Y_train, batch_size=100), steps_per_epoch=len(X_train)/100,
epochs=20, validation_data=(X_test, Y_test), callbacks=[reduce_lr] ) | Digit Recognizer |
8,872,016 | train = pd.read_csv("/kaggle/input/nlp-getting-started/train.csv")
train_input = bert_encode(train.text.values, bert_layer, max_len=128)
train_labels = np.array(train.target )<load_from_csv> | Digit Recognizer | |
8,872,016 | test = pd.read_csv("/kaggle/input/nlp-getting-started/test.csv")
test_input = bert_encode(test.text.values, bert_layer, max_len=128)
model.load_weights('model.h5')
test_pred = model.predict(test_input )<save_to_csv> | score = model.evaluate(X_test, Y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1] ) | Digit Recognizer |
8,872,016 | submission = pd.read_csv("/kaggle/input/nlp-getting-started/sample_submission.csv")
submission['target'] = np.round(test_pred ).astype('int')
submission.to_csv('submission.csv', index=False)
submission.groupby('target' ).count()<load_from_csv> | test_data = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
8,872,016 | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
data = pd.read_csv('/kaggle/input/nlp-getting-started/train.csv')
data.sample(10 )<count_duplicates> | test_data = test_data.values
test_data = test_data.reshape(28000, 28, 28,1)
test_data = test_data.astype('float32')
test_data /= 255
print("Test data matrix shape", test_data.shape ) | Digit Recognizer |
8,872,016 | text = data.text
duplicates = data[text.isin(text[text.duplicated() ])].sort_values(by='text')
conflicting_check = pd.DataFrame(duplicates.groupby(['text'] ).target.mean())
conflicting_check.sample(10 )<filter> | y_pred = model.predict_classes(test_data, verbose=0)
print(y_pred ) | Digit Recognizer |
8,872,016 | conflicting = conflicting_check.loc[(conflicting_check.target != 1)&(conflicting_check.target != 0)].index
data = data.drop(data[text.isin(conflicting)].index)
print('Conflicting samples count:', conflicting.shape[0] )<set_options> | i = 9713
predicted_value = np.argmax(model.predict(X_test[i].reshape(1,28, 28,1)))
print('predicted value:',predicted_value)
plt.imshow(X_test[i].reshape([28, 28]), cmap='Greys_r' ) | Digit Recognizer |
8,872,016 | if torch.cuda.is_available() :
device = torch.device("cuda")
print('There are %d GPU(s)available.' % torch.cuda.device_count())
print('We will use the GPU:', torch.cuda.get_device_name(0))
else:
print('No GPU available, using the CPU instead.')
device = torch.device("cpu" )<install_modules> | submissions=pd.DataFrame({"ImageId": list(range(1,len(y_pred)+1)) ,
"Label": y_pred})
submissions.to_csv("LeNet_CNN.csv", index=False ) | Digit Recognizer |
8,872,016 | !pip install transformers<define_variables> | !pip install emnist | Digit Recognizer |
8,872,016 | sentences = data.text.values
labels =data.target.values<load_pretrained> | import matplotlib.pyplot as plt,seaborn as sns,pandas as pd,numpy as np
from keras.models import Sequential, load_model
from keras.layers.core import Dense, Dropout, Activation
from keras.layers import Conv2D, MaxPooling2D,MaxPool2D,Flatten,BatchNormalization
from keras.utils import np_utils
from keras.preprocessing.im... | Digit Recognizer |
8,872,016 | tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True )<categorify> | x_train, y_train = extract_training_samples('digits')
x_test, y_test = extract_test_samples('digits' ) | Digit Recognizer |
8,872,016 | print(' Original: ', sentences[0])
print('Tokenized: ', tokenizer.tokenize(sentences[0]))
print('Token IDs: ', tokenizer.convert_tokens_to_ids(tokenizer.tokenize(sentences[0])) )<define_variables> | in_train_data = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
ex_y_train = in_train_data["label"]
ex_x_train = in_train_data.drop(labels = ["label"],axis = 1 ) | Digit Recognizer |
8,872,016 | 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 tweet length: ', max_len )<categorify> | X_train = x_train.reshape(240000, 28, 28,1)
X_test = x_test.reshape(40000, 28, 28,1)
ex_x_train = ex_x_train.values.reshape(42000,28,28,1)
X_train = np.vstack(( X_train, ex_x_train))
print(X_train.shape ) | Digit Recognizer |
8,872,016 | 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... | X_train = X_train.astype('float32')
X_test = X_test.astype('float32' ) | Digit Recognizer |
8,872,016 | SPLIT = 0.999
dataset = TensorDataset(input_ids, attention_masks, labels)
train_size = int(SPLIT * 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(v... | X_train /= 255
X_test /= 255 | Digit Recognizer |
8,872,016 | 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> | y_train = np.concatenate([y_train,ex_y_train.values])
print(y_train.shape ) | Digit Recognizer |
8,872,016 | model = BertForSequenceClassification.from_pretrained(
"bert-base-uncased",
num_labels = 2,
output_attentions = False,
output_hidden_states = False,
)
model.cuda()<choose_model_class> | n_classes = 10
print("Shape before one-hot encoding: ", y_train.shape)
Y_train = np_utils.to_categorical(y_train, n_classes)
Y_test = np_utils.to_categorical(y_test, n_classes)
print("Shape after one-hot encoding: ", Y_train.shape ) | Digit Recognizer |
8,872,016 | optimizer = AdamW(model.parameters() ,
lr = 2e-5,
eps = 1e-8
)<init_hyperparams> | model = Sequential()
model.add(Conv2D(filters=32, kernel_size=(5,5), padding='same', activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPool2D(pool_size = 2,strides=2))
model.add(Conv2D(filters=48, kernel_size=(5,5), padding='valid', activation='relu'))
model.add(MaxPool2D(pool_size = 2,strides=2))
model.add(Fl... | Digit Recognizer |
8,872,016 | epochs = 2
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> | reduce_lr = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.2,
min_lr=1e-6 ) | Digit Recognizer |
8,872,016 | 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 )<define_variables> | datagen = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1)
history = datagen.fit(X_train ) | Digit Recognizer |
8,872,016 | seed_val = 42
random.seed(seed_val)
np.random.seed(seed_val)
torch.manual_seed(seed_val)
torch.cuda.manual_seed_all(seed_val)
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.... | history = model.fit_generator(datagen.flow(X_train, Y_train, batch_size=100), steps_per_epoch=len(X_train)/100,
epochs=20, validation_data=(X_test, Y_test), callbacks=[reduce_lr] ) | Digit Recognizer |
8,872,016 | pd.set_option('precision', 2)
df_stats = pd.DataFrame(data=training_stats)
df_stats = df_stats.set_index('epoch')
df_stats<load_from_csv> | Digit Recognizer | |
8,872,016 | test_data = pd.read_csv('/kaggle/input/nlp-getting-started/test.csv')
print('Number of test sentences: {:,}
'.format(test_data.shape[0]))
sentences = test_data.text.values
input_ids = []
attention_masks = []
for sent in sentences:
encoded_dict = tokenizer.encode_plus(
sent,
add_special_tokens = True,
max_length = 64,... | score = model.evaluate(X_test, Y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1] ) | Digit Recognizer |
8,872,016 | 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... | test_data = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
8,872,016 | flat_predictions = np.concatenate(predictions, axis=0)
flat_predictions = np.argmax(flat_predictions, axis=1 ).flatten()<save_to_csv> | test_data = test_data.values
test_data = test_data.reshape(28000, 28, 28,1)
test_data = test_data.astype('float32')
test_data /= 255
print("Test data matrix shape", test_data.shape ) | Digit Recognizer |
8,872,016 | submission = pd.read_csv('/kaggle/input/nlp-getting-started/sample_submission.csv')
submission.target = flat_predictions
submission.to_csv('submission.csv', index=False )<set_options> | y_pred = model.predict_classes(test_data, verbose=0)
print(y_pred ) | Digit Recognizer |
8,872,016 | pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 1000)
warnings.filterwarnings("ignore")
eng_stopwords = set(stopwords.words("english"))<load_from_csv> | i = 9713
predicted_value = np.argmax(model.predict(X_test[i].reshape(1,28, 28,1)))
print('predicted value:',predicted_value)
plt.imshow(X_test[i].reshape([28, 28]), cmap='Greys_r' ) | Digit Recognizer |
8,872,016 | train_df = pd.read_csv(".. /input/nlp-getting-started/train.csv")
test_df = pd.read_csv(".. /input/nlp-getting-started/test.csv")
submission = pd.read_csv(".. /input/nlp-getting-started/sample_submission.csv")
print("Training Shape rows = {}, columns = {}".format(train_df.shape[0],train_df.shape[1]))
print("Testing ... | submissions=pd.DataFrame({"ImageId": list(range(1,len(y_pred)+1)) ,
"Label": y_pred})
submissions.to_csv("LeNet_CNN.csv", index=False ) | Digit Recognizer |
7,764,469 | train_df.isnull().sum()<count_missing_values> | random_seed = 2020
np.random.seed(random_seed)
| Digit Recognizer |
7,764,469 | test_df.isnull().sum()<groupby> | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv')
Y = train['label']
X = train.drop(labels="label", axis=1)
X = X.values.reshape(-1, 28, 28, 1)/ 255
test = test.values.reshape(-1, 28, 28, 1)/ 255
print(X.shape, test.shape ) | Digit Recognizer |
7,764,469 | keyword_dist = train_df.groupby("keyword")['target'].value_counts().unstack(fill_value=0)
keyword_dist = keyword_dist.add_prefix(keyword_dist.columns.name ).rename_axis(columns=None ).reset_index()<sort_values> | learning_rate_reduction = ReduceLROnPlateau(monitor = 'val_acc',
patience = 3,
verbose = 1,
factor = 0.5,
min_lr = 0.0001)
es = EarlyStopping(monitor='val_loss',
mode='min',
verbose=1,
patience=15,
restore_best_weights=True)
def new_model(hidden=512, learning_rate=0.00128):
INPUT = Input(( 28, 28, 1))
inputs = Conv2D... | Digit Recognizer |
7,764,469 | keyword_dist.sort_values('target1',ascending = False ).head(10 )<sort_values> | datagen = ImageDataGenerator(featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=10,
zoom_range=0.1,
shear_range=0.02,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False ) | Digit Recognizer |
7,764,469 | keyword_dist.sort_values('target0',ascending = False ).head(10 )<feature_engineering> | epochs = 200
batch_size = 128
print("Learning Properties: Epoch:%i \t Batch Size:%i" %(epochs, batch_size))
predict_accumulator = np.zeros(model.predict(test ).shape)
accumulated_history = []
for i in range(1, 6):
X_train, X_val, Y_train, Y_val = train_test_split(X, Y, test_size=0.20, shuffle=True, random_state=random... | Digit Recognizer |
7,764,469 | train_df['word_count'] = train_df['text'].apply(lambda x : len(str(x ).split()))
test_df['word_count'] = test_df['text'].apply(lambda x : len(str(x ).split()))
train_df['unique_word_count'] = train_df['text'].apply(lambda x : len(set(str(x ).split())))
test_df['unique_word_count'] = test_df['text'].apply(lambda x : le... | print("Completed Training.")
results = np.argmax(predict_accumulator, axis=1)
results = pd.Series(results, name="Label")
print("Saving prediction to output...")
submission = pd.concat([pd.Series(range(1, 1+test.shape[0]), name="ImageId"), results], axis=1)
submission.to_csv('submission.csv', index=False ) | Digit Recognizer |
7,764,469 | <categorify><EOS> | end_time = time.time()
total_time = int(end_time - start_time)
print("Total time spent: %i hours, %i minutes, %i seconds" \
%(( total_time//3600),(total_time%3600)//60,(total_time%60)) ) | Digit Recognizer |
5,786,490 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<categorify> | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Digit Recognizer |
5,786,490 | def clean(tweet):
tweet = re.sub(r"\x89Û_", "", tweet)
tweet = re.sub(r"\x89ÛÒ", "", tweet)
tweet = re.sub(r"\x89ÛÓ", "", tweet)
tweet = re.sub(r"\x89ÛÏWhen", "When", tweet)
tweet = re.sub(r"\x89ÛÏ", "", tweet)
tweet = re.sub(r"China\x89Ûªs", "China's", tweet)
tweet = re.sub(r"let\x89Ûªs", "let's", tweet)
tweet ... | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
5,786,490 | def encode(texts, tokenizer, max_len=512):
all_tokens = []
all_masks = []
all_segments = []
for text in texts:
text = tokenizer.tokenize(text)
text = text[:max_len-2]
input_sequence = ["[CLS]"] + text + ["[SEP]"]
pad_len = max_len - len(input_sequence)
tokens = tokenizer.convert_tokens_to_ids(input_sequence)
tokens ... | X=train.iloc[:,1:].values
Y=train.iloc[:,0].values | Digit Recognizer |
5,786,490 | def build_model(bert_layer, max_len=512):
input_word_ids = Input(shape=(max_len,), dtype=tf.int32, name="input_word_ids")
input_mask = Input(shape=(max_len,), dtype=tf.int32, name="input_mask")
segment_ids = Input(shape=(max_len,), dtype=tf.int32, name="segment_ids")
_, sequence_output = bert_layer([input_word_ids, ... | X = X.reshape(X.shape[0], 28, 28,1)
print(X.shape)
Y = keras.utils.to_categorical(Y, 10)
print(Y.shape ) | Digit Recognizer |
5,786,490 | %%time
bert_layer = hub.KerasLayer('https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/1', trainable=True )<feature_engineering> | X_train, X_valid, Y_train, Y_valid = train_test_split(X, Y, test_size = 0.15, random_state=42 ) | Digit Recognizer |
5,786,490 | vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()
do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()
tokenizer = tokenization.FullTokenizer(vocab_file, do_lower_case )<categorify> | train_datagen = ImageDataGenerator(rescale = 1./255.,
rotation_range = 10,
width_shift_range = 0.15,
height_shift_range = 0.15,
shear_range = 0.1,
zoom_range = 0.2,
horizontal_flip = False ) | Digit Recognizer |
5,786,490 | train_input = encode(train_df.text_cleaned.values, tokenizer, max_len=160)
test_input = encode(test_df.text_cleaned.values, tokenizer, max_len=160)
train_labels = train_df.target.values<train_model> | valid_datagen = ImageDataGenerator(rescale=1./255 ) | Digit Recognizer |
5,786,490 | checkpoint = ModelCheckpoint('model.h5', monitor='val_loss', save_best_only=True)
train_history = model.fit(
train_input, train_labels,
validation_split=0.2,
epochs=3,
callbacks=[checkpoint],
batch_size=32
)<predict_on_test> | model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(64,(3,3), padding='same', input_shape=(28, 28, 1)) ,
tf.keras.layers.LeakyReLU(alpha=0.1),
tf.keras.layers.Conv2D(64,(3,3), padding='same'),
tf.keras.layers.LeakyReLU(alpha=0.1),
tf.keras.layers.MaxPooling2D(2, 2),
tf.keras.layers.Dropout(0.2),
tf.keras.layers... | Digit Recognizer |
5,786,490 | model.load_weights('model.h5')
test_pred_BERT = model.predict(test_input)
test_pred_BERT_int = test_pred_BERT.round().astype('int' )<save_to_csv> | initial_learningrate=1e-3
batch_size = 128
epochs = 40
input_shape =(28, 28, 1 ) | Digit Recognizer |
5,786,490 | submission['target'] = test_pred_BERT_int
submission.to_csv("submission_BERT.csv", index=False, header=True )<import_modules> | def lr_decay(epoch):
return initial_learningrate * 0.9 ** epoch | Digit Recognizer |
5,786,490 | import pandas as pd
from tqdm import tqdm<load_from_csv> | model.compile(loss="categorical_crossentropy",
optimizer=RMSprop(lr=initial_learningrate),
metrics=['accuracy'] ) | Digit Recognizer |
5,786,490 | train = pd.read_csv('.. /input/ames-housing-dataset/AmesHousing.csv')
train.drop(['PID'], axis=1, inplace=True)
origin = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/train.csv')
train.columns = origin.columns
test = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/test.csv')
... | history = model.fit_generator(
train_datagen.flow(X_train,Y_train, batch_size=batch_size),
steps_per_epoch=100,
epochs=epochs,
callbacks=[LearningRateScheduler(lr_decay)
],
validation_data=valid_datagen.flow(X_valid,Y_valid),
validation_steps=50,
verbose=2 ) | Digit Recognizer |
5,786,490 | missing = test.isnull().sum()
missing = missing[missing>0]
train.drop(missing.index, axis=1, inplace=True)
train.drop(['Electrical'], axis=1, inplace=True)
test.dropna(axis=1, inplace=True)
test.drop(['Electrical'], axis=1, inplace=True )<feature_engineering> | predictions = model.predict_classes(x_test/255.) | Digit Recognizer |
5,786,490 | l_test = tqdm(range(0, len(test)) , desc='Matching')
for i in l_test:
for j in range(0, len(train)) :
for k in range(1, len(test.columns)) :
if test.iloc[i,k] == train.iloc[j,k]:
continue
else:
break
else:
submission.iloc[i, 1] = train.iloc[j, -1]
break
l_test.close()<save_to_csv> | final=pd.DataFrame({"ImageId": list(range(1,len(predictions)+1)) ,
"Label": predictions} ) | Digit Recognizer |
5,786,490 | <import_modules><EOS> | final.to_csv("cnn_submission.csv",index=False)
| Digit Recognizer |
2,539,513 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<load_from_csv> | %matplotlib inline | Digit Recognizer |
2,539,513 | def load_data() :
data_dir = Path(".. /input/house-prices-advanced-regression-techniques/")
df_train = pd.read_csv(data_dir / "train.csv", index_col="Id")
df_test = pd.read_csv(data_dir / "test.csv", index_col="Id")
df = pd.concat([df_train, df_test])
df = clean(df)
df = encode(df)
df = impute_plus(df)
df_train ... | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
2,539,513 | data_dir = Path(".. /input/house-prices-advanced-regression-techniques/")
df = pd.read_csv(data_dir / "train.csv", index_col="Id")
df.Exterior2nd.unique()<feature_engineering> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
2,539,513 | def clean(df):
df['Exterior2nd'] = df['Exterior2nd'].replace({'Brk Cmn': 'BrkComm'})
df['GarageYrBlt'] = df['GarageYrBlt'].where(df.GarageYrBlt <= 2010, df.YearBuilt)
df.rename(columns={
'1stFlrSF': 'FirstFlrSF',
'2ndFlrSF': 'SecondFlrSF',
'3SsnPorch': 'Threeseasonporch'
}, inplace=True)
return df<define_variables> | X_train = train.drop(labels = ["label"],axis = 1)
Y_train = train["label"]
len(Y_train ) | Digit Recognizer |
2,539,513 | features_nom = ["MSSubClass", "MSZoning", "Street", "Alley", "LandContour", "LotConfig",
"Neighborhood", "Condition1", "Condition2", "BldgType", "HouseStyle",
"RoofStyle", "RoofMatl", "Exterior1st", "Exterior2nd", "MasVnrType",
"Foundation", "Heating", "CentralAir", "GarageType", "MiscFeature",
"SaleType", "SaleConditi... | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
2,539,513 | def impute_plus(df):
cols_with_missing = [col for col in df.columns if col != 'SalePrice' and df[col].isnull().any() ]
for col in cols_with_missing:
df[col + '_was_missing'] = df[col].isnull()
df[col + '_was_missing'] =(df[col + '_was_missing'])* 1
for name in df.select_dtypes("number"):
df[name] = df[name].fillna(0)
... | img_width = 28
img_height = 28
n_channels = 1
X_train = X_train.values.reshape(-1,img_height,img_width,n_channels)
test = test.values.reshape(-1,img_height,img_width,n_channels ) | Digit Recognizer |
2,539,513 | df_train, df_test = load_data()<init_hyperparams> | Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
2,539,513 | xgb_params = dict(
max_depth=3,
learning_rate=0.1,
n_estimators=100,
min_child_weight=1,
colsample_bytree=1,
subsample=1,
reg_alpha=0,
reg_lambda=1,
num_parallel_tree=1,
)<compute_train_metric> | X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.1, random_state=2 ) | Digit Recognizer |
2,539,513 | def score_dataset(X, y, model=XGBRegressor(**xgb_params)) :
for colname in X.select_dtypes(["category"]):
X[colname] = X[colname].cat.codes
log_y = np.log(y)
score = cross_val_score(
model, X, log_y, cv=5, scoring='neg_mean_squared_error'
)
score = -1 * score.mean()
score = np.sqrt(score)
return score<compute_test... | print("Total Images:",len(Y_train)+len(Y_val))
print("Training Images:",len(Y_train))
print("Validation Images:",len(Y_val)) | Digit Recognizer |
2,539,513 | X = df_train.copy()
y = X.pop("SalePrice")
baseline_score = score_dataset(X, y)
print(f"Baseline score: {baseline_score:.5f} RMSE" )<normalization> | model = Sequential()
model.add(Convolution2D(filters = 32, kernel_size =(5,5),padding = 'Same', activation ='relu', input_shape = input_shape))
model.add(Convolution2D(filters = 32, kernel_size =(5,5),padding = 'Same', activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Convol... | Digit Recognizer |
2,539,513 | mi_scores = make_mi_scores(X, y)
<drop_column> | optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)
model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
2,539,513 | def drop_uninformative(df, mi_scores, threshold=0.0):
return df.loc[:, mi_scores > threshold]<drop_column> | 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 |
2,539,513 | drop_uninformative(X, mi_scores )<prepare_x_and_y> | Model = model.fit_generator(datagen.flow(X_train, Y_train,batch_size=200),epochs=30,verbose=1,validation_data=(X_val, Y_val)) | Digit Recognizer |
2,539,513 | X = df_train.copy()
y = X.pop("SalePrice")
mi_scores = make_mi_scores(X, y)
X["AllPub"] = X["Utilities"] == "AllPub"
mi_scores = make_mi_scores(X, y)
X = drop_uninformative(X, mi_scores)
X.head()
score_dataset(X, y )<categorify> | model.save("cnn_digit_recognizer.h5" ) | Digit Recognizer |
2,539,513 | def label_encode(df):
X = df.copy()
for colname in X.select_dtypes(['category']):
X[colname] = X[colname].cat.codes
return X<feature_engineering> | score = model.evaluate(X_train, Y_train, verbose=1)
print('Train Loss:', score[0])
print('Train Accuracy:', score[1] ) | Digit Recognizer |
2,539,513 | def mathematical_transforms(df):
X = pd.DataFrame()
X['LivLotRatio'] = df.GrLivArea / df.LotArea
X['Spaciousness'] =(df.FirstFlrSF + df.SecondFlrSF)/ df.TotRmsAbvGrd
X['AgeAtTOS'] = df.YrSold - df.YearBuilt
return X<categorify> | score = model.X_valuate(X_val, Y_val, verbose=1)
print('Validation Loss:', score[0])
print('Validation Accuracy:', score[1] ) | Digit Recognizer |
2,539,513 | def interactions(df):
X_inter_1 = pd.get_dummies(df.BldgType, prefix='Bldg')
X_inter_1 = X_inter_1.mul(df.GrLivArea, axis=0)
X_inter_2 = pd.get_dummies(df.BsmtCond, prefix='BsmtCond')
X_inter_2 = X_inter_2.mul(df.TotalBsmtSF, axis=0)
X_inter_3 = pd.get_dummies(df.GarageQual, prefix='GarageQual')
X_inter_3 = X_inte... | Y_pred = model.predict(X_val)
Y_pred_classes = np.argmax(Y_pred,axis = 1)
Y_true = np.argmax(Y_val,axis = 1)
confusion_Matrix = confusion_matrix(Y_true, Y_pred_classes)
print(confusion_Matrix ) | Digit Recognizer |
2,539,513 | def counts(df):
X = pd.DataFrame()
X['PorchTypes'] = df[['WoodDeckSF',
'OpenPorchSF',
'EnclosedPorch',
'Threeseasonporch',
'ScreenPorch'
]].gt(0.0 ).sum(axis=1)
X['TotalHalfBath'] = df.BsmtFullBath + df.BsmtHalfBath
X['TotalRoom'] = df.TotRmsAbvGrd + df.FullBath + df.HalfBath
return X<create_dataframe> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
2,539,513 | def group_transforms(df):
X = pd.DataFrame()
X['MedNhbdArea'] = df.groupby('Neighborhood')['GrLivArea'].transform('median')
X['MeanAgeAtTOS'] = df.groupby('Neighborhood')['AgeAtTOS'].transform('mean')
return X<define_variables> | final_Result = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
final_Result.to_csv("cnn_mnist_datagen.csv",index=False ) | Digit Recognizer |
7,324,632 | cluster_features = [
"LotArea",
"TotalBsmtSF",
"FirstFlrSF",
"SecondFlrSF",
"GrLivArea",
]<find_best_model_class> | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv');
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv'); | Digit Recognizer |
7,324,632 | def cluster_labels(df, features, n_clusters=20):
X = df.copy()
X_scaled = X.loc[:, features]
X_scaled =(X_scaled - X_scaled.mean(axis=0)) / X_scaled.std(axis=0)
kmeans = KMeans(n_clusters=n_clusters, n_init=50, random_state=0)
X_new = pd.DataFrame()
X_new["Cluster"] = kmeans.fit_predict(X_scaled)
return X_new<normal... | rows = 28
cols = 28
tot_rows = train.shape[0]
X_train = train.values[:,1:]
y_train = keras.utils.to_categorical(train.label, 10)
X_train = X_train.reshape(tot_rows, rows, cols, 1)/255.0
X_test = test.values[:]
test_num_img = test.shape[0]
X_test = X_test.reshape(test_num_img, rows, cols, 1)/255.0 | Digit Recognizer |
7,324,632 | def cluster_distance(df, features, n_clusters=20):
X = df.copy()
X_scaled = X.loc[:, features]
X_scaled =(X_scaled - X_scaled.mean(axis=0)) / X_scaled.std(axis=0)
kmeans = KMeans(n_clusters=20, n_init=50, random_state=0)
X_cd = kmeans.fit_transform(X_scaled)
X_cd = pd.DataFrame(
X_cd, columns=[f"Centroid_{i}" for i... | classifier = Sequential()
classifier.add(Conv2D(32,(5,5),input_shape=(28,28,1),activation = 'relu',padding='same'))
classifier.add(BatchNormalization())
classifier.add(Conv2D(32,(3,3),activation = 'relu',padding='same'))
classifier.add(BatchNormalization())
classifier.add(MaxPooling2D(pool_size=(2,2), strides=None))
... | Digit Recognizer |
7,324,632 | def apply_pca(X, standardize=True):
if standardize:
X =(X - X.mean(axis=0)) / X.std(axis=0)
pca = PCA()
X_pca = pca.fit_transform(X)
component_names = [f"PC{i+1}" for i in range(X_pca.shape[1])]
X_pca = pd.DataFrame(X_pca, columns=component_names)
loadings = pd.DataFrame(
pca.components_.T,
columns=component_names,... | classifier.compile(optimizer='adam',loss = 'binary_crossentropy',metrics=['accuracy'])
classifier.fit(X_train,y_train,epochs=100,batch_size=64,validation_split=0.1,shuffle=True ) | Digit Recognizer |
7,324,632 | pca_features = [
"GarageArea",
"YearRemodAdd",
"TotalBsmtSF",
"GrLivArea",
]<load_pretrained> | result = classifier.predict_classes(X_test ) | Digit Recognizer |
7,324,632 | <feature_engineering><EOS> | out = pd.DataFrame({"ImageId": i+1 , "Label": result[i]} for i in range(0, test_num_img))
out.to_csv('submission.csv', index=False ) | Digit Recognizer |
3,811,526 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<sort_values> | import PIL
import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import keras
from matplotlib import pyplot
from sklearn import preprocessing | Digit Recognizer |
3,811,526 | component = "PC1"
idx = X_pca[component].sort_values(ascending=False ).index
df_train[["SalePrice", "Neighborhood", "SaleCondition"] + pca_features].iloc[idx]<create_dataframe> | run_model1 = False
run_model2 = False
run_model3 = False
run_model_adv = True | Digit Recognizer |
3,811,526 | def indicate_outliers(df):
X_new = pd.DataFrame()
X_new["Outlier"] =(df.Neighborhood == "Edwards")&(df.SaleCondition == "Partial")
return X_new<categorify> | train = pd.read_csv('.. /input/train.csv', delimiter=',')
test = pd.read_csv('.. /input/test.csv', delimiter=',' ) | Digit Recognizer |
3,811,526 | class CrossFoldEncoder:
def __init__(self, encoder, **kwargs):
self.encoder_ = encoder
self.kwargs_ = kwargs
self.cv_ = KFold(n_splits=5)
def fit_transform(self, X, y, cols):
self.fitted_encoders_ = []
self.cols_ = cols
X_encoded = []
for idx_encode, idx_train in self.cv_.split(X):
fitted_encoder = self.encoder_(cols=... | train_size = train.shape[0]
test_size = test.shape[0]
X_train = train.iloc[:, 1:].values.astype('uint8')
Y_train = train.iloc[:, 0]
X_test = test.iloc[:, :].values.astype('uint8')
img_dimension = np.int32(np.sqrt(X_train.shape[1]))
img_rows, img_cols = img_dimension, img_dimension
nb_of_color_channels = 1
if(keras.ba... | Digit Recognizer |
3,811,526 | def create_features(df, df_test=None):
X = df.copy()
y = X.pop('SalePrice')
mi_scores = make_mi_scores(X, y)
if df_test is not None:
X_test = df_test.copy()
y_test = X_test.pop("SalePrice")
X = pd.concat([X, X_test])
X = X.join(mathematical_transforms(X))
X = X.join(counts(X))
X = X.join(group_transforms(X))
X = X.... | X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train_nor = X_train / 255
X_test_nor= X_test / 255 | Digit Recognizer |
3,811,526 | df_train, df_test = load_data()
X_train = create_features(df_train)
y_train = df_train.loc[:, 'SalePrice']
score_dataset(X_train, y_train )<prepare_x_and_y> | oh_encoder = preprocessing.OneHotEncoder(categories='auto')
oh_encoder.fit(Y_train.values.reshape(-1,1))
Y_train_oh = oh_encoder.transform(Y_train.values.reshape(-1,1)).toarray() | Digit Recognizer |
3,811,526 | X_train = create_features(df_train)
y_train = df_train.loc[:, "SalePrice"]
xgb_params = dict(
max_depth=4,
learning_rate=0.0058603076512435655,
n_estimators=5045,
min_child_weight=2,
colsample_bytree=0.22556099175248345,
subsample=0.5632348136091383,
reg_alpha=0.09888625622197889,
reg_lambda=0.00890758697724437,
num_... | print('One-hot:')
print(Y_train_oh[:5])
print('
Label:')
print(Y_train[:5] ) | Digit Recognizer |
3,811,526 |
<predict_on_test> | to_categorical(Y_train, Y_train.unique().shape[0])[:5]
| Digit Recognizer |
3,811,526 | X_train, X_test = create_features(df_train, df_test)
y_train = df_train.loc[:, "SalePrice"]
xgb = XGBRegressor(**xgb_params)
xgb.fit(X_train, np.log(y))
predictions = np.exp(xgb.predict(X_test))
output = pd.DataFrame({'Id': X_test.index, 'SalePrice': predictions} )<save_to_csv> | from keras.layers import Activation,Dropout,Dense,Conv2D,AveragePooling2D,Flatten,ZeroPadding2D,MaxPooling2D
from keras.models import Sequential
from keras import optimizers
from keras.callbacks import ReduceLROnPlateau | Digit Recognizer |
3,811,526 | output.to_csv('submission.csv', index=False)
print("Your predictions are successfully saved!" )<save_to_csv> | def build_lenet5(model, input_shape=X_train.shape[1:], dropout=0):
S = [1,2,1,2,1]
N_input = [28,28,14,10,5]
P = [2,0,0,0,0]
N = [28,14,10,5,1]
F = [i[0] + 2*i[1] - i[3]*(i[2] - 1)for i in zip(N_input, P, N, S)]
model.add(Conv2D(filters=6, kernel_size=(F[0],F[0]), padding='same', strides=S[0],
activation='relu', input_... | Digit Recognizer |
3,811,526 | filename = 'ames_house_xgb_model.pkl'
pickle.dump(xgb, open(filename, 'wb'))
X_test.to_csv('df_test_processed.csv', index=False )<predict_on_test> | hist_dict = {}
if __name__ == '__main__' and run_model1:
adam = optimizers.Adam()
model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer=adam)
hist_dict['run_model1'] = model.fit(X_train, Y_train_oh, batch_size=64, epochs=20,
shuffle=True, validation_split=0.2, verbose=2)
| Digit Recognizer |
3,811,526 | row_to_show = 42
data_for_prediction = X_test.iloc[[row_to_show]]
y_sample = np.exp(xgb.predict(data_for_prediction))
explainer = shap.TreeExplainer(xgb)
shap_values = explainer.shap_values(data_for_prediction )<predict_on_test> | def model_predict(model):
print("Generating test predictions...")
predictions = model.predict_classes(X_test, verbose=1)
print("OK.")
return predictions
def model_predict_val(model, set_check):
print("Generating set predictions...")
predictions = model.predict_classes(set_check, verbose=1)
print("OK.")
return pre... | Digit Recognizer |
3,811,526 | data_for_prediction = X_test
y_sample = np.exp(xgb.predict(data_for_prediction))
explainer = shap.TreeExplainer(xgb)
shap_values = explainer.shap_values(data_for_prediction )<define_variables> | if __name__ == '__main__' and run_model2:
model = Sequential()
build_lenet5(model, input_shape=X_train.shape[1:], dropout=0.3)
model.summary()
adam = optimizers.Adam()
model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer=adam)
hist_dict['run_model2'] = model.fit(X_train, Y_train_oh, batch_si... | Digit Recognizer |
3,811,526 | BATCH_SIZE = 128
EPOCHS = 15<load_from_csv> | if __name__ == '__main__' and run_model2:
predictions = model_predict(model)
print(predictions[:5])
write_preds(predictions, "keras-lenet5-basic-droupout.csv" ) | Digit Recognizer |
3,811,526 | train = pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/train.csv")
test = pd.read_csv("/kaggle/input/house-prices-advanced-regression-techniques/test.csv" )<set_options> |
datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=15,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(X... | Digit Recognizer |
3,811,526 | sns.set_theme(rc = {'grid.linewidth': 0.5,
'axes.linewidth': 0.75, 'axes.facecolor': '
'figure.facecolor': '
'xtick.labelcolor': '<prepare_x_and_y> | for x_batch, y_batch in datagen.flow(X_train, Y_train_oh, batch_size=9, shuffle = False):
print(x_batch.shape)
print(y_batch.shape)
break | Digit Recognizer |
3,811,526 | ntrain = train.shape[0]
ntest = test.shape[0]
y_train = train.SalePrice.values
all_data = pd.concat(( train, test)).reset_index(drop=True)
all_data.drop(['SalePrice', 'GarageArea', 'TotRmsAbvGrd'], axis=1, inplace=True)
print("all_data size is : {}".format(all_data.shape))<create_dataframe> | if __name__ == '__main__' and run_model3:
X_train_s, X_val, Y_train_s, Y_val = train_test_split(X_train, Y_train_oh, test_size=0.13, random_state=42)
model = Sequential()
build_lenet5(model, input_shape=X_train_s.shape[1:], dropout=0.15)
model.summary()
adam = optimizers.Adam()
model.compile(loss='categorical_crossen... | Digit Recognizer |
3,811,526 | all_data_na =(all_data.isnull().sum() / len(all_data)) * 100
all_data_na = all_data_na.drop(all_data_na[all_data_na == 0].index ).sort_values(ascending=False)[:30]
missing_data = pd.DataFrame({'Missing Ratio' :all_data_na})
missing_data.head(20 )<data_type_conversions> | if __name__ == '__main__' and run_model3:
predictions = model_predict(model)
print(predictions[:5])
write_preds(predictions, "keras-lenet5-aug.csv")
| Digit Recognizer |
3,811,526 | all_data["PoolQC"] = all_data["PoolQC"].fillna("None" )<data_type_conversions> | Digit Recognizer | |
3,811,526 | all_data["MiscFeature"] = all_data["MiscFeature"].fillna("None" )<data_type_conversions> | def build_net_advanced(model, input_shape=X_train.shape[1:], dropout=0.25):
model.add(Conv2D(filters=32, kernel_size=(5,5), padding='same', strides=1,
activation='relu', input_shape=input_shape))
model.add(Conv2D(filters=32, kernel_size=(5,5), padding='valid', strides=2,
activation='relu'))
model.add(MaxPooling2D(pool_... | Digit Recognizer |
3,811,526 | all_data["Alley"] = all_data["Alley"].fillna("None" )<data_type_conversions> | if __name__ == '__main__' and run_model_adv:
X_train_s, X_val, Y_train_s, Y_val = train_test_split(X_train, Y_train_oh, test_size=0.15, random_state=42)
model = Sequential()
build_net_advanced(model, input_shape=X_train_s.shape[1:], dropout=0.3)
model.summary()
adam = optimizers.Adam()
model.compile(loss='categorical... | Digit Recognizer |
3,811,526 | all_data["Fence"] = all_data["Fence"].fillna("None" )<data_type_conversions> | if __name__ == '__main__' and run_model_adv:
predictions = model_predict(model)
print(predictions[:5])
write_preds(predictions, "keras-adv-net.csv")
| Digit Recognizer |
3,811,526 | all_data["FireplaceQu"] = all_data["FireplaceQu"].fillna("None" )<categorify> | _, X_val_check, _, Y_val_check = train_test_split(X_train, Y_train, test_size=0.1, random_state=1)
Ypred_val_check = model_predict_val(model, set_check=X_val_check)
| Digit Recognizer |
3,811,526 | all_data["LotFrontage"] = all_data.groupby("Neighborhood")["LotFrontage"].transform(
lambda x: x.fillna(x.median()))<data_type_conversions> | cm = confusion_matrix(Y_val_check.values, Ypred_val_check)
cm | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.