kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
2,075,583 | %matplotlib inline
<merge> | def model_cnn(input_shape=input_shape, num_classes=num_classes):
model = Sequential()
model.add(Conv2D(32, kernel_size =(3,3), activation='relu', input_shape = input_shape))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size =(3,3), activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(32... | Digit Recognizer |
2,075,583 | train_c = train.join(COLOR)
test_c = test.join(COLOR2)
<choose_model_class> | def LeNet5(input_shape=input_shape,num_classes=num_classes):
model = Sequential()
model.add(Conv2D(6, kernel_size=(5, 5), strides=(1, 1), activation='relu', input_shape=input_shape, padding="same"))
model.add(AveragePooling2D(pool_size=(2, 2), strides=(1, 1), padding='valid'))
model.add(Conv2D(16, kernel_size=(5, 5), s... | Digit Recognizer |
2,075,583 | def GOB() :
global y_pred_c
global train
global test
hidden_layer_sizes=(100,)
activation = 'relu'
solver = 'adam'
batch_size = 'auto'
alpha = 0.0001
random_state = 0
max_iter = 10000
early_stopping = True
train_X = train_c
train_y1 = target_GOB
clf = MLPRegressor(
hidden_layer_sizes=hidden_layer_sizes,
activation=ac... | datagen = ImageDataGenerator(rotation_range=10, zoom_range = 0.1, width_shift_range=0.1, height_shift_range=0.1)
datagen.fit(x_train ) | Digit Recognizer |
2,075,583 | dataset = pd.concat([train, test], ignore_index = True)
',train.isnull().sum() )<choose_model_class> | models = []
for i in range(len(model)) :
model[i].fit_generator(datagen.flow(x_train,y_train, batch_size=batch_size),
epochs = epochs, steps_per_epoch=x_train.shape[0] // batch_size,
validation_data =(x_test,y_test),
callbacks=[ReduceLROnPlateau(monitor='loss', patience=3, factor=0.1)],
verbose=2)
models.append(model[... | Digit Recognizer |
2,075,583 | def lightGBM_k() :
global y_pred_AA
hidden_layer_sizes=(100,)
activation = 'relu'
solver = 'adam'
batch_size = 'auto'
alpha = 0.0001
random_state = 0
max_iter = 10000
early_stopping = True
train_X = train_k
train_y1 = target_k
clf = MLPRegressor(
hidden_layer_sizes=hidden_layer_sizes,
activation=activation,
solver=so... | labels = []
for m in models:
predicts = np.argmax(m.predict(test), axis=1)
labels.append(predicts)
labels = np.array(labels)
labels = np.transpose(labels,(1, 0))
labels = scipy.stats.mode(labels, axis=-1)[0]
labels = np.squeeze(labels ) | Digit Recognizer |
2,075,583 | <save_to_csv><EOS> | pd.DataFrame({'ImageId' : np.arange(1, predicts.shape[0] + 1), 'Label' : labels } ).to_csv('submission.csv', index=False ) | Digit Recognizer |
897,687 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<set_options> | sns.set(style='white', context='notebook', palette='deep')
plt.rcParams['image.cmap']='gray'
| Digit Recognizer |
897,687 | sns.set_style("whitegrid")
warnings.filterwarnings('ignore')
<load_from_csv> | col_names = ['label']+[str(x)for x in range(784)]
df = pd.concat([
pd.read_csv('.. /input/mnist-in-csv/mnist_train.csv', names=col_names, header=0),
pd.read_csv('.. /input/mnist-in-csv/mnist_test.csv', names=col_names, header=0),
pd.read_csv('.. /input/digit-recognizer/train.csv', names=col_names, header=0),
pd.read_cs... | Digit Recognizer |
897,687 | train_data=pd.read_csv('/kaggle/input/walmart-recruiting-store-sales-forecasting/train.csv.zip',parse_dates=True)
sample_submission=pd.read_csv('/kaggle/input/walmart-recruiting-store-sales-forecasting/sampleSubmission.csv.zip')
features_data=pd.read_csv('/kaggle/input/walmart-recruiting-store-sales-forecasting/featu... | num_classes = 10
X, y = df[col_names[1:]], df[col_names[0]] | Digit Recognizer |
897,687 | df = pd.DataFrame()
for i in tq.tqdm(range(1,46)) :
model=Prophet()
filled=features_data[(( features_data['Store']==i)&(features_data['Date']<'2013-05-03')) ][['Date','CPI']]
tserie = filled.rename(columns = {'Date': 'ds', 'CPI': 'y'}, inplace = False)
tserie =tserie.sort_values(by=['ds'])
tserie['ds'] = pd.to_dateti... | train = y.notna()
test = ~train
y_matrix =(y[:,None] == range(num_classes)).astype(int)
Xtrain, ytrain = X[train], y_matrix[train]
Xtest , ytest = X[test] , y_matrix[test] | Digit Recognizer |
897,687 | df = pd.DataFrame()
for i in tq.tqdm(range(1,46)) :
model=Prophet()
filled=features_data[(( features_data['Store']==i)&(features_data['Date']<'2013-05-03')) ][['Date','Unemployment']]
tserie = filled.rename(columns = {'Date': 'ds', 'Unemployment': 'y'}, inplace = False)
tserie =tserie.sort_values(by=['ds'])
tserie['d... | def baseline_model() :
model = Sequential()
model.add(Conv2D(32, kernel_size=(6, 6), strides=(2, 2), activation='relu',input_shape=Xtrain[0].shape))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(64,(5, 5), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
... | Digit Recognizer |
897,687 | stores = stores_data.merge(features_data, on ='Store' , how = 'left')
final_data_train = train_data.merge(stores, on = ['Store', 'Date', 'IsHoliday'], how = 'left' )<merge> | datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=20,
width_shift_range=0.1,
height_shift_range=0.1,
brightness_range=None,
shear_range=5,
zoom_range=-0.4,
fill_mode='nearest',
ho... | Digit Recognizer |
897,687 | stores = stores_data.merge(features_data, on ='Store' , how = 'left')
final_data_test = test_data.merge(stores, on = ['Store', 'Date', 'IsHoliday'], how = 'left' )<categorify> | datagen.fit(Xtrain ) | Digit Recognizer |
897,687 | def markdown_imputation(final_data):
final_data.loc[final_data.MarkDown1.isnull() ,'MarkDown1']= 0
final_data.loc[final_data.MarkDown2.isnull() ,'MarkDown2']= 0
final_data.loc[final_data.MarkDown3.isnull() ,'MarkDown3']= 0
final_data.loc[final_data.MarkDown4.isnull() ,'MarkDown4']= 0
final_data.loc[final_data.MarkDown5... | augmentation = True
if augmentation:
history = estimator.fit_generator(
datagen.flow(Xtrain, ytrain, batch_size=10),
steps_per_epoch=Xtrain.shape[0],
epochs=10
)
else:
history = estimator.fit(
Xtrain, ytrain,
batch_size=32, epochs=10,
validation_split=len(ytest)/len(y)
) | Digit Recognizer |
897,687 | def train_temp_bins(final_data):
temp_100_110_f=final_data[(( final_data.Temperature>100)&(final_data.Temperature< 110)) ].Weekly_Sales.sum()
temp_90_100_f=final_data[(( final_data.Temperature>90)&(final_data.Temperature< 100)) ].Weekly_Sales.sum()
temp_80_90_f=final_data[(( final_data.Temperature>80)&(final_data.Tempe... | ytest = estimator.predict_classes(Xtest ) | Digit Recognizer |
897,687 | def test_temp_bins(final_data,list1):
final_data['Temp_bins'] = np.nan
final_data.loc[(( final_data.Temperature>-10)&(final_data.Temperature<0)) ,'Temp_bins']= list1[0]
final_data.loc[(( final_data.Temperature>0)&(final_data.Temperature< 30)) ,'Temp_bins']= list1[1]
final_data.loc[(( final_data.Temperature>30)&(final_d... | submit = pd.DataFrame(data={'ImageId': range(1, ytest.shape[0]+1), 'Label': ytest} ) | Digit Recognizer |
897,687 | def split(final_data):
final_data['Date'] = pd.to_datetime(final_data['Date'])
final_data['Year'] = final_data['Date'].dt.year
final_data['Month']= final_data['Date'].dt.month
final_data['Week'] = final_data['Date'].dt.week
final_data['Day'] = final_data['Date'].dt.day
return final_data<feature_engineering> | submit.to_csv("submit.csv", index=None ) | Digit Recognizer |
7,780,225 | def days_from_christmas_for_train(x):
if x['Year']== 2010 :
diff=datetime.datetime(2010, 12, 31)-x['Date']
return diff.days
if(( x['Year']== 2011)and(x['Date']< datetime.datetime(2011, 12, 30))):
diff=datetime.datetime(2011, 12, 30)-x['Date']
return diff.days
else:
return 0<feature_engineering> | import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from keras.utils.np_utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D, BatchNormalization
from keras.preprocessing.image import ImageDataGenerator... | Digit Recognizer |
7,780,225 | def days_from_christmas_for_test(x):
if x['Year']== 2010 :
diff=datetime.datetime(2010, 12, 31)-x['Date']
return diff.days
if(( x['Year']== 2011)and(x['Date']< datetime.datetime(2011, 12, 30))):
diff=datetime.datetime(2011, 12, 30)-x['Date']
return diff.days
if(( x['Year']== 2012)and(x['Date']< datetime.datetime(2012, ... | sample_submission = pd.read_csv(".. /input/digit-recognizer/sample_submission.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv")
train = pd.read_csv(".. /input/digit-recognizer/train.csv" ) | Digit Recognizer |
7,780,225 | def days_from_thanksgiving_for_train(x):
if(( x['Year']== 2010)and(x['Date']< datetime.datetime(2010, 11, 26))):
diff=datetime.datetime(2010, 11, 26)-x['Date']
return diff.days
if(( x['Year']== 2011)and(x['Date']< datetime.datetime(2011, 11, 25))):
diff=datetime.datetime(2011, 11, 25)-x['Date']
return diff.days
else:
r... | Y_train = train["label"]
X_train = train.drop(labels = ["label"],axis = 1)
X_train = X_train / 255.0
X_test = test / 255.0
X_train = X_train.values.reshape(-1,28,28,1)
X_test = X_test.values.reshape(-1,28,28,1)
Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
7,780,225 | def days_from_thanksgiving_for_test(x):
if(( x['Year']== 2010)and(x['Date']< datetime.datetime(2010, 11, 26))):
diff=datetime.datetime(2010, 11, 26)-x['Date']
return diff.days
if(( x['Year']== 2011)and(x['Date']< datetime.datetime(2011, 11, 25))):
diff=datetime.datetime(2011, 11, 25)-x['Date']
return diff.days
if(( x['... | datagen = ImageDataGenerator(
rotation_range=10,
zoom_range = 0.10,
width_shift_range=0.1,
height_shift_range=0.1 ) | Digit Recognizer |
7,780,225 | def holiday_type(x):
if(x['IsHoliday']== 1)&(x['Week']==6):
return 1
elif(x['IsHoliday']== 1)&(x['Week']==36):
return 2
elif(x['IsHoliday']== 1)&(x['Week']==47):
return 3
elif(x['IsHoliday']== 1)&(x['Week']==52):
return 4
else:
return 0<feature_engineering> | nets = 15
model = [0] *nets
for j in range(nets):
model[j] = Sequential()
model[j].add(Conv2D(32, kernel_size = 3, activation='relu', input_shape =(28, 28, 1)))
model[j].add(BatchNormalization())
model[j].add(Conv2D(32, kernel_size = 3, activation='relu'))
model[j].add(BatchNormalization())
model[j].add(Conv2D(32, k... | Digit Recognizer |
7,780,225 | def holiday_label(final_data):
final_data.loc[(final_data.IsHoliday==True),'IsHoliday']= 1
final_data.loc[(final_data.IsHoliday==False),'IsHoliday']= 0
return final_data<categorify> | annealer = LearningRateScheduler(lambda x: 1e-3 * 0.95 ** x)
history = [0] * nets
epochs = 20
for j in range(nets):
X_train2, X_val2, Y_train2, Y_val2 = train_test_split(X_train, Y_train, test_size = 0.1)
history[j] = model[j].fit_generator(datagen.flow(X_train2,Y_train2, batch_size=66),
epochs = epochs, steps_per_ep... | Digit Recognizer |
7,780,225 | def type_label(final_data):
final_data.loc[(final_data.Type=='A'),'Type']= 1
final_data.loc[(final_data.Type=='B'),'Type']= 2
final_data.loc[(final_data.Type=='C'),'Type']= 3
return final_data<categorify> | results = np.zeros(( X_test.shape[0],10))
for j in range(nets):
results = results + model[j].predict(X_test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("submission_digit.csv",... | Digit Recognizer |
8,708,408 | def holiday_in_week_train(final_data):
dates =[]
for ptr in holidays.US(years = 2010 ).items() :
dates.append(ptr[0])
for ptr in holidays.US(years = 2011 ).items() :
dates.append(ptr[0])
for ptr in holidays.US(years = 2012 ).items() :
dates.append(ptr[0])
holiday_count=[]
for index, row in final_data.iterrows() :
da... | file_path = "/kaggle/input/digit-recognizer/train.csv"
X_train = pd.read_csv(file_path)
y_train = X_train.label
X_train = X_train.drop(columns = ["label"])
file_path = "/kaggle/input/digit-recognizer/test.csv"
X_test = pd.read_csv(file_path)
X_test = np.array(X_test ) | Digit Recognizer |
8,708,408 | def holiday_in_week_test(final_data):
dates =[]
for ptr in holidays.US(years = 2010 ).items() :
dates.append(ptr[0])
for ptr in holidays.US(years = 2011 ).items() :
dates.append(ptr[0])
for ptr in holidays.US(years = 2012 ).items() :
dates.append(ptr[0])
for ptr in holidays.US(years = 2013 ).items() :
dates.append(p... | X_train = np.array(X_train)
X_test = np.array(X_test ) | Digit Recognizer |
8,708,408 | final_data_train=markdown_imputation(final_data_train)
final_data_train=weekly_sales_imputation(final_data_train)
final_data_train,list1=train_temp_bins(final_data_train)
final_data_train=split(final_data_train)
final_data_train['diff_from_christmas'] = final_data_train.apply(days_from_christmas_for_train, axis=1)
... | X_train = X_train /255
X_test = X_test / 255 | Digit Recognizer |
8,708,408 | final_data_test=markdown_imputation(final_data_test)
final_data_test=test_temp_bins(final_data_test,list1)
final_data_test=split(final_data_test)
final_data_test['diff_from_christmas'] = final_data_test.apply(days_from_christmas_for_test, axis=1)
final_data_test['days_from_thanksgiving'] = final_data_test.apply(day... | y_train = to_categorical(y_train, num_classes = 10 ) | Digit Recognizer |
8,708,408 | final_data_train=final_data_train.reset_index(drop=True )<data_type_conversions> | 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 |
8,708,408 | final_data_train=final_data_train[['Store','Dept','IsHoliday','Size','Week','Type','Year','Weekly_Sales','Holidays','Day']]
final_data_test=final_data_test[['Store','Dept','IsHoliday','Size','Week','Type','Year','Holidays','Day']]
final_data_train['IsHoliday']=final_data_train['IsHoliday'].astype('bool')
final_data_te... | from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score
from keras.models import Model | Digit Recognizer |
8,708,408 | sample_submission['Weekly_Sales'] = list(y_hat )<save_to_csv> | !pip install -q efficientnet
model = Sequential()
model.add(Conv2D(64, kernel_size=5, activation="relu", padding = "same", input_shape=(28,28,1)))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(256, kernel_size=3, activation="relu", padding = "same"))
model.add(MaxPooling2D... | Digit Recognizer |
8,708,408 | sample_submission.to_csv('submission.csv',index = False )<set_options> | optimizer = keras.optimizers.RMSprop(learning_rate=0.001,
rho=0.9,
epsilon=1e-08,
decay=0.0 ) | Digit Recognizer |
8,708,408 | %%HTML
<style type="text/css">
div.h1 {
background-color:
color: white;
padding: 8px;
padding-right: 300px;
font-size: 35px;
max-width: 1500px;
margin: auto;
margin-top: 50px;
}
div.h2 {
background-color:
color: white;
padding: 8px;
padding-right: 300px;
font-size: 35px;
max-width: 1500px;
margin: auto;
margin-top: 50p... | model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
8,708,408 | warnings.filterwarnings('ignore' )<import_modules> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
8,708,408 | from sklearn.preprocessing import QuantileTransformer<load_from_csv> | epochs = 40
batch_size = 50 | Digit Recognizer |
8,708,408 | train_features = pd.read_csv('.. /input/lish-moa/train_features.csv')
train_targets_scored = pd.read_csv('.. /input/lish-moa/train_targets_scored.csv')
train_targets_nonscored = pd.read_csv('.. /input/lish-moa/train_targets_nonscored.csv')
test_features = pd.read_csv('.. /input/lish-moa/test_features.csv')
sample_s... | datagen = keras.preprocessing.image.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_fl... | Digit Recognizer |
8,708,408 | GENES = [col for col in train_features.columns if col.startswith('g-')]
CELLS = [col for col in train_features.columns if col.startswith('c-')]<normalization> | history = model.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 |
8,708,408 | for col in(GENES + CELLS):
transformer = QuantileTransformer(n_quantiles=100, random_state=0, output_distribution="normal")
vec_len = len(train_features[col].values)
vec_len_test = len(test_features[col].values)
raw_vec = train_features[col].values.reshape(vec_len, 1)
transformer.fit(raw_vec)
train_features[col] =... | results = model.predict(X_test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label")
| Digit Recognizer |
8,708,408 | def seed_everything(seed=42):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
seed_everything(seed=42 )<sort_values> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Digit Recognizer |
8,708,408 | train_targets_scored.sum() [1:].sort_values()<concatenate> | file_path = "/kaggle/input/digit-recognizer/train.csv"
X_train = pd.read_csv(file_path)
y_train = X_train.label
X_train = X_train.drop(columns = ["label"])
file_path = "/kaggle/input/digit-recognizer/test.csv"
X_test = pd.read_csv(file_path)
X_test = np.array(X_test ) | Digit Recognizer |
8,708,408 | n_comp = 50
data = pd.concat([pd.DataFrame(train_features[GENES]), pd.DataFrame(test_features[GENES])])
data2 =(PCA(n_components=n_comp, random_state=42 ).fit_transform(data[GENES]))
train2 = data2[:train_features.shape[0]]; test2 = data2[-test_features.shape[0]:]
train2 = pd.DataFrame(train2, columns=[f'pca_G-{i}' fo... | X_train = np.array(X_train)
X_test = np.array(X_test ) | Digit Recognizer |
8,708,408 | n_comp = 15
data = pd.concat([pd.DataFrame(train_features[CELLS]), pd.DataFrame(test_features[CELLS])])
data2 =(PCA(n_components=n_comp, random_state=42 ).fit_transform(data[CELLS]))
train2 = data2[:train_features.shape[0]]; test2 = data2[-test_features.shape[0]:]
train2 = pd.DataFrame(train2, columns=[f'pca_C-{i}' fo... | X_train = X_train /255
X_test = X_test / 255 | Digit Recognizer |
8,708,408 | var_thresh = VarianceThreshold(threshold=0.5)
data = train_features.append(test_features)
data_transformed = var_thresh.fit_transform(data.iloc[:, 4:])
train_features_transformed = data_transformed[ : train_features.shape[0]]
test_features_transformed = data_transformed[-test_features.shape[0] : ]
train_features = p... | y_train = to_categorical(y_train, num_classes = 10 ) | Digit Recognizer |
8,708,408 | train = train_features.merge(train_targets_scored, on='sig_id')
train = train[train['cp_type']!='ctl_vehicle'].reset_index(drop=True)
test = test_features[test_features['cp_type']!='ctl_vehicle'].reset_index(drop=True)
target = train[train_targets_scored.columns]<drop_column> | 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 |
8,708,408 | train = train.drop('cp_type', axis=1)
test = test.drop('cp_type', axis=1 )<feature_engineering> | from keras.models import Sequential
from keras.layers import Dense, Conv2D, Flatten
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score
from keras.models import Model | Digit Recognizer |
8,708,408 |
<feature_engineering> | !pip install -q efficientnet
model = Sequential()
model.add(Conv2D(64, kernel_size=5, activation="relu", padding = "same", input_shape=(28,28,1)))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(256, kernel_size=3, activation="relu", padding = "same"))
model.add(MaxPooling2D... | Digit Recognizer |
8,708,408 |
<create_dataframe> | optimizer = keras.optimizers.RMSprop(learning_rate=0.001,
rho=0.9,
epsilon=1e-08,
decay=0.0 ) | Digit Recognizer |
8,708,408 |
<drop_column> | model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
8,708,408 | target_cols = target.drop('sig_id', axis=1 ).columns.values.tolist()<split> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
8,708,408 | folds = train.copy()
mskf = MultilabelStratifiedKFold(n_splits=5)
for f,(t_idx, v_idx)in enumerate(mskf.split(X=train, y=target)) :
folds.loc[v_idx, 'kfold'] = int(f)
folds['kfold'] = folds['kfold'].astype(int)
folds<categorify> | epochs = 40
batch_size = 50 | Digit Recognizer |
8,708,408 | class MoADataset:
def __init__(self, features, targets):
self.features = features
self.targets = targets
def __len__(self):
return(self.features.shape[0])
def __getitem__(self, idx):
dct = {
'x' : torch.tensor(self.features[idx, :], dtype=torch.float),
'y' : torch.tensor(self.targets[idx, :], dtype=torch.float)
}
ret... | datagen = keras.preprocessing.image.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_fl... | Digit Recognizer |
8,708,408 | def train_fn(model, optimizer, scheduler, loss_fn, dataloader, device):
model.train()
final_loss = 0
for data in dataloader:
optimizer.zero_grad()
inputs, targets = data['x'].to(device), data['y'].to(device)
outputs = model(inputs)
loss = loss_fn(outputs, targets)
loss.backward()
optimizer.step()
scheduler.step()
fi... | history = model.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 |
8,708,408 | class Model(nn.Module):
def __init__(self, num_features, num_targets, hidden_size):
super(Model, self ).__init__()
self.batch_norm1 = nn.BatchNorm1d(num_features)
self.dropout1 = nn.Dropout(0.2)
self.dense1 = nn.utils.weight_norm(nn.Linear(num_features, hidden_size))
self.batch_norm2 = nn.BatchNorm1d(hidden_size)
se... | results = model.predict(X_test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label")
| Digit Recognizer |
8,708,408 | def process_data(data):
data = pd.get_dummies(data, columns=['cp_time','cp_dose'])
return data<define_variables> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Digit Recognizer |
3,233,000 | feature_cols = [c for c in process_data(folds ).columns if c not in target_cols]
feature_cols = [c for c in feature_cols if c not in ['kfold','sig_id']]
len(feature_cols )<define_variables> | train_dir = ".. /input/train.csv"
test_dir = ".. /input/test.csv"
df = pd.read_csv(train_dir)
df.info() | Digit Recognizer |
3,233,000 | DEVICE =('cuda' if torch.cuda.is_available() else 'cpu')
EPOCHS = 25
BATCH_SIZE = 128
LEARNING_RATE = 1e-3
WEIGHT_DECAY = 1e-5
NFOLDS = 5
EARLY_STOPPING_STEPS = 10
EARLY_STOP = False
num_features=len(feature_cols)
num_targets=len(target_cols)
hidden_size=1024
<prepare_x_and_y> | labels = df["label"].values.tolist()
labels = np.array(labels)
n_classes = len(set(labels))
labels = keras.utils.to_categorical(labels ) | Digit Recognizer |
3,233,000 | def run_training(fold, seed):
seed_everything(seed)
train = process_data(folds)
test_ = process_data(test)
trn_idx = train[train['kfold'] != fold].index
val_idx = train[train['kfold'] == fold].index
train_df = train[train['kfold'] != fold].reset_index(drop=True)
valid_df = train[train['kfold'] == fold].reset_index(... | df_train = df.drop(["label"], axis = 1)
data = df_train.values.tolist()
data = np.array(data)
data = data.astype('float32')/255.0 | Digit Recognizer |
3,233,000 | def run_k_fold(NFOLDS, seed):
oof = np.zeros(( len(train), len(target_cols)))
predictions = np.zeros(( len(test), len(target_cols)))
for fold in range(NFOLDS):
oof_, pred_ = run_training(fold, seed)
predictions += pred_ / NFOLDS
oof += oof_
return oof, predictions<categorify> | print("Training data shape = " + str(data.shape))
print("Training labels shape = " + str(labels.shape)) | Digit Recognizer |
3,233,000 | SEED = [0, 1, 2, 3 ,4, 5]
oof = np.zeros(( len(train), len(target_cols)))
predictions = np.zeros(( len(test), len(target_cols)))
for seed in SEED:
oof_, predictions_ = run_k_fold(NFOLDS, seed)
oof += oof_ / len(SEED)
predictions += predictions_ / len(SEED)
train[target_cols] = oof
test[target_cols] = predictions
... | gen_model = Sequential()
gen_model.add(Dense(784, activation = 'relu', input_shape =(784,)))
gen_model.add(Dense(512, activation = 'relu'))
gen_model.add(Dense(264, activation = 'relu'))
gen_model.add(Dense(10, activation = 'softmax'))
print("STANDARD NEURAL NETWORK MODEL :-")
gen_model.summary() | Digit Recognizer |
3,233,000 | valid_results = train_targets_scored.drop(columns=target_cols ).merge(train[['sig_id']+target_cols], on='sig_id', how='left' ).fillna(0)
y_true = train_targets_scored[target_cols].values
y_pred = valid_results[target_cols].values
score = 0
for i in range(len(target_cols)) :
score_ = log_loss(y_true[:, i], y_pred[:, i]... | gen_model.compile(loss = 'categorical_crossentropy', optimizer = keras.optimizers.Adadelta() , metrics = ['accuracy'] ) | Digit Recognizer |
3,233,000 | sub = sample_submission.drop(columns=target_cols ).merge(test[['sig_id']+target_cols], on='sig_id', how='left' ).fillna(0)
sub.to_csv('submission.csv', index=False )<define_variables> | gen_model_hist = gen_model.fit(data, labels, batch_size = 32, epochs = 5, validation_split = 0.1 ) | Digit Recognizer |
3,233,000 | TEST_MODE = False
MOCK_MODE = False
SKIP_ADD_FEATURE = False
LOCAL = False
SAINT_PICKLE_PATH = ".. /input/saint-final"
SAINT_MODEL_PATH = ".. /input/saint-final/saintv113.pth"<import_modules> | del gen_model, gen_model_hist
gc.collect() | Digit Recognizer |
3,233,000 | if MOCK_MODE:
<import_modules> | X_train_cnn = data.reshape(len(data), 28, 28, 1 ) | Digit Recognizer |
3,233,000 | if LOCAL is False:
<load_pretrained> | cnn_model = Sequential()
cnn_model.add(Conv2D(32, kernel_size = [3,3], activation = 'relu', input_shape =(28,28,1)))
cnn_model.add(Conv2D(64, kernel_size = [3,3], activation = 'relu'))
cnn_model.add(BatchNormalization())
cnn_model.add(MaxPool2D(pool_size = [2,2], strides = 2))
cnn_model.add(Conv2D(128, kernel_size = ... | Digit Recognizer |
3,233,000 | def load_group() :
group = None
for i in range(10):
with open(f"{SAINT_PICKLE_PATH}/{i}groupv1.pickle", "rb")as f:
if group is None:
group = pickle.load(f)
else:
group = pd.concat([group, pickle.load(f)])
gc.collect()
gc.collect()
return group<groupby> | cnn_model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])
cnn_model_hist = cnn_model.fit(X_train_cnn, labels, batch_size = 32, epochs = 6, validation_split = 0.1 ) | Digit Recognizer |
3,233,000 | group = load_group()<define_variables> | del cnn_model, cnn_model_hist
gc.collect() | Digit Recognizer |
3,233,000 | SEED = 123
def seed_everything(seed):
random.seed(seed)
np.random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
seed_everything(SEED )<categorify> | data_aug = 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 = Fals... | Digit Recognizer |
3,233,000 | MAX_SEQ = 100
n_skill = 13523
n_part = 7
n_et = 300
n_lt = 1441
n_lsi = 128
DROPOUT = 0.1
EMBED_SIZE = 256
BATCH_SIZE = 256
def future_mask(seq_length):
future_mask = np.triu(np.ones(( seq_length, seq_length)) , k=1 ).astype('bool')
return torch.from_numpy(future_mask)
class FFN(nn.Module):
def __init__(self, state_s... | models_ensemble = []
for i in range(7):
model = Sequential()
model.add(Conv2D(32, kernel_size = [3,3], activation = 'relu', input_shape =(28,28,1)))
model.add(Conv2D(64, kernel_size = [3,3], activation = 'relu'))
model.add(BatchNormalization())
model.add(MaxPool2D(pool_size = [2,2], strides = 2))
model.add(Conv2D(128... | Digit Recognizer |
3,233,000 | def create_model() :
return SAINTModel(n_skill, n_pt=7, n_lsi=n_lsi, n_et=n_et, n_lt=n_lt, max_seq=MAX_SEQ, embed_dim=EMBED_SIZE, forward_expansion=1, enc_layers=2, dec_layers=2, heads=8, dropout=0.1 )<load_pretrained> | model_histories = []
i = 1
for model in models_ensemble:
xtrain, xtest, ytrain, ytest = train_test_split(X_train_cnn, labels, test_size = 0.07)
print("Model " +str(i)+ " : ",end="")
model_history = model.fit_generator(data_aug.flow(xtrain, ytrain, batch_size = 64), epochs = 1, verbose = 1, validation_data =(xtest, yt... | Digit Recognizer |
3,233,000 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
saint_model = create_model()
try:
saint_model.load_state_dict(torch.load(SAINT_MODEL_PATH))
except:
saint_model.load_state_dict(torch.load(SAINT_MODEL_PATH, map_location='cpu'))
saint_model.to(device)
saint_model.eval()<categorify> | testdata = pd.read_csv(test_dir)
testdata = testdata.values.tolist()
testdata = np.array(testdata)
testdata_reshaped = testdata.reshape(testdata.shape[0], 28, 28, 1)
testdata_reshaped = testdata_reshaped.astype('float')/255.0
def make_predictions_final_model(curr_model):
prediction_array = curr_model.predict_on_batc... | Digit Recognizer |
3,233,000 | class PredictEnv:
def __init__(self, folds_path, folds):
self.conn = sqlite3.connect(':memory:')
self.c = self.conn.cursor()
self.setup_folds(folds_path, folds)
def setup_folds(self, folds_path, folds):
self.c.executescript(f ).fetchone()
self.group_num = 0
self.records_remaining = self.c.execute('SELECT COUNT(*)FROM... | predictions_ensemble = []
for model in models_ensemble:
curr_predictions = make_predictions_final_model(model)
predictions_ensemble.append(curr_predictions)
prediction_per_image = []
for i in range(len(predictions_ensemble[0])) :
temppred = [predictions_ensemble[0][i], predictions_ensemble[1][i], predictions_ensemble... | Digit Recognizer |
3,233,000 | if MOCK_MODE:
FOLDS = Path('.. /input/riiid-folds/riiid.db')
env = PredictEnv(FOLDS, [0, 1])
iter_test = env.iter_test()
else:
env = riiideducation.make_env()
iter_test = env.iter_test()
set_predict = env.predict
if TEST_MODE and type(iter_test)!= list:
list_df = []
for itr,(df_test, sample_prediction_df)in enumerate... | final_csv = []
csv_title = ['ImageId', 'Label']
final_csv.append(csv_title)
for i in range(len(final_predictions)) :
image_id = i + 1
label = final_predictions[i]
temp = [image_id, label]
final_csv.append(temp)
print(len(final_csv))
with open('submission_csv_aug.csv', 'w')as file:
writer = csv.writer(file)
writer.wr... | Digit Recognizer |
4,950,920 | TARGET = "answered_correctly"<categorify> | data_train = pd.read_csv(".. /input/train.csv")
data_train.head()
| Digit Recognizer |
4,950,920 | QUESTION_FEATURES = ["part", "question_id", "lsi_topic"]
question_file = ".. /input/question-features-0102/questions.pickle"
questions_df = pd.read_pickle(question_file)[QUESTION_FEATURES]
questions_df["lsi_topic"] = questions_df["lsi_topic"].fillna(-1)
questions_df["lsi_topic"] = questions_df["lsi_topic"].map(dict(ma... | y_train = data_train['label']
x_train = data_train.drop(labels = ["label"], axis = 1)
print('Shape of whole data for training', data_train.shape)
print('x_train:', x_train.shape)
print('y_train:', y_train.shape)
%matplotlib inline
def convert_to_grid(x_input):
N, H, W = x_input.shape
grid_size = int(ceil(sqrt(N)))
... | Digit Recognizer |
4,950,920 | warnings.filterwarnings(action="ignore" )<load_pretrained> | x_test = pd.read_csv(".. /input/test.csv")
x_test.head()
| Digit Recognizer |
4,950,920 | last_row_file = ".. /input/saint-final/last_row_states.pickle"
with open(last_row_file, "rb")as f:
last_row_states = pickle.load(f)
def inference(iter_test, TARGET, saint_model, questions_df):
previous_test_df = None
for(test_df, sample_prediction_df)in tqdm(iter_test):
if previous_test_df is not None:
previous_test_d... | def pre_process_mnist(x_train, y_train, x_test):
x_train = x_train / 255.0
x_test = x_test / 255.0
batch_mask = list(range(41000, 42000))
x_validation = x_train[batch_mask]
y_validation = y_train[batch_mask]
batch_mask = list(range(41000))
x_train = x_train[batch_mask]
y_train = y_train[batch_mask]
mean_image = np.mean... | Digit Recognizer |
4,950,920 | global_test = 2
<import_modules> | model = Sequential()
model.add(Conv2D(64, kernel_size=7, padding='same', activation='relu', input_shape=(28, 28, 1)))
model.add(BatchNormalization())
model.add(Conv2D(64, kernel_size=9, strides=2, padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(64, kernel_size=7, padding='same', ... | Digit Recognizer |
4,950,920 | import numpy as np
import pandas as pd
import glob
import riiideducation
import matplotlib.pyplot as plt
from tqdm import tqdm
from catboost import CatBoostClassifier
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
<set_options> | annealer = LearningRateScheduler(lambda x: 1e-3 * 0.95 **(x + epochs))
epochs = 50
h = model.fit(data['x_train'], data['y_train'], batch_size=100, epochs = epochs,
validation_data =(data['x_validation'], data['y_validation']), callbacks=[annealer], verbose=1)
| Digit Recognizer |
4,950,920 | pd.options.display.max_rows = 100
pd.options.display.max_columns = 100<data_type_conversions> | print("Epochs={0:d}, Train accuracy={1:.5f}, Validation accuracy={2:.5f}".format(epochs, max(h.history['acc']),
max(h.history['val_acc'])))
| Digit Recognizer |
4,950,920 | def df_to_np(df, filter_lectures:bool, convert_answers:bool):
tmstmp =(df['timestamp']/3600000 ).to_numpy(dtype = np.float32)
userid = df['user_id'].to_numpy()
ctntid = df['content_id'].to_numpy()
ctnttp = df['content_type_id'].to_numpy()
contnr = df['task_container_id'].to_numpy()
pqtime = np.nan_to_num(df['prior_que... | model.save('my_model.h5' ) | Digit Recognizer |
4,950,920 | <load_from_csv><EOS> | results = model.predict(data['x_test'])
results = np.argmax(results, axis=1)
submission = pd.read_csv('.. /input/sample_submission.csv')
submission['Label'] = results
submission.to_csv('sample_submission.csv', index=None)
| Digit Recognizer |
3,081,290 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<data_type_conversions> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from keras import layers
from keras import models
from keras import optimizers
from keras.utils import to_categorical
from sklearn.utils import shuffle
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_... | Digit Recognizer |
3,081,290 | def get_cor_table() :
max_neigbrs = 1000
global cor_table
map1 = np.load('.. /input/content-correlation-100to300/ctnt_map.npy')
map2 = np.load('.. /input/content-correlation/ctnt_map.npy')
cor1 = np.load('.. /input/content-correlation-100to300/result.npy')
cor2 = np.load('.. /input/content-correlation/result.npy')
... | train_data = pd.read_csv('/kaggle/input/train.csv')
test_data = pd.read_csv('/kaggle/input/test.csv' ) | Digit Recognizer |
3,081,290 | def get_content_answer_shares() :
global ca_shares_all
columns = ['user_id',
'content_id',
'content_type_id',
'user_answer',
'answered_correctly']
df = get_train_large(t_part=99, columns=columns)
df = df.loc[df.content_type_id == 0, df.columns != 'content_type_id']
ca_shares_all = pd.pivot_table(df,
values='answered_c... | X_model = train_data.drop('label', axis=1)
y_model = train_data['label'].copy()
Y_finish = test_data
print('size train data:', X_model.shape)
print('size train labels:', y_model.shape)
print('size finish test data:', Y_finish.shape ) | Digit Recognizer |
3,081,290 | def get_content_first_answer_mean() :
global ctnt_fam
columns = ['user_id',
'new_order',
'answered_correctly',
'content_id',
'content_type_id']
df = get_train_large(t_part = 99, columns = columns)
df = df\
.loc[df.content_type_id==0, df.columns!='content_type_id']\
.sort_values(by = 'new_order')
df = df.groupby(['u... | def img_rotate(df_x, angle):
change_img = np.empty([df_x.shape[0], df_x.shape[1]])
for i, image in enumerate(df_x.values):
img = rotate(image.reshape(28, 28), angle, cval=0, reshape=False, order=0)
change_img[i] = img.ravel()
return pd.DataFrame(data=change_img, columns=df_x.columns)
def img_zoom(df_x, scale):
i... | Digit Recognizer |
3,081,290 | def get_ctnt_enc() :
global ctnt_enc
qestn_tagsmap_ohe = np.zeros(( len(qestn_tagsmap), 189), dtype = np.bool)
for i,j in enumerate(qestn_tagsmap):
for k in j:
qestn_tagsmap_ohe[i,k] = True
tags_comps = StandardScaler().fit_transform(
PCA(n_components=3, random_state=0 ).fit_transform(qestn_tagsmap_ohe)
)
corr_comps... | X_train, X_test, y_train, y_test = train_test_split(X_model, y_model, test_size=0.2 ) | Digit Recognizer |
3,081,290 | def get_train_small(t_part:int):
all_files = glob.glob('.. /input/riiid-parquets-v5/df_*')
read_files = [file for file in all_files if file.endswith('_'+str(t_part)) ]
df = pd.read_parquet(read_files[0])
return df<load_pretrained> | X_train_add = X_train.append(img_zoom(X_train, 0.2))
X_train_add = X_train_add.append(img_zoom(X_train, -0.3))
X_train_add = X_train_add.append(img_rotate(X_train, 11))
X_train_add = X_train_add.append(img_rotate(X_train, -11))
y_train_add = y_train.append(y_train)
y_train_add = y_train_add.append(y_train)
y_train_ad... | Digit Recognizer |
3,081,290 | def get_train_large(t_part:int, columns:list):
all_files = glob.glob('.. /input/riiid-parquets-v5/df_*')
read_files = [file for file in all_files if not file.endswith('_'+str(t_part)) ]
df = pd.concat([pd.read_parquet(file, columns = columns)for file in read_files])
return df<groupby> | X_train = X_train.values.reshape(X_train.shape[0], 28, 28 ,1)
X_train = X_train.astype('float32')/ 255
X_test = X_test.values.reshape(X_test.shape[0], 28, 28, 1)
X_test = X_test.astype('float32')/ 255
Y_finish = Y_finish.values.reshape(Y_finish.shape[0], 28, 28 ,1)
Y_finish = Y_finish.astype('float32')/ 255 | Digit Recognizer |
3,081,290 | def get_train_groups(t_part:int):
df = get_train_small(t_part)
groups = []
for i in np.arange(0, 10000, dtype = np.int16):
group = df.loc[df.new_order == i].reset_index(drop = True)
groups.append(group)
return groups<data_type_conversions> | def build_model() :
model = models.Sequential()
model.add(layers.Conv2D(32,(3,3), activation='relu', input_shape=(28,28,1)))
model.add(layers.MaxPooling2D(( 2,2)))
model.add(layers.Dropout(0.12))
model.add(layers.Conv2D(64,(3,3), activation='relu'))
model.add(layers.MaxPooling2D(( 2,2)))
model.add(layers.Dropout(0.1... | Digit Recognizer |
3,081,290 | def get_arrays_and_lists() :
global next_uplace,\
au_ctntid,\
a_userid,\
lu_seq,\
lu_seq_part,\
au_anshar,\
au_ctshar,\
user_map,\
au_tmstmp_prv
au_ctntid = np.zeros(( max_users, max_content, 3), dtype = np.int8)
a_userid = np.zeros(( max_users, 2), dtype = np.int16)
au_anshar = np.zeros(( max_users, 2), dtype = np.f... | y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)
cnn = build_model()
cnn.fit(X_train,
y_train,
epochs=4,
batch_size=64 ) | Digit Recognizer |
3,081,290 | def update_user_map(unique_users):
global next_uplace
for u in unique_users:
if user_map[u] == int32_0:
user_map[u] = next_uplace
next_uplace += int32_1<feature_engineering> | test_loss, test_acc = cnn.evaluate(X_test, y_test)
test_acc | Digit Recognizer |
3,081,290 | def update_arrays(df):
tmstmp,userid,ctntid,ctnttp,contnr,pqtime,pqexpl,usrans,anscor = df_to_np(df,False,True)
for r in range(len(df)) :
user_ = user_map[userid[r]]
if tmstmp[r] > au_tmstmp_prv[user_,0]:
au_tmstmp_prv[user_,2] = au_tmstmp_prv[user_,1]
au_tmstmp_prv[user_,1] = au_tmstmp_prv[user_,0]
au_tmstmp_prv[user... | predict_test = cnn.predict_classes(X_test)
y_correct = np.argmax(y_test, axis=1)
correct_idx = np.nonzero(predict_test==y_correct)
incorrect_idx = np.nonzero(predict_test!=y_correct ) | Digit Recognizer |
3,081,290 | def get_features(df, is_test:bool):
if is_test:
tmstmp,userid,ctntid,ctnttp,contnr,pqtime,pqexpl=\
df_to_np(df,True,False)
else:
tmstmp,userid,ctntid,ctnttp,contnr,pqtime,pqexpl,usrans,anscor=\
df_to_np(df,True,True)
user = user_map[userid]
part = qestn_partmap[ctntid]
userid_ctntid_ = au_ctntid[user,ctntid]
userid_ ... | target_names = ["Class {}".format(i)for i in range(10)]
print(classification_report(y_correct, predict_test, target_names=target_names)) | Digit Recognizer |
3,081,290 | %%time
uint8_0 = np.uint8(0)
uint8_1 = np.uint8(1)
uint16_0 = np.uint16(0)
uint16_1 = np.uint16(1)
int8_0 = np.int8(0)
int8_1 = np.int8(1)
int16_0 = np.int16(0)
int16_1 = np.int16(1)
int32_0 = np.int32(0)
int32_1 = np.int32(1)
float32m1 = np.float32(-1)
max_users = 450000
max_content = 13523
m = 100
s = 20
e... | predict = cnn.predict_classes(Y_finish ) | Digit Recognizer |
3,081,290 | %%time
if global_test == 1:
for i in tqdm(range(10)) :
X = []
y = []
get_arrays_and_lists()
groups = get_train_groups(i)
for df in groups:
update_user_map(df.user_id.unique())
X_, y_ = get_features(df,False)
X.append(X_)
y.append(y_)
update_arrays(df)
del(groups)
X = pd.concat(X)
y = np.concatenate(y)
X.to_par... | df_out = pd.DataFrame({'ImageId': range(1, len(predict)+1),
'Label': predict} ) | Digit Recognizer |
3,081,290 | <split><EOS> | df_out.to_csv('mnist_cnn.csv', index=False, header=True ) | Digit Recognizer |
2,858,410 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<feature_engineering> | %matplotlib inline
plt.rcParams['figure.figsize'] =(5.0, 4.0)
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
print(os.listdir(".. /input"))
np.random.seed(2)
| Digit Recognizer |
2,858,410 | %%time
if global_test == 2:
old_df = None
for(new_df, sample)in iter_test:
if old_df is not None:
old_df['user_answer'] = np.array(
[int(x)for x in new_df.iloc[0,9][1:-1].split(', ')], dtype = np.int8)
old_df['answered_correctly'] = np.array(
[int(x)for x in new_df.iloc[0,8][1:-1].split(', ')], dtype = np.int8)
upd... | def convert_to_one_hot(Y, C):
Y = np.eye(C)[Y.reshape(-1)]
return Y | Digit Recognizer |
2,858,410 | import pandas as pd
import numpy as np
import gc
import pickle
import psutil
import joblib
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
import sqlite3<define_search_space> | def read_csv(filename):
X,Y=[],[]
test=pd.read_csv(filename)
if filename.find("train.csv")>0:
Y=test.iloc[:,0].values
Y=convert_to_one_hot(Y,10)
X=test.iloc[:,1:785].values
else:
X=test.iloc[:,0:784].values
return X, Y | Digit Recognizer |
2,858,410 | c1, c1_2, c2, c3 , c4 = 0.175, 0.075, 0.25, 0.25, 0.25<init_hyperparams> | def write_csv(filename,predictions):
my_submission = pd.DataFrame({'ImageId': range(1,predictions.shape[0]+1), 'Label': predictions})
my_submission.to_csv('submission.csv', index=False)
| Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.