kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
6,485,130 | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head()<define_variables> | learn = cnn_learner(data, base_arch = models.resnet34, metrics = accuracy,model_dir="/tmp/models", callback_fns=ShowGraph)
| Digit Recognizer |
6,485,130 | women = train_data.loc[train_data.Sex == 'female']["Survived"]
rate_women = sum(women)/len(women)
print("% of women who survived:", rate_women )<define_variables> | doc(fit_one_cycle ) | Digit Recognizer |
6,485,130 | men = train_data.loc[train_data.Sex == 'male']["Survived"]
rate_men = sum(men)/len(men)
print("% of men who survived:", rate_men )<count_missing_values> | learn.fit_one_cycle(3 ) | Digit Recognizer |
6,485,130 | for column in train_data.columns:
print("%-15s%3d" %(column, pd.isnull(train_data[column] ).sum()))<count_missing_values> | learn.save('model1' ) | Digit Recognizer |
6,485,130 | for column in test_data.columns:
print("%-15s%3d" %(column, pd.isnull(test_data[column] ).sum()))<count_duplicates> | learn.load('model1' ) | Digit Recognizer |
6,485,130 | print(train_data.drop_duplicates().groupby('Embarked')['PassengerId'].count() )<feature_engineering> | learn.lr_find() | Digit Recognizer |
6,485,130 | train_data['Embarked'] = train_data['Embarked'].fillna("S" )<feature_engineering> | learn.fit_one_cycle(30 , slice(1e-3, 1e-2)) | Digit Recognizer |
6,485,130 | test_data['Fare'] = test_data['Fare'].fillna(0 )<feature_engineering> | interp = ClassificationInterpretation.from_learner(learn ) | Digit Recognizer |
6,485,130 | train_data['TicketLength'] = train_data['Ticket'].apply(lambda x: len(x))<feature_engineering> | class_score , y = learn.get_preds(DatasetType.Test ) | Digit Recognizer |
6,485,130 | test_data['TicketLength'] = test_data['Ticket'].apply(lambda x: len(x))<save_to_csv> | probabilities = class_score[0].tolist()
[f"{index}: {probabilities[index]}" for index in range(len(probabilities)) ] | Digit Recognizer |
6,485,130 | y = train_data["Survived"]
features = ["Pclass", "Sex", "SibSp", "Parch", "Fare", "Embarked", "TicketLength"]
X = pd.get_dummies(train_data[features])
X_test = pd.get_dummies(test_data[features])
model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=1)
model.fit(X, y)
predictions = model.predic... | class_score = np.argmax(class_score, axis=1 ) | Digit Recognizer |
6,485,130 | import random
import html
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from tqdm.notebook import tqdm
import tensorflow as tf
import tensorflow.keras.backend as K
import os
from scipy.stats import spearmanr
from scipy.optimize import minimize
from transformers import *
from tensorflow.keras.la... | ImageId = [os.path.splitext(path)[0] for path in os.listdir(TEST)]
ImageId = [int(path)for path in ImageId]
ImageId = [ID+1 for ID in ImageId] | Digit Recognizer |
6,485,130 | <set_options><EOS> | submission = pd.DataFrame({
"ImageId": ImageId,
"Label": class_score
})
submission.to_csv("submission.csv", index=False)
display(submission.head(3))
display(submission.tail(3))
| Digit Recognizer |
9,904,099 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<feature_engineering> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Flatten, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
from... | Digit Recognizer |
9,904,099 | seed = 13
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
tf.random.set_seed(seed )<load_from_csv> | df_train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
df_test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
9,904,099 | def get_data() :
print('getting test and train data...')
path = '.. /input/google-quest-challenge/'
train = pd.read_csv(path+'train.csv')
test = pd.read_csv(path+'test.csv')
submission = pd.read_csv(path+'sample_submission.csv')
y = train[train.columns[11:]]
X = train[['question_title', 'question_body', 'answer']]
... | X_train = df_train.drop('label', axis=1 ).values
y_train = df_train['label'].values.reshape(-1,1)
X_test = df_test.values | Digit Recognizer |
9,904,099 | def get_tokenizer(model_name):
print(f'getting tokenizer for {model_name}...')
if model_name == 'xlnet-base-cased':
tokenizer = XLNetTokenizer.from_pretrained('xlnet-base-cased')
elif model_name == 'roberta-base':
tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
elif model_name == 'bert-base-uncased':
to... | X_train = X_train.astype('float32')/255.0
X_test = X_test.astype('float32')/255.0 | Digit Recognizer |
9,904,099 | def fix_length(tokens, max_sequence_length=512, q_max_len=254, a_max_len=254, model_type='questions'):
if model_type == 'questions':
length = len(tokens)
if length > max_sequence_length:
tokens = tokens[:max_sequence_length-1]
return tokens
else:
question_tokens, answer_tokens = tokens
q_len = len(question_tokens)
a_... | X_train = X_train.reshape(-1,28,28,1)
X_test = X_test.reshape(-1,28,28,1)
y_train = to_categorical(y_train)
target_count = y_train.shape[1] | Digit Recognizer |
9,904,099 | def transformer_inputs(title, question, answer, tokenizer, model_type='questions', MAX_SEQUENCE_LENGTH = 512):
if model_type == 'questions':
question = f"{title} [SEP] {question}"
question_tokens = tokenizer.tokenize(question)
question_tokens = fix_length(question_tokens, model_type=model_type)
ids_q = tokenizer.conv... | 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 |
9,904,099 | def input_data(df, tokenizer, model_type='questions'):
print(f'generating {model_type} input for transformer...')
input_ids, input_token_type_ids, input_attention_masks = [], [], []
for title, body, answer in tqdm(zip(df["question_title"].values, df["question_body"].values, df["answer"].values)) :
ids, type_ids, mask ... | X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.1, random_state=42 ) | Digit Recognizer |
9,904,099 | def get_model(name):
if name == 'xlnet-base-cased':
config = XLNetConfig.from_pretrained('xlnet-base-cased', output_hidden_states=True)
model = TFXLNetModel.from_pretrained('xlnet-base-cased', config=config)
elif name == 'roberta-base':
config = RobertaConfig.from_pretrained('roberta-base', output_hidden_states=True)... | model = Sequential()
model.add(Conv2D(filters=64, kernel_size=(3,3), padding='valid', activation='relu', input_shape=(28, 28, 1)))
model.add(BatchNormalization())
model.add(Conv2D(filters=64, kernel_size=(3,3), padding='valid', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(filters=64, kernel_s... | Digit Recognizer |
9,904,099 | def create_model(name='xlnet-base-cased', model_type='questions'):
print(f'creating model {name}...')
K.clear_session()
max_seq_length = 512
input_tokens = tf.keras.layers.Input(shape=(max_seq_length,), dtype=tf.int32, name="input_tokens")
input_mask = tf.keras.layers.Input(shape=(max_seq_length,), dtype=tf.int32, na... | y_val_m = y_val.argmax(axis=1)
y_val_hat_prob = model.predict(X_val)
y_val_hat = y_val_hat_prob.argmax(axis=1)
X_val_inc = X_val[y_val_m != y_val_hat, :, :, :]
y_val_inc = y_val_m[y_val_m != y_val_hat]
y_val_hat_inc = y_val_hat[y_val_m != y_val_hat]
y_val_hat_prob_inc = y_val_hat_prob[y_val_m != y_val_hat] | Digit Recognizer |
9,904,099 | class data_generator:
def __init__(self, X, X_test, tokenizer, type_):
tokens, masks, segments = input_data(X_test, tokenizer, type_)
self.test_data = {'input_tokens': tokens,
'input_mask': masks,
'input_segment': segments}
self.tokens, self.masks, self.segments = input_data(X, tokenizer, type_)
def generate_data(tr,... | for i in range(0,10):
act = y_val_inc[i]
pred = y_val_hat_inc[i]
print('Actual: {}; Confidence(act/pred): \t{} - {:.0f}% \t{} - {:.0f}%'.format(act, act, y_val_hat_prob_inc[i][act]*100, pred, y_val_hat_prob_inc[i][pred]*100)) | Digit Recognizer |
9,904,099 | def optimize_ranks(preds, unique_labels):
print(f'optimizing the predicted values...')
new_preds = np.zeros(preds.shape)
for i in range(preds.shape[1]):
interpolate_bins = np.digitize(preds[:, i], bins=unique_labels, right=False)
if len(np.unique(interpolate_bins)) == 1:
new_preds[:, i] = preds[:, i]
else:
new_preds... | y_test_hat = model.predict(X_test ).argmax(axis=1)
df_submission = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv')
df_submission['Label'] = y_test_hat.astype('int32')
df_submission.to_csv('Submission.csv', index=False)
print('Submission saved!' ) | Digit Recognizer |
9,904,099 | def get_exp_labels(train):
X = train.iloc[:, 11:]
unique_labels = np.unique(X.values)
denominator = 60
q = np.arange(0, 101, 100 / denominator)
exp_labels = np.percentile(unique_labels, q)
return exp_labels<compute_test_metric> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Flatten, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
from... | Digit Recognizer |
9,904,099 | def compute_spearmanr_ignore_nan(trues, preds):
rhos = []
for tcol, pcol in zip(np.transpose(trues), np.transpose(preds)) :
rhos.append(spearmanr(tcol, pcol ).correlation)
return np.nanmean(rhos )<compute_test_metric> | df_train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
df_test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
9,904,099 | def rhos(y, y_pred):
return tf.py_function(compute_spearmanr_ignore_nan,(y, y_pred), tf.double )<train_model> | X_train = df_train.drop('label', axis=1 ).values
y_train = df_train['label'].values.reshape(-1,1)
X_test = df_test.values | Digit Recognizer |
9,904,099 | def fit_model(model, model_name, model_type, data_gen, file_path, train, use_saved_weights=True):
path = '.. /input/google-qna-predicted-data/'
if use_saved_weights:
print(f'getting saved weights for {model_name}...')
model.load_weights(path+file_path)
else:
print(f'fitting data on {model_name}...')
optimizer = tf.k... | X_train = X_train.astype('float32')/255.0
X_test = X_test.astype('float32')/255.0 | Digit Recognizer |
9,904,099 | def get_weighted_avg(model_predictions):
xlnet_q, xlnet_a, roberta_q, roberta_a, roberta_qa, bert_q, bert_a, bert_qa = model_predictions
xlnet_concat = np.concatenate(( xlnet_q, xlnet_a), axis=1)
bert_concat = np.concatenate(( bert_q, bert_a), axis=1)
roberta_concat = np.concatenate(( roberta_q, roberta_a), axis=1)
... | X_train = X_train.reshape(-1,28,28,1)
X_test = X_test.reshape(-1,28,28,1)
y_train = to_categorical(y_train)
target_count = y_train.shape[1] | Digit Recognizer |
9,904,099 | def get_predictions(predictions_present=True, model_saved_weights_present=True):
msw = model_saved_weights_present
X, X_test, y, train, test = get_data()
path = '.. /input/google-qna-predicted-data/'
model_names = ['xlnet-base-cased', 'roberta-base', 'bert-base-uncased']
model_types = ['questions', 'answers', 'question... | 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 |
9,904,099 | submission = get_predictions(predictions_present=True)
<save_to_csv> | X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.1, random_state=42 ) | Digit Recognizer |
9,904,099 | submission = pd.read_csv('.. /input/google-qna-predicted-data/output.csv')
sample_submission = pd.read_csv('.. /input/google-quest-challenge/sample_submission.csv')
sample_submission = pd.read_csv('.. /input/google-quest-challenge/sample_submission.csv')
id_in_sub = set(submission.qa_id)
id_in_sample_submission = s... | model = Sequential()
model.add(Conv2D(filters=64, kernel_size=(3,3), padding='valid', activation='relu', input_shape=(28, 28, 1)))
model.add(BatchNormalization())
model.add(Conv2D(filters=64, kernel_size=(3,3), padding='valid', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(filters=64, kernel_s... | Digit Recognizer |
9,904,099 | %matplotlib inline
<load_from_csv> | y_val_m = y_val.argmax(axis=1)
y_val_hat_prob = model.predict(X_val)
y_val_hat = y_val_hat_prob.argmax(axis=1)
X_val_inc = X_val[y_val_m != y_val_hat, :, :, :]
y_val_inc = y_val_m[y_val_m != y_val_hat]
y_val_hat_inc = y_val_hat[y_val_m != y_val_hat]
y_val_hat_prob_inc = y_val_hat_prob[y_val_m != y_val_hat] | Digit Recognizer |
9,904,099 | train_df = pd.read_csv(".. /input/GiveMeSomeCredit/cs-training.csv")
test_df = pd.read_csv(".. /input/GiveMeSomeCredit/cs-test.csv")
combine = [train_df, test_df]<create_dataframe> | for i in range(0,10):
act = y_val_inc[i]
pred = y_val_hat_inc[i]
print('Actual: {}; Confidence(act/pred): \t{} - {:.0f}% \t{} - {:.0f}%'.format(act, act, y_val_hat_prob_inc[i][act]*100, pred, y_val_hat_prob_inc[i][pred]*100)) | Digit Recognizer |
9,904,099 | <count_missing_values><EOS> | y_test_hat = model.predict(X_test ).argmax(axis=1)
df_submission = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv')
df_submission['Label'] = y_test_hat.astype('int32')
df_submission.to_csv('Submission.csv', index=False)
print('Submission saved!' ) | Digit Recognizer |
9,782,103 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<define_variables> | %matplotlib inline
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Digit Recognizer |
9,782,103 | def detect_outliers(df,n,features):
outlier_indices = []
for col in features:
Q1 = np.percentile(df[col], 25)
Q3 = np.percentile(df[col],75)
IQR = Q3 - Q1
outlier_step = 1.5 * IQR
outlier_list_col = df[(df[col] < Q1 - outlier_step)|(df[col] > Q3 + outlier_step)].index
outlier_indices.extend(outlier_list_col)
outli... | ds_train = pd.read_csv('.. /input/digit-recognizer/train.csv')
ds_test = pd.read_csv('.. /input/digit-recognizer/test.csv')
| Digit Recognizer |
9,782,103 | Outliers_to_drop = detect_outliers(train_df,3,train_df.columns.values[2:])
print("异常值：",round(len(Outliers_to_drop)/train_df.shape[0]*100,2),"%")
train_df.loc[Outliers_to_drop]<count_duplicates> | val_size = 0.1
X_all = ds_train.loc[:, ds_train.columns != 'label'].to_numpy()
y_all = ds_train['label'].to_numpy()
test = ds_test.to_numpy() | Digit Recognizer |
9,782,103 | train_df.duplicated().value_counts()<filter> | X_all = X_all / 255.0
X_all = X_all.reshape(-1,28,28,1)
test = test / 255.0
test = test.reshape(-1,28,28,1)
y_all = to_categorical(y_all, num_classes = 10)
X_train, X_val, y_train, y_val = model_selection.train_test_split(X_all, y_all, test_size=val_size, random_state=1 ) | Digit Recognizer |
9,782,103 | len(train_df.loc[train_df['age'] == 0] )<define_variables> | optimizer = RMSprop(lr=0.001, rho=0.9, decay=0.0 ) | Digit Recognizer |
9,782,103 | late_pay_cols = ['NumberOfTime30-59DaysPastDueNotWorse','NumberOfTimes90DaysLate','NumberOfTime60-89DaysPastDueNotWorse']<count_values> | def get_simple_model() :
model = Sequential()
model.add(Flatten(input_shape=(28,28,1)))
model.add(Dense(64, activation = 'sigmoid'))
model.add(Dropout(0.2))
model.add(Dense(24, activation = 'sigmoid'))
model.add(Dropout(0.2))
model.add(Dense(10, activation = 'softmax'))
model.compile(optimizer = optimizer, loss = "cat... | Digit Recognizer |
9,782,103 | train_df["NumberOfTime30-59DaysPastDueNotWorse"].value_counts().sort_index()<count_values> | def get_cnn_model() :
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(Co... | Digit Recognizer |
9,782,103 | train_df["NumberOfTimes90DaysLate"].value_counts().sort_index()<count_values> | def test_submission(model):
results = model.predict(test)
results = np.argmax(results, axis=1)
results = pd.Series(results, name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("cnn_mnist_datagen.csv",index=False ) | Digit Recognizer |
9,782,103 | train_df["NumberOfTime60-89DaysPastDueNotWorse"].value_counts().sort_index()<feature_engineering> | cnn_model_2, _ = train_model(get_cnn_model() , epochs = 30)
test_submission(cnn_model_2 ) | Digit Recognizer |
9,041,790 | distinct_triples_counts = dict()
for arr in train_df.loc[train_df["NumberOfTimes90DaysLate"] > 17][late_pay_cols].values:
triple = ",".join(list(map(str, arr)))
if triple not in distinct_triples_counts:
distinct_triples_counts[triple] = 0
else:
distinct_triples_counts[triple] += 1
distinct_triples_counts<count_values> | from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.utils import np_utils | Digit Recognizer |
9,041,790 | train_df.loc[train_df["DebtRatio"] > train_df["DebtRatio"].quantile(0.975)]['MonthlyIncome'].value_counts()<filter> | ( X_train, y_train),(X_test, y_test)= mnist.load_data() | Digit Recognizer |
9,041,790 | len(train_df[(train_df["DebtRatio"] > train_df["DebtRatio"].quantile(0.9)) &(train_df['SeriousDlqin2yrs'] == train_df['MonthlyIncome'])] )<count_values> | num_pixels = X_train.shape[1] * X_train.shape[2]
X_train = X_train.reshape(( X_train.shape[0], num_pixels)).astype('float32')
X_test = X_test.reshape(( X_test.shape[0], num_pixels)).astype('float32' ) | Digit Recognizer |
9,041,790 | train_df["NumberRealEstateLoansOrLines"].value_counts()<count_values> | X_train = X_train / 255
X_test = X_test / 255 | Digit Recognizer |
9,041,790 | train_df["NumberOfDependents"].value_counts()<rename_columns> | y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
num_classes = y_test.shape[1] | Digit Recognizer |
9,041,790 | for df in combine:
df.rename(columns={'Unnamed: 0':'ID'}, inplace=True )<data_type_conversions> | def baseline_model() :
model = Sequential()
model.add(Dense(num_pixels, input_dim=num_pixels, kernel_initializer='normal', activation='relu'))
model.add(Dense(num_classes, kernel_initializer='normal', activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
... | Digit Recognizer |
9,041,790 | for df in combine:
df['NumberOfDependents'].fillna(0, inplace=True )<prepare_x_and_y> | model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200, verbose=2)
scores = model.evaluate(X_test, y_test, verbose=0)
print("Baseline Error: %.2f%%" %(100-scores[1]*100)) | Digit Recognizer |
9,041,790 | def randomforest_filled_func(df):
train = df[df.MonthlyIncome.notnull() ]
test = df[df.MonthlyIncome.isnull() ]
train_x = train.iloc[:,2:].drop('MonthlyIncome',axis=1)
train_y = train['MonthlyIncome']
test_x = test.iloc[:,2:].drop('MonthlyIncome',axis=1)
rfr = RandomForestRegressor(random_state=2021, n_estimators=200... | ( X_train, y_train),(X_test, y_test)= mnist.load_data()
X_train = X_train.reshape(( X_train.shape[0], 28, 28, 1)).astype('float32')
X_test = X_test.reshape(( X_test.shape[0], 28, 28, 1)).astype('float32')
X_train = X_train / 255
X_test = X_test / 255
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_ca... | Digit Recognizer |
9,041,790 | for df in combine:
df = randomforest_filled_func(df )<filter> | model_simple.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200)
scores = model_simple.evaluate(X_test, y_test, verbose=1)
print("CNN Error: %.2f%%" %(100-scores[1]*100)) | Digit Recognizer |
9,041,790 | train_df = train_df[train_df['age'] > 0]<filter> | ( X_train, y_train),(X_test, y_test)= mnist.load_data()
X_train = X_train.reshape(( X_train.shape[0], 28, 28, 1)).astype('float32')
X_test = X_test.reshape(( X_test.shape[0], 28, 28, 1)).astype('float32')
X_train = X_train / 255
X_test = X_test / 255
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_ca... | Digit Recognizer |
9,041,790 | train_df = train_df[train_df['RevolvingUtilizationOfUnsecuredLines'] < 13]<filter> | model_large.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200)
scores = model_large.evaluate(X_test, y_test, verbose=1)
print("Large CNN Error: %.2f%%" %(100-scores[1]*100)) | Digit Recognizer |
9,041,790 | train_df = train_df[train_df['NumberOfTimes90DaysLate'] <= 17]<filter> | ( X_train, y_train),(X_test, y_test)= mnist.load_data()
X_train = X_train.reshape(( X_train.shape[0], 28, 28, 1)).astype('float32')
X_test = X_test.reshape(( X_test.shape[0], 28, 28, 1)).astype('float32')
X_train = X_train / 255
X_test = X_test / 255
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_ca... | Digit Recognizer |
9,041,790 | train_df = train_df.loc[train_df["DebtRatio"] <= train_df["DebtRatio"].quantile(0.975)]<count_duplicates> | model_larger.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=100)
scores = model_larger.evaluate(X_test, y_test, verbose=1)
print("Larger CNN Error: %.2f%%" %(100-scores[1]*100)) | Digit Recognizer |
9,041,790 | train_df.duplicated().value_counts()<remove_duplicates> | X_test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ).values.astype('float32')
X_test = X_test.reshape(-1, 28, 28, 1)
X_test = X_test.astype('float32')/255
testY = model_larger.predict_classes(X_test, verbose=1 ) | Digit Recognizer |
9,041,790 | train_df = train_df.drop_duplicates()<split> | sub = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv')
sub['Label'] = testY
sub.to_csv('submission.csv',index=False ) | Digit Recognizer |
9,041,790 | x_train = train_df.iloc[:,2:]
y_train = train_df['SeriousDlqin2yrs'].astype('uint8')
train_X, test_X, train_y, test_y = train_test_split(x_train,y_train,test_size=.1,random_state=2021, stratify = y_train )<find_best_model_class> | YouTubeVideo('3JQ3hYko51Y', width=800, height=450 ) | Digit Recognizer |
9,041,790 | num_estimators = range(100,401,10)
train_scores = []
test_scores = []
for num_estimator in num_estimators:
lgbm = LGBMClassifier(is_unbalance = True,num_leaves=60,learning_rate=0.02,n_estimators=num_estimator)
lgbm.fit(train_X,train_y)
pre_y1 = lgbm.predict_proba(train_X)[:,1]
pre_y2 = lgbm.predict_proba(test_X)[:,1... | from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.utils import np_utils | Digit Recognizer |
9,041,790 | num_estimators[test_scores.index(max(test_scores)) ]<filter> | ( X_train, y_train),(X_test, y_test)= mnist.load_data() | Digit Recognizer |
9,041,790 | learning_rates [test_scores.index(max(test_scores)) ]<filter> | num_pixels = X_train.shape[1] * X_train.shape[2]
X_train = X_train.reshape(( X_train.shape[0], num_pixels)).astype('float32')
X_test = X_test.reshape(( X_test.shape[0], num_pixels)).astype('float32' ) | Digit Recognizer |
9,041,790 | max_bins[test_scores.index(max(test_scores)) ]<filter> | X_train = X_train / 255
X_test = X_test / 255 | Digit Recognizer |
9,041,790 | num_leaves[test_scores.index(max(test_scores)) ]<filter> | y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
num_classes = y_test.shape[1] | Digit Recognizer |
9,041,790 | max_depths[test_scores.index(max(test_scores)) ]<filter> | def baseline_model() :
model = Sequential()
model.add(Dense(num_pixels, input_dim=num_pixels, kernel_initializer='normal', activation='relu'))
model.add(Dense(num_classes, kernel_initializer='normal', activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
... | Digit Recognizer |
9,041,790 | feature_fractions[test_scores.index(max(test_scores)) ]<train_model> | model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200, verbose=2)
scores = model.evaluate(X_test, y_test, verbose=0)
print("Baseline Error: %.2f%%" %(100-scores[1]*100)) | Digit Recognizer |
9,041,790 | lgbm = LGBMClassifier(is_unbalance = True,max_depth=14,num_leaves=30,max_bin=40,learning_rate=0.025,n_estimators=180,feature_fraction=0.6)
lgbm.fit(train_X,train_y)
pre_y = lgbm.predict_proba(test_X)[:,1]<predict_on_test> | ( X_train, y_train),(X_test, y_test)= mnist.load_data()
X_train = X_train.reshape(( X_train.shape[0], 28, 28, 1)).astype('float32')
X_test = X_test.reshape(( X_test.shape[0], 28, 28, 1)).astype('float32')
X_train = X_train / 255
X_test = X_test / 255
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_ca... | Digit Recognizer |
9,041,790 | test_df_x = test_df.iloc[:,2:]
pre_y2 = lgbm.predict_proba(test_df_x)[:,1]<load_from_csv> | model_simple.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200)
scores = model_simple.evaluate(X_test, y_test, verbose=1)
print("CNN Error: %.2f%%" %(100-scores[1]*100)) | Digit Recognizer |
9,041,790 | result = pd.read_csv('/kaggle/input/GiveMeSomeCredit/sampleEntry.csv')
result['Probability'] = pre_y2
result.to_csv('./submit.csv',index=False)
reload = pd.read_csv('./submit.csv')
reload<load_from_csv> | ( X_train, y_train),(X_test, y_test)= mnist.load_data()
X_train = X_train.reshape(( X_train.shape[0], 28, 28, 1)).astype('float32')
X_test = X_test.reshape(( X_test.shape[0], 28, 28, 1)).astype('float32')
X_train = X_train / 255
X_test = X_test / 255
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_ca... | Digit Recognizer |
9,041,790 | warnings.filterwarnings("ignore")
x_train = pd.read_csv('/kaggle/input/GiveMeSomeCredit/cs-training.csv')
x_test = pd.read_csv('/kaggle/input/GiveMeSomeCredit/cs-test.csv')
combine = [x_train, x_test]<count_missing_values> | model_large.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200)
scores = model_large.evaluate(X_test, y_test, verbose=1)
print("Large CNN Error: %.2f%%" %(100-scores[1]*100)) | Digit Recognizer |
9,041,790 | x_train.isnull().mean()<count_missing_values> | ( X_train, y_train),(X_test, y_test)= mnist.load_data()
X_train = X_train.reshape(( X_train.shape[0], 28, 28, 1)).astype('float32')
X_test = X_test.reshape(( X_test.shape[0], 28, 28, 1)).astype('float32')
X_train = X_train / 255
X_test = X_test / 255
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_ca... | Digit Recognizer |
9,041,790 | x_test.isnull().mean()<count_missing_values> | model_larger.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=100)
scores = model_larger.evaluate(X_test, y_test, verbose=1)
print("Larger CNN Error: %.2f%%" %(100-scores[1]*100)) | Digit Recognizer |
9,041,790 | [x_train[x_train['NumberOfDependents'].isnull() ][x_train['MonthlyIncome'].notnull() ]['DebtRatio'].count() ,
x_test[x_test['NumberOfDependents'].isnull() ][x_test['MonthlyIncome'].notnull() ]['DebtRatio'].count() ]<define_variables> | X_test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ).values.astype('float32')
X_test = X_test.reshape(-1, 28, 28, 1)
X_test = X_test.astype('float32')/255
testY = model_larger.predict_classes(X_test, verbose=1 ) | Digit Recognizer |
9,041,790 | x_train[x_train['NumberOfDependents'].notnull() ][x_train['MonthlyIncome'].isnull() ][['NumberOfDependents']].median()<import_modules> | sub = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv')
sub['Label'] = testY
sub.to_csv('submission.csv',index=False ) | Digit Recognizer |
9,041,790 | <feature_engineering><EOS> | YouTubeVideo('3JQ3hYko51Y', width=800, height=450 ) | Digit Recognizer |
8,921,515 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<filter> | import pandas as pd
import numpy as np
import time
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from keras.models import Model
from keras.layers import Input, Conv2D, BatchNormalization, Activation
from keras.layers import Add, Flatten, AveragePooling2D, Dense, Dropout
from keras... | Digit Recognizer |
8,921,515 | [len(x_train[x_train['NumberOfTime30-59DaysPastDueNotWorse'] == 98]),
len(x_train[x_train['NumberOfTime60-89DaysPastDueNotWorse'] == 98]),
len(x_train[x_train['NumberOfTimes90DaysLate'] == 98]),
len(x_train[x_train['NumberOfTime30-59DaysPastDueNotWorse'] == 98][x_train['NumberOfTimes90DaysLate'] == 98][x_train['NumberO... | train = pd.read_csv(".. /input/digit-recognizer/train.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv")
X = train.drop(columns=['label'] ).values.reshape(-1, 28, 28, 1)/ 255
y = train['label'].values
test = test.values.reshape(-1, 28, 28, 1)/ 255
X_train, X_test, y_train, y_test = train_test_split(X, y,... | Digit Recognizer |
8,921,515 | [len(x_test[x_test['NumberOfTime30-59DaysPastDueNotWorse'] == 98]),
len(x_test[x_test['NumberOfTime60-89DaysPastDueNotWorse'] == 98]),
len(x_test[x_test['NumberOfTimes90DaysLate'] == 98]),
len(x_test[x_test['NumberOfTime30-59DaysPastDueNotWorse'] == 98][x_test['NumberOfTimes90DaysLate'] == 98][x_test['NumberOfTime60-89... | def residual_block(inputs, filters, strides=1):
y = inputs
x = Conv2D(
filters=filters,
kernel_size=3,
strides=strides,
padding='same',
)(inputs)
x = BatchNormalization()(x)
x = Activation('relu' )(x)
x = Conv2D(
filters=filters,
kernel_size=3,
strides=1,
padding='same',
)(x)
x = BatchNormalization()(x)
if str... | Digit Recognizer |
8,921,515 | for dataset in combine:
dataset.loc[dataset['MonthlyIncome'].isnull() ,'DebtRatio'] = dataset.loc[dataset['MonthlyIncome'].isnull() ,'DebtRatio'] / 3915;
dataset.loc[dataset['MonthlyIncome'] == 1,'DebtRatio'] = dataset.loc[dataset['MonthlyIncome'] == 1,'DebtRatio'] / 3915;
dataset.loc[dataset['MonthlyIncome'] == 0,'Deb... | def train_model(epochs, filters, stages, batch_size, visualize=False):
model = resnet(
input_shape=X[0].shape,
num_classes=np.unique(y ).shape[-1],
filters=filters,
stages=stages
)
model.compile(
loss='sparse_categorical_crossentropy',
optimizer='adam',
metrics=['accuracy']
)
checkpoint = ModelCheckpoint(
file... | Digit Recognizer |
8,921,515 | for dataset in combine:
dataset.drop(columns = ['Unnamed: 0'], inplace = True)
dataset['RevolvingUtilizationOfUnsecuredLines'].mask(dataset['RevolvingUtilizationOfUnsecuredLines'] > 2, 2, inplace=True)
dataset['NumberOfTime60-89DaysPastDueNotWorse'].mask(dataset['NumberOfTime60-89DaysPastDueNotWorse'] > 95, 20, inpla... | models = []
for i in range(1):
print('-------------------------')
print('Model: ', i+1)
print('-------------------------')
model = train_model(
epochs=10,
filters=64,
stages=[3, 3, 3],
batch_size=128,
visualize=True
)
models.append(model ) | Digit Recognizer |
8,921,515 | result = x_train['SeriousDlqin2yrs' ]
data = x_train.drop(['SeriousDlqin2yrs'], axis = 1)
train_data, test_data, train_result, test_result = train_test_split(data, result, test_size = 0.2, stratify = result, random_state=33 )<import_modules> | predictions = []
for model in models:
predictions.append(model.predict(test))
predictions = np.sum(predictions, axis=0)
predictions = np.argmax(predictions, axis=1)
submission = pd.DataFrame({'ImageId': np.arange(1, 28001, 1), 'Label': predictions})
submission.to_csv('mnist_resnet_submission.csv', index=False ) | Digit Recognizer |
8,678,113 | models = []
scores = []
models.append("AdaBoost")
print("AdaBoost:")
model = AdaBoostClassifier()
result = cross_val_score(model,train_data,train_result,scoring='roc_auc',cv=StratifiedKFold(n_splits=10))
print('mean score:', result.mean())
scores.append(result.mean())
models.append("LGBM")
print("LGBM:")
model = ... | train = pd.read_csv(".. /input/train.csv")
print(train.shape)
train.head() | Digit Recognizer |
8,678,113 | model = LGBMClassifier()
model.fit(train_data, train_result)
predict_proba = model.predict_proba(test_data)[:,1]
roc_auc_score(test_result, predict_proba )<find_best_model_class> | test= pd.read_csv(".. /input/test.csv")
print(test.shape)
test.head() | Digit Recognizer |
8,678,113 | model = LGBMClassifier(n_estimators = 290, learning_rate = 0.025,max_depth = 6, num_leaves = 22)
model.fit(train_data, train_result)
predict_proba = model.predict_proba(test_data)[:,1]
roc_auc_score(test_result, predict_proba )<save_to_csv> | X_train =(train.iloc[:,1:].values ).astype('float32')
y_train = train.iloc[:,0].values.astype('int32')
X_test = test.values.astype('float32')
X = X_train
y = y_train
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.10, random_state=42 ) | Digit Recognizer |
8,678,113 | x_test = x_test.drop(['SeriousDlqin2yrs'],axis=1)
y_test = model.predict_proba(x_test)[:,1]
ids = np.arange(1,101504)
res = pd.DataFrame({'Id': ids, 'Probability': y_test})
res.to_csv("submission.csv", index=False )<load_from_csv> | \
mean_px = X_train.mean().astype(np.float32)
std_px = X_train.std().astype(np.float32)
def standardize(x):
return(x-mean_px)/std_px | Digit Recognizer |
8,678,113 | train_df = pd.read_csv('/kaggle/input/GiveMeSomeCredit/cs-training.csv')
test_df = pd.read_csv('/kaggle/input/GiveMeSomeCredit/cs-test.csv' )<count_missing_values> | y_train = np_utils.to_categorical(y_train,10)
X = X.reshape(-1,28,28,1)
y = np_utils.to_categorical(y,10 ) | Digit Recognizer |
8,678,113 | train_df.isnull().sum()<count_missing_values> | seed = 43
np.random.seed(seed ) | Digit Recognizer |
8,678,113 | test_df.isnull().sum()<filter> | from keras.models import Sequential
from keras.layers.core import Lambda , Dense, Flatten, Dropout
from keras.callbacks import EarlyStopping
from keras.layers import BatchNormalization, Convolution2D , MaxPooling2D | Digit Recognizer |
8,678,113 | train_df.loc[train_df['age'] < 18]<remove_duplicates> | def get_bn_model() :
model = Sequential([
Lambda(standardize, input_shape=(28,28,1)) ,
Convolution2D(32,(3,3), activation='relu'),
BatchNormalization(axis=1),
Convolution2D(32,(3,3), activation='relu'),
MaxPooling2D() ,
BatchNormalization(axis=1),
Convolution2D(64,(3,3), activation='relu'),
BatchNormalization(axis=1),
... | Digit Recognizer |
8,678,113 | train_df.drop_duplicates(inplace=True )<rename_columns> | model= get_bn_model()
gen =ImageDataGenerator(rotation_range=8, width_shift_range=0.08, shear_range=0.3,
height_shift_range=0.08, zoom_range=0.08)
batches = gen.flow(X, y, batch_size=64)
history=model.fit_generator(generator=batches, steps_per_epoch=batches.n, epochs=1)
| Digit Recognizer |
8,678,113 | <filter><EOS> | X_test.shape
results = model.predict(X_test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("Aniket_Digit_pred2.csv",index=False ) | Digit Recognizer |
10,799,576 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<define_variables> | num_classes = 10
train_fname = '/kaggle/input/digit-recognizer/train.csv'
train_db = pd.read_csv(train_fname)
label = train_db['label'].to_numpy()
label = to_categorical(label, num_classes=num_classes)
data = train_db.drop('label', axis=1 ).to_numpy()
data = data.reshape(( data.shape[0], 28, 28, 1))
data = data.astyp... | Digit Recognizer |
10,799,576 | k = 0
for i in train_df['NumberOfDependents']:
if i>8:
train_df['NumberOfDependents'].values[k]=8
k +=1
k = 0
for i in test_df['NumberOfDependents']:
if i>8:
test_df['NumberOfDependents'].values[k]=8
k +=1<feature_engineering> | train_datagen = ImageDataGenerator(rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.1,
zoom_range=0.1)
batch_size = 16
train_generator = train_datagen.flow(x_train, y_train, batch_size=batch_size ) | Digit Recognizer |
10,799,576 | train_df.loc[train_df['age'] < 18, 'age'] = train_df['age'].median()<feature_engineering> | model = Sequential([
Conv2D(32,(3, 3), activation='relu', input_shape=(28, 28, 1)) ,
Conv2D(32,(3, 3), activation='relu'),
SeparableConv2D(32,(5, 5), activation='relu', padding='same'),
BatchNormalization() ,
MaxPooling2D(( 2,2)) ,
SpatialDropout2D(0.35),
Conv2D(64,(3, 3), activation='relu'),
Conv2D(64,(3, 3), activati... | Digit Recognizer |
10,799,576 | train_df['MonthlyIncome'] = train_df['MonthlyIncome'].replace(np.nan,train_df['MonthlyIncome'].mean())
test_df['MonthlyIncome'] = test_df['MonthlyIncome'].replace(np.nan,test_df['MonthlyIncome'].mean())
train_df['NumberOfDependents'] = train_df['NumberOfDependents'].replace(np.nan,train_df['NumberOfDependents'].media... | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001)
epochs = 30
performance = model.fit(train_generator,
steps_per_epoch=x_train.shape[0] // batch_size,
epochs=epochs,
validation_data=(x_valid, y_valid),
callbacks=[learning_rate_reduction] ) | Digit Recognizer |
10,799,576 | <save_to_csv><EOS> | test_fname = '/kaggle/input/digit-recognizer/test.csv'
test_db = pd.read_csv(test_fname)
x_test = test_db.to_numpy()
x_test = x_test.reshape(( x_test.shape[0], 28, 28, 1))
x_test = x_test.astype('float32')/ 255
predictions = np.argmax(model.predict(x_test), axis=1)
imageIds = pd.Series(range(1,28001), name='ImageId')... | Digit Recognizer |
10,728,166 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<import_modules> | %matplotlib inline
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename)) | Digit Recognizer |
10,728,166 | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score,roc_curve, auc
from sklearn.ensemble import RandomForestRegressor
from lightgbm import LGBMClassifier<load_from_cs... | df_train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
df_test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv")
df_submission = pd.read_csv("/kaggle/input/digit-recognizer/sample_submission.csv" ) | Digit Recognizer |
10,728,166 | train=pd.read_csv('/kaggle/input/GiveMeSomeCredit/cs-training.csv')
train.info()
<feature_engineering> | print("Train File", df_train.isnull().any().sum())
print("Test File", df_test.isnull().any().sum() ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.