kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
3,729,811 | model = CNNStacking(CFG['target_size'])
states = [torch.load(STAGE2_DIR+f'/fold{fold}_best.pth')for fold in CFG['trn_fold']]
test_dataset = StackingDataset(stage1_predictions)
test_loader = DataLoader(test_dataset, batch_size=CFG['batch_size'], shuffle=False,
num_workers=CFG['num_workers'], pin_memory=True)
predicti... | log_dir = '.. /work' | Digit Recognizer |
3,729,811 | from fastai.vision.all import *
import albumentations<define_variables> | train_df_n = train_df.astype('float32')/ 255
test_df_n = test_df.astype('float32')/ 255
train_np_n = train_df_n.values
test_np_n = test_df_n.values
print(train_np_n.shape)
print(test_np_n.shape ) | Digit Recognizer |
3,729,811 | set_seed(42 )<categorify> | X_train, X_val, y_train, y_val = train_test_split(train_np_n, train_label_np, test_size=0.25, random_state=42)
print(X_train.shape)
print(y_train.shape)
print(X_val.shape)
print(y_val.shape ) | Digit Recognizer |
3,729,811 | class AlbumentationsTransform(RandTransform):
"A transform handler for multiple `Albumentation` transforms"
split_idx,order=None,2
def __init__(self, train_aug, valid_aug): store_attr()
def before_call(self, b, split_idx):
self.idx = split_idx
def encodes(self, img: PILImage):
if self.idx == 0:
aug_img = self.train_aug... | print(y_train.shape)
print(y_val.shape)
Y_train = to_categorical(y_train)
Y_val = to_categorical(y_val)
print(Y_train.shape)
print(Y_val.shape ) | Digit Recognizer |
3,729,811 | def get_x(row): return data_path/row['image_id']
def get_y(row): return row['label']<choose_model_class> | def step_decay_for_conv2(epoch):
x = 0.0005
if epoch >= 20: x = 0.0001
if epoch >= 40: x = 0.00005
return x
lr_decay = LearningRateScheduler(step_decay_for_conv2,verbose=0 ) | Digit Recognizer |
3,729,811 | class CassavaModel(Module):
def __init__(self, num_classes):
self.effnet = EfficientNet.from_pretrained("efficientnet-b3")
self.dropout = nn.Dropout(0.1)
self.out = nn.Linear(1536, num_classes)
def forward(self, image):
batch_size, _, _, _ = image.shape
x = self.effnet.extract_features(image)
x = F.adaptive_avg_poo... | def create_model2() :
inputs_mnist = Input(shape=(28,28,1))
inputs = Conv2D(filters=64, kernel_size=(3,3), padding='same', bias_regularizer=regularizers.l2(0.005))(inputs_mnist)
inputs = Conv2D(filters=128, kernel_size=(3,3), padding='same', bias_regularizer=regularizers.l2(0.005))(inputs)
inputs = BatchNormalization... | Digit Recognizer |
3,729,811 | Path('/kaggle/input' ).ls()<load_pretrained> | _model = create_model2() | Digit Recognizer |
3,729,811 | learn = load_learner(Path('/kaggle/input/effnet-inference/inference(1)'), cpu=False )<define_variables> | def fit_the_model(_model, _epochs):
original_hist = _model.fit(np.array(X_train), [np.array(Y_train),np.array(Y_train),np.array(Y_train)], epochs=_epochs, batch_size=batch_size,
verbose=1,
callbacks=[lr_decay],
validation_data=(np.array(X_val), [np.array(Y_val),np.array(Y_val),np.array(Y_val)]))
return original_hist | Digit Recognizer |
3,729,811 | path = Path(".. /input")
data_path = path/'cassava-leaf-disease-classification'<load_from_csv> | def fit_the_model_with_data(_model, _epochs, X_train, Y_train, X_val, Y_val, _cp):
original_hist = _model.fit(np.array(X_train), [np.array(Y_train),np.array(Y_train),np.array(Y_train)], epochs=_epochs, batch_size=batch_size,
verbose=0,
callbacks=[lr_decay, _cp],
validation_data=(np.array(X_val), [np.array(Y_val),np.arr... | Digit Recognizer |
3,729,811 | test_df = pd.read_csv(data_path/'sample_submission.csv')
test_df.head()<prepare_output> | from sklearn.model_selection import KFold
import numpy as np | Digit Recognizer |
3,729,811 | test_copy = test_df.copy()
test_copy['image_id'] = test_copy['image_id'].apply(lambda x: f'test_images/{x}' )<train_model> | X = np.copy(train_np_n)
y = np.copy(train_label_np)
kf = KFold(n_splits=4,shuffle=True)
kf.get_n_splits(X)
print(kf ) | Digit Recognizer |
3,729,811 | test_dl = learn.dls.test_dl(test_copy )<predict_on_test> | _i = 0
for train_index, val_index in kf.split(X):
filepath=".. /work/kfold_cp"+str(_i)+".hdf5"
_cp = ModelCheckpoint(filepath, monitor='val_last_fc_acc', verbose=1, save_best_only=True, save_weights_only=False, mode='max', period=1)
_m = create_model2() ;
X_t, X_v = X[train_index], X[val_index]
y_t, y_v = y[train_inde... | Digit Recognizer |
3,729,811 | preds, _ = learn.get_preds(dl=test_dl )<feature_engineering> | model_cp0 = load_model(".. /work/kfold_cp0.hdf5")
model_cp1 = load_model(".. /work/kfold_cp1.hdf5")
model_cp2 = load_model(".. /work/kfold_cp2.hdf5")
model_cp3 = load_model(".. /work/kfold_cp3.hdf5" ) | Digit Recognizer |
3,729,811 | test_df['label'] = preds.argmax(dim=-1 ).numpy()<save_to_csv> | def pred_argmax(_model, _data, _label=np.array([0])) :
c_prob, c_prob1, c_prob2 = _model.predict(_data)
pred= np.argmax(c_prob, axis=1)
if len(_label)!= 1:
correct = np.argmax(_label,axis=1)
else:
correct = 0
return c_prob, pred, correct
def pred_argmax2(_model,_gen, _data, _label=np.array([0])) :
_batch_size=128
_s... | Digit Recognizer |
3,729,811 | test_df.to_csv('submission.csv', index=False )<define_variables> | X_all = train_np_n.reshape(train_np_n.shape[0], 28, 28, 1)
Y_all = to_categorical(train_label_np)
print(X_all.shape)
print(Y_all.shape)
| Digit Recognizer |
3,729,811 | package_paths = [
'.. /input/pytorch-image-models/pytorch-image-models-master'
]
for pth in package_paths:
sys.path.append(pth )<import_modules> | X0_cp_all_prob, X0_cp_all_pred, X0_cp_all_correct = pred_argmax(model_cp0, X_all,Y_all)
X1_cp_all_prob, X1_cp_all_pred, X1_cp_all_correct = pred_argmax(model_cp1, X_all,Y_all)
X2_cp_all_prob, X2_cp_all_pred, X2_cp_all_correct = pred_argmax(model_cp2, X_all,Y_all)
X3_cp_all_prob, X3_cp_all_pred, X3_cp_all_correct = p... | Digit Recognizer |
3,729,811 |
<load_from_csv> | X0_test_prob, X0_test_pred, X0_test_correct = pred_argmax(model_cp0, X_test)
X1_test_prob, X1_test_pred, X1_test_correct = pred_argmax(model_cp1, X_test)
X2_test_prob, X2_test_pred, X2_test_correct = pred_argmax(model_cp2, X_test)
X3_test_prob, X3_test_pred, X3_test_correct = pred_argmax(model_cp3, X_test)
| Digit Recognizer |
3,729,811 | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head()<set_options> | pred_info_test = np.concatenate([X0_test_pred.reshape(X0_test_pred.shape[0],1), X1_test_pred.reshape(X1_test_pred.shape[0],1), X2_test_pred.reshape(X2_test_pred.shape[0],1), X3_test_pred.reshape(X3_test_pred.shape[0],1)], axis=1)
print(pred_info_test.shape)
print(pred_info_test ) | Digit Recognizer |
3,729,811 |
def seed_everything(seed):
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
torch.backends.cudnn.benchmark = True
def get_img(path):
im_bgr = cv2.imread(path)
im_rgb = im_bgr[:, :, ::-1]... | def return_result(preds):
_c = Counter(preds)
_v = _c.most_common(1)[0][0]
_n = _c.most_common(1)[0][1]
if _n == 4 or _n ==3:
return _v
else:
return preds[DF_cp]
| Digit Recognizer |
3,729,811 |
class LeafDataset(Dataset):
def __init__(self, df, img_dir, transforms=None, include_labels=True):
super().__init__()
self.df = df
self.img_dir = img_dir
self.transforms = transforms
self.include_labels = include_labels
if include_labels:
self.labels = self.df['label'].values
def __len__(self):
return len(self.df)
d... | rdf_test = pd.DataFrame(pred_info_test ).apply(return_result, axis=1)
rdf_test | Digit Recognizer |
3,729,811 |
class LeafDiseaseClassifier(nn.Module):
def __init__(self, model_arch, num_classes, pretrained=False):
super().__init__()
self.model = timm.create_model(model_arch, pretrained=pretrained)
n_features = self.model.classifier.in_features
self.model.classifier = nn.Linear(n_features, num_classes)
def forward(self, x):
... | pred_df["label"]=rdf_test
pred_df | Digit Recognizer |
3,729,811 |
if __name__ == '__main__':
seed_everything(config['seed'])
test = pd.DataFrame()
test['image_id'] = list(os.listdir('.. /input/cassava-leaf-disease-classification/test_images/'))
test_ds = LeafDataset(test, '.. /input/cassava-leaf-disease-classification/test_images/', transforms=get_infer_transforms() , include_labe... | pred_df.to_csv('submission.csv', index=False ) | Digit Recognizer |
4,269,364 | test['label'] = np.argmax(preds, axis=1)
test.head()
test.to_csv('submission.csv', index=False )<find_best_params> | dataset=pd.read_csv('.. /input/train.csv' ) | Digit Recognizer |
4,269,364 | del model
torch.cuda.empty_cache()<load_from_csv> | y=dataset['label'] | Digit Recognizer |
4,269,364 | train=pd.read_csv(r'.. /input/bike-sharing-demand/train.csv')
test=pd.read_csv(r'.. /input/bike-sharing-demand/test.csv')
df=train.copy()
test_df=test.copy()
df.head()<feature_engineering> | X_train=dataset.iloc[:,1:] | Digit Recognizer |
4,269,364 | df['datetime'] = pd.to_datetime(df['datetime'])
test_df['datetime'] = pd.to_datetime(test_df['datetime'])
df['year'] = df['datetime'].apply(lambda x: x.year)
df['month'] = df['datetime'].apply(lambda x: x.month)
df['day'] = df['datetime'].apply(lambda x: x.day)
df['hour'] = df['datetime'].apply(lambda x: x.hour)
... | X_test=pd.read_csv('.. /input/test.csv' ) | Digit Recognizer |
4,269,364 | df = pd.get_dummies(df, columns=['year', 'month', 'day', 'hour', 'holiday', 'workingday', 'season', 'weather'])
test_df = pd.get_dummies(test_df, columns=['year', 'month', 'day', 'hour', 'holiday', 'workingday', 'season', 'weather'])
df, test_df = df.align(test_df, join='left', axis=1)
test_df = test_df.drop(['count... | X_train=X_train/255.0
X_test=X_test/255.0 | Digit Recognizer |
4,269,364 | def rmsle(y, pred):
log_y = np.log1p(y)
log_pred = np.log1p(pred)
squared_error =(log_y - log_pred)**2
rmsle = np.sqrt(np.mean(squared_error))
return rmsle<train_on_grid> | from keras.models import Sequential
from keras.layers import Dense,Dropout,Flatten,Conv2D,MaxPool2D
from keras.preprocessing.image import ImageDataGenerator
from keras.utils.np_utils import to_categorical
from sklearn.model_selection import train_test_split, cross_val_score
import itertools | Digit Recognizer |
4,269,364 | df_train_target = df['count']
df_train_features = df.drop('count',axis=1)
def print_best_params(model, params):
grid_model = GridSearchCV(
model,
param_grid = params,
cv=5,
scoring='neg_mean_squared_error')
grid_model.fit(df_train_features, df_train_target)
rmse = np.sqrt(-1*grid_model.best_score_)
print(
'{0} 5 ... | target=to_categorical(y,10 ) | Digit Recognizer |
4,269,364 | df['count'] = np.log1p(df['count'] )<train_model> | X_t, X_v, Y_t, Y_v = train_test_split(X_train, target, test_size = 0.1 ) | Digit Recognizer |
4,269,364 | x_train,x_test,y_train,y_test=train_test_split(df.drop('count',axis=1),df['count'],test_size=0.3,random_state=42)
lr_reg = LinearRegression()
lr_reg.fit(x_train, y_train)
lr_pred = lr_reg.predict(x_test)
y_test_exp = np.expm1(y_test)
lr_pred_exp = np.expm1(lr_pred)
print('LinearRegression RMSLE:', rmsle(y_test_exp... | model=Sequential()
model.add(Conv2D(filters=64,kernel_size=(7,7),padding = 'Same',
activation ='relu', input_shape =(28,28,1)) ) | Digit Recognizer |
4,269,364 | rf_model = RandomForestRegressor()
rf_model.fit(x_train, y_train)
rf_pred = rf_model.predict(x_test)
y_test_exp = np.expm1(y_test)
rf_pred_exp = np.expm1(rf_pred)
print('RandomForest RMSLE:', rmsle(y_test_exp, rf_pred_exp))<compute_test_metric> | model.add(Conv2D(filters=64,kernel_size=(7,7),padding = 'Same',
activation ='relu')) | Digit Recognizer |
4,269,364 | xgb_model = XGBRegressor(learning_rate=0.2)
xgb_model.fit(x_train, y_train)
xgb_pred = xgb_model.predict(x_test)
y_test_exp = np.expm1(y_test)
xgb_pred_exp = np.expm1(xgb_pred)
print('xgboost RMSLE:', rmsle(y_test_exp, xgb_pred_exp))<import_modules> | model.add(MaxPool2D(pool_size=(2,2)) ) | Digit Recognizer |
4,269,364 | lgb_params = {
'learning_rate' : [0.05],
'n_estimators':[500],
'max_bin' : [80],
}
lgb_model = LGBMRegressor()
lgb_model.fit(x_train, y_train)
lgb_pred = lgb_model.predict(x_test)
y_test_exp = np.expm1(y_test)
lgb_pred_exp = np.expm1(lgb_pred)
print('LGBMRegressor RMSLE:', rmsle(y_test_exp,lgb_pred_exp))
lgb_estima... | model.add(Dropout(0.3)) | Digit Recognizer |
4,269,364 | X_train = df.drop(['count'], axis=1)
y_train = df['count']
X_test = test_df
X_test<load_from_csv> | model.add(Conv2D(filters = 128, kernel_size =(3,3),padding = 'Same',
activation ='relu'))
model.add(Conv2D(filters = 128, kernel_size =(3,3),padding = 'Same',
activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)) ) | Digit Recognizer |
4,269,364 | lgb_model = LGBMRegressor()
lgb_model.fit(X_train, y_train)
pred = lgb_model.predict(X_test)
pred_exp = np.expm1(pred)
submission = pd.read_csv('.. /input/bike-sharing-demand/sampleSubmission.csv')
submission.loc[:, 'count'] = pred_exp
submission<save_to_csv> | model.add(Dropout(0.3))
model.add(Flatten())
model.add(Dense(512, activation = "relu", use_bias= True))
model.add(Dropout(0.5))
model.add(Dense(10, activation = "softmax")) | Digit Recognizer |
4,269,364 | submission.to_csv('submission.csv', index=False )<save_to_csv> | model.compile(optimizer = 'adam' , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
4,269,364 | submission.to_csv('submission.csv', index=False )<set_options> | datagen = ImageDataGenerator(
rotation_range=10,
zoom_range = 0.2,
width_shift_range=0.2,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(X_t ) | Digit Recognizer |
4,269,364 | warnings.filterwarnings('always')
warnings.filterwarnings('ignore')
style.use('fivethirtyeight')
sns.set(style='whitegrid',color_codes=True)
<load_from_csv> | model.fit_generator(datagen.flow(X_t,Y_t, batch_size= 82),
epochs = 60, validation_data =(X_v,Y_v),
verbose = 2, steps_per_epoch=X_t.shape[0] // 82)
| Digit Recognizer |
4,269,364 | train=pd.read_csv(r'.. /input/bike-sharing-demand/train.csv')
test=pd.read_csv(r'.. /input/bike-sharing-demand/test.csv')
df=train.copy()
test_df=test.copy()
df.head()<count_values> | ewsult=model.predict(X_test ) | Digit Recognizer |
4,269,364 | df.season.value_counts()<count_values> | ewsult=np.argmax(ewsult,axis=1 ) | Digit Recognizer |
4,269,364 | df.holiday.value_counts()
<count_values> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),ewsult],axis = 1)
submission.to_csv("cnnmodel.csv",index=False ) | Digit Recognizer |
3,809,504 | df.workingday.value_counts()
<count_values> | x_train = pd.read_csv('.. /input/train.csv')
x_train.head() | Digit Recognizer |
3,809,504 | df.weather.value_counts()
<categorify> | dim_x = 28
dim_y = 28
batch_size=32
x_train.shape
y_train = np.array(x_train['label'])
x_train.drop('label', axis = 1, inplace = True)
x_train = np.array(x_train.values)
print("data shapes", x_train.shape, y_train.shape, "classes: ",len(np.unique(y_train)))
classes = len(np.unique(y_train))
x_train = x_train.reshap... | Digit Recognizer |
3,809,504 | season=pd.get_dummies(df['season'],prefix='season')
df=pd.concat([df,season],axis=1)
df.head()
season=pd.get_dummies(test_df['season'],prefix='season')
test_df=pd.concat([test_df,season],axis=1)
test_df.head()<categorify> | no_validation = int(0.1 *(x_train.shape[0]))
x_val = x_train[0:no_validation,...]
y_val = y_train[0:no_validation,...]
x_train = x_train[no_validation:,...]
y_train = y_train[no_validation:,...]
print(x_train.shape, y_train.shape, x_val.shape, y_val.shape)
train_datagen = ImageDataGenerator(rescale = 1./255,\
rotation... | Digit Recognizer |
3,809,504 | weather=pd.get_dummies(df['weather'],prefix='weather')
df=pd.concat([df,weather],axis=1)
df.head()
weather=pd.get_dummies(test_df['weather'],prefix='weather')
test_df=pd.concat([test_df,weather],axis=1)
test_df.head()<drop_column> | model = Sequential()
model.add(Conv2D(filters=96, kernel_size=(5,5), strides=1,input_shape=(dim_x,dim_y,1), activation=tf.nn.relu))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Conv2D(filters=256, kernel_size=(5,5), strides=1, activation=tf.nn.relu))
model.add(Conv2D(filters=384, kernel_size=(3,3), strides... | Digit Recognizer |
3,809,504 | df.drop(['season','weather'],inplace=True,axis=1)
df.head()
test_df.drop(['season','weather'],inplace=True,axis=1)
test_df.head()<feature_engineering> | def learning_schedule(epoch):
if epoch <= 1:
lr = 3e-4
elif epoch <= 10:
lr = 1e-5
elif epoch <= 50:
lr = 3e-6
elif epoch <= 150:
lr = 1e-6
else:
lr = 1e-8
return lr
lrate = LearningRateScheduler(learning_schedule)
early = EarlyStopping(monitor='val_acc', min_delta=0, patience=600, verbose=1, mode='auto' ) | Digit Recognizer |
3,809,504 | df["hour"] = [t.hour for t in pd.DatetimeIndex(df.datetime)]
df["day"] = [t.dayofweek for t in pd.DatetimeIndex(df.datetime)]
df["month"] = [t.month for t in pd.DatetimeIndex(df.datetime)]
df['year'] = [t.year for t in pd.DatetimeIndex(df.datetime)]
df['year'] = df['year'].map({2011:0, 2012:1})
df.head()
test_df["hour... | steps_per_epoch = int(len(y_train)/batch_size)
max_epochs = 4096
history = model.fit_generator(generator=train_generator,\
steps_per_epoch=steps_per_epoch,\
validation_data=val_generator,\
validation_steps=50,\
epochs=max_epochs,\
callbacks=[early, lrate],\
verbose=2 ) | Digit Recognizer |
3,809,504 | df.drop('datetime',axis=1,inplace=True)
df.head()<drop_column> | x_test = pd.read_csv('.. /input/test.csv')
x_test.head()
x_test = np.array(x_test.values)
x_test = x_test / 255.
print("data shape", x_test.shape)
x_test = x_test.reshape(( -1, dim_x,dim_y,1))
| Digit Recognizer |
3,809,504 | df.drop(['casual','registered'],axis=1,inplace=True )<feature_engineering> | y_pred = model.predict(x_test ) | Digit Recognizer |
3,809,504 | df.drop(['month'],inplace=True,axis=1)
test_df.drop(['month'],inplace=True,axis=1)
df['holiday'] = df['holiday']
df['workingday'] = df['workingday']<filter> | results = np.argmax(y_pred,axis = 1)
results = pd.Series(results,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("cnn_mnist_datagen.csv",index=False ) | Digit Recognizer |
4,996,129 | df[(df.atemp-df.temp ).abs() >10]<train_model> | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv')
print(train.shape)
print(test.shape)
n_train_img = train.shape[0]
MAX_LR=3e-3
VALID_PCT=3000/n_train_img
VALID_PCT=.1
VALID_PCT | Digit Recognizer |
4,996,129 | line_fitter = LinearRegression()
line_fitter.fit(df['temp'].values.reshape(-1,1), df['atemp'].values.reshape(-1,1))<predict_on_test> | class ArrayDataset(Dataset):
"Sample numpy array dataset"
def __init__(self, x, y):
self.x, self.y = x, y
self.c = 10
def __len__(self):
return len(self.x)
def __getitem__(self, i):
return self.x[i], self.y[i]
def reshape_and_normalize(arr):
return arr.astype(np.float32 ).reshape([-1, 1, 28, 28])/255.0
def conv2(ni,nf... | Digit Recognizer |
4,996,129 | pred_result = line_fitter.predict(df[(df.atemp-df.temp ).abs() >10]['temp'].values.reshape(-1,1))<find_best_model_class> | %%time
data = prepare_dataset(train, test)
learn = create_learner(data, create_nn())
learn.fit_one_cycle(1, max_lr=MAX_LR)
learn.lr_find(end_lr=10)
learn.recorder.plot() | Digit Recognizer |
4,996,129 | df.columns.to_series().groupby(df.dtypes ).groups
x_train,x_test,y_train,y_test=train_test_split(df.drop('count',axis=1),df['count'],test_size=0.25,random_state=42)
models=[RandomForestRegressor() ]
model_names=['RandomForestRegressor']
rmsle=[]
d={}
for model in range(len(models)) :
clf=models[model]
clf.fit(x_train,... | def prepare_dataset(train, test):
X = reshape_and_normalize(train.drop('label', axis=1 ).values)
y = train.label.values
train_x, valid_x, train_y, valid_y = train_test_split(X, y,test_size=VALID_PCT)
test_x = reshape_and_normalize(test.values)
train_ds, valid_ds = ArrayDataset(train_x, train_y), ArrayDataset(valid_x... | Digit Recognizer |
4,996,129 | no_of_test=[500]
params_dict={'n_estimators':no_of_test,'n_jobs':[-1],'max_features':["auto",'sqrt','log2']}
clf_rf=GridSearchCV(estimator=RandomForestRegressor() ,param_grid=params_dict,scoring='neg_mean_squared_log_error')
clf_rf.fit(x_train,y_train)
pred=clf_rf.predict(x_test)
print(( np.sqrt(mean_squared_log_err... | tfms = get_transforms(do_flip=False)
len(tfms)
tfms
| Digit Recognizer |
4,996,129 | clf_rf.best_params_<save_to_csv> | %%time
data = ImageDataBunch.from_folder('png/train',
bs=100,
ds_tfms=tfms,
valid_pct=VALID_PCT
)
data.add_test(ImageList.from_df(test_df, '.'))
data.normalize()
data | Digit Recognizer |
4,996,129 | pred=clf_rf.predict(test_df.drop('datetime',axis=1))
d={'datetime':test['datetime'],'count':pred}
ans=pd.DataFrame(d)
ans.to_csv('answer.csv',index=False )<load_from_csv> | data.show_batch(figsize=(7,6)) | Digit Recognizer |
4,996,129 | !unzip.. /input/jigsaw-toxic-comment-classification-challenge/train.csv.zip
!unzip.. /input/jigsaw-toxic-comment-classification-challenge/test.csv.zip
!unzip.. /input/jigsaw-toxic-comment-classification-challenge/test_labels.csv.zip
!unzip.. /input/jigsaw-toxic-comment-classification-challenge/sample_submission.csv.zip... | %%time
learn1 = create_learner(data, create_nn(3))
learn1.fit_one_cycle(1, max_lr=MAX_LR)
learn1.lr_find(end_lr=10)
learn1.recorder.plot() | Digit Recognizer |
4,996,129 | TRAIN = './train.csv'
TEST = './test.csv'
TEST_LABEL = './test_labels.csv'
SAMPLE = './sample_submission.csv'
EPOCHS = 2
MAX_TOKEN_COUNT = 128
BATCH_SIZE = 32<set_options> | learn1.fit_one_cycle(100, max_lr=MAX_LR)
learn1.recorder.plot() | Digit Recognizer |
4,996,129 | %matplotlib inline
%config InlineBackend.figure_format='retina'
RANDOM_SEED = 42
sns.set(style='whitegrid', palette='muted', font_scale=1.2)
HAPPY_COLORS_PALETTE = ["
sns.set_palette(sns.color_palette(HAPPY_COLORS_PALETTE))
rcParams['figure.figsize'] = 12, 8
pl.seed_everything(RANDOM_SEED )<load_from_csv> | %%time
learn2 = cnn_learner(data,
models.resnet50,
metrics=[accuracy], callback_fns=get_callbacks())
learn2.fit_one_cycle(1, max_lr=MAX_LR)
learn2.lr_find(end_lr=10)
learn2.recorder.plot() | Digit Recognizer |
4,996,129 | df = pd.read_csv(TRAIN)
test_df = pd.read_csv(TEST)
test_label = pd.read_csv(TEST_LABEL)
sample_sub = pd.read_csv(SAMPLE)
df.describe()<split> | %%time
learn2.fit_one_cycle(100, max_lr=MAX_LR)
learn2.recorder.plot() | Digit Recognizer |
4,996,129 | <create_dataframe><EOS> | !rm -Rf png | Digit Recognizer |
3,605,350 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<load_pretrained> | import numpy as np
import pandas as pd
from IPython.display import Image
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from tensorflow.python import keras
from tensorflow.python.keras.models import Sequential
from tensorflow.python.keras.layers import Dense, Flatten, Conv2D, Dropo... | Digit Recognizer |
3,605,350 | BERT_MODEL_NAME = 'bert-base-cased'
tokenizer = BertTokenizer.from_pretrained(BERT_MODEL_NAME )<create_dataframe> | digit_data = pd.read_csv('.. /input/train.csv')
digit_data.head(5 ) | Digit Recognizer |
3,605,350 | train_dataset = ToxicCommentsDataset(
train_df,
tokenizer,
max_token_len=MAX_TOKEN_COUNT
)
val_dataset = ToxicCommentsDataset(
val_df,
tokenizer,
max_token_len=MAX_TOKEN_COUNT
)
<create_dataframe> | img_rows, img_cols = 28,28
num_classes = 10
def data_prep_train(raw,val_frac):
num_images = int(raw.shape[0])
y_full = keras.utils.to_categorical(raw.label, num_classes)
X_as_array = raw.values[:,1:]
X_shaped_array = X_as_array.reshape(num_images, img_rows, img_cols, 1)
X_full = X_shaped_array / 255
X_train, X_val... | Digit Recognizer |
3,605,350 | test_dataset = ToxicCommentsDataset(
test_df,
tokenizer,
max_token_len=MAX_TOKEN_COUNT,
test=True
)
<load_pretrained> | def build_model(layer_sizes=[32, 32, 64, 64, 256], kernel_sizes=[5,5,3,3], activation = 'relu'):
model = Sequential()
model.add(Conv2D(layer_sizes[0], kernel_size=kernel_sizes[0], padding = 'same', input_shape=(img_rows, img_cols, 1)))
model.add(BatchNormalization())
model.add(Activation(activation))
model.add(Conv... | Digit Recognizer |
3,605,350 | train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
val_dataloader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False)
test_dataloader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False )<set_options> | 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, ) | Digit Recognizer |
3,605,350 | gc.collect()<choose_model_class> | def train_model(model, optimizer='adam', batch_size=64, epochs=1, verbose=1, callbacks=[]):
model.compile(loss=categorical_crossentropy, optimizer=optimizer, metrics=['accuracy'])
history = model.fit(datagen.flow(X_train, y_train, batch_size=batch_size),
epochs=epochs,
verbose=verbose,
validation_data=(X_val,y_val),... | Digit Recognizer |
3,605,350 | class ToxicCommentTagger(nn.Module):
def __init__(self, n_classes: int, n_training_steps=None, n_warmup_steps=None):
super().__init__()
self.bert = BertModel.from_pretrained(BERT_MODEL_NAME, return_dict=True)
self.classifier = nn.Linear(self.bert.config.hidden_size, n_classes)
self.n_training_steps = n_training_steps... | X_train, X_val, y_train, y_val = data_prep_train(digit_data,0.1)
leaky_relu = lambda x: relu(x, alpha=0.1)
optimizer = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)
lr_reduction = ReduceLROnPlateau(monitor='val_acc', patience=3, verbose=1, factor=0.5, min_lr=0.00001)
my_model = bu... | Digit Recognizer |
3,605,350 | <choose_model_class><EOS> | subm_examples = pd.read_csv('.. /input/test.csv')
X_subm = data_prep_predict(subm_examples)
y_subm = my_model.predict(X_subm)
n_rows = y_subm.shape[0]
y_subm = [np.argmax(y_subm[row,:])for row in range(n_rows)]
output = pd.DataFrame({'ImageId': range(1,n_rows+1), 'Label': y_subm})
output.to_csv('submission.csv', in... | Digit Recognizer |
3,946,383 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<define_variables> | import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader, sampler
from torchvision import transforms
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import time
from random import shuffle, randint
from PIL import Image
import math | Digit Recognizer |
3,946,383 | N_EPOCHS = EPOCHS
steps_per_epoch=len(train_df)// BATCH_SIZE
total_training_steps = steps_per_epoch * N_EPOCHS
warmup_steps = total_training_steps // 5
warmup_steps, total_training_steps<choose_model_class> | class DigitDataset(Dataset):
def __init__(self, csv_file, root_dir, train=False, transform=None):
self.digit_df = pd.read_csv(root_dir + csv_file)
self.transform = transform
self.train = train
def __len__(self):
return len(self.digit_df)
def __getitem__(self, item):
if self.train:
digit = self.digit_df.iloc[item, 1... | Digit Recognizer |
3,946,383 | optimizer = AdamW(model.parameters() , lr=2e-5)
scheduler = get_linear_schedule_with_warmup(
optimizer,
num_warmup_steps=warmup_steps,
num_training_steps=total_training_steps
)<train_model> | class Regularize(object):
def __init__(self, max_pixel=255):
self.max_pixel = max_pixel
def __call__(self, digit):
assert isinstance(digit, np.ndarray)
digit = digit / self.max_pixel
return digit
class ToTensor(object):
def __call__(self, digit):
assert isinstance(digit, np.ndarray)
digit = digit.reshape(( 1, 28,... | Digit Recognizer |
3,946,383 | def train() :
model.train()
total_loss, total_accuracy = 0, 0
avg_loss = 0
total_preds=[]
for step,batch in enumerate(train_dataloader):
if step % 50 == 0 and not step == 0:
print(' Batch {:>5,} of {:>5,}.'.format(step, len(train_dataloader)))
input_ids = batch["input_ids"].to(device)
attention_mask = batch["attentio... | data_np = DigitDataset('train.csv', '.. /input/', train=True)
print("Number of Training Images: ", len(data_np))
plt.imshow(data_np[5][0], cmap='gray')
plt.show()
print("Label for the Image: ", data_np[5][1] ) | Digit Recognizer |
3,946,383 |
<train_model> | composed_transform = transforms.Compose([Regularize() , ToTensor() ])
data_torch = DigitDataset('train.csv', '.. /input/', train=True, transform=composed_transform)
dataloader = DataLoader(data_torch,
batch_size=4,
shuffle=True,
num_workers=4)
for i, data in enumerate(dataloader, 0):
digits, labels = data
print("Typ... | Digit Recognizer |
3,946,383 | def evaluate() :
print("
Evaluating...")
model.eval()
total_loss, total_accuracy = 0, 0
total_preds = []
total_labels = []
for step,batch in enumerate(val_dataloader):
if step % 50 == 0 and not step == 0:
print(' Batch {:>5,} of {:>5,}.'.format(step, len(val_dataloader)))
input_ids = batch["input_ids"].to(device)
at... | def digits_per_class(digit_df, indices):
assert isinstance(digit_df, pd.DataFrame)
assert isinstance(indices, list)
digit_num = [0 for num in range(10)]
for idx in indices:
label = digit_df.iloc[idx, 0]
digit_num[label] += 1
return digit_num | Digit Recognizer |
3,946,383 | %%time
best_valid_loss = float('inf')
train_losses=[]
valid_losses=[]
EPOCHS = 2
for epoch in range(EPOCHS):
print('
Epoch {:} / {:}'.format(epoch + 1, EPOCHS))
train_loss, _ = train()
valid_loss, _, _ = evaluate()
if valid_loss < best_valid_loss:
best_valid_loss = valid_loss
torch.save(model.state_dict() , 'saved_wei... | digit_class_num = digits_per_class(data_torch.digit_df,
[num for num in range(len(data_torch)) ])
for i, num in enumerate(digit_class_num, 0):
print("Number of Images for Digit ", i, ": ", num)
print("Overall Images: ", sum(digit_class_num)) | Digit Recognizer |
3,946,383 | def test() :
print("
Testing...")
model.eval()
total_loss, total_accuracy = 0, 0
total_preds = []
_ids = []
for step,batch in enumerate(test_dataloader):
if step % 50 == 0 and not step == 0:
print(' Batch {:>5,} of {:>5,}.'.format(step, len(test_dataloader)))
_id = batch["_id"]
input_ids = batch["input_ids"].to(devic... | def train_validate_split(digit_df, test_ratio=0.2):
assert isinstance(digit_df, pd.DataFrame)
digit_num = len(digit_df)
overall_indices = [num for num in range(digit_num)]
overall_class_num = digits_per_class(digit_df, overall_indices)
test_class_num = [int(num*test_ratio)for num in overall_class_num]
tmp_test_class... | Digit Recognizer |
3,946,383 | def evaluate_roc(probs, y_true):
preds = probs
fpr, tpr, threshold = roc_curve(y_true, preds)
roc_auc = auc(fpr, tpr)
print(f'AUC: {roc_auc:.4f}')
y_pred = np.where(preds >= 0.5, 1, 0)
accuracy = accuracy_score(y_true, y_pred)
print(f'Accuracy: {accuracy*100:.2f}%')
plt.title('Receiver Operating Characteristic'... | train_data, val_data = train_validate_split(data_torch.digit_df)
train_class_num = digits_per_class(data_torch.digit_df, train_data)
val_class_num = digits_per_class(data_torch.digit_df, val_data)
for i, num in enumerate(train_class_num, 0):
print("Number of Images for Digit ", i, "- Train: ", num, "Validate: ", val... | Digit Recognizer |
3,946,383 | avg_loss, total_preds, total_labels = evaluate()<compute_test_metric> | train_sampler = sampler.SubsetRandomSampler(train_data)
train_dataloader = DataLoader(data_torch,
batch_size=4,
shuffle=False,
sampler=train_sampler,
num_workers=4 ) | Digit Recognizer |
3,946,383 | for i, name in enumerate(LABEL_COLUMNS):
print(f"label: {name}")
evaluate_roc(total_preds[:,i]>0.5, total_labels[:,i] )<compute_test_metric> | class BasicLeNet(nn.Module):
def __init__(self):
super(BasicLeNet, self ).__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 6, 5),
nn.ReLU(inplace=True),
nn.MaxPool2d(2),
nn.Conv2d(6, 16, 5),
nn.ReLU(inplace=True),
nn.MaxPool2d(2)
)
self.classifier = nn.Sequential(
nn.Linear(16*4*4, 120),
nn.ReLU(inplace=True... | Digit Recognizer |
3,946,383 | avg_test_loss, total_test_preds, sub = test()<create_dataframe> | def training(network, criterion, optimizer, epoch_num, test=True):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("Start Training with", device, epoch_num, "overall epoch")
network.to(device)
composed_transform = transforms.Compose([Regularize() , ToTensor() ])
digit_dataset = DigitDa... | Digit Recognizer |
3,946,383 | D = pd.DataFrame()
D['id'] = sub['id']
D<data_type_conversions> | def validating(network, loader):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
correct_num = 0
total_num = 0
for i, data in enumerate(loader, 0):
digits, labels = data
total_num += labels.size(0)
digits, labels = digits.to(device), labels.to(device)
outputs = network(digits)
_, predicted =... | Digit Recognizer |
3,946,383 | D[LABEL_COLUMNS] =(sub['predictions'].cpu().numpy())
D<save_to_csv> | lenet = BasicLeNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(lenet.parameters())
lenet, batch_ita, loss_list, val_acc_list = training(lenet, criterion, optimizer, 30 ) | Digit Recognizer |
3,946,383 | D.to_csv("submission.csv", index=False )<import_modules> | class DigitDataset(Dataset):
def __init__(self, csv_file, root_dir, train=False, argument=True, transform=None):
self.digit_df = pd.read_csv(root_dir + csv_file)
self.transform = transform
self.train = train
self.argument = argument
def __len__(self):
if self.argument:
return 2 * len(self.digit_df)
else:
return len... | Digit Recognizer |
3,946,383 | import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score
from sklearn.linear_model import LogisticRegression
from tensorflow import keras
from keras import layers
from keras.callbacks import Callback
from keras.preprocessing.text import Tokenizer
from keras.... | def train_validate_split(digit_df, test_ratio=0.2, argument=True):
assert isinstance(digit_df, pd.DataFrame)
digit_num = len(digit_df)
overall_indices = [num for num in range(digit_num)]
overall_class_num = digits_per_class(digit_df, overall_indices)
test_class_num = [int(num*test_ratio)for num in overall_class_num]... | Digit Recognizer |
3,946,383 | !unzip -q "/kaggle/input/jigsaw-toxic-comment-classification-challenge/*.zip"
!dir<load_from_csv> | class EnhancedLeNet(nn.Module):
def __init__(self):
super(EnhancedLeNet, self ).__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 64, 5, padding=2),
nn.ReLU(inplace=True),
nn.Conv2d(64, 64, 5, padding=2),
nn.ReLU(inplace=True),
nn.BatchNorm2d(64),
nn.MaxPool2d(2),
nn.Conv2d(64, 128, 5, padding=2),
nn.ReLU(inplace... | Digit Recognizer |
3,946,383 | train_data_file = "train.csv"
test_data_file = "test.csv"
submission_file = "sample_submission.csv"
train_data = pd.read_csv(train_data_file)
test_data = pd.read_csv(test_data_file)
submission_result = pd.read_csv(submission_file )<define_variables> | lenet = EnhancedLeNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(lenet.parameters())
lenet, batch_ita, loss_list, val_acc_list = training(lenet, criterion, optimizer, 30 ) | Digit Recognizer |
3,946,383 | max_len = 120
embedding_dim = 300
vocabulary_size = 20000
num_tokens = vocabulary_size+1<categorify> | def testing(network):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
composed_transform = transforms.Compose([Regularize() , ToTensor() ])
digit_dataset = DigitDataset('test.csv', '.. /input/', train=False, argument=False, transform=composed_transform)
test_dataloader = DataLoader(
digit_da... | Digit Recognizer |
3,946,383 | def preprocess(corpus):
printable = set(string.printable)
corpus = ''.join(filter(lambda x: x in printable, corpus))
corpus = corpus.lower()
corpus = re.sub(r"won't", "will not", corpus)
corpus = re.sub(r"can't", "can not", corpus)
corpus = re.sub(r"ain't","is not", corpus)
corpus = re.sub(r"shan't", "shall not", c... | lenet = EnhancedLeNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(lenet.parameters())
lenet, batch_ita, loss_list, val_acc_list = training(lenet, criterion, optimizer, 50, test=False)
testing(lenet ) | Digit Recognizer |
4,188,803 | tokenizer = Tokenizer(num_words = vocabulary_size+1,\
filters='!"
0123456789',\
lower=True, split=' ')
X_train_raw = train_data["comment_text"]
X_test_raw = test_data["comment_text"]
bad_comment_cat = ['toxic', 'severe_toxic', 'obscene', 'threat',\
'insult', 'identity_hate']
Y_train = train_data[bad_comment_cat]<strin... | %matplotlib inline
np.random.seed(2)
sns.set(style='white', context='notebook', palette='deep' ) | Digit Recognizer |
4,188,803 | X_train_raw = X_train_raw.apply(lambda x: preprocess(str(x)))
X_test_raw = X_test_raw.apply(lambda x: preprocess(str(x)))
tokenizer.fit_on_texts(X_train_raw)
tokenizer.fit_on_texts(X_test_raw)
X_train = pad_sequences(tokenizer.texts_to_sequences(X_train_raw),\
maxlen = max_len, truncating = "pre")
X_test = pad_seq... | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
4,188,803 | def get_weights(embedding_vectors,embedding_dim):
global num_tokens,tokenizer
embedding_weights = np.zeros(( num_tokens,embedding_dim))
misses = 0
for word, i in tokenizer.word_index.items() :
vector = embedding_vectors.get(word)
if i>=num_tokens :
break
elif vector is not None:
embedding_weights[i] = vector
else:
if ... | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
4,188,803 | embedding_vectors_fasttext = {}
with open("/kaggle/input/fasttext-crawl-300d-2m/crawl-300d-2M.vec","r")as file:
file.readline()
for line in file:
word , vector = line.split(maxsplit=1)
vector = np.fromstring(vector,"float32",sep=" ")
embedding_vectors_fasttext[word] = vector<load_pretrained> | Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
4,188,803 | embedding_weights_fasttext = get_weights(embedding_vectors_fasttext,embedding_dim=300 )<feature_engineering> | 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 |
4,188,803 | embedding_vectors_glove = {}
with open("/kaggle/input/glove6b/glove.6B.300d.txt","r")as file:
for line in file:
word , vector = line.split(maxsplit=1)
vector = np.fromstring(vector,"float32",sep=" ")
embedding_vectors_glove[word] = vector<load_pretrained> | model_test = Sequential()
model_test.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model_test.add(MaxPool2D(pool_size=(2,2)))
model_test.add(Dropout(0.5))
model_test.add(Flatten())
model_test.add(Dense(256, activation = "relu"))
model_test.add(Dropout(0.5)... | Digit Recognizer |
4,188,803 | embedding_weights_glove = get_weights(embedding_vectors_glove,embedding_dim=300 )<choose_model_class> | optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)
model_test.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"])
epochs = 2
batch_size = 86 | Digit Recognizer |
4,188,803 | def GRU_model_glove() :
global max_len,num_tokens,embedding_weights_glove
inputs = layers.Input(shape=(max_len,))
x = layers.Embedding(input_dim=num_tokens,\
output_dim=embedding_dim,\
embeddings_initializer=keras.initializers.Constant(embedding_weights_glove),\
trainable=True )(inputs)
x = layers.SpatialDropout1D(0.3... | history = model_test.fit(X_train, Y_train, batch_size = batch_size, epochs = epochs,
validation_data =(X_val, Y_val), verbose = 2 ) | Digit Recognizer |
4,188,803 | history = GRU_model_glove.fit(x_train, y_train, epochs=2,\
batch_size=128, validation_data=(x_val,y_val))<choose_model_class> | model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model.add(BatchNormalization())
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu'))
model.add(BatchNormalization())
model.add(MaxPool2D(pool_size=... | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.