kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,029,170 | class Regressor(pl.LightningModule):
def __init__(self, input_size, output_size, params, model_path='models/'):
super(Regressor, self ).__init__()
dim_1 = params['dim_1']
dim_2 = params['dim_2']
dim_3 = params['dim_3']
dim_4 = params['dim_4']
self.dropout_prob = params['dropout']
self.lr = params['lr']
self.activation ... | mnist_train.isna().any().any() | Digit Recognizer |
10,029,170 | def final_train(p, load=False):
data_ = load_data(root_dir='./data/', mode='train',overide='/kaggle/input/jane-street-market-prediction/train.csv')
data, target, features, date = preprocess_data(data_, nn=True)
dataset = FinData(data=data, target=target, date=date)
input_size = data.shape[-1]
output_size = 1
train_i... | mnist_train_data = mnist_train.loc[:, "pixel0":]
mnist_train_label = mnist_train.loc[:, "label"]
mnist_train_data = mnist_train_data/255.0
mnist_test = mnist_test/255.0 | Digit Recognizer |
10,029,170 | def fillna_npwhere(array, values):
if np.isnan(array.sum()):
array = np.nan_to_num(array)+ np.isnan(array)* values
return array
def test_model(models, features, cache_dir='cache'):
env = janestreet.make_env()
iter_test = env.iter_test()
if type(models)== list:
models = [model.eval() for model in models]
else:
models.ev... | standardized_scalar = StandardScaler()
standardized_data = standardized_scalar.fit_transform(mnist_train_data)
standardized_data.shape | Digit Recognizer |
10,029,170 | def main(train=True):
p = {'dim_1': 167,
'dim_2': 454,
'dim_3': 371,
'dim_4': 369,
'dim_5': 155,
'activation': nn.LeakyReLU,
'dropout': 0.21062362698532755,
'lr': 0.0022252024054478523,
'label_smoothing': 0.05564974140461841,
'weight_decay': 0.04106097088288333,
'amsgrad': True,
'batch_size': 10072}
if train:
models,... | cov_matrix = np.matmul(standardized_data.T, standardized_data)
cov_matrix.shape | Digit Recognizer |
10,029,170 | pca_components = 60<choose_model_class> | lambdas, vectors = eigh(cov_matrix, eigvals=(782, 783))
vectors.shape | Digit Recognizer |
10,029,170 | e_size = 64
fc_input = pca_components
h_dims = [512,512,256,128]
dropout_rate = 0.5
epochs = 200
minibatch_size = 100000
class MarketPredictor(nn.Module):
def __init__(self):
super(MarketPredictor, self ).__init__()
self.e = nn.Embedding(2,e_size)
self.deep = nn.Sequential(
nn.Linear(fc_input,h_dims[0]),
nn.BatchNorm... | new_coordinates = np.matmul(vectors, standardized_data.T)
print(new_coordinates.shape)
new_coordinates = np.vstack(( new_coordinates, mnist_train_label)).T | Digit Recognizer |
10,029,170 | epochs = 200
path = '/kaggle/input/pytorch-nn-model-more-feature-engineering/marketpredictor_state_dict_'+str(epochs)+'epochs.pt'
model = MarketPredictor()
model.load_state_dict(torch.load(path,map_location=dev))
model.to(dev)
model.eval()<load_pretrained> | df_new = pd.DataFrame(new_coordinates, columns=["f1", "f2", "labels"])
df_new.head() | Digit Recognizer |
10,029,170 | with open('/kaggle/input/pytorch-nn-model-more-feature-engineering/feature_processing.pkl', 'rb')as f:
sc, pca, maxindex, fill_val, remove_names= pickle.load(f )<define_variables> | pca = decomposition.PCA()
pca.n_components = 2
pca_data = pca.fit_transform(standardized_data)
pca_data.shape | Digit Recognizer |
10,029,170 | feature_names = ['feature_'+str(i)for i in range(1,130)]
exclude = np.where([maxindex[i,1] > 100 and maxindex [i,2] > 1 for i in range(129)])[0]
keep = np.where([(feature_names[i] != remove_names ).all() for i in range(129)])[0]<split> | pca_data = np.vstack(( pca_data.T, mnist_train_label)).T | Digit Recognizer |
10,029,170 | env = janestreet.make_env()
iter_test = env.iter_test()<data_type_conversions> | df_PCA = pd.DataFrame(new_coordinates, columns=["f1", "f2", "labels"])
df_PCA.head() | Digit Recognizer |
10,029,170 | for(test_df, sample_prediction_df)in iter_test:
if test_df['weight'].item() == 0:
sample_prediction_df.action = 0
else:
test_df_features = test_df[feature_names].to_numpy()
for i in exclude:
if test_df_features[0,i] == maxindex[i,0]:
test_df_features[0,i] = fill_val[i]
test_df_int_features = test_df['feature_0'].to_num... | mnist_train_data = np.array(mnist_train_data)
mnist_train_label = np.array(mnist_train_label ) | Digit Recognizer |
10,029,170 | e_size = 64
fc_input = 130
h_dims = [512,512,256,128]
dropout_rate = 0.5
epochs = 2000
minibatch_size = 100000
class MarketPredictor(nn.Module):
def __init__(self):
super(MarketPredictor, self ).__init__()
self.deep = nn.Sequential(
nn.Linear(fc_input,h_dims[0]),
nn.BatchNorm1d(h_dims[0]),
nn.LeakyReLU() ,
nn.Dropout(... | from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Lambda, Flatten, BatchNormalization
from tensorflow.keras.layers import Conv2D, MaxPool2D, AvgPool2D
from tensorflow.keras.optimizers import Adadelta
from keras.utils.np_utils import to_categorical
from tensorflow.keras.p... | Digit Recognizer |
10,029,170 | path = '/kaggle/input/pytorch-nn-model-w-o-feature-reduction/marketpredictor_state_dict_'+str(epochs)+'epochs.pt'
model = MarketPredictor()
model.load_state_dict(torch.load(path,map_location=dev))
model.to(dev)
model.eval()<load_pretrained> | nclasses = mnist_train_label.max() - mnist_train_label.min() + 1
mnist_train_label = to_categorical(mnist_train_label, num_classes = nclasses)
print("Shape of ytrain after encoding: ", mnist_train_label.shape ) | Digit Recognizer |
10,029,170 | with open('/kaggle/input/pytorch-nn-model-w-o-feature-reduction/feature_processing.pkl', 'rb')as f:
sc, maxindex, fill_val = pickle.load(f )<define_variables> | def build_model(input_shape=(28, 28, 1)) :
model = Sequential()
model.add(Conv2D(32, kernel_size = 3, activation='relu', input_shape = input_shape))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size = 3, activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size = 5, strides=2... | Digit Recognizer |
10,029,170 | feature_names = ['feature_'+str(i)for i in range(130)]
exclude = np.where([maxindex[i,1] > 100 and maxindex [i,2] > 1 for i in range(129)])[0]<split> | cnn_model = build_model(( 28, 28, 1))
compile_model(cnn_model, 'adam', 'categorical_crossentropy')
model_history = train_model(cnn_model, mnist_train_data, mnist_train_label, 80, 0.2 ) | Digit Recognizer |
10,029,170 | env = janestreet.make_env()
iter_test = env.iter_test()<data_type_conversions> | predictions = cnn_model.predict(mnist_test_arr ) | Digit Recognizer |
10,029,170 | for(test_df, sample_prediction_df)in iter_test:
if test_df['weight'].item() == 0:
sample_prediction_df.action = 0
else:
test_df_features = test_df[feature_names].to_numpy()
for i in exclude:
if test_df_features[0,i+1] == maxindex[i,0]:
test_df_features[0,i+1] = fill_val[i]
nans = np.isnan(test_df_features)
for i in ra... | predictions_test = []
for i in predictions:
predictions_test.append(np.argmax(i)) | Digit Recognizer |
10,029,170 | from tensorflow.keras.layers import Input, Dense, BatchNormalization, Dropout, Concatenate, Lambda, GaussianNoise, Activation
from tensorflow.keras.models import Model, Sequential
from tensorflow.keras.losses import BinaryCrossentropy
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import E... | submission = pd.DataFrame({
"ImageId": mnist_test.index+1,
"Label": predictions_test
})
submission.to_csv('my_submission.csv', index=False ) | Digit Recognizer |
8,460,609 | 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)) :
x = tf.keras.layers.Dense(hidd... | train_df = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test_df = pd.read_csv("/kaggle/input/digit-recognizer/test.csv")
submission_df = pd.read_csv("/kaggle/input/digit-recognizer/sample_submission.csv" ) | Digit Recognizer |
8,460,609 | data = dd.read_parquet('.. /input/janestreetparquetdata/date*.parquet')
features = ['feature_{}'.format(i)for i in range(130)]
resp_cols = ['resp_1', 'resp_2', 'resp_3', 'resp', 'resp_4']
train = data.compute()
train = train.query('date > 85' ).reset_index(drop = True)
train = train[train['weight'] != 0]
f_mean = tra... | X_train = train_df.iloc[:, 1:].values
y_train = train_df.iloc[:, 0].values
X_test = test_df.values
print(f"X_train shape: {X_train.shape}")
print(f"y_train shape: {y_train.shape}")
print(f"X_test shape: {X_test.shape}" ) | Digit Recognizer |
8,460,609 | SEED = 1111
tf.random.set_seed(SEED)
np.random.seed(SEED)
hidden_units = [150, 150, 150]
dropout_rates = [0.2, 0.2, 0.2, 0.2]
label_smoothing = 1e-2
learning_rate = 1e-3
epochs = 250
batch_size = 5000
save_every_n_epochs = 10
save_freq =(len(X_train)//batch_size)*save_every_n_epochs
clf = create_mlp(
len(features), ... | X_train_combined = np.r_[X_train, X_train_add]
y_train_combined = np.r_[y_train, y_train_add]
del X_train
del X_train_add
del y_train
del y_train_add
print(f"X_train_combined shape: {X_train_combined.shape}")
print(f"y_train_combined shape: {y_train_combined.shape}" ) | Digit Recognizer |
8,460,609 | class TrainData(Dataset):
def __init__(self,file_name,root_dir,predict=False):
self.file_name = file_name
self.root_dir = root_dir
self.feature = ['feature_{}'.format(i)for i in range(130)]
self.resp = ['resp_{}'.format(i)for i in range(1,5)]+['resp']
self.prediction = predict
def __len__(self):
return len(glob(os.path... | class ImageReshaper(BaseEstimator, TransformerMixin):
def __init__(self, shape):
self.shape = shape
def fit(self, X, y=None):
return self
def transform(self, X, y=None):
return X.reshape(self.shape ) | Digit Recognizer |
8,460,609 | dataset = TrainData('date','.. /input/janestreetparquetdata/',predict = True)
weight_path = glob('./*.ckpt.index')
weight_path = [os.path.basename(each ).split('.')[0] for each in weight_path]
weight_path.sort()
for path in weight_path:
clf.load_weights('./{}.ckpt'.format(path))
p = []
for i in range(len(dataset)) :
... | def build_lenet5_model() :
model = Sequential()
model.add(Conv2D(6, kernel_size=5, activation='relu',
input_shape=(28,28,1)))
model.add(MaxPooling2D())
model.add(Conv2D(16, kernel_size=5, activation='relu'))
model.add(MaxPooling2D())
model.add(Flatten())
model.add(Dense(400, activation='relu'))
model.add(Dense(12... | Digit Recognizer |
8,460,609 | selection = 'cp-0200'
clf.load_weights('./{}.ckpt'.format(selection))<predict_on_test> | def build_custom_lenet5_model() :
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',activat... | Digit Recognizer |
8,460,609 | env = janestreet.make_env()
th = 0.5
for(test_df, pred_df)in tqdm(env.iter_test()):
if test_df['weight'].item() > 0:
x_tt = test_df.loc[:, features].values
x_tt = np.nan_to_num(x_tt)+f_mean*(np.isnan(x_tt ).astype(int))
pred = np.median(clf(x_tt, training=False))
pred_df.action = np.where(pred >= th, 1, 0 ).astype(int)... | stratified_fold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
for fold, indices in enumerate(stratified_fold.split(X_train_combined, y_train_combined)) :
X_train_, y_train_ = X_train_combined[indices[0]], y_train_combined[indices[0]]
X_test_, y_test_ = X_train_combined[indices[1]], y_train_combined[indi... | Digit Recognizer |
8,460,609 | SEED = 1111
inference = False
cv = False
tf.random.set_seed(SEED)
np.random.seed(SEED)
train_pickle_file = '/kaggle/input/pickling/train.csv.pandas.pickle'
train = pickle.load(open(train_pickle_file, 'rb'))
train = train.query('date > 85' ).reset_index(drop = True)
train = train[train['weight'] != 0]
train.fillna(tr... | lenet5_model = Pipeline([
('min_max_scaler', MinMaxScaler()),
('image_reshaper', ImageReshaper(shape=(-1, 28, 28, 1))),
('model', KerasClassifier(build_lenet5_model, epochs=5, batch_size=32))
])
custom_lenet5_model = Pipeline([
('min_max_scaler', MinMaxScaler()),
('image_reshaper', ImageReshaper(shape=(-1, 28, 28... | Digit Recognizer |
8,460,609 | def build_neutralizer(train, features, proportion, return_neut=False):
neutralizer = {}
neutralized_features = np.zeros(( train.shape[0], len(features)))
target = train[['resp', 'bias']].values
for i, f in enumerate(features):
feature = train[f].values.reshape(-1, 1)
coeffs = np.linalg.lstsq(target, feature)[0]
neu... | predictions = lenet5_model_predictions + custom_lenet5_model_predictions
predictions = np.argmax(predictions, axis=1 ) | Digit Recognizer |
8,460,609 | <prepare_x_and_y><EOS> | submission_df["Label"] = predictions
submission_df.to_csv('submissions.csv', index=False)
FileLink('submissions.csv' ) | Digit Recognizer |
1,425,655 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | %matplotlib inline | Digit Recognizer |
1,425,655 | 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)) :
x = tf.keras.layers.Dense(hidd... | IMG_ROWS = 28
IMG_COLS = 28
NUM_CLASSES = 10
TEST_SIZE = 0.1
RANDOM_STATE = 2018
NO_EPOCHS = 150
PATIENCE = 20
VERBOSE = 1
BATCH_SIZE = 128
IS_LOCAL = False
if(IS_LOCAL):
PATH=".. /input/digit-recognizer/"
else:
PATH=".. /input/"
print(os.listdir(PATH)) | Digit Recognizer |
1,425,655 | if cv:
oof_probas = np.zeros(y.shape)
val_idx_all = []
N_SPLITS = 5
gkf = GroupKFold(n_splits=N_SPLITS)
for fold,(train_idx, val_idx)in enumerate(gkf.split(train.action.values, groups=train.date.values)) :
X_train, X_val = X.iloc[train_idx], X.iloc[val_idx].values
y_train, y_val = y[train_idx], y[val_idx]
clf.fit(X_t... | train_file = PATH+"train.csv"
test_file = PATH+"test.csv"
train_df = pd.read_csv(train_file)
test_df = pd.read_csv(test_file ) | Digit Recognizer |
1,425,655 | if cv:
auc_oof = roc_auc_score(y[val_idx], oof_probas[val_idx])
print(auc_oof )<compute_test_metric> | print("MNIST train - rows:",train_df.shape[0]," columns:", train_df.shape[1])
print("MNIST test - rows:",test_df.shape[0]," columns:", test_df.shape[1] ) | Digit Recognizer |
1,425,655 | def determine_action(df, thresh):
action =(df.weight * df.resp > thresh ).astype(int)
return action
def date_weighted_resp(df):
cols = ['weight', 'resp', 'action']
weighted_resp = np.prod(df[cols], axis=1)
return weighted_resp.sum()
def calculate_t(dates_p):
e_1 = dates_p.sum() / np.sqrt(( dates_p**2 ).sum())
... | def get_classes_distribution(data):
label_counts = data["label"].value_counts()
total_samples = len(data)
for i in range(len(label_counts)) :
label = label_counts.index[i]
count = label_counts.values[i]
percent =(count / total_samples)* 100
print("{}: {} or {}%".format(label, count, percent))
get_classes_distribution(... | Digit Recognizer |
1,425,655 | env = janestreet.make_env()
for(test_df, pred_df)in tqdm(env.iter_test()):
if test_df['weight'].item() > 0:
x_tt = test_df.loc[:, features].values
if np.isnan(x_tt[:, 1:].sum()):
x_tt[:, 1:] = np.nan_to_num(x_tt[:, 1:])+ np.isnan(x_tt[:, 1:])* f_mean
x_tt = np.append(x_tt, [[1]], axis=1)
x_tt = neutralize_array(x_tt, ... | def sample_images_data(data, hasLabel=True):
sample_images = []
sample_labels = []
if(hasLabel):
for k in range(0,10):
samples = data[data["label"] == k].head(4)
for j, s in enumerate(samples.values):
img = np.array(samples.iloc[j, 1:] ).reshape(IMG_ROWS,IMG_COLS)
sample_images.append(img)
sample_labels.append(sampl... | Digit Recognizer |
1,425,655 | def install(package):
subprocess.check_call([sys.executable, "-m", "pip","install",package])
install(".. /input/fastremap/fastremap-1.10.2-cp37-cp37m-manylinux1_x86_64.whl")
install(".. /input/fillvoids/fill_voids-2.0.0-cp37-cp37m-manylinux1_x86_64.whl")
install(".. /input/finalmask")
install("pydicom" )<set_option... | def data_preprocessing(raw, hasLabel=True):
start_pixel = 0
if(hasLabel):
start_pixel = 1
if(hasLabel):
out_y = keras.utils.to_categorical(raw.label, NUM_CLASSES)
else:
out_y = None
num_images = raw.shape[0]
x_as_array = raw.values[:,start_pixel:]
x_shaped_array = x_as_array.reshape(num_images, IMG_ROWS, IMG_COLS, 1)
... | Digit Recognizer |
1,425,655 | sns.set(style="whitegrid")
sns.set_context("paper")
<define_variables> | X, y = data_preprocessing(train_df)
X_test, y_test = data_preprocessing(test_df,hasLabel=False ) | Digit Recognizer |
1,425,655 | def seed_everything(seed=2020):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
seed_everything(42 )<load_from_csv> | X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=TEST_SIZE, random_state=RANDOM_STATE ) | Digit Recognizer |
1,425,655 | ROOT = ".. /input/osic-pulmonary-fibrosis-progression"
train=pd.read_csv(f"{ROOT}/train.csv")
train.head()<load_from_csv> | print("MNIST train - rows:",X_train.shape[0]," columns:", X_train.shape[1:4])
print("MNIST valid - rows:",X_val.shape[0]," columns:", X_val.shape[1:4])
print("MNIST test - rows:",X_test.shape[0]," columns:", X_test.shape[1:4] ) | Digit Recognizer |
1,425,655 | sample_submission=pd.read_csv(f"{ROOT}/sample_submission.csv")
test=pd.read_csv(f"{ROOT}/test.csv")
test.head()<merge> | model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),activation='relu', padding="same",
kernel_initializer='he_normal',input_shape=(IMG_ROWS, IMG_COLS, 1)))
model.add(BatchNormalization())
model.add(Conv2D(32,kernel_size=(3, 3), activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(32,kernel_s... | Digit Recognizer |
1,425,655 | train['Patient_Week']=train['Patient']+'_'+train['Weeks'].astype(str)
lists=train['Patient_Week'][train.duplicated(['Patient_Week'], keep=False)].unique().tolist()
for patient_week in lists:
new_row=train.loc[train['Patient_Week']==patient_week].groupby(['Patient','Weeks','Age','Sex','SmokingStatus','Patient_Week'] ).... | model.compile(loss = "categorical_crossentropy", optimizer="adam", metrics=["accuracy"] ) | Digit Recognizer |
1,425,655 | test.rename(columns={'Weeks': 'base_Week', 'FVC': 'base_FVC', 'Percent': 'base_Percent', 'Age': 'base_Age'},inplace=True)
Week=sample_submission['Patient_Week'].apply(lambda x : x.split('_')[1] ).unique()
Week=np.tile(Week, len(test['Patient']))
test=test.loc[test.index.repeat(146)].reset_index(drop=True)
test['predi... | plot_model(model, to_file='model.png')
SVG(model_to_dot(model ).create(prog='dot', format='svg')) | Digit Recognizer |
1,425,655 | file_path= '.. /input/osic-pulmonary-fibrosis-progression/train/ID00007637202177411956430/10.dcm'
dataset = pydicom.dcmread(file_path)
<compute_test_metric> | NO_EPOCHS = 10 | Digit Recognizer |
1,425,655 | def score(y_true, y_pred):
tf.dtypes.cast(y_true, tf.float32)
tf.dtypes.cast(y_pred, tf.float32)
sigma = abs(y_pred[:,2] - y_pred[:,0])
fvc_pred = y_pred[:,1]
sigma_clip = tf.maximum(sigma, 70)
delta = tf.abs(y_true[:, 0] - fvc_pred)
delta = tf.minimum(delta, 1000)
sq2 = tf.sqrt(tf.dtypes.cast(2, dtype=tf.float32... | earlystopper = EarlyStopping(monitor='loss', patience=PATIENCE, verbose=VERBOSE)
checkpointer = ModelCheckpoint('best_model.h5',
monitor='val_acc',
verbose=VERBOSE,
save_best_only=True,
save_weights_only=True)
history = model.fit(X_train, y_train,
batch_size=BATCH_SIZE,
epochs=NO_EPOCHS,
verbose=1,
validation_data=(X... | Digit Recognizer |
1,425,655 | input_image = sitk.ReadImage('.. /input/osic-pulmonary-fibrosis-progression/train/ID00007637202177411956430/12.dcm')
segmentation = mask.apply(input_image)
plt.figure(figsize=(10,10))
plt.imshow(segmentation[0] )<load_from_csv> | print("run model - predict validation set")
score = model.evaluate(X_val, y_val, verbose=0)
print(f'Last validation loss: {score[0]}, accuracy: {score[1]}')
model_optimal = model
model_optimal.load_weights('best_model.h5')
score = model_optimal.evaluate(X_val, y_val, verbose=0)
print(f'Best validation loss: {score... | Digit Recognizer |
1,425,655 | atten=pd.read_csv('.. /input/attent-1/atten(1 ).csv')
patients=os.listdir(f"{ROOT}/{how}")
avg_atten_test=[]
for patient in patients:
try:
mid=mid_image_test(patient,True,True)
postives=mid>mid.min()
mid[postives].mean()
avg_atten_test.append(mid[postives].mean())
except:
avg_atten_test.append(np.nan)
continue<pre... | def predict_show_classes(model, X_val, y_val):
predicted_classes = model.predict_classes(X_val)
y_true = np.argmax(y_val,axis=1)
correct = np.nonzero(predicted_classes==y_true)[0]
incorrect = np.nonzero(predicted_classes!=y_true)[0]
print("Correct predicted classes:",correct.shape[0])
print("Incorrect predicted clas... | Digit Recognizer |
1,425,655 | final1=final.copy()
final1=final1.merge(atten,on='Patient')
X1=final1[['base_fvc','base_percent','Age','sex','smokingstatus','weeks_passed','avg_atten','base_week']].copy()
y1=final1.FVC.copy()<categorify> | correct, incorrect = predict_show_classes(model, X_val, y_val ) | Digit Recognizer |
1,425,655 | enc = OneHotEncoder(handle_unknown='ignore')
enc.fit(X1[['sex','smokingstatus']])
encoded=pd.DataFrame(enc.transform(X1[['sex','smokingstatus']] ).toarray())
X1=X1.join(encoded)
X1.drop(['smokingstatus','sex'],axis=1,inplace=True)
scaler=preprocessing.MinMaxScaler().fit(X1)
X1=pd.DataFrame(scaler.transform(X1))
X... | correct, incorrect = predict_show_classes(model_optimal, X_val, y_val ) | Digit Recognizer |
1,425,655 | atten_test=pd.DataFrame({'Patient':patients,'avg_atten':avg_atten_test})
atten_test['avg_atten']=atten_test['avg_atten'].fillna(atten["avg_atten"].mean())
X_test=test.merge(atten_test,on='Patient')
X_test=X_test[['base_fvc','base_percent','Age','sex','smokingstatus','weeks_passed','avg_atten','base_week']].copy()
en... | y_cat = model.predict(X_test, batch_size=64 ) | Digit Recognizer |
1,425,655 | inputs= keras.Input(shape=[11])
dense = layers.Dense(100, activation="relu")
x = dense(inputs)
x = layers.Dense(100, activation="relu" )(x)
output1 = layers.Dense(3,activation='linear' )(x)
model = keras.Model(inputs=inputs, outputs=output1)
model.summary()<train_model> | y_pred = np.argmax(y_cat,axis=1 ) | Digit Recognizer |
1,425,655 | model.compile(loss=mloss(0.8),optimizer='adam',metrics=score)
model.fit(X1, y1,batch_size=512,epochs=130 )<predict_on_test> | output_file = "submission.csv"
with open(output_file, 'w')as f :
f.write('ImageId,Label
')
for i in range(len(y_pred)) :
f.write("".join([str(i+1),',',str(y_pred[i]),'
'])) | Digit Recognizer |
1,425,655 | preds_high=model.predict(X_test)[:,0]
preds_low=model.predict(X_test)[:,2]
preds=model.predict(X_test)[:,1]<prepare_output> | y_cat = model_optimal.predict(X_test, batch_size=64)
y_pred = np.argmax(y_cat,axis=1)
output_file = "submission_optimal.csv"
with open(output_file, 'w')as f :
f.write('ImageId,Label
')
for i in range(len(y_pred)) :
f.write("".join([str(i+1),',',str(y_pred[i]),'
'])) | Digit Recognizer |
2,712,650 | preds_set=pd.DataFrame({'preds_high':preds_high})
preds_set['preds']=preds
preds_set['preds_low']=preds_low
preds_set['sigma_pred']=abs(preds_set['preds_high']-preds_set['preds_low'])
preds_set.reset_index(inplace=True,drop=True)
preds_set<save_to_csv> | print(K.image_data_format() ) | Digit Recognizer |
2,712,650 | submission=pd.DataFrame({'Patient_Week':test['Patient_Week'],'FVC': preds_set['preds'],'Confidence':preds_set['sigma_pred']})
submission['FVC']=submission['FVC'].apply(lambda x: round(x, 4)) /1
submission['Confidence']=submission['Confidence'].apply(lambda x: round(x, 4))
submission.to_csv('submission.csv',index=False... | ( x_train, y_train),(x_test, y_test)= mnist.load_data() | Digit Recognizer |
2,712,650 | train_arc = zipfile.ZipFile('/kaggle/input/whats-cooking/train.json.zip','r')
train_data = pd.read_json(train_arc.read('train.json'))
train_data.head()<load_pretrained> | y_train = to_categorical(y_train, num_classes = 10)
y_test = to_categorical(y_test, num_classes=10 ) | Digit Recognizer |
2,712,650 | test_arc = zipfile.ZipFile('/kaggle/input/whats-cooking/test.json.zip','r')
test_data = pd.read_json(test_arc.read('test.json'))
test_data.head()<count_values> | x_train.astype('float32')
x_test.astype('float32' ) | Digit Recognizer |
2,712,650 | train_data['cuisine'].value_counts()<feature_engineering> | x_train = x_train/255
x_test = x_test/255 | Digit Recognizer |
2,712,650 | train_ingredients_count = {}
for i in range(len(train_data)) :
for j in train_data['ingredients'][i]:
if j in train_ingredients_count.keys() :
train_ingredients_count[j]+=1
else:
train_ingredients_count[j] = 1<count_values> | input_shape =(28,28,1)
model = Sequential()
model.add(Conv2D(96,(3, 3),
padding='Same',
activation='relu',
input_shape=input_shape))
model.add(BatchNormalization())
model.add(Conv2D(96,(3, 3),
padding='Same',
activation='relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Con... | Digit Recognizer |
2,712,650 | train_ingredients_count['romaine lettuce']<feature_engineering> | call_back = keras.callbacks.EarlyStopping(monitor='val_acc', min_delta=0, patience=5, verbose=0, restore_best_weights=True)
reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='val_acc',
factor=0.25,
verbose=1,
patience=2,
min_lr=0.000001 ) | Digit Recognizer |
2,712,650 | test_ingredients_count = {}
for i in range(len(test_data)) :
for j in test_data['ingredients'][i]:
if j in test_ingredients_count.keys() :
test_ingredients_count[j]+=1
else:
test_ingredients_count[j] = 1<define_variables> | model.compile(loss='categorical_crossentropy',
optimizer=keras.optimizers.Adam(lr=0.001),
metrics=['accuracy'])
train_datagen = ImageDataGenerator(shear_range=0.2,
zoom_range=0.2,
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=F... | Digit Recognizer |
2,712,650 | train_ingred_miss = []
for i in test_ingredients_count.keys() :
if i not in train_ingredients_count.keys() :
train_ingred_miss.append(i )<feature_engineering> | xtest = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
2,712,650 | <define_variables><EOS> | submission = model.predict(xtest)
submission = np.argmax(submission, axis = 1)
submission = pd.Series(submission,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),submission],axis = 1)
submission.to_csv("submission.csv",index=False ) | Digit Recognizer |
2,188,530 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<feature_engineering> | tf.set_random_seed(42 ) | Digit Recognizer |
2,188,530 | for i in test_ingred_miss:
test_ingredients_count[i] = 0
len(test_ingredients_count )<feature_engineering> | train_path = os.path.join('.. ', 'input', 'train.csv')
test_path = os.path.join('.. ', 'input', 'test.csv')
size = 28
lr = 0.001
num_classes = 10
epochs = 30
batch_size = 128 | Digit Recognizer |
2,188,530 | for i in train_ingredients_count.keys() :
train_data[i] = np.zeros(len(train_data))<feature_engineering> | raw_train_df = pd.read_csv(train_path)
raw_test_df = pd.read_csv(test_path ) | Digit Recognizer |
2,188,530 | for i in test_ingredients_count.keys() :
test_data[i] = np.zeros(len(test_data))<feature_engineering> | def parse_train_df(_train_df):
labels = _train_df.iloc[:,0].values
imgs = _train_df.iloc[:,1:].values
imgs_2d = np.array([[[[float(imgs[index][i*28 + j])/ 255] for j in range(28)] for i in range(28)] for index in range(len(imgs)) ])
processed_labels = [[0 for _ in range(10)] for i in range(len(labels)) ]
for i in rang... | Digit Recognizer |
2,188,530 | for i in range(len(train_data)) :
for j in train_data['ingredients'][i]:
train_data[j].iloc[i] = 1<feature_engineering> | y_train_set, x_train_set = parse_train_df(raw_train_df)
x_test = parse_test_df(raw_test_df)
x_train, x_val, y_train, y_val = train_test_split(x_train_set, y_train_set, test_size=0.20, random_state=42 ) | Digit Recognizer |
2,188,530 | for i in range(len(test_data)) :
for j in test_data['ingredients'][i]:
test_data[j].iloc[i] = 1<drop_column> | print("Number of 1: {}".format(len(raw_train_df[raw_train_df['label'] == 1])))
print("Number of 5: {}".format(len(raw_train_df[raw_train_df['label'] == 5])) ) | Digit Recognizer |
2,188,530 | test_data=test_data[train_data.drop('cuisine',axis=1 ).columns]<import_modules> | model = keras.Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), strides=(1, 1),
activation='relu',
input_shape=(size, size, 1)))
model.add(Conv2D(32,(3, 3), activation='relu', strides=(2, 2)))
model.add(BatchNormalization())
model.add(Dropout(0.3))
model.add(Conv2D(64,(3, 3), activation='relu'))
model.add(Conv2D... | Digit Recognizer |
2,188,530 | from sklearn.linear_model import LogisticRegression
from sklearn import preprocessing<prepare_x_and_y> | training_history = model.fit(
x_train,
y_train,
epochs=epochs,
verbose=1,
validation_data=(x_val, y_val),
callbacks=callback_list
) | Digit Recognizer |
2,188,530 | X = train_data.drop(['id','cuisine','ingredients'],axis =1)
Y = train_data['cuisine']<split> | image_generator = ImageDataGenerator(
rotation_range=15,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1
)
image_generator.fit(x_train ) | Digit Recognizer |
2,188,530 | X_train,X_val,y_train,y_val = train_test_split(X,Y,random_state =42 )<train_model> | model_augmented = keras.Sequential()
model_augmented.add(Conv2D(32, kernel_size=(3, 3), strides=(1, 1),
activation='relu',
input_shape=(size, size, 1)))
model_augmented.add(Conv2D(32,(3, 3), activation='relu', strides=(2, 2)))
model_augmented.add(BatchNormalization())
model_augmented.add(Dropout(0.3))
model_augmente... | Digit Recognizer |
2,188,530 | lr = LogisticRegression(solver='liblinear')
lr.fit(X_train,y_train )<compute_test_metric> | pred = model.predict(x_test)
pred_aug = model_augmented.predict(x_test ) | Digit Recognizer |
2,188,530 | <predict_on_test><EOS> | def convert_prediction_result(model_result):
result = []
for i in range(len(model_result)) :
result += [np.argmax(model_result[i])]
return result
def write_submission(_submission_path, result_arr):
f_out = open(_submission_path, 'w')
f_out.write("ImageId,Label
")
for i in range(len(result_arr)) :
f_out.write("{},{}
"... | Digit Recognizer |
5,811,807 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<prepare_output> | np.random.seed(92)
| Digit Recognizer |
5,811,807 | Submission=test_data[['id','cuisine']]
Submission.set_index('id',inplace=True )<save_to_csv> | train_data = '/kaggle/input/digit-recognizer/train.csv'
test_data = '/kaggle/input/digit-recognizer/test.csv'
| Digit Recognizer |
5,811,807 | Submission.to_csv('Submission.csv' )<load_pretrained> | train_df = pd.read_csv(train_data)
print(train_df.shape)
train_df.head()
| Digit Recognizer |
5,811,807 | archive_train=zipfile.ZipFile('/kaggle/input/whats-cooking/train.json.zip','r')
train_data=pd.read_json(archive_train.read('train.json'))
train_data.head()<load_pretrained> | test_df = pd.read_csv(test_data)
print(test_df.shape)
test_df.head() | Digit Recognizer |
5,811,807 | archive_test=zipfile.ZipFile('/kaggle/input/whats-cooking/test.json.zip','r')
test_data=pd.read_json(archive_test.read('test.json'))
test_data.head()<count_values> | if 'label' in train_df.columns:
y_train = train_df['label'].values.astype('int32')
train_df = train_df.drop('label', axis = 1)
else:
pass
x_train = train_df.values.astype('float32')
x_test = test_df.values.astype('float32' ) | Digit Recognizer |
5,811,807 | train_data['cuisine'].value_counts()<count_missing_values> | train_max = np.max(x_train)
train_min = np.min(x_train)
test_max = np.max(x_test)
test_min = np.min(x_test)
| Digit Recognizer |
5,811,807 | train_data.isna().sum()<count_missing_values> | x_train = x_train/255.0
x_test = x_test/255.0 | Digit Recognizer |
5,811,807 | test_data.isna().sum()<define_variables> | norm_train_max = np.max(x_train)
norm_train_min = np.min(x_train)
norm_test_max = np.max(x_test)
norm_test_min = np.min(x_test ) | Digit Recognizer |
5,811,807 | train_ingredients_count={}
for i in range(len(train_data)) :
for j in train_data['ingredients'][i]:
if j in train_ingredients_count.keys() :
train_ingredients_count[j]+=1
else:
train_ingredients_count[j]=1<define_variables> | y_train= to_categorical(y_train)
num_classes = y_train.shape[1]
num_classes
| Digit Recognizer |
5,811,807 | test_ingredients_count={}
for i in range(len(test_data)) :
for j in test_data['ingredients'][i]:
if j in test_ingredients_count.keys() :
test_ingredients_count[j]+=1
else:
test_ingredients_count[j]=1<define_variables> | model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(16,(5,5),activation='relu', input_shape=(28,28,1)) ,
tf.keras.layers.Conv2D(16,(5,5), activation= 'relu'),
tf.keras.layers.Conv2D(16,(5,5), activation= 'relu'),
tf.keras.layers.BatchNormalization() ,
tf.keras.layers.Dropout(0.25),
tf.keras.layers.Conv2D(32,(3,... | Digit Recognizer |
5,811,807 | ingredients_missing_train=[]
for i in test_ingredients_count.keys() :
if i not in train_ingredients_count.keys() :
ingredients_missing_train.append(i)
print(len(ingredients_missing_train))<define_variables> | Digit Recognizer | |
5,811,807 | for i in ingredients_missing_train:
train_ingredients_count[i]=0
print(len(train_ingredients_count))<define_variables> | Digit Recognizer | |
5,811,807 | ingredients_missing=[]
for i in train_ingredients_count.keys() :
if i not in test_ingredients_count.keys() :
ingredients_missing.append(i)
print(len(ingredients_missing))<define_variables> | Digit Recognizer | |
5,811,807 | for i in ingredients_missing:
test_ingredients_count[i]=0
print(len(test_ingredients_count))<feature_engineering> | model.compile(loss = 'categorical_crossentropy', optimizer= RMSprop(lr=0.003), metrics = ['acc'] ) | Digit Recognizer |
5,811,807 | for i in train_ingredients_count.keys() :
train_data[i]=np.zeros(len(train_data))
for i in test_ingredients_count.keys() :
test_data[i]=np.zeros(len(test_data))<filter> | train_generator = image.ImageDataGenerator() | Digit Recognizer |
5,811,807 | for i in range(len(train_data)) :
for j in train_data['ingredients'][i]:
train_data[j].iloc[i]=1<filter> | X = x_train
Y = y_train
X_train, X_val, Y_train , Y_val = train_test_split(x_train,y_train, test_size= 0.05, random_state = 92)
print(X_train.shape)
batches = train_generator.flow(X_train, Y_train, batch_size=32)
val_batches = train_generator.flow(X_val, Y_val, batch_size=32 ) | Digit Recognizer |
5,811,807 | for i in range(len(test_data)) :
for j in test_data['ingredients'][i]:
test_data[j].iloc[i]=1<drop_column> | history = model.fit_generator(
generator=batches,
steps_per_epoch=batches.n,
epochs=20,
validation_data=val_batches,
validation_steps=val_batches.n,
) | Digit Recognizer |
5,811,807 | test_data=test_data[train_data.drop('cuisine',axis=1 ).columns]<prepare_x_and_y> | predictions = model.predict_classes(x_test, verbose=0)
| Digit Recognizer |
5,811,807 | <split><EOS> | submissions=pd.DataFrame({"ImageId": list(range(1,len(predictions)+1)) ,
"Label": predictions})
submissions.to_csv("DR.csv", index=False, header=True ) | Digit Recognizer |
2,619,265 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<train_model> | %matplotlib inline
keras_version = keras.__version__
tf_version = K.tensorflow_backend.tf.VERSION
print("keras version:", keras_version)
print(K.backend() , "version:", tf_version ) | Digit Recognizer |
2,619,265 | lr=LogisticRegression()
lr.fit(X_train,y_train)
lr.score(X_val,y_val )<predict_on_test> | rawdata = np.loadtxt('.. /input/train.csv', dtype=int, delimiter=',', skiprows=1 ) | Digit Recognizer |
2,619,265 | test_data['cuisine']=lr.predict(test_data.drop(['id','ingredients'],axis=1))<prepare_output> | y_oh = to_categorical(y, num_classes)
X_scaled = X / 127.5 - 1
X_scaled = np.expand_dims(X_scaled, -1)
num_val = int(y.shape[0] * 0.1)
validation_mask = np.zeros(y.shape[0], np.bool)
np.random.seed(1)
for c in range(num_classes):
idxs = np.random.choice(np.flatnonzero(y == c), num_val // 10, replace=False)
valida... | Digit Recognizer |
2,619,265 | Submission=test_data[['id','cuisine']]
Submission.set_index('id',inplace=True )<save_to_csv> | def conv2D_bn_relu(x, filters, kernel_size, strides, padding='valid', kernel_initializer='glorot_uniform', name=None):
x = layers.Conv2D(filters=filters,
kernel_size=kernel_size,
strides=strides,
padding=padding,
kernel_initializer=kernel_initializer,
name=name,
use_bias=False )(x)
x = layers.BatchNormalization(scal... | Digit Recognizer |
2,619,265 | Submission.to_csv('Submission.csv' )<import_modules> | K.clear_session()
stem_width = 64
inputs = layers.Input(shape=X_scaled.shape[1:])
x = conv2D_bn_relu(inputs,
filters=stem_width,
kernel_size=5,
strides=2,
padding='valid',
name='conv_1')
x = inception_module_A(x, filters=int(1.5*stem_width))
x = layers.SpatialDropout2D(0.2 )(x)
x = inception_module_A(x, filters=int(... | Digit Recognizer |
2,619,265 | import xgboost as xgb
import numpy as np
import pandas as pd
import random
import optuna
from sklearn.model_selection import KFold, train_test_split
from sklearn.metrics import accuracy_score
from sklearn.metrics import mean_squared_error<load_from_csv> | epsilon = 0.001
y_train_smooth = y_train *(1 - epsilon)+ epsilon / 10
print(y_train_smooth ) | Digit Recognizer |
2,619,265 | train = pd.read_csv(".. /input/tabular-playground-series-feb-2021/train.csv")
test = pd.read_csv(".. /input/tabular-playground-series-feb-2021/test.csv" )<categorify> | def elastic_transform(image, alpha_range, sigma, random_state=None):
if random_state is None:
random_state = np.random.RandomState(None)
if np.isscalar(alpha_range):
alpha = alpha_range
else:
alpha = np.random.uniform(low=alpha_range[0], high=alpha_range[1])
shape = image.shape
dx = gaussian_filter(( random_state.r... | Digit Recognizer |
2,619,265 | df=train
for c in df.columns:
if df[c].dtype=='object':
lbl = LabelEncoder()
df[c]=df[c].fillna('N')
lbl.fit(list(df[c].values))
df[c] = lbl.transform(df[c].values)
train=df<categorify> | class CosineAnneal(keras.callbacks.Callback):
def __init__(self, max_lr, min_lr, T, T_mul=1, decay_rate=1.0):
self.max_lr = max_lr
self.min_lr = min_lr
self.decay_rate = decay_rate
self.T = T
self.T_cur = 0
self.T_mul = T_mul
self.step = 0
def on_batch_begin(self, batch, logs=None):
if self.T <= self.T_cur:
self.max_... | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.