kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,650,794 | del pickle
gc.collect()<set_options> | optimizer = Adam(learning_rate=0.001, epsilon=1e-07)
model.compile(optimizer = optimizer, loss = 'categorical_crossentropy', metrics=['accuracy'])
earlyStopping = EarlyStopping(monitor='val_accuracy', patience=10, verbose=0, mode='auto')
mcp = ModelCheckpoint('.mdl_wts.hdf5', save_best_only=True, monitor='val_accura... | Digit Recognizer |
11,650,794 | torch.cuda.is_available()<set_options> | datagen = ImageDataGenerator(
rotation_range=5,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=5,
zoom_range=0.1)
datagen.fit(X_train ) | Digit Recognizer |
11,650,794 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu" )<choose_model_class> | history = model.fit_generator(datagen.flow(X_train, y_train, batch_size=64),
epochs = 100,
validation_data =(X_val,y_val),
verbose = 1,
steps_per_epoch=X_train.shape[0]//64,
callbacks = [earlyStopping, mcp, reduce_lr_loss] ) | Digit Recognizer |
11,650,794 | def create_model() :
return SAKTModel(n_skill, max_seq=MAX_SEQ, embed_dim=EMBED_SIZE, forward_expansion=1, enc_layers=1, heads=8, dropout=0.1 )<load_pretrained> | model.load_weights(filepath = '.mdl_wts.hdf5' ) | Digit Recognizer |
11,650,794 | model_attention = create_model()
try:
model_attention.load_state_dict(torch.load("/kaggle/input/attention/attention.pth"))
except:
model_attention.load_state_dict(torch.load("/kaggle/input/attention/attention.pth", map_location='cpu'))
model_attention.to(device )<split> | scores = model.evaluate(X_val, y_val, callbacks = [earlyStopping, mcp, reduce_lr_loss] ) | Digit Recognizer |
11,650,794 | env = riiideducation.make_env()
iter_test = env.iter_test()
prior_test_df = None
prev_test_df = None<feature_engineering> | img_tensor = X_test[5].reshape(-1, 28, 28, 1 ) | Digit Recognizer |
11,650,794 | %%time
model_attention.eval()
for(test_df, sample_prediction_df)in(iter_test):
if(prev_test_df is not None)&(psutil.virtual_memory().percent < 95):
print(psutil.virtual_memory().percent)
prev_test_df['answered_correctly'] = eval(test_df['prior_group_answers_correct'].iloc[0])
prev_test_df = prev_test_df[prev_test_df.... | for layer in model.layers:
if'conv' in layer.name:
filters, biases = layer.get_weights()
print('Layer: ', layer.name, filters.shape)
f_min, f_max = filters.min() , filters.max()
filters =(filters - f_min)/(f_max - f_min)
print('Filter size:(', filters.shape[0], ',', filters.shape[1], ')')
print('Channels in this lay... | Digit Recognizer |
11,650,794 | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
<define_variables> | layer_outputs = [layer.output for layer in model.layers[0:8]]
activation_model = models.Model(inputs = model.input, outputs = layer_outputs ) | Digit Recognizer |
11,650,794 | path = Path('/kaggle/input')
assert path.exists()<data_type_conversions> | activations = activation_model.predict(img_tensor ) | Digit Recognizer |
11,650,794 | def add_features(df, answered_correctly_u_count, answered_correctly_u_sum, elapsed_time_u_sum, explanation_u_sum,
timestamp_u, timestamp_u_incorrect, answered_correctly_q_count, answered_correctly_q_sum,
elapsed_time_q_sum, explanation_q_sum, answered_correctly_uq, update=True):
answered_correctly_u_avg = np.zeros(len(... | results = np.argmax(model.predict(X_test), axis=1)
results = pd.Series(results, name = "Label")
results.head(2 ) | Digit Recognizer |
11,650,794 | <load_from_csv><EOS> | submission.to_csv("CNN_MNIST_results.csv",index=False ) | Digit Recognizer |
11,821,654 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<define_variables> | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import random
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
from keras.utils import np_utils | Digit Recognizer |
11,821,654 | gbm = lgb.Booster(model_file='.. /input/lightgbmmodel/model.txt' )<load_from_disk> | ( X_train, y_train),(X_test, y_test)= mnist.load_data()
print("X_train shape", X_train.shape)
print("y_train shape", y_train.shape)
print("X_test shape", X_test.shape)
print("y_test shape", y_test.shape ) | Digit Recognizer |
11,821,654 | json_file = ".. /input/lightgbm-features-dicts/lightgbm_features_dicts.json"
f = open(json_file)
features_dicts = json.load(f )<drop_column> | test_data = pd.read_csv('/kaggle/input/digit-recognizer/test.csv', delimiter = ',', header = 0, usecols = [x for x in range(0, 784)] ) | Digit Recognizer |
11,821,654 | del f<data_type_conversions> | X_train = X_train.reshape(60000, 784)
X_test = X_test.reshape(10000, 784)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
print("Training matrix shape", X_train.shape)
print("Testing matrix shape", X_test.shape ) | Digit Recognizer |
11,821,654 | def change_type(temp):
result = defaultdict(int)
for k,v in temp.items() :
key = float(k)
value = int(float(v))
result[key] =value
return result
answered_correctly_u_count = change_type(answered_correctly_u_count_)
answered_correctly_u_sum = change_type(answered_correctly_u_sum_)
elapsed_time_u_sum = change_type(el... | no_classes = 10
Y_train = np_utils.to_categorical(y_train, no_classes)
Y_test = np_utils.to_categorical(y_test, no_classes ) | Digit Recognizer |
11,821,654 | def change_answered_correctly_uq_type(t):
result = defaultdict(lambda: defaultdict(int))
for k,v in t.items() :
key = float(k)
temp = defaultdict(int)
for k1,v1 in v.items() :
k1 = float(k1)
temp[k1] = v1
result[key] = temp
return result
answered_correctly_uq = change_answered_correctly_uq_type(answered_correctly_uq... | model = Sequential() | Digit Recognizer |
11,821,654 | def changetolist(t):
result = defaultdict(list)
for k,v in t.items() :
key = float(k)
value = list(v)
result[key] = value
return result
timestamp_u = changetolist(timestamp_u_)
timestamp_u_incorrect = changetolist(timestamp_u_incorrect_)
del timestamp_u_
del timestamp_u_incorrect_<define_variables> | model.add(Dense(512, input_shape=(784,)) ) | Digit Recognizer |
11,821,654 | TARGET = 'answered_correctly'
FEATURES = ['answered_correctly_u_avg', 'explanation_u_avg', 'elapsed_time_u_avg',
'answered_correctly_q_avg', 'explanation_q_avg', 'elapsed_time_q_avg',
'answered_correctly_uq_count', 'timestamp_u_recency_1',
'timestamp_u_recency_2', 'timestamp_u_recency_3',
'timestamp_u_incorrect_recency... | model.add(Activation('relu')) | Digit Recognizer |
11,821,654 | import riiideducation
import numpy as np
import pandas as pd
from tqdm import tqdm<compute_test_metric> | model.add(Dropout(0.2)) | Digit Recognizer |
11,821,654 | def get_new_theta(is_good_answer, beta, left_asymptote, theta, nb_previous_answers):
return theta + learning_rate_theta(nb_previous_answers)*(
is_good_answer - probability_of_good_answer(theta, beta, left_asymptote)
)
def get_new_beta(is_good_answer, beta, left_asymptote, theta, nb_previous_answers):
return beta - le... | model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.2)) | Digit Recognizer |
11,821,654 | def estimate_parameters(answers_df, granularity_feature_name='content_id'):
item_parameters = {
granularity_feature_value: {"beta": 0, "nb_answers": 0}
for granularity_feature_value in np.unique(answers_df[granularity_feature_name])
}
student_parameters = {
student_id: {"theta": 0, "nb_answers": 0}
for student_id in n... | model.add(Dense(10))
model.add(Activation('softmax')) | Digit Recognizer |
11,821,654 | def update_parameters(answers_df, student_parameters, item_parameters, granularity_feature_name='content_id'):
for student_id, item_id, left_asymptote, answered_correctly in tqdm(zip(
answers_df.student_id.values,
answers_df[granularity_feature_name].values,
answers_df.left_asymptote.values,
answers_df.answered_correc... | model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'] ) | Digit Recognizer |
11,821,654 | def estimate_probas(test_df, student_parameters, item_parameters, granularity_feature_name='content_id'):
probability_of_success_list = []
for student_id, item_id, left_asymptote in tqdm(
zip(test_df.student_id.values, test_df[granularity_feature_name].values, test_df.left_asymptote.values)
):
theta = student_paramete... | history = model.fit(X_train, Y_train,
batch_size=128, epochs=10,
verbose=1 ) | Digit Recognizer |
11,821,654 | compute_estimations = False
nb_rows_training = None<load_from_csv> | score = model.evaluate(X_test, Y_test)
print('Test accuracy:', score[1] ) | Digit Recognizer |
11,821,654 | if compute_estimations:
training = pd.read_csv(
filepath_or_buffer="/kaggle/input/riiid-test-answer-prediction/train.csv",
usecols=["content_id", "user_id", "answered_correctly"],
dtype={'answered_correctly': "int8"},
nrows=nb_rows_training
)
training.rename(columns={'user_id': 'student_id'}, inplace=True)
training... | results = model.predict(test_data ) | Digit Recognizer |
11,821,654 | def format_test_df(test_df):
test_copy = test_df.copy()
test_copy = test_copy[test_copy['content_type_id'] == 0]
test_copy['left_asymptote'] = 1/4
test_copy = test_copy.rename(columns={'user_id': 'student_id'})
return test_copy<predict_on_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("submission.csv",index=False ) | Digit Recognizer |
11,821,654 | <compute_test_metric><EOS> | predicted_classes = model.predict_classes(X_test)
correct_indices = np.nonzero(predicted_classes == y_test)[0]
incorrect_indices = np.nonzero(predicted_classes != y_test)[0] | Digit Recognizer |
12,529,129 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<import_modules> | np.random.seed(1)
get_ipython().magic('matplotlib inline')
print(tf.__version__ ) | Digit Recognizer |
12,529,129 | import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import RandomForestRegressor<load_from_csv> | train_path=".. /input/digit-recognizer/train.csv"
test_path=".. /input/digit-recognizer/test.csv"
train = pd.read_csv(train_path)
test= pd.read_csv(test_path)
print(train.shape)
print(test.shape)
train.head() | Digit Recognizer |
12,529,129 | np.random.seed(seed=1234)
skiprows = np.random.rand(55 * 10 ** 7)> 0.02
skiprows[0] = False
df_ = pd.read_csv("/kaggle/input/new-york-city-taxi-fare-prediction/train.csv", skiprows=lambda x: skiprows[x])
df_.head()<define_variables> | x = x.values.reshape(-1,28,28,1)
print("x shape: ",x.shape)
y = to_categorical(y, num_classes = 10)
print("y shape: ",y.shape)
print(y[10])
plt.imshow(-x[10][:,:,0],cmap='gray')
plt.axis(False)
plt.show() | Digit Recognizer |
12,529,129 | lon_min, lon_max = -75, -72
lat_min, lat_max = 40, 43<feature_engineering> | X_train, X_val, Y_train, Y_val = train_test_split(x, y, test_size = 0.2, random_state=1)
print("x_train shape",X_train.shape)
print("x_val shape",X_val.shape)
print("y_train shape",Y_train.shape)
print("y_val shape",Y_val.shape ) | Digit Recognizer |
12,529,129 | df = df_.copy()
df = df.drop(columns=["key"])
df["date"] = df["pickup_datetime"].apply(lambda x: x.split() [0])
df["time"] = df["pickup_datetime"].apply(lambda x: x.split() [1])
df = df.drop("pickup_datetime", axis=1)
df["year"] = df["date"].apply(lambda x: int(x.split("-")[0]))
df["month"] = df["date"].apply(lambd... | datagen = ImageDataGenerator(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_train ) | Digit Recognizer |
12,529,129 | X = np.array(df.drop(
columns=[
"fare_amount",
]
))
y = np.array(df["fare_amount"] )<split> | Image = [[0,0,0],
[0,1,1],
[0,1,2]]
kernel = [[-4,0,0],
[0,0,0],
[0,0,4]]
result = signal.convolve(Image,kernel,'valid')
result2 = 4*0 + 0*0 + 0*0 + 0*0 + 0*1 + 0*1 + 0*1 + 0*0 + -4*2
print("Result with scipy: {}
Result with manual calculs : {}".format(result,result2))
print("
With 'same':
{}".format(signal.convolve(I... | Digit Recognizer |
12,529,129 | np.random.seed(seed=1234)
train_rows = np.random.rand(y.size)> 0.2
X_train, y_train = X[train_rows, :], y[train_rows]
X_valid, y_valid = X[~train_rows, :], y[~train_rows]<train_model> | def define_model(actifun="elu",actifundense1="elu",actifundense2="softsign",optimizer="Adam"):
model = model = Sequential([
Conv2D(32,(3, 3), padding = 'same', activation = 'relu', input_shape =(28,28,1)) ,
BatchNormalization() ,
Conv2D(32,(3, 3), padding = 'same', activation = 'relu'),
BatchNormalization() ,
MaxPool2D... | Digit Recognizer |
12,529,129 | model = RandomForestRegressor(max_depth=30, n_estimators=100, n_jobs=-1)
model.fit(X_train, y_train)
y_valid_pred = model.predict(X_valid)
rmse(y_valid, y_valid_pred )<load_from_csv> | %%time
X_train_train, X_train_val, Y_train_train, Y_train_val = train_test_split(X_train, Y_train, test_size = 0.3, random_state = 0)
models={}
history={}
optim_list = ["Adam","RMSprop"]
lr_sched = ReduceLROnPlateau(monitor = 'val_acc',
patience = 10,
verbose = 1,
factor = 0.1,
min_lr = 0.00001)
early_stopping = Earl... | Digit Recognizer |
12,529,129 | test = pd.read_csv("/kaggle/input/new-york-city-taxi-fare-prediction/test.csv")
test.head()<feature_engineering> | rslts={}
k=0
for optim in optim_list:
for fun in ["elu","relu"]:
fun1 = fun
fun2 = fun
fun3 = "softsign"
mtype = optim + ' + ' + fun1 + ' + ' + fun2 + ' + ' + fun3
rslts[mtype] =(models[mtype].evaluate(X_val, Y_val, verbose = 0)[1])
k=k+1
for item in sorted(rslts.items() , key=lambda x: x[1],reverse=True):
print(item[... | Digit Recognizer |
12,529,129 | test["date"] = test["pickup_datetime"].apply(lambda x: x.split() [0])
test["time"] = test["pickup_datetime"].apply(lambda x: x.split() [1])
test = test.drop("pickup_datetime", axis=1)
test["year"] = test["date"].apply(lambda x: int(x.split("-")[0]))
test["month"] = test["date"].apply(lambda x: int(x.split("-")[1]))
... | datagen.fit(x)
X_train, X_val, Y_train, Y_val = train_test_split(x, y, test_size = 0.1, random_state = 0)
lr_sched = ReduceLROnPlateau(monitor = 'val_acc',
patience = 10,
verbose = 1,
factor = 0.1,
min_lr = 0.00001)
early_stopping = EarlyStopping(monitor = 'val_acc',
patience = 10,
verbose = 1,
mode = 'auto',
restor... | Digit Recognizer |
12,529,129 | X_test = np.array(test.drop(columns=[
"key",
]))
y_pred = model.predict(X_test)
test["fare_amount"] = y_pred
submission= test[["key", "fare_amount"]]
submission.to_csv("./submission.csv", index=False )<load_from_csv> | test_path=".. /input/digit-recognizer/test.csv"
test = pd.read_csv(test_path)
test = test / 255.0
test = test.values.reshape(-1,28,28,1)
Y_pred_test = model.predict(test)
Y_pred_classes_test = np.argmax(Y_pred_test,axis = 1)
np.savetxt('submission.csv',
np.c_[range(1,len(test)+1), Y_pred_classes_test],
delimiter=',... | Digit Recognizer |
12,445,197 | MODE = 1
FUDGE = 2.0
FILE = '.. /input/rfcx-minimal/submission.csv'
df = pd.read_csv(FILE)
for k in range(24):
df.iloc[:,1+k] -= df.iloc[:,1+k].min()
df.iloc[:,1+k] /= df.iloc[:,1+k].max()
def scale(probs, factor):
probs = probs.copy()
idx = np.where(probs!=1)[0]
odds = factor * probs[idx] /(1-probs[idx])
probs[idx] ... | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
12,445,197 | save_to_disk = 0<install_modules> | X_train_raw = train.drop(columns=['label'] ).to_numpy()
y_train_raw = train['label'].to_numpy() | Digit Recognizer |
12,445,197 | !pip install resnest > /dev/null<normalization> | x_mean = np.mean(X_train_raw)
x_std = np.std(X_train_raw)
def standarize(X):
return(X - x_mean)/ x_std
X_train = np.reshape(X_train_raw,(-1,28,28,1))
X_train = standarize(X_train)
y_train_cat = keras.utils.to_categorical(y_train_raw ) | Digit Recognizer |
12,445,197 | def horizontal_flip(img):
horizontal_flip_img = img[:, ::-1]
return addChannels(horizontal_flip_img)
def vertical_flip(img):
vertical_flip_img = img[::-1, :]
return addChannels(vertical_flip_img)
def addNoisy(img):
noise_img = util.random_noise(img)
return addChannels(noise_img)
def contrast_stretching(img):
contra... | data_generator = keras.preprocessing.image.ImageDataGenerator(
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1
)
data_generator.fit(X_train ) | Digit Recognizer |
12,445,197 | def get_model() :
resnet_model = resnest50(pretrained=True)
num_ftrs = resnet_model.fc.in_features
resnet_model.fc = nn.Linear(num_ftrs, num_birds)
resnet_model = resnet_model.to(device)
return resnet_model<define_variables> | def make_model() :
model = keras.models.Sequential()
model.add(keras.layers.Conv2D(32, kernel_size=3,activation='relu',kernel_initializer='he_normal',input_shape=(28, 28, 1)))
model.add(keras.layers.BatchNormalization())
model.add(keras.layers.Conv2D(32, kernel_size=3,activation='relu'))
model.add(keras.layers.BatchN... | Digit Recognizer |
12,445,197 | class AudioData(Dataset):
def __init__(self, X, y, data_type):
self.data = []
self.labels = []
self.augs = [
addNoisy, contrast_stretching,
randomGaussian, grayScale,
randomGamma, vertical_flip,
horizontal_flip, addChannels
]
self.data_type=data_type
for i in range(0, len(X)) :
recording_id = X[i]
label = y[i]
mel_spec... | ens_size=16
model = [0]*ens_size
for i in range(ens_size):
model[i] = make_model() | Digit Recognizer |
12,445,197 | import torch
import torch.nn as nn
import copy<init_hyperparams> | history = [0]*ens_size
start = time.perf_counter()
for i in range(ens_size):
callbacks = [keras.callbacks.ModelCheckpoint('/kaggle/working/mdl-{}-of-{}.hdf5'
.format(i,ens_size-1),save_best_only=True, monitor='val_accuracy', mode='max')]
X_train_ens, X_valid_ens, y_train_ens, y_valid_ens = train_test_split(X_train, y_... | Digit Recognizer |
12,445,197 | class Adas(Optimizer):
r
def __init__(self, params,
lr = 0.001, lr2 =.005, lr3 =.0005,
beta_1 = 0.999, beta_2 = 0.999, beta_3 = 0.9999,
epsilon = 1e-8, **kwargs):
if not 0.0 <= lr:
raise ValueError("Invalid lr: {}".format(lr))
if not 0.0 <= lr2:
raise ValueError("Invalid lr2: {}".format(lr))
if not 0.0 <= lr3:
raise Va... | X_test = np.reshape(test.to_numpy() ,(-1,28,28,1))
X_test = standarize(X_test ) | Digit Recognizer |
12,445,197 | num_birds = 24
if torch.cuda.is_available() :
device=torch.device('cuda:0')
else:
device=torch.device('cpu' )<train_model> | preds = np.zeros(( X_test.shape[0],10))
for i in range(ens_size):
mdl = keras.models.load_model('/kaggle/working/mdl-{}-of-{}.hdf5'.format(i,ens_size-1))
preds = preds + mdl.predict(X_test ) | Digit Recognizer |
12,445,197 | learning_rate = 2e-4
epochs = 20
loss_fn = nn.CrossEntropyLoss()
def train(model, loss_fn, train_loader, valid_loader, epochs, optimizer, scheduler):
best_model_wts = copy.deepcopy(model.state_dict())
best_acc = 0.0
train_losses = []
valid_losses = []
for epoch in tqdm(range(1,epochs+1)) :
model.train()
batch_losses=[... | submit_pred = np.argmax(preds,axis=1)
submit_pred.shape | Digit Recognizer |
12,445,197 | fft = 2048
hop = 512
sr = 48000
length = 10 * sr
with open('/kaggle/input/rfcx-species-audio-detection/train_tp.csv')as f:
reader = csv.reader(f)
next(reader, None)
data = list(reader)
fmin = 24000
fmax = 0
for i in range(0, len(data)) :
if fmin > float(data[i][4]):
fmin = float(data[i][4])
if fmax < float(data[i][... | submition = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv')
submition['Label'] = submit_pred | Digit Recognizer |
12,445,197 | nfold = 5
skf = KFold(n_splits=nfold, shuffle=True, random_state=32)
for fold_id,(train_index, val_index)in enumerate(skf.split(data_list, label_list)) :
print("Fold", fold_id)
X_train = np.take(data_list, train_index)
y_train = np.take(label_list, train_index, axis = 0)
X_val = np.take(data_list, val_index)
y_val... | submition.to_csv('/kaggle/working/submition_ens3.csv', index=False ) | Digit Recognizer |
12,468,048 | def load_test_file(f):
wav, sr = librosa.load('/kaggle/input/rfcx-species-audio-detection/test/' + f, sr=None)
segments = len(wav)/ length
segments = int(np.ceil(segments))
mel_array = []
for i in range(0, segments):
if(i + 1)* length > len(wav):
slice = wav[len(wav)- length:len(wav)]
else:
slice = wav[i * length:(i +... | import pandas as pd
import numpy as np | Digit Recognizer |
12,468,048 | del audio_data
members = []
for i in range(nfold):
model = get_model()
model.load_state_dict(torch.load('/kaggle/working/model'+str(i)+'.pt'))
model.eval()
members.append(model )<save_to_csv> | import pandas as pd
import numpy as np | Digit Recognizer |
12,468,048 | if save_to_disk == 0:
for f in os.listdir('/kaggle/working/'):
os.remove('/kaggle/working/' + f)
print('Starting prediction loop')
with open('submission.csv', 'w', newline='')as csvfile:
submission_writer = csv.writer(csvfile, delimiter=',')
submission_writer.writerow(['recording_id','s0','s1','s2','s3','s4','s5','s... | import tensorflow as tf
from tensorflow import keras | Digit Recognizer |
12,468,048 | ! pip install -q efficientnet<import_modules> | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
train.head() | Digit Recognizer |
12,468,048 | import math, os, re, warnings, random , time
from collections import namedtuple
import tensorflow as tf
import numpy as np
import pandas as pd
import librosa
from kaggle_datasets import KaggleDatasets
import matplotlib.pyplot as plt
from IPython.display import Audio
from tensorflow.keras import Model, layers , optimize... | test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
test.head() | Digit Recognizer |
12,468,048 | try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
print(f'Running on TPU {tpu.master() }')
except ValueError:
tpu = None
if tpu:
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.experimental.initialize_tpu_system(tpu)
strategy = tf.distribute.experimental.TPUStrategy(tpu)
else:
strategy = tf.distr... | X_train /= 255
test /= 255 | Digit Recognizer |
12,468,048 | def seed_everything(seed=0):
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
os.environ['TF_DETERMINISTIC_OPS'] = '1'
seed = 42
seed_everything(seed)
warnings.filterwarnings('ignore' )<define_variables> | X_train = X_train.values.reshape(-1,28,28,1)
test = test.values.reshape(-1,28,28,1 ) | Digit Recognizer |
12,468,048 | def count_data_items(filenames):
n = [int(re.compile(r"-([0-9]*)\." ).search(filename ).group(1)) for filename in filenames]
return np.sum(n)
TRAIN_DATA_DIR = 'rfcx-audio-detection'
TRAIN_GCS_PATH = KaggleDatasets().get_gcs_path(TRAIN_DATA_DIR)
FILENAMES = tf.io.gfile.glob(TRAIN_GCS_PATH + '/tp*.tfrec')
TEST_DATA_DI... | Y_train = to_categorical(y_train,num_classes = 10 ) | Digit Recognizer |
12,468,048 | CUT = 10
TIME = 10
EPOCHS = 25
GLOBAL_BATCH_SIZE = 4 * REPLICAS
LEARNING_RATE = 0.0015
WARMUP_LEARNING_RATE = 1e-5
WARMUP_EPOCHS = int(EPOCHS*0.1)
PATIENCE = 10
STEPS_PER_EPOCH = 64
N_FOLDS = 5
NUM_TRAINING_SAMPLES = no_of_training_samples
class params:
sample_rate = 48000
stft_window_seconds: float = 0.025
stft_hop_s... | random_seed=2
X_train, X_val, Y_train, Y_val = train_test_split(X_train,Y_train,test_size = 0.1, random_state=random_seed ) | Digit Recognizer |
12,468,048 | feature_description = {
'wav': tf.io.FixedLenFeature([], tf.string),
'recording_id': tf.io.FixedLenFeature([], tf.string),
'target' : tf.io.FixedLenFeature([], tf.float32),
'song_id': tf.io.FixedLenFeature([], tf.float32),
'tmin' : tf.io.FixedLenFeature([], tf.float32),
'fmin' : tf.io.FixedLenFeature([], tf.float32),
'... | from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D
from keras.optimizers import RMSprop
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import ReduceLROnPlateau | Digit Recognizer |
12,468,048 | def waveform_to_log_mel_spectrogram(waveform,target_or_rec_id):
window_length_samples = int(
round(params.sample_rate * params.stft_window_seconds))
hop_length_samples = int(
round(params.sample_rate * params.stft_hop_seconds))
fft_length = 2 ** int(np.ceil(np.log(window_length_samples)/ np.log(2.0)))
num_spectrog... | cnn = Sequential()
cnn.add(Conv2D(filters=32,kernel_size=(5,5),padding='Same',activation='relu', input_shape=(28,28,1)))
cnn.add(Conv2D(filters=32,kernel_size=(5,5),padding='Same',activation='relu'))
cnn.add(MaxPool2D(pool_size=(2,2)))
cnn.add(Dropout(0.25))
cnn.add(Conv2D(filters=64,kernel_size=(3,3),padding='Same',... | Digit Recognizer |
12,468,048 | def frequency_masking(mel_spectrogram):
frequency_masking_para = 80,
frequency_mask_num = 2
fbank_size = tf.shape(mel_spectrogram)
n, v = fbank_size[0], fbank_size[1]
for i in range(frequency_mask_num):
f = tf.random.uniform([], minval=0, maxval= tf.squeeze(frequency_masking_para), dtype=tf.int32)
v = tf.cast(v, dtyp... | optimizer = RMSprop(lr=0.001,rho=0.9,epsilon=1e-08,decay=0.0 ) | Digit Recognizer |
12,468,048 | def preprocess(image, target_or_rec_id):
image = tf.image.grayscale_to_rgb(image)
image = tf.image.resize(image, [params.height,params.width])
image = tf.image.per_image_standardization(image)
return image , target_or_rec_id
def read_labeled_tfrecord(example_proto):
sample = tf.io.parse_single_example(example_proto,... | cnn.compile(optimizer = optimizer, loss ='categorical_crossentropy', metrics=['accuracy'] ) | Digit Recognizer |
12,468,048 | def load_dataset(filenames, labeled = True, ordered = False , training = True):
ignore_order = tf.data.Options()
if not ordered:
ignore_order.experimental_deterministic = False
dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads = AUTO)
dataset = dataset.map(read_labeled_tfrecord , num_parallel_calls = AUT... | learning_rate_reduction = ReduceLROnPlateau(moniter = 'val_acc',
patience = 3,
verbose = 1,
factor=0.5,
min_lr = 0.00001 ) | Digit Recognizer |
12,468,048 | def get_dataset(filenames, training = True):
if training:
dataset = load_dataset(filenames , training = True)
dataset = dataset.shuffle(256 ).repeat()
dataset = dataset.batch(GLOBAL_BATCH_SIZE, drop_remainder = True)
else:
dataset = load_dataset(filenames , training = False)
dataset = dataset.repeat().batch(GLOBAL_B... | epochs = 10
batch_size = 86 | Digit Recognizer |
12,468,048 | @tf.function
def _one_sample_positive_class_precisions(example):
y_true, y_pred = example
y_true = tf.reshape(y_true, tf.shape(y_pred))
retrieved_classes = tf.argsort(y_pred, direction='DESCENDING')
class_rankings = tf.argsort(retrieved_classes)
retrieved_class_true = tf.gather(y_true, retrieved_classes)
retrieved_c... | Digit Recognizer | |
12,468,048 | learning_rate_base = LEARNING_RATE
total_steps = STEPS_PER_EPOCH * EPOCHS
warmup_learning_rate = WARMUP_LEARNING_RATE
warmup_steps= WARMUP_EPOCHS * STEPS_PER_EPOCH
@tf.function
def cosine_decay_with_warmup(global_step,
hold_base_rate_steps=0):
if total_steps < warmup_steps:
raise ValueError('total_steps must be larger ... | 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... | Digit Recognizer |
12,468,048 | class RFCX_MODEL(tf.keras.Model):
def __init__(self):
super(RFCX_MODEL , self ).__init__()
self.gaussian_noise = GaussianNoise(0.05)
self.resnet_model = ResNet50(include_top=False, weights='imagenet')
self.model_output = GlobalAveragePooling2D()
self.dropout = Dropout(params.dropout)
self.predictions = Dense(params.... | history = cnn.fit_generator(datagen.flow(X_train,Y_train,batch_size=batch_size),
epochs =epochs, validation_data =(X_val, Y_val),
verbose=2, steps_per_epoch=X_train.shape[0]//batch_size,
callbacks = [learning_rate_reduction] ) | Digit Recognizer |
12,468,048 | def train_one_fold(train_dataset, valid_dataset):
print('Start fine-tuning!', flush=True)
train_dist_dataset = strategy.experimental_distribute_dataset(train_dataset)
valid_dist_dataset = strategy.experimental_distribute_dataset(valid_dataset)
start_time = epoch_start_time = time.time()
print("Steps per epoch:", STE... | results = cnn.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
12,468,048 | <create_dataframe><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("cnn_mnist_datagen.csv",index=False)
| Digit Recognizer |
12,607,235 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<predict_on_test> | import numpy as np
import pandas as pd | Digit Recognizer |
12,607,235 | test_predict = []
test_data = get_test_dataset(TEST_FILES, training = False)
test_audio = test_data.map(lambda frames, recording_id: frames)
for fold in range(N_FOLDS):
model.load_weights(f'./RFCX_model_fold {fold}.h5')
test_predict.append(model.predict(test_audio, verbose = 1))<load_from_csv> | print(tf.__version__ ) | Digit Recognizer |
12,607,235 | SUB = pd.read_csv('.. /input/rfcx-species-audio-detection/sample_submission.csv')
predict = np.array(test_predict ).reshape(N_FOLDS, len(SUB), 60 // TIME, params.num_classes)
predict = np.mean(np.max(predict ,axis = 2), axis = 0)
recording_id = test_data.map(lambda frames, recording_id: recording_id ).unbatch()
test... | try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
print('Running on TPU ', tpu.master())
except ValueError:
tpu = None
if tpu:
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.experimental.initialize_tpu_system(tpu)
strategy = tf.distribute.experimental.TPUStrategy(tpu)
else:
strategy = tf.distrib... | Digit Recognizer |
12,607,235 | pred_df.sort_values('recording_id', inplace = True)
pred_df.to_csv('submission.csv', index = False )<import_modules> | EPOCHS = 75
DROP_RATE = 0.4
BATCH_SIZE = 16 * strategy.num_replicas_in_sync
RESIZE_SIZE =(224, 224)
TTA_COUNT = 10
MODEL_VERSION = 'V17' | Digit Recognizer |
12,607,235 | import pandas as pd, numpy as np
import os<define_variables> | DATA_DIR = '.. /input/digit-recognizer/'
def read_df(file_name):
file_path = DATA_DIR + file_name
data_df = pd.read_csv(file_path)
return data_df | Digit Recognizer |
12,607,235 | paths = [
".. /input/rfcx-best-performing-public-kernels/kkiller_inference-tpu-rfcx-audio-detection-fast_0861.csv",
".. /input/rfcx-best-performing-public-kernels/submission_khoongweihao_0845.csv",
]
weights = np.array([0.6, 0.4])
sum(weights )<define_variables> | train_df = read_df('train.csv')
train_df | Digit Recognizer |
12,607,235 | cols = [f"s{i}" for i in range(24)]<load_from_csv> | IMAGE_SIZE =(28, 28)
IMAGE_SHAPE =(*IMAGE_SIZE, 1)
def get_images_from(data_df):
pixels_df = data_df.loc[ : , 'pixel0':'pixel783' ]
pixels_array = pixels_df.to_numpy(dtype=np.uint8)
images = pixels_array.reshape(-1, *IMAGE_SHAPE)
return images | Digit Recognizer |
12,607,235 | scores = []
for path in paths:
df = pd.read_csv(path ).sort_values("recording_id" ).reset_index(drop=True)
score = np.empty(( len(df), 24))
o = df[cols].values.argsort(1)
score[np.arange(len(df)) [:, None], o] = np.arange(24)[None]
scores.append(score)
scores = np.stack(scores)
scores.shape<compute_test_metric> | def get_labels_from(data_df):
labels = data_df['label'].to_numpy(dtype=np.int32)
return labels | Digit Recognizer |
12,607,235 | sub_score = np.sum(scores*weights[:, None, None], 0)
print(sub_score.shape)
sub_score<prepare_output> | X = get_images_from(train_df)
y = get_labels_from(train_df)
print(X.shape)
print(y.shape ) | Digit Recognizer |
12,607,235 | sub = pd.DataFrame(sub_score, columns=cols)
sub["recording_id"] = df["recording_id"]
sub = sub[["recording_id"] + cols]
print(sub.shape)
sub.head()<save_to_csv> | RESIZE_SHAPE =(*RESIZE_SIZE, 1)
def resize_image(orig_np):
reshape_np = np.reshape(orig_np, IMAGE_SIZE)
orig_im = Image.fromarray(reshape_np)
resized_im = orig_im.resize(RESIZE_SIZE, Image.LANCZOS)
resized_np = np.asarray(resized_im, dtype=np.uint8)
resized_reshaped_np = np.reshape(resized_np, RESIZE_SHAPE)
retur... | Digit Recognizer |
12,607,235 | sub.to_csv("submission.csv", index=False )<import_modules> | def resize_images(orig_nps):
n_images = orig_nps.shape[0]
resized_shape =(n_images, *RESIZE_SHAPE)
resized_nps = np.empty(resized_shape, dtype=np.uint8)
for i in range(n_images):
if i % 100 == 0:
print('.', end='', flush=True)
x_np = orig_nps[i]
resized_nps[i] = resize_image(x_np)
print()
return resized_nps | Digit Recognizer |
12,607,235 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import cv2
import keras
import math<load_from_csv> | def get_mat(rotation, shear, height_zoom, width_zoom, height_shift, width_shift):
rotation = math.pi * rotation / 180.
shear = math.pi * shear / 180.
c1 = tf.math.cos(rotation)
s1 = tf.math.sin(rotation)
one = tf.constant([1],dtype='float32')
zero = tf.constant([0],dtype='float32')
rotation_matrix = tf.reshape(tf... | Digit Recognizer |
12,607,235 | test = pd.read_csv('.. /input/quickdraw-doodle-recognition/test_simplified.csv')
print(test.shape)
test.head()<categorify> | def do_transform(image,label):
DIM = RESIZE_SIZE[0]
XDIM = DIM%2
rot = 10.* tf.random.normal([1],dtype='float32')
shr = 5.* tf.random.normal([1],dtype='float32')
h_zoom = 1.0 + tf.random.normal([1],dtype='float32')/10.
w_zoom = 1.0 + tf.random.normal([1],dtype='float32')/10.
h_shift = DIM * 0.05 * tf.random.normal(... | Digit Recognizer |
12,607,235 | def img_to_np(img_str, ht, wt, lw, pad):
strokes = eval(img_str)
ht_ = ht - 2*pad
wt_ = wt - 2*pad
img = np.zeros(( ht, wt), np.uint8)
for s in strokes:
sx =(np.array(s[0])* wt_ / 256 ).round().astype('int')+ pad
sy =(np.array(s[1])* ht_ / 256 ).round().astype('int')+ pad
for i in range(len(sx)- 1):
p1 =(sx[i], sy[i]... | def randints(shape, minval, maxval):
return tf.random.uniform(
shape=shape, minval=minval, maxval=maxval+1, dtype=tf.int32 ) | Digit Recognizer |
12,607,235 | test_imgs = np.zeros(shape =(test.shape[0], 64, 64, 1))<feature_engineering> | def make_range_mask(size, start, end):
indice = tf.range(size, dtype=tf.int32)
start_mask =(start <= indice)
end_mask =(indice <= end)
range_mask = start_mask & end_mask
return range_mask
def make_region_mask(image_height, image_width, top, left, bottom, right):
row_mask = make_range_mask(image_height, top, bottom)
... | Digit Recognizer |
12,607,235 | %%time
for i, row in test.iterrows() :
test_imgs[i,:,:,0] = img_to_np(row.drawing, 64, 64, 1, 2)/ 255
<predict_on_test> | def do_cutout(orig_image, label):
mask_ratio = 0.5
image_shape = tf.shape(orig_image)
image_height = image_shape[0]
image_width = image_shape[1]
mask_h = tf.cast(tf.cast(image_height, tf.float32)* mask_ratio, tf.int32)
mask_w = tf.cast(tf.cast(image_width, tf.float32)* mask_ratio, tf.int32)
mask_value = 0.0
top = ra... | Digit Recognizer |
12,607,235 | %%time
probs = cnn.predict(test_imgs)
print(probs.shape )<concatenate> | unique_y = np.unique(y)
label_count = len(unique_y)
print(unique_y)
print(label_count ) | Digit Recognizer |
12,607,235 | N_train = probs.shape[0]
top_3_probs = np.zeros(shape=(N_train, 3))
for i in range(N_train):
p = probs[i, :]
top_classes = np.argpartition(p, -3)[-3:]
top_classes = top_classes[np.argsort(p[top_classes])]
top_classes = np.flip(top_classes)
top_probs = p[top_classes]
top_3_probs[i,:] = top_probs
print(top_3_probs[:10, ... | AUTO = tf.data.experimental.AUTOTUNE
def make_dataset(
X_np, y_np,
transform=False, cutout=False, repeat=False, shuffle=False):
def _cast_to_float(x, y):
return tf.cast(x, tf.float32), y
ds = tf.data.Dataset.from_tensor_slices(( X_np, y_np))
ds = ds.map(_cast_to_float, num_parallel_calls=AUTO)
if shuffle:
ds = ds.shu... | Digit Recognizer |
12,607,235 | N_train = probs.shape[0]
predictions = []
t = 0.35
for i in range(N_train):
p = probs[i, :]
top_classes = np.argpartition(p, -3)[-3:]
top_classes = top_classes[np.argsort(p[top_classes])]
top_classes = np.flip(top_classes)
top_probs = p[top_classes]
sel = top_probs > t
sel[0] = True
predictions.append(top_classes[sel]... | def make_train_ds(X_np, y_np):
ds = make_dataset(
X_np, y_np, transform=True, cutout=True, repeat=True, shuffle=True)
return ds
def make_val_ds(X_np, y_np):
ds = make_dataset(
X_np, y_np, transform=False, cutout=False, repeat=False, shuffle=False)
return ds
def make_test_ds(X_np):
y_np = np.zeros(X_np.shape[0], dty... | Digit Recognizer |
12,607,235 | submission = pd.read_csv('.. /input/quickdraw-doodle-recognition/sample_submission.csv')
submission.head()<load_from_csv> | NFOLD = 5
k_fold = StratifiedKFold(n_splits=NFOLD)
fold_index_list = []
for train_index, val_index in k_fold.split(X_resized, y):
fold_index_list.append(( train_index, val_index))
def get_fold(fold_i):
train_index, val_index = fold_index_list[fold_i]
X_train, y_train = X_resized[train_index], y[train_index]
X_val, y_v... | Digit Recognizer |
12,607,235 | label_lookup_df = pd.read_csv('.. /input/models-and-submissions/Quick Draw Models/label_lookup.csv')
label_lookup = {k:v for k,v in zip(label_lookup_df.index.values, label_lookup_df.label.values)}
label_lookup[0]<feature_engineering> | def calc_steps_per_epoch(fold_i):
train_index, val_index = fold_index_list[fold_i]
steps_per_epoch =(len(train_index)+ BATCH_SIZE - 1)// BATCH_SIZE
return steps_per_epoch | Digit Recognizer |
12,607,235 | %%time
for i in range(N_train):
classes = predictions[i]
words_list = [label_lookup[c] for c in classes]
words_string = ' '.join(words_list)
submission.loc[i, 'word'] = words_string
submission.head()<save_to_csv> | MODEL_INPUT_SHAPE =(*RESIZE_SIZE, 3)
def make_model(name):
with strategy.scope() :
inputs = L.Input(shape=RESIZE_SHAPE, name="input")
scaled = L.Lambda(lambda v: v / 255.0, name='scaling' )(inputs)
img_input = L.Concatenate(name='concat' )([scaled, scaled, scaled])
x = ResNet50(
include_top=False, weights='imagene... | Digit Recognizer |
12,607,235 | submission.to_csv('submission.csv', index=False )<save_to_csv> | LR_START = 0.00001
LR_MAX = 0.00005 * strategy.num_replicas_in_sync
LR_MIN = 0.00001
LR_RAMPUP_EPOCHS = min(5, EPOCHS // 5)
LR_SUSTAIN_EPOCHS = 0
def lrfn(epoch):
if epoch < LR_RAMPUP_EPOCHS:
lr =(LR_MAX - LR_START)/ LR_RAMPUP_EPOCHS * epoch + LR_START
elif epoch < LR_RAMPUP_EPOCHS + LR_SUSTAIN_EPOCHS:
lr = LR_MAX
els... | Digit Recognizer |
12,607,235 | submission.to_csv('submission.csv', index=False )<load_pretrained> | def make_best_model_file_path(fold_i):
file_name = "best_model_{0}_{1}.hdf5".format(MODEL_VERSION, fold_i)
return file_name | Digit Recognizer |
12,607,235 | pd.set_option('display.max_columns', 100)
pd.set_option('display.max_rows', 100)
DATA_PATH = '.. /input/jane-street-market-prediction/'
NFOLDS = 5
TRAIN = False
CACHE_PATH = '.. /input/mlp012003weights'
def save_pickle(dic, save_path):
with open(save_path, 'wb')as f:
pickle.dump(dic, f)
def load_pickle(load_path):
w... | def make_model_check_point(fold_i):
best_model_file_path = make_best_model_file_path(fold_i)
return ModelCheckpoint(
best_model_file_path, monitor='val_accuracy', mode='max',
verbose=0, save_best_only=True, save_weights_only=False, period=1 ) | Digit Recognizer |
12,607,235 | SEED = 1111
np.random.seed(SEED)
def create_mlp(
num_columns, num_labels, hidden_units, dropout_rates, label_smoothing, learning_rate
):
inp = tf.keras.layers.Input(shape=(num_columns,))
x = tf.keras.layers.BatchNormalization()(inp)
x = tf.keras.layers.Dropout(dropout_rates[0] )(x)
for i in range(len(hidden_units)... | initial_weights_file_path = "initial_weights.hdf5"
model.save_weights(initial_weights_file_path ) | Digit Recognizer |
12,607,235 | if True:
env = janestreet.make_env()
env_iter = env.iter_test()
for(test_df, pred_df)in tqdm(env_iter):
if test_df['weight'].item() > 0:
x_tt = test_df.loc[:, feat_cols].values
if np.isnan(x_tt.sum()):
x_tt = np.nan_to_num(x_tt)+ np.isnan(x_tt)* f_mean
cross_41_42_43 = x_tt[:, 41] + x_tt[:, 42] + x_tt[:, 43]
cross_1_2 ... | history_list = []
for fold_i in range(NFOLD):
print("
print("
train_ds, val_ds = get_fold(fold_i)
steps_per_epoch = calc_steps_per_epoch(fold_i)
lr_callback = make_lr_callback()
check_point = make_model_check_point(fold_i)
model.load_weights(initial_weights_file_path)
history = model.fit(
train_ds, epochs=EPOCHS, ... | Digit Recognizer |
12,607,235 | import pandas as pd
import gc
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import StratifiedKFold<load_from_csv> | test_df = read_df('test.csv')
test_df | Digit Recognizer |
12,607,235 | train = pd.read_csv('/kaggle/input/jane-street-market-prediction/train.csv')
train = reduce_mem_usage(train)
features = [c for c in train.columns if 'feature' in c]
train = train.astype({c: np.float32 for c in train.select_dtypes(include='float16' ).columns})
train = train.fillna(train.mean())
f_mean = np.mean(trai... | def make_val_pred_file_path(fold_i):
file_name = "val_pred_{0}_{1}".format(MODEL_VERSION, fold_i)
return file_name | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.