kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,728,166 | train = train[train['age']>0]
train.loc[train['NumberOfTime30-59DaysPastDueNotWorse']>20, 'NumberOfTime30-59DaysPastDueNotWorse'] = 6
train.loc[train['NumberOfTimes90DaysLate']>20, 'NumberOfTimes90DaysLate'] = 2
train.loc[train['NumberOfTime60-89DaysPastDueNotWorse']>20, 'NumberOfTime60-89DaysPastDueNotWorse'] = 3<trai... | y_train = df_train['label'].astype('float32')
X_train = df_train.drop(['label'], axis=1 ).astype('int32')
X_test = df_test.astype('float32')
X_train.shape, y_train.shape, X_test.shape | Digit Recognizer |
10,728,166 | train["NumberOfDependents"].fillna(train["NumberOfDependents"].mode() [0], inplace=True)
mData = train.iloc[:,[6,2,3,4,5,7,8,9,10,11]]
train_known = mData[mData.MonthlyIncome.notnull() ].values
train_unknown = mData[mData.MonthlyIncome.isnull() ].values
train_X = train_known[:,1:]
train_y = train_known[:,0]
rfr = Rand... | X_train = X_train/255
X_test = X_test/255 | Digit Recognizer |
10,728,166 | train_X = train_2[train_2.columns[2:]]
train_y = train_2[train_2.columns[1]]
train_X, test_X, train_y, test_y = train_test_split(train_X, train_y, test_size=0.1, random_state=20, stratify=train_y )<predict_on_test> | y_train = to_categorical(y_train, num_classes = 10)
y_train.shape | Digit Recognizer |
10,728,166 | lgbm = LGBMClassifier(max_depth=20,num_leaves=30,learning_rate=0.02,n_estimators=270,feature_fraction=0.7)
lgbm.fit(train_X,train_y)
pre_y = lgbm.predict_proba(test_X)[:,1]<feature_engineering> | x = tf.Variable(5.0)
with tf.GradientTape() as tape:
y = x**3 | Digit Recognizer |
10,728,166 | test=pd.read_csv('/kaggle/input/GiveMeSomeCredit/cs-test.csv')
test.info()
test.loc[test['NumberOfTime30-59DaysPastDueNotWorse']>20, 'NumberOfTime30-59DaysPastDueNotWorse'] = 6
test.loc[test['NumberOfTimes90DaysLate']>20, 'NumberOfTimes90DaysLate'] = 2
test.loc[test['NumberOfTime60-89DaysPastDueNotWorse']>20, 'NumberO... | dy_dx = tape.gradient(y, x)
dy_dx.numpy() | Digit Recognizer |
10,728,166 | test["NumberOfDependents"].fillna(train["NumberOfDependents"].mode() [0], inplace=True)
mData2 = test.iloc[:,[6,2,3,4,5,7,8,9,10,11]]
test_known = mData2[mData2.MonthlyIncome.notnull() ].values
test_unknown = mData2[mData2.MonthlyIncome.isnull() ].values
test_X2 = test_known[:,1:]
test_y2 = test_known[:,0]
rfr2 = Rand... | w = tf.Variable(tf.random.normal(( 3, 2)) , name='w')
b = tf.Variable(tf.zeros(2, dtype=tf.float32), name='b')
x = [[1., 2., 3.]]
with tf.GradientTape(persistent=True)as tape:
y = x @ w + b
loss = tf.reduce_mean(y**2)
| Digit Recognizer |
10,728,166 | test2 = test[test.columns[2:]]
pre_y2 = lgbm.predict_proba(test2)[:,1]<save_to_csv> | [dl_dw, dl_db] = tape.gradient(loss, [w, b] ) | Digit Recognizer |
10,728,166 | 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<import_modules> | x = tf.constant(3.0)
with tf.GradientTape() as g:
g.watch(x)
with tf.GradientTape() as gg:
gg.watch(x)
y = x * x
dy_dx = gg.gradient(y, x)
print(dy_dx.numpy())
d2y_dx2 = g.gradient(dy_dx, x)
print(d2y_dx2.numpy() ) | 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... | def build_model(width, height, depth, classes):
inputShape =(height, width, depth)
chanDim = -1
model = Sequential([
Conv2D(16,(3, 3), padding="same", input_shape=inputShape),
Activation("relu"),
BatchNormalization(axis=chanDim),
MaxPooling2D(pool_size=(2, 2)) ,
Conv2D(32,(3, 3), padding="same"),
Activation("relu"),
B... | Digit Recognizer |
10,728,166 | train=pd.read_csv('/kaggle/input/GiveMeSomeCredit/cs-training.csv')
train.info()
train = train[train['age']>0]
train.loc[train['NumberOfTime30-59DaysPastDueNotWorse']>20, 'NumberOfTime30-59DaysPastDueNotWorse'] = 6
train.loc[train['NumberOfTimes90DaysLate']>20, 'NumberOfTimes90DaysLate'] = 2
train.loc[train['NumberO... | def step(X, y):
with tf.GradientTape() as tape:
pred = model(X)
loss = categorical_crossentropy(y, pred)
grads = tape.gradient(loss, model.trainable_variables)
opt.apply_gradients(zip(grads, model.trainable_variables)) | Digit Recognizer |
10,728,166 | train["NumberOfDependents"].fillna(train["NumberOfDependents"].mode() [0], inplace=True)
mData = train.iloc[:,[6,2,3,4,5,7,8,9,10,11]]
train_known = mData[mData.MonthlyIncome.notnull() ].values
train_unknown = mData[mData.MonthlyIncome.isnull() ].values
train_X = train_known[:,1:]
train_y = train_known[:,0]
rfr = Rand... | EPOCHS = 50
BS = 32
INIT_LR = 1e-3
model = build_model(28, 28, 1, 10)
opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
numUpdates = int(X_train.shape[0] / BS)
for epoch in range(0, EPOCHS):
print("[INFO] starting epoch {}/{}...".format(epoch + 1, EPOCHS), end="")
sys.stdout.flush()
epochStart = time.time()
for i in r... | Digit Recognizer |
10,728,166 | train_X = train_2[train_2.columns[2:]]
train_y = train_2[train_2.columns[1]]
train_X, test_X, train_y, test_y = train_test_split(train_X, train_y, test_size=0.1, random_state=20, stratify=train_y )<predict_on_test> | plot_model(model, to_file='model.png', show_shapes=True, show_layer_names=True)
Image("model.png" ) | Digit Recognizer |
10,728,166 | lgbm = LGBMClassifier(max_depth=20,num_leaves=30,learning_rate=0.02,n_estimators=250,feature_fraction=0.7)
lgbm.fit(train_X,train_y)
pre_y = lgbm.predict_proba(test_X)[:,1]<feature_engineering> | model.compile(optimizer=opt, loss=categorical_crossentropy,metrics=["acc"])
| Digit Recognizer |
10,728,166 | test=pd.read_csv('/kaggle/input/GiveMeSomeCredit/cs-test.csv')
test.info()
test.loc[test['NumberOfTime30-59DaysPastDueNotWorse']>20, 'NumberOfTime30-59DaysPastDueNotWorse'] = 6
test.loc[test['NumberOfTimes90DaysLate']>20, 'NumberOfTimes90DaysLate'] = 2
test.loc[test['NumberOfTime60-89DaysPastDueNotWorse']>20, 'NumberO... | y_pred = model.predict(X_test)
y_pred = np.argmax(y_pred,axis=1)
my_submission = pd.DataFrame({'ImageId': list(range(1, len(y_pred)+1)) , 'Label': y_pred})
my_submission.to_csv('submission.csv', index=False ) | Digit Recognizer |
10,720,766 | test["NumberOfDependents"].fillna(train["NumberOfDependents"].mode() [0], inplace=True)
mData2 = test.iloc[:,[6,2,3,4,5,7,8,9,10,11]]
test_known = mData2[mData2.MonthlyIncome.notnull() ].values
test_unknown = mData2[mData2.MonthlyIncome.isnull() ].values
test_X2 = test_known[:,1:]
test_y2 = test_known[:,0]
rfr2 = Rand... | hist = model.fit_generator(datagen.flow(X_train, Y_train, batch_size=32),
steps_per_epoch=1000,
epochs=1000,
verbose=2,
validation_data=(X_train[:400,:], Y_train[:400,:]),
callbacks=[annealer])
final_loss, final_acc = model.evaluate(X_train, Y_train, verbose=0)
print("Final loss: {0:.4f}, final accuracy: {1:.4f}".for... | Digit Recognizer |
10,720,766 | test2 = test[test.columns[2:]]
pre_y2 = lgbm.predict_proba(test2)[:,1]<save_to_csv> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("MNIST_ver21.csv",index=False ) | Digit Recognizer |
10,123,364 | 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> | train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
10,123,364 | train = pd.read_csv('/kaggle/input/GiveMeSomeCredit/cs-training.csv',index_col=0)
test = pd.read_csv('/kaggle/input/GiveMeSomeCredit/cs-test.csv',index_col=0)
sample = pd.read_csv('/kaggle/input/GiveMeSomeCredit/sampleEntry.csv')
train.shape, test.shape, sample.shape<count_missing_values> | X = train.drop("label", axis = 1)
y = train["label"] | Digit Recognizer |
10,123,364 | train.MonthlyIncome.fillna(train_default_dict['MonthlyIncome'][0], inplace=True)
test.MonthlyIncome.fillna(train_default_dict['MonthlyIncome'][0], inplace=True)
train.NumberOfDependents.fillna(test_default_dict['NumberOfDependents'][1], inplace=True)
test.NumberOfDependents.fillna(test_default_dict['NumberOfDependen... | X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size = 0.25 ) | Digit Recognizer |
10,123,364 | X_train = train.iloc[:,1:].values
y_train = train.iloc[:,0].values
X_test = test.iloc[:,1:].values
X_train.shape, y_train.shape, X_test.shape<normalization> | X_train = X_train / 255
X_test = X_test / 255
test = test / 255 | Digit Recognizer |
10,123,364 | train_scaler = preprocessing.StandardScaler().fit(X_train)
print(train_scaler.mean_ , '
'+'-'*50+'
', train_scaler.scale_)
print('='*50)
test_scaler = preprocessing.StandardScaler().fit(X_test)
print(test_scaler.mean_ , '
'+'-'*50+'
', test_scaler.scale_)
<normalization> | y_train = to_categorical(y_train)
y_test = to_categorical(y_test ) | Digit Recognizer |
10,123,364 | X_train_scaled = train_scaler.transform(X_train)
X_test_scaled = test_scaler.transform(X_test)
X_train_scaled.mean(axis=0), X_train_scaled.std(axis=0), X_test_scaled.mean(axis=0), X_test_scaled.std(axis=0)
<split> | X_train = X_train.values.reshape(-1, 28, 28, 1)
X_test = X_test.values.reshape(-1, 28, 28, 1)
test = test.values.reshape(-1, 28, 28, 1 ) | Digit Recognizer |
10,123,364 | X_learn, X_valid, y_learn, y_valid = train_test_split(X_train_scaled, y_train, random_state=0)
X_learn.shape, X_valid.shape, y_learn.shape, y_valid.shape<import_modules> | model = Sequential()
model.add(Conv2D(64, kernel_size =(3, 3), activation = "relu", padding = "same", input_shape =(28, 28, 1)))
model.add(BatchNormalization())
model.add(Conv2D(64, kernel_size =(3, 3), activation = "relu", padding = "same"))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size =(2, 2)))... | Digit Recognizer |
10,123,364 | from sklearn.metrics import roc_auc_score<choose_model_class> | y_sub = pd.Series(np.argmax(model.predict(test), axis = 1), name = "Label")
submission = pd.concat([pd.Series(range(1, 28001), name = "ImageId"), y_sub], axis = 1)
submission.to_csv("submission.csv", index = False)
submission.head() | Digit Recognizer |
9,484,758 | estimators = [
('lgb', lgb.LGBMClassifier(n_estimators=54)) ,
('rfc', RandomForestClassifier(n_estimators=200)) ,
('mlp', MLPClassifier(hidden_layer_sizes=2)) ,
('knn', KNeighborsClassifier(n_neighbors=320, weights='distance', algorithm='auto'))
]<train_model> | %matplotlib inline
| Digit Recognizer |
9,484,758 | best_l, best_pt, maxauc = 0, 'none', 0
for hid_lay_siz in [1,2,3,4,5]:
for pass_throu in [True, False]:
reg = StackingClassifier(
estimators=estimators,
final_estimator=MLPClassifier(
hidden_layer_sizes=hid_lay_siz,
random_state=0
),
passthrough=pass_throu,
verbose=3
)
reg.fit(X_learn, y_learn)
y_pred = reg.predi... | img_rows, img_cols = 28, 28 | Digit Recognizer |
9,484,758 | reg = StackingClassifier(
estimators=estimators,
final_estimator=MLPClassifier(
hidden_layer_sizes=best_l,
random_state=0
),
passthrough=best_pt,
verbose=3
)
reg.fit(X_train, y_train)
y_pred = reg.predict_proba(X_test)[:,1]
<load_from_csv> | df_train = pd.read_csv(".. /input/digit-recognizer/train.csv")
df_test = pd.read_csv(".. /input/digit-recognizer/test.csv")
df_train.head() | Digit Recognizer |
9,484,758 | sample = pd.read_csv('.. /input/GiveMeSomeCredit/sampleEntry.csv')
sample<save_to_csv> | y_train = df_train["label"]
X_train = df_train.drop(labels = ["label"],axis = 1)
X_test = df_test
X_train /= 255
X_test /= 255
X_train = X_train.values.reshape(X_train.shape[0], img_rows, img_cols, 1)
X_test = X_test.values.reshape(X_test.shape[0], img_rows, img_cols, 1)
X_train, X_val, y_train, y_val = train_test_s... | Digit Recognizer |
9,484,758 | sample['Probability'] = y_pred
sample.to_csv('./submit.csv',index=False)
reload = pd.read_csv('./submit.csv')
reload
<set_options> | batch_size = 128
epochs = 200
lr = 1e-4
rho = 0.7
learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.000001 ) | Digit Recognizer |
9,484,758 | np.set_printoptions(suppress=True)
print(tf.__version__ )<load_from_csv> | input_shape =(img_rows, img_cols, 1)
num_classes = 10
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)))
mo... | Digit Recognizer |
9,484,758 | PATH = '.. /input/google-quest-challenge/'
BERT_PATH = '.. /input/bert-base-uncased-huggingface-transformer/'
tokenizer = BertTokenizer.from_pretrained(BERT_PATH+'bert-base-uncased-vocab.txt')
MAX_SEQUENCE_LENGTH = 384
df_train = pd.read_csv(PATH+'train.csv')
df_test = pd.read_csv(PATH+'test.csv')
df_sub = pd.read_c... | model.fit(X_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(X_val, y_val))
score = model.evaluate(X_val, y_val, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1] ) | Digit Recognizer |
9,484,758 | def _convert_to_transformer_inputs(title, question, answer, tokenizer, max_sequence_length):
def return_id(str1, str2, truncation_strategy, length):
inputs = tokenizer.encode_plus(str1, str2,
add_special_tokens=True,
max_length=length,
truncation_strategy=truncation_strategy)
input_ids = inputs["input_ids"]
input_ma... | results = model.predict(X_test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
9,484,758 | 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)
def create_model() :
q_id = tf.keras.layers.Input(( MAX_SEQUENCE_LENGTH,), dtype=tf.int32)
a_id = tf.keras.layers.Input((... | 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,056,716 | outputs = compute_output_arrays(df_train, output_categories)
inputs = compute_input_arrays(df_train, input_categories, tokenizer, MAX_SEQUENCE_LENGTH)
test_inputs = compute_input_arrays(df_test, input_categories, tokenizer, MAX_SEQUENCE_LENGTH)
<split> | from keras.utils.np_utils import to_categorical | Digit Recognizer |
9,056,716 | gkf = GroupKFold(n_splits=5 ).split(X=df_train.question_body, groups=df_train.question_body)
valid_preds = []
test_preds = []
for fold,(train_idx, valid_idx)in enumerate(gkf):
if fold in [0, 2]:
train_inputs = [inputs[i][train_idx] for i in range(len(inputs)) ]
train_outputs = outputs[train_idx]
valid_inputs = [inputs... | 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 = X_train.reshape(X_train.shape[0], 28,... | Digit Recognizer |
9,056,716 | df_sub.iloc[:, 1:] = np.average(test_preds, axis=0)
df_sub.to_csv('submission.csv', index=False )<set_options> | X_train = X_train / 255.0
X_test = X_test / 255.0 | Digit Recognizer |
9,056,716 | py.init_notebook_mode(connected=True)
pd.set_option('max_columns', None)
warnings.filterwarnings("ignore" )<load_from_csv> | X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.1, random_state=42)
X_train.shape, X_val.shape, y_train.shape, y_val.shape | Digit Recognizer |
9,056,716 | train = pd.read_csv('.. /input/tmdb-box-office-prediction/train.csv')
test = pd.read_csv('.. /input/tmdb-box-office-prediction/test.csv')
dict_columns = ['belongs_to_collection','genres','spoken_languages','production_companies',
'production_countries','Keywords','cast','crew']
def text_to_dict(df):
for columns in di... | datagen = ImageDataGenerator(
rotation_range=8,
width_shift_range=0.08,
shear_range=0.3,
height_shift_range=0.08,
zoom_range=0.08
) | Digit Recognizer |
9,056,716 | train.loc[train['id'] == 16,'revenue'] = 192864
train.loc[train['id'] == 90,'budget'] = 30000000
train.loc[train['id'] == 118,'budget'] = 60000000
train.loc[train['id'] == 149,'budget'] = 18000000
train.loc[train['id'] == 313,'revenue'] = 12000000
train.loc[train['id'] == 451,'revenue'] = 12000000
train.loc[train['id']... | learning_rate_reduction = ReduceLROnPlateau(monitor='val_accuracy',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
9,056,716 | train['popularity'] = np.log1p(train['popularity'])
train['revenue'] = np.log1p(train['revenue'])
train['totalVotes'] = np.log1p(train['totalVotes'])
train['budget'] = np.log1p(train['budget'])
train['runtime'] = np.log1p(train['runtime'])
train['popularity2'] = np.log1p(train['popularity2'])
test['popularity'] =... | from keras.models import Sequential
from keras.layers import Dense, Flatten, Dropout, Conv2D, MaxPool2D, BatchNormalization | Digit Recognizer |
9,056,716 | for i,e in enumerate(train['belongs_to_collection'][:2]):
print(i,e )<count_values> | model = Sequential()
model.add(Conv2D(32, kernel_size=3, activation='relu', input_shape=(28, 28, 1)))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size=3, activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size=5, strides=2, padding='same', activation='relu'))
model.add(Ba... | Digit Recognizer |
9,056,716 | train['belongs_to_collection'].apply(lambda x: 1 if x!= {} else 0 ).value_counts()<feature_engineering> | epochs = 30
batch_size = 64
history = model.fit_generator(generator=datagen.flow(X_train, y_train),
steps_per_epoch=X_train.shape[0] // batch_size,
epochs=epochs,
validation_data=datagen.flow(X_val, y_val),
validation_steps=X_val.shape[0] // batch_size ) | Digit Recognizer |
9,056,716 | <define_variables><EOS> | predictions = model.predict_classes(X_test, verbose=0)
submissions = pd.DataFrame({'ImageID': list(range(1, len(predictions)+ 1)) ,
'Label': predictions})
submissions.to_csv('cnn_part3.csv', index=False, header=True ) | Digit Recognizer |
8,755,892 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<count_values> | !pip install torchsummary | Digit Recognizer |
8,755,892 | print('Number of genres in films:')
train['genres'].apply(lambda x: len(x)if x!={} else 0 ).value_counts()<define_variables> | df = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test_df = pd.read_csv("/kaggle/input/digit-recognizer/test.csv")
print(df.shape, test_df.shape)
| Digit Recognizer |
8,755,892 | list_of_genres = list(train['genres'].apply(lambda x: [i['name'] for i in x] if x!={} else [] ).values )<feature_engineering> | class MNIST_dataset(Dataset):
def __init__(self, df):
self.df = df
self.aug = A.Compose([
A.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=10, p=.75)
])
def __len__(self):
return(len(self.df))
def __getitem__(self, idx):
img_data = self.df.iloc[idx,1:].values.reshape(( 1,28,28)).astype(np.float32)/ 2... | Digit Recognizer |
8,755,892 | train['num_of_genres'] = train['genres'].apply(lambda x: len(x)if x!={} else 0)
train['all_genres'] = train['genres'].apply(lambda x: ' '.join(sorted([i['name'] for i in x ]))
if x!= {} else '')
test['num_of_genres'] = test['genres'].apply(lambda x: len(x)if x!={} else 0)
test['all_genres'] = test['genres'].apply(la... | train_df , valid_df = train_test_split(df, test_size=0.2, random_state=1 ) | Digit Recognizer |
8,755,892 | for g in top_genres:
train['genre_' + g] = train['all_genres'].apply(lambda x: 1 if g in x else 0)
test['genre_' + g] = test['all_genres'].apply(lambda x: 1 if g in x else 0 )<define_variables> | train_dl = DataLoader(MNIST_dataset(train_df), batch_size=128)
valid_dl = DataLoader(MNIST_dataset(valid_df), batch_size=128 ) | Digit Recognizer |
8,755,892 | for i,e in enumerate(train['production_companies'][:2]):
print(i,e )<count_values> | num_groups = 4
class Model(nn.Module):
def __init__(self):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1),
nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True),
nn.BatchNorm2d(32),
nn.Conv2d(32, 32, kernel_size=3, stride=2, padding=1),
nn.... | Digit Recognizer |
8,755,892 | print('Number of Production Companies for a movie:')
train['production_companies'].apply(lambda x: len(x)if x!= {} else 0 ).value_counts()<filter> | summary(model, input_size=(1, 28, 28)) | Digit Recognizer |
8,755,892 | train[train['production_companies'].apply(lambda x: len(x)if x!= {} else 0)> 10]<count_unique_values> | from torch import optim
from tqdm.auto import tqdm | Digit Recognizer |
8,755,892 | list_of_companies = list(train['production_companies'].apply(lambda x : [i['name'] for i in x]
if x!= {} else [] ).values)
Counter(i for j in list_of_companies for i in j ).most_common(20 )<feature_engineering> | criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters() , lr=1e-3 ) | Digit Recognizer |
8,755,892 | train['num_prod_companies'] = train['production_companies'].apply(lambda x: len(x)if
x!={} else 0)
test['num_prod_companies'] = test['production_companies'].apply(lambda x: len(x)if
x!={} else 0)
train['all_prod_companies'] = train['production_companies'].apply(lambda x: ' '.join(sorted([i['name'] for i in x])) if x!... | def train_one_epoch(dl, epoch_num):
total_loss = 0.0
accumulation_steps = 1024 // 128
optimizer.zero_grad()
for i,(X, y)in enumerate(tqdm(dl)) :
y1 = model(X.cuda())
loss = criterion(y1, y.cuda())
loss /= accumulation_steps
loss.backward()
if(( i+1)% accumulation_steps == 0):
optimizer.step()
optimizer.zero_grad()
to... | Digit Recognizer |
8,755,892 | top_prod_companies = [m[0] for m in Counter(i for j in list_of_companies for i in j ).most_common(10)]
for pc in top_prod_companies:
train['production_' + pc] = train['all_prod_companies'].apply(lambda x: 1 if pc in x else 0)
test['production_'+ pc] = test['all_prod_companies'].apply(lambda x: 1 if pc in x else 0 )<de... | def evaluate(dl):
total_loss = 0.0
total_correct = 0.0
with torch.no_grad() :
for X,y in dl :
y1 = model(X.cuda())
loss = criterion(y1,y.cuda())
pred = torch.argmax(y1, dim=1 ).cpu()
total_loss+=loss.item()
total_correct += torch.sum(y==pred ).float().item()
accuracy = total_correct/len(dl.dataset)
print(f'Loss : {t... | Digit Recognizer |
8,755,892 | for i, e in enumerate(train['production_countries'][:2]):
print(i,e )<count_values> | epoch_num = 20
for epoch in range(epoch_num):
train_one_epoch(train_dl, epoch)
evaluate(valid_dl ) | Digit Recognizer |
8,755,892 | print('Number of Production Countries in Movies:')
train['production_countries'].apply(lambda x: len(x)if x!={} else 0 ).value_counts()<filter> | class MNIST_dataset(Dataset):
def __init__(self, df):
self.df = df
def __len__(self):
return(len(self.df))
def __getitem__(self, idx):
img_data = self.df.iloc[idx].values.reshape(( 1,28,28)).astype(np.float32)/ 255.
return img_data
| Digit Recognizer |
8,755,892 | train[train['production_countries'].apply(lambda x: len(x)if x!= {} else 0)> 5]<count_values> | test_dl = DataLoader(MNIST_dataset(test_df), batch_size=128 ) | Digit Recognizer |
8,755,892 | List_of_countries = list(train['production_countries'].apply(lambda x: [i['name'] for i in x]
if x!= {} else []))
Counter(i for j in List_of_countries for i in j ).most_common(10 )<feature_engineering> | def evaluate_Submssions(dl):
total_loss = 0.0
total_correct = 0.0
pred_list =[]
with torch.no_grad() :
for X in dl :
y1 = model(X.cuda())
pred = torch.argmax(y1, dim=1 ).detach().cpu().numpy().tolist()
pred_list.extend(pred)
return pred_list
| Digit Recognizer |
8,755,892 | train['num_prod_countries'] = train['production_countries'].apply(lambda x: len(x)if x!= {}
else 0)
test['num_prod_countries'] = test['production_countries'].apply(lambda x: len(x)if x!={}
else 0)
train['all_prod_countries'] = train['production_countries'].apply(lambda x: ' '.join(sorted(i['name'] for i in x))
if x!=... | pred_list = evaluate_Submssions(test_dl)
| Digit Recognizer |
8,755,892 | top_prod_countries = [m[0] for m in Counter(i for j in List_of_countries for i in j ).most_common(6)]
for t in top_prod_countries:
train['prod_country_' + t] = train['all_prod_countries'].apply(lambda x: 1 if t in x else 0)
test['prod_country_'+ t] = test['all_prod_countries'].apply(lambda x: 1 if t in x else 0 )<defi... | subs = pd.DataFrame({
'ImageId': range(1, len(pred_list)+1),
'Label' : pred_list
})
subs.head() | Digit Recognizer |
8,755,892 | for i, e in enumerate(train['spoken_languages'][:2]):
print(i,e )<count_values> | subs.to_csv("submission.csv", index= False ) | Digit Recognizer |
4,907,015 | print('Number of languages for a movie:')
train['spoken_languages'].apply(lambda x: len(x)if x!={} else 0 ).value_counts()<count_unique_values> | %matplotlib inline | Digit Recognizer |
4,907,015 | list_of_langs = list(train['spoken_languages'].apply(lambda x: [i['name'] for i in x]
if x!= {} else []))
top_langs = [m[0] for m in Counter(i for j in list_of_langs for i in j ).most_common(5)]
Counter(i for j in list_of_langs for i in j ).most_common(5 )<feature_engineering> | from keras.models import Sequential
from keras.layers import Dense , Dropout , Lambda, Flatten
from keras.optimizers import Adam ,RMSprop
from sklearn.model_selection import train_test_split
from keras import backend as K
from keras.preprocessing.image import ImageDataGenerator | Digit Recognizer |
4,907,015 | train['num_of_langs'] = train['spoken_languages'].apply(lambda x: len(x)if x!= {} else 0)
test['num_of_langs'] = test['spoken_languages'].apply(lambda x: len(x)if x!= {} else 0)
train['all_langs'] = train['spoken_languages'].apply(lambda x: ' '.join(sorted([i['name']for i in x]))
if x!= {} else '')
test['all_langs']... | train = pd.read_csv(".. /input/train.csv")
print(train.shape ) | Digit Recognizer |
4,907,015 | for i, e in enumerate(train['Keywords'][:2]):
print(i,e )<count_values> | test= pd.read_csv(".. /input/test.csv")
print(test.shape ) | Digit Recognizer |
4,907,015 | list_of_keys = list(train['Keywords'].apply(lambda x: [i['name'] for i in x] if x!= {} else []))
Counter(i for j in list_of_keys for i in j ).most_common(10 )<feature_engineering> | X_train =(train.iloc[:,1:].values ).astype('float32')
y_train = train.iloc[:,0].values.astype('int32')
X_test = test.values.astype('float32' ) | Digit Recognizer |
4,907,015 | top_keywords = [m[0] for m in Counter(i for j in list_of_keys for i in j ).most_common(10)]
train['num_of_keywords'] = train['Keywords'].apply(lambda x: len(x)if x!={} else 0)
test['num_of_keywords'] = test['Keywords'].apply(lambda x: len(x)if x!={} else 0)
train['all_keywords'] = train['Keywords'].apply(lambda x: ' ... | 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 |
4,907,015 | for i, e in enumerate(train['cast'][:1]):
print(i,e )<count_values> | y_train= to_categorical(y_train)
num_classes = y_train.shape[1]
num_classes | Digit Recognizer |
4,907,015 | print('Number of casts used per movie:')
train['cast'].apply(lambda x: len(x)if x!={} else 0 ).value_counts().head(10 )<define_variables> | seed = 10
np.random.seed(seed ) | Digit Recognizer |
4,907,015 | list_cast_name = list(train['cast'].apply(lambda x: [i['name'] for i in x]if x!= {} else []))
top_cast_name = [m[0] for m in Counter(i for j in list_cast_name for i in j ).most_common(20)]
Counter(i for j in list_cast_name for i in j ).most_common(20 )<feature_engineering> | 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 |
4,907,015 | train['num_of_cast']= train['cast'].apply(lambda x: len(x)if x!={} else 0)
test['num_of_cast'] = test['cast'].apply(lambda x: len(x)if x!={} else 0)
train['all_cast_name'] = train['cast'].apply(lambda x: ' '.join(sorted([i['name']for i in x]))
if x!={} else '')
test['all_cast_name'] = test['cast'].apply(lambda x: ' ... | model= Sequential()
model.add(Lambda(standardize,input_shape=(28,28,1)))
model.add(Flatten())
model.add(Dense(10, activation='softmax'))
print("input shape ",model.input_shape)
print("output shape ",model.output_shape ) | Digit Recognizer |
4,907,015 | print('Number of crew members per movie:')
train['crew'].apply(lambda x: len(x)if x!= {} else 0 ).value_counts().head(10 )<count_values> | model.compile(optimizer=RMSprop(lr=0.001),
loss='categorical_crossentropy',
metrics=['accuracy'] ) | Digit Recognizer |
4,907,015 | list_crew_names = list(train['crew'].apply(lambda x: [i['name'] for i in x] if x!= {} else [] ).values)
Counter(i for j in list_crew_names for i in j ).most_common(15 )<feature_engineering> | X = X_train
y = y_train
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.20, random_state=10)
batches = gen.flow(X_train, y_train, batch_size=64)
val_batches=gen.flow(X_val, y_val, batch_size=64 ) | Digit Recognizer |
4,907,015 | top_crew_names = [m[0] for m in Counter(i for j in list_crew_names for i in j ).most_common(20)]
train['num_of_crew'] = train['crew'].apply(lambda x: len(x)if x!= {} else 0)
test['num_of_crew']= test['crew'].apply(lambda x: len(x)if x!= {} else 0)
for cn in top_crew_names:
train['crew_name_'+ cn]= train['crew'].apply... | history=model.fit_generator(generator=batches, steps_per_epoch=batches.n, epochs=3,
validation_data=val_batches, validation_steps=val_batches.n ) | Digit Recognizer |
4,907,015 | train['homepage'].isna().sum()<feature_engineering> | def get_cnn_model() :
model = Sequential([
Lambda(standardize, input_shape=(28,28,1)) ,
Convolution2D(32,(3,3), activation='relu'),
Convolution2D(32,(3,3), activation='relu'),
MaxPooling2D() ,
Convolution2D(64,(3,3), activation='relu'),
Convolution2D(64,(3,3), activation='relu'),
MaxPooling2D() ,
Flatten() ,
Dense(512,... | Digit Recognizer |
4,907,015 | train['has_homepage'] = 1
train.loc[pd.isnull(train['homepage']),"has_homepage"] = 0
test['has_homepage'] = 1
test.loc[pd.isnull(test['homepage']),"has_homepage"] = 0<count_missing_values> | model= get_cnn_model()
model.optimizer.lr=0.01 | Digit Recognizer |
4,907,015 | train['runtime'].isna().sum()<data_type_conversions> | history=model.fit_generator(generator=batches, steps_per_epoch=batches.n, epochs=1,
validation_data=val_batches, validation_steps=val_batches.n ) | Digit Recognizer |
4,907,015 | train['runtime'].fillna(train['runtime'].mean() ,inplace= True )<correct_missing_values> | 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 |
4,907,015 | test['runtime'].fillna(test['runtime'].mean() ,inplace= True )<feature_engineering> | model= get_bn_model()
model.optimizer.lr=0.01
history=model.fit_generator(generator=batches, steps_per_epoch=batches.n, epochs=1,
validation_data=val_batches, validation_steps=val_batches.n ) | Digit Recognizer |
4,907,015 | train.loc[train['release_date'].isnull() == True, 'release_date'] = '01/01/98'
test.loc[test['release_date'].isnull() == True, 'release_date'] = '01/01/98'
<categorify> | model.optimizer.lr=0.01
gen = image.ImageDataGenerator()
batches = gen.flow(X, y, batch_size=64)
history=model.fit_generator(generator=batches, steps_per_epoch=batches.n, epochs=3 ) | Digit Recognizer |
4,907,015 | <data_type_conversions><EOS> | predictions = model.predict_classes(X_test, verbose=0)
submissions=pd.DataFrame({"ImageId": list(range(1,len(predictions)+1)) ,
"Label": predictions})
submissions.to_csv("Digit_Recog.csv", index=False, header=True ) | Digit Recognizer |
10,296,992 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<data_type_conversions> | import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten, Convolution2D, MaxPooling2D
from keras.utils import np_utils
from keras.preprocessing.image import ImageDataGenerator
from keras.... | Digit Recognizer |
10,296,992 | def process_date(df):
date_parts = ["year", "weekday", "month", 'weekofyear', 'day', 'quarter']
for part in date_parts:
part_col = 'release' + "_" + part
df[part_col] = getattr(df['release_date'].dt, part ).astype(int)
return df
train = process_date(train)
test = process_date(test )<groupby> | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
10,296,992 | d = train['release_date'].dt.year.value_counts().sort_index()
g = train.groupby('release_date')['revenue'].sum()<count_values> | y_train = train['label'].astype('int32')
X_train =(train.drop(['label'], axis = 1)).values.astype('float32')
X_test = test.values.astype('float32')
batch_size, img_rows, img_cols = 64, 28, 28
X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1)
X_test = X_test.reshape(X_test.shape[0], img_rows, img_co... | Digit Recognizer |
10,296,992 | train['status'].value_counts()<merge> | X_train /= 255
X_test /= 255 | Digit Recognizer |
10,296,992 | rating_na = train.groupby(["release_year","original_language"])['rating'].mean().reset_index()
train[train.rating.isna() ]['rating'] = train.merge(rating_na, how = 'left' ,on = ["release_year","original_language"])
vote_count_na = train.groupby(["release_year","original_language"])['totalVotes'].mean().reset_index()
t... | y_train = np_utils.to_categorical(y_train, 10 ) | Digit Recognizer |
10,296,992 | rating_na = test.groupby(["release_year","original_language"])['rating'].mean().reset_index()
test[test.rating.isna() ]['rating'] = test.merge(rating_na, how = 'left' ,on = ["release_year","original_language"])
vote_count_na = test.groupby(["release_year","original_language"])['totalVotes'].mean().reset_index()
test[t... | X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train,
test_size = 0.1, random_state = 12345 ) | Digit Recognizer |
10,296,992 | train = train.drop(['id','belongs_to_collection','genres','homepage','imdb_id','overview','runtime'
,'poster_path','production_companies','production_countries','release_date','spoken_languages'
,'status','title','Keywords','cast','crew','original_language','original_title','tagline','all_genres',
'all_prod_companies',... | input_shape =(img_rows, img_cols, 1)
callback_es = EarlyStopping(monitor = 'val_accuracy', patience = 3)
def first_cnn_model_keras(optimizer):
model = Sequential()
model.add(Convolution2D(64, 5, 5, padding = 'same', kernel_initializer = 'he_uniform',
input_shape = input_shape))
model.add(Activation('relu'))
model.add... | Digit Recognizer |
10,296,992 | train.fillna(value=0.0, inplace = True)
test.fillna(value=0.0, inplace = True )<data_type_conversions> | model1 = first_cnn_model_keras(Adam(learning_rate = 0.001, amsgrad = True))
h1 = model1.fit(X_train, y_train, batch_size = batch_size, epochs = 20, verbose = 1,
validation_data =(X_valid, y_valid), callbacks = [callback_es])
final_loss_first_adam, final_acc_first_adam = model1.evaluate(X_valid, y_valid, verbose=0)
pr... | Digit Recognizer |
10,296,992 | def clean_dataset(df):
assert isinstance(df, pd.DataFrame), "df needs to be a pd.DataFrame"
df.dropna(inplace=True)
indices_to_keep = ~df.isin([np.nan, np.inf, -np.inf] ).any(1)
return df[indices_to_keep].astype(np.float64)
train = clean_dataset(train )<split> | model2 = first_cnn_model_keras(RMSprop(lr=0.001))
h2 = model2.fit(X_train, y_train, batch_size = batch_size, epochs = 20, verbose = 1,
validation_data =(X_valid, y_valid),callbacks = [callback_es])
final_loss_first_rmsprop, final_acc_first_rmsprop = model2.evaluate(X_valid, y_valid, verbose=0)
print("Final loss: {0:.... | Digit Recognizer |
10,296,992 | X = train.drop(['revenue'],axis=1)
y = train.revenue
X_train, X_valid, y_train, y_valid = train_test_split(X,y,test_size=0.2,random_state=25 )<compute_train_metric> | datagen = ImageDataGenerator(rotation_range = 10,
zoom_range = 0.1,
width_shift_range = 0.1,
height_shift_range = 0.1)
datagen.fit(X_train)
train_batches = datagen.flow(X_train, y_train, batch_size = batch_size ) | Digit Recognizer |
10,296,992 | lr = LinearRegression()
lr.fit(X_train, y_train)
pred = lr.predict(X_valid)
accuracy = r2_score(y_valid,pred)
print('Linear Regression R2 Score: ', accuracy)
mse = mean_squared_error(y_valid,pred)
print('Mean Squared Error: ', mse)
print('Root Mean Square Error',np.sqrt(mse))
cv_pred = cross_val_predict(lr,X,y,n_... | model3 = first_cnn_model_keras(Adam(learning_rate = 0.001, amsgrad = True))
h3 = model3.fit_generator(train_batches, epochs = 40, verbose = 1,
validation_data =(X_valid, y_valid), callbacks = [callback_es])
final_loss_first_adam_aug, final_acc_first_adam_aug = model3.evaluate(X_valid, y_valid, verbose=0)
print("Final... | Digit Recognizer |
10,296,992 | ls = Lasso()
ls.fit(X_train, y_train)
pred = ls.predict(X_valid)
accuracy = r2_score(y_valid,pred)
print('Lasso Regression R2 Score: ', accuracy)
mse = mean_squared_error(y_valid,pred)
print('Mean Squared Error: ', mse)
print('Root Mean Squared Error', np.sqrt(mse))
cv_pred = cross_val_predict(ls,X,y,n_jobs=-1, c... | model4 = first_cnn_model_keras(RMSprop(lr=0.001))
h4 = model4.fit_generator(train_batches, epochs = 40, verbose = 1,
validation_data =(X_valid, y_valid), callbacks = [callback_es])
final_loss_first_rmsprop_aug, final_acc_first_rmsprop_aug = model4.evaluate(X_valid, y_valid, verbose=0)
print("Final loss: {0:.4f}, fina... | Digit Recognizer |
10,296,992 | dt = DecisionTreeRegressor()
dt.fit(X_train, y_train)
pred = dt.predict(X_valid)
accuracy = r2_score(y_valid,pred)
print('Decision Tree R2 Score: ', accuracy)
mse = mean_squared_error(y_valid,pred)
print('Mean Squared Error: ', mse)
print('Root Mean Square Error',np.sqrt(mse))
cv_pred = cross_val_predict(dt,X,y,n... | def second_cnn_model_keras(optimizer):
model = Sequential()
model.add(Convolution2D(64, kernel_size =(5, 5), input_shape = input_shape, kernel_initializer = 'he_uniform'))
model.add(Activation('relu'))
model.add(Convolution2D(64, kernel_size =(5, 5), kernel_initializer = 'he_uniform'))
model.add(Activation('relu'))
mod... | Digit Recognizer |
10,296,992 | rf = RandomForestRegressor()
rf.fit(X_train, y_train)
pred = rf.predict(X_valid)
accuracy = r2_score(y_valid,pred)
print('Random Forest Regressor R2: ', accuracy)
mse = mean_squared_error(y_valid,pred)
print('Mean Squared Error: ', mse)
print('Root Mean Square Error',np.sqrt(mse))
cv_pred = cross_val_predict(rf,X... | model5 = second_cnn_model_keras(Adam(learning_rate = 0.001, amsgrad = True))
h5 = model5.fit(X_train, y_train, batch_size = batch_size, epochs = 20, verbose = 1,
validation_data =(X_valid, y_valid), callbacks = [callback_es])
final_loss_second_adam, final_acc_second_adam = model5.evaluate(X_valid, y_valid, verbose=0)
... | Digit Recognizer |
10,296,992 | rfr = RandomForestRegressor()
n_estimators = [int(x)for x in np.linspace(start = 50 , stop = 300, num = 5)]
max_features = [10,20,40,60,80,100,120]
max_depth = [int(x)for x in np.linspace(5, 10, num = 2)]
max_depth.append(None)
bootstrap = [True, False]
r_grid = {'n_estimators': n_estimators,
'max_features': max_featu... | model6 = second_cnn_model_keras(RMSprop(lr=0.001))
h6 = model6.fit(X_train, y_train, batch_size = batch_size, epochs = 20, verbose = 1,
validation_data =(X_valid, y_valid), callbacks = [callback_es])
final_loss_second_rmsprop, final_acc_second_rmsprop = model6.evaluate(X_valid, y_valid, verbose=0)
print("Final loss: ... | Digit Recognizer |
10,296,992 | import h2o
from h2o.estimators.gbm import H2OGradientBoostingEstimator
from h2o.automl import H2OAutoML<set_options> | model7 = second_cnn_model_keras(Adam(learning_rate = 0.001, amsgrad = True))
h7 = model7.fit_generator(train_batches, epochs = 20, verbose = 1,
validation_data =(X_valid, y_valid),callbacks = [callback_es])
final_loss_second_adam_aug, final_acc_second_adam_aug = model7.evaluate(X_valid, y_valid, verbose=0)
print("Fin... | Digit Recognizer |
10,296,992 | h2o.init()<prepare_output> | model8 = second_cnn_model_keras(RMSprop(lr=0.001))
h8 = model8.fit_generator(train_batches, epochs = 20, verbose = 1,
validation_data =(X_valid, y_valid), callbacks = [callback_es])
final_loss_second_rmsprop_aug, final_acc_second_rmsprop_aug = model8.evaluate(X_valid, y_valid, verbose=0)
print("Final loss: {0:.4f}, f... | Digit Recognizer |
10,296,992 | h2o_df=h2o.H2OFrame(train)
h2o_df.head()<split> | models = ['first_cnn_adam', 'first_cnn_rmsprop', 'first_cnn_adam_aug', 'first_cnn_rmsprop_aug',
'second_cnn_adam', 'second_cnn_rmsprop', 'second_cnn_adam_aug', 'second_cnn_rmsprop_aug']
dict_values = {'loss': [final_loss_first_adam, final_loss_first_rmsprop, final_loss_first_adam_aug,
final_loss_first_rmsprop_aug, fina... | Digit Recognizer |
10,296,992 | splits = h2o_df.split_frame(ratios=[0.8],seed=1)
h2o_train = splits[0]
h2o_valid = splits[1]<prepare_x_and_y> | model = [0]*10
for i in range(10):
model[i] = Sequential()
model[i].add(Convolution2D(64, kernel_size =(3, 3), input_shape = input_shape, kernel_initializer = 'he_uniform'))
model[i].add(Activation('relu'))
model[i].add(BatchNormalization())
model[i].add(Convolution2D(64, kernel_size =(3, 3), kernel_initializer = 'he_... | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.