kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,481,021 | submission = pd.concat([pd.Series(range(1, 28001), name = "ImageId"), predictions], axis = 1)
submission.to_csv("MNIST_top_CNN_submission.csv", index = False )<import_modules> | new_test_data = test_data.copy() | Titanic - Machine Learning from Disaster |
11,481,021 | import numpy
import pandas
import matplotlib.pyplot as plt
from keras.utils import to_categorical
from keras.layers import Conv2D, MaxPooling2D, Dense, Flatten, Dropout
from keras.models import Sequential
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import EarlyStopping<load_from_csv> | new_train_data_cabin['Cabin_type'] = new_train_data_cabin['Cabin'].str.split(r'[0-9]' ).str[0].tolist()
new_test_data['Cabin_type'] = new_test_data['Cabin'].str.split(r'[0-9]' ).str[0].tolist() | Titanic - Machine Learning from Disaster |
11,481,021 | train_data = pandas.read_csv('.. /input/digit-recognizer/train.csv')
test_data = pandas.read_csv('.. /input/digit-recognizer/test.csv' )<prepare_x_and_y> | new_train_data_cabin['Cabin_type'].value_counts() | Titanic - Machine Learning from Disaster |
11,481,021 | train_y = to_categorical(train_data["label"])
train_x = train_data.loc[:, train_data.columns != "label"]
train_x /= 256<choose_model_class> | new_test_data['Cabin_type'].value_counts() | Titanic - Machine Learning from Disaster |
11,481,021 | callback = EarlyStopping(monitor='loss', patience=8, restore_best_weights=True )<choose_model_class> | lb1 = LabelEncoder()
new_train_data_cabin['Cabin_type'] = lb1.fit_transform(new_train_data_cabin['Cabin_type'].astype(str))
new_test_data['Cabin_type'] = lb1.fit_transform(new_test_data['Cabin_type'].astype(str)) | Titanic - Machine Learning from Disaster |
11,481,021 | model = Sequential()
model.add(Conv2D(64,(3,3), activation='relu', input_shape=(28,28, 1)))
model.add(MaxPooling2D(( 2,2)))
model.add(Conv2D(64,(3,3), activation='relu'))
model.add(MaxPooling2D(( 2,2)))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(256, activa... | new_train_data_cabin['Cabin_type'].value_counts() | Titanic - Machine Learning from Disaster |
11,481,021 | model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'] )<train_model> | new_train_data_cabin['Cabin_type'].value_counts() | Titanic - Machine Learning from Disaster |
11,481,021 | datagen = ImageDataGenerator(
rotation_range=10,
zoom_range=0.1,
width_shift_range=0.1,
height_shift_range=0.1
)
datagen.fit(train_x )<train_model> | new_train_data_cabin['Cabin_type'] = new_train_data_cabin['Cabin_type'].replace(0,11)
new_train_data_cabin['Cabin_type'] = new_train_data_cabin['Cabin_type'].replace(10,0)
new_train_data_cabin['Cabin_type'] = new_train_data_cabin['Cabin_type'].replace(11,10 ) | Titanic - Machine Learning from Disaster |
11,481,021 | history = model.fit(datagen.flow(train_x, train_y, batch_size=32), epochs=80, callbacks=[callback] )<predict_on_test> | new_test_data['Cabin_type'] = new_test_data['Cabin_type'].replace(0,11)
new_test_data['Cabin_type'] = new_test_data['Cabin_type'].replace(10,0)
new_test_data['Cabin_type'] = new_test_data['Cabin_type'].replace(11,10 ) | Titanic - Machine Learning from Disaster |
11,481,021 | test_data /= 256
test_x = test_data.values.reshape(-1, 28, 28, 1)
y_pred = model.predict(test_x)
y_pred = numpy.argmax(y_pred, axis=1)
y_pred = pandas.Series(y_pred,name='Label')
submission = pandas.concat([pandas.Series(range(1, 28001), name='ImageId'), y_pred], axis=1 )<save_to_csv> | new_train_data_cabin['Cabin_type'].value_counts() | Titanic - Machine Learning from Disaster |
11,481,021 | submission.to_csv('my_submission.csv', index=False )<load_from_csv> | new_test_data['Cabin_type'].value_counts() | Titanic - Machine Learning from Disaster |
11,481,021 | X_train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
X_test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
print('Shape of the training data: ', X_train.shape)
print('Shape of the test data: ', X_test.shape )<drop_column> | new_train_data_cabin['Family'] = new_train_data_cabin['SibSp'] + new_train_data_cabin['Parch'] + 1
new_train_data_cabin | Titanic - Machine Learning from Disaster |
11,481,021 | y_train = X_train['label']
X_train.drop(labels = ['label'], axis=1, inplace=True )<count_missing_values> | new_test_data['Family'] = new_test_data['SibSp'] + new_test_data['Parch'] + 1
new_test_data | Titanic - Machine Learning from Disaster |
11,481,021 | print('Null values in training data: ',X_train.isna().any().sum())
print('Null values in test data: ',X_test.isna().any().sum())
X_train = X_train / 255.0
X_test = X_test / 255.0<categorify> | new_test_data.drop('Name',axis=1,inplace=True)
new_test_data['Sex'] = pd.get_dummies(new_test_data['Sex'])
new_test_data | Titanic - Machine Learning from Disaster |
11,481,021 | y_train = to_categorical(y_train, num_classes=10 )<split> | len(set(test_data.Ticket)- set(test_data.Ticket ).intersection(set(new_train_data_cabin.Ticket))),len(set(test_data.Ticket)) ,len(test_data ) | Titanic - Machine Learning from Disaster |
11,481,021 | X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size = 0.1 )<choose_model_class> | group = new_train_data_cabin.groupby(['Sex'] ).agg({'Fare':['mean']})
group.columns = ['mean_fare_sex']
group.reset_index(inplace=True)
new_train_data_cabin = pd.merge(new_train_data_cabin,group,on=['Sex'], how='left')
new_train_data_cabin | Titanic - Machine Learning from Disaster |
11,481,021 | model = keras.models.Sequential([layers.Conv2D(32,(3,3), activation="relu",padding='same', input_shape=(28,28,1)) ,
layers.MaxPooling2D(2,2),
layers.Dropout(0.25),
layers.Conv2D(64,(3,3), activation="relu",padding='same'),
layers.MaxPooling2D(2,2),
layers.Dropout(0.25),
layers.Flatten() ,
layers.BatchNormalization() ,
... | group = new_test_data.groupby(['Sex'] ).agg({'Fare':['mean']})
group.columns = ['mean_fare_sex']
group.reset_index(inplace=True)
new_test_data = pd.merge(new_test_data,group,on=['Sex'], how='left')
new_test_data | Titanic - Machine Learning from Disaster |
11,481,021 | optimizer = Adam(learning_rate=0.001, epsilon=1e-07)
model.compile(optimizer = optimizer, loss = 'categorical_crossentropy', metrics=['accuracy'])
earlyStopping = EarlyStopping(monitor='val_accuracy', patience=10, verbose=0, mode='auto')
mcp = ModelCheckpoint('.mdl_wts.hdf5', save_best_only=True, monitor='val_accura... | new_train_data_cabin.drop('Ticket',axis=1, inplace=True)
new_train_data_cabin | Titanic - Machine Learning from Disaster |
11,481,021 | datagen = ImageDataGenerator(
rotation_range=5,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=5,
zoom_range=0.1)
datagen.fit(X_train )<train_model> | new_test_data.drop('Ticket',axis=1, inplace=True)
new_test_data | Titanic - Machine Learning from Disaster |
11,481,021 | Batch_size=100
Epochs = 100
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 = [earlyStopping, mcp, reduce_lr_loss] )<train_model> | new_train_data_cabin.drop('PassengerId',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
11,481,021 | model.load_weights(filepath = '.mdl_wts.hdf5')
scores = model.evaluate(X_val, y_val, callbacks = [earlyStopping, mcp, reduce_lr_loss] )<categorify> | new_test_data.drop('PassengerId',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
11,481,021 | for layer in model.layers:
if'conv' in layer.name:
filters, biases = layer.get_weights()
print('Layer: ', layer.name, filters.shape)
print('Filter size:(', filters.shape[0], ',', filters.shape[1], ')')
print('Channels in this layer: ', filters.shape[2])
print('Number of filters: ', filters.shape[3])
count = 1
plt.f... | new_train_data_cabin['Pclass'].value_counts() | Titanic - Machine Learning from Disaster |
11,481,021 | print('total number of layers',len(model.layers))<choose_model_class> | new_train_data_cabin.drop('Cabin',axis=1,inplace=True)
new_train_data_cabin | Titanic - Machine Learning from Disaster |
11,481,021 | layer_outputs = [layer.output for layer in model.layers[0:6]]
activation_model = models.Model(inputs = model.input, outputs = layer_outputs )<predict_on_test> | new_test_data.drop('Cabin',axis=1,inplace=True)
new_test_data | Titanic - Machine Learning from Disaster |
11,481,021 | img_tensor = X_test[4].reshape(-1, 28, 28, 1)
activations = activation_model.predict(img_tensor )<save_to_csv> | bins = np.linspace(min(new_test_data['Age']),max(new_test_data['Age']),4)
group_names = [1,2,3]
new_test_data['Age_binned'] = pd.cut(new_test_data['Age'],bins,labels=group_names,include_lowest=True)
new_test_data | Titanic - Machine Learning from Disaster |
11,481,021 | submissions = pd.DataFrame({"ImageId": list(range(1,len(test_pred)+1)) ,
"Label": test_pred})
submissions.to_csv("submission.csv", index=False, header=True )<install_modules> | bins = np.linspace(min(new_test_data['Fare']),max(new_test_data['Fare']),4)
group_names = [1,2,3]
new_test_data['Fare_binned'] = pd.cut(new_test_data['Fare'],bins,labels=group_names,include_lowest=True)
new_test_data | Titanic - Machine Learning from Disaster |
11,481,021 |
<import_modules> | new_train_data_cabin.duplicated().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | from fastai.vision.all import *<categorify> | new_train_data_cabin.drop_duplicates(inplace=True)
new_train_data_cabin.duplicated().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | 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... | training = new_train_data_cabin.copy()
training | Titanic - Machine Learning from Disaster |
11,481,021 | def get_x(row): return row['image_id']
def get_y(row): return row['label']<install_modules> | training.drop('C',axis=1,inplace=True)
training.drop('Q',axis=1,inplace=True)
training.drop('S',axis=1,inplace=True)
training | Titanic - Machine Learning from Disaster |
11,481,021 |
<load_pretrained> | x_data = training.drop('Survived',axis=1,inplace=False)
y_data = training[['Survived']] | Titanic - Machine Learning from Disaster |
11,481,021 | learn=load_learner(".. /input/resnext50/baseline_rsnx",cpu=False )<categorify> | x_data.drop('mean_fare_sex',axis=1,inplace = True ) | Titanic - Machine Learning from Disaster |
11,481,021 | learn = learn.to_native_fp32()<define_variables> | x_data['Age_binned']= x_data['Age_binned'].astype('int16')
x_data['Fare_binned']= x_data['Fare_binned'].astype('int16')
x_data.dtypes | Titanic - Machine Learning from Disaster |
11,481,021 | data_path=".. /input/cassava-leaf-disease-classification/"<load_from_csv> | new_test_data.drop('mean_fare_sex',axis=1,inplace = True ) | Titanic - Machine Learning from Disaster |
11,481,021 | sample_df = pd.read_csv(data_path+'sample_submission.csv')
sample_df.head()<prepare_output> | new_test_data['Age_binned']= new_test_data['Age_binned'].astype('int16')
new_test_data['Fare_binned']= new_test_data['Fare_binned'].astype('int16')
new_test_data.dtypes | Titanic - Machine Learning from Disaster |
11,481,021 | sample_copy = sample_df.copy()
sample_copy['image_id'] = sample_copy['image_id'].apply(lambda x: ".. /input/cassava-leaf-disease-classification/test_images/"+x )<train_model> | Dt = DecisionTreeClassifier()
Dt.fit(x_data,y_data)
y_pred = Dt.predict(x_data)
accuracy_score(y_data,y_pred)*100 | Titanic - Machine Learning from Disaster |
11,481,021 | test_dl = learn.dls.test_dl(sample_copy )<normalization> | rto = RandomForestClassifier(n_estimators=28)
rto.fit(x_data,y_data.values.ravel())
y_pred = rto.predict(x_data)
accuracy_score(y_data,y_pred)*100 | Titanic - Machine Learning from Disaster |
11,481,021 | preds, _ = learn.tta(dl=test_dl, n=15, beta=0 )<feature_engineering> | new_test_data['Embarked'] = lb1.fit_transform(new_test_data['Embarked'])
new_test_data | Titanic - Machine Learning from Disaster |
11,481,021 | sample_df['label'] = preds.argmax(dim=-1 ).numpy()<save_to_csv> | x_data1 = x_data.drop('Fare_binned',axis= 1,inplace= False)
x_data1 | Titanic - Machine Learning from Disaster |
11,481,021 | sample_df.to_csv('submission.csv',index=False )<load_from_csv> | new_test_data1 = new_test_data.drop('Fare_binned',axis= 1,inplace= False)
new_test_data1 | Titanic - Machine Learning from Disaster |
11,481,021 | pd.read_csv("./submission.csv" )<import_modules> | model_names = {
'svm' : {
'model': SVC(gamma='auto'),
'params': {
'C': [1,5,10,15,20,25,26,28,29,30],
'kernel' : ['rbf','linear']
}
},
'logistic_regression': {
'model': LogisticRegression(solver='liblinear',multi_class='auto'),
'params' : {
'C': [1,5,10,15,20,25,26,28,29,30],
}
},
'random_forest' : {
'model' : RandomFo... | Titanic - Machine Learning from Disaster |
11,481,021 | !nvidia-smi<install_modules> | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
11,481,021 | !pip install.. /input/timmmodels/dist/timm-0.3.4.tar<import_modules> | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
11,481,021 | import os
import cv2
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from torchvision import models
from torch.utils.data import DataLoader, Dataset
from torch.cuda import amp
import albumentations as A
from albumentations.pytorch import ToTen... | scores = []
for model_name, mp in model_names.items() :
clf = GridSearchCV(mp['model'],mp['params'],cv=5,return_train_score=False)
clf.fit(x_data1,y_data.values.ravel())
scores.append({
'model' : model_name,
'best_score' : clf.best_score_,
'best_params' : clf.best_params_
} ) | Titanic - Machine Learning from Disaster |
11,481,021 | ROOT_DIR = ".. /input/cassava-leaf-disease-classification"
TEST_DIR = ".. /input/cassava-leaf-disease-classification/test_images"<define_variables> | d=pd.DataFrame(scores,columns=['model','best_score','best_params'] ) | Titanic - Machine Learning from Disaster |
11,481,021 | class CFG:
model_name = 'tf_efficientnet_b4_ns'
img_size = 512
loadmodelpath = '/kaggle/input/cassava-bitempered-logistic-loss/bitemp-01.pth'
num_classes = 5
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu" )<choose_model_class> | bgc = BaggingClassifier(DecisionTreeClassifier() , max_samples= 0.5,max_features=1.0,n_estimators=28)
bgc.fit(x_data,y_data.values.ravel())
pred = bgc.predict(x_data)
accuracy_score(y_data,pred)*100 | Titanic - Machine Learning from Disaster |
11,481,021 | model = timm.create_model(CFG.model_name, pretrained=False)
num_features = model.classifier.in_features
model.classifier = nn.Linear(num_features, CFG.num_classes)
model.to(CFG.device);<load_pretrained> | predic1 = bgc.predict(new_test_data)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predic1})
output.to_csv('my_submission31.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
11,481,021 | model = torch.load(CFG.loadmodelpath)
model.eval()<load_from_csv> | rto1 = RandomForestClassifier(n_estimators=10)
rto1.fit(x_data,y_data.values.ravel())
y_pred = rto1.predict(x_data)
accuracy_score(y_data,y_pred)*100 | Titanic - Machine Learning from Disaster |
11,481,021 | T_DIR = TEST_DIR
t_df = pd.read_csv(f"{ROOT_DIR}/sample_submission.csv" )<create_dataframe> | predic = rto.predict(new_test_data)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predic})
output.to_csv('my_submission32.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
11,481,021 | t_data = CassavaLeafDataset(T_DIR, t_df, transforms=data_transforms["valid"])
t_loader = DataLoader(dataset=t_data, batch_size=1, num_workers=4, pin_memory=True, shuffle=False )<prepare_output> | xgb = xgb.XGBClassifier(objective ='reg:logistic', colsample_bytree = 0.3, learning_rate = 0.1,
max_depth = 5,alpha=1,n_estimators=28)
xgb.fit(x_data,y_data.values.ravel())
y_pred = xgb.predict(x_data)
accuracy_score(y_data,y_pred)*100 | Titanic - Machine Learning from Disaster |
11,481,021 | submit_df = pd.DataFrame(t_df ).copy(deep=True)
for i,(inputs, _)in enumerate(t_loader):
inputs = inputs.to(CFG.device)
outputs = model(inputs ).detach().cpu().numpy()
pred_label = np.argmax(outputs)
submit_df.iloc[i] = [t_df.iloc[i]['image_id'], pred_label]<save_to_csv> | predic3 = xgb.predict(new_test_data)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predic3})
output.to_csv('my_submission33.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
11,481,021 | submit_df.to_csv("/kaggle/working/submission.csv", index=False )<set_options> | estimator3 = []
estimator3.append(( 'svm', SVC(gamma='auto',kernel='linear',C=1)))
estimator3.append(( 'lg', LogisticRegression(solver='liblinear',multi_class='auto',C=1)))
estimator3.append(( 'rfc', RandomForestClassifier(n_estimators=28)))
estimator3.append(( 'xgb', xgb.XGBClassifier(objective ='reg:logistic', col... | Titanic - Machine Learning from Disaster |
11,481,021 | <train_model><EOS> | predic = votin.predict(new_test_data1)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predic})
output.to_csv('my_submission21.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
10,569,409 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_disk> | pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 1000)
%matplotlib inline
sns.set(style="whitegrid")
warnings.filterwarnings("ignore")
gc.collect()
SEED = 29082013
os.environ['PYTHONHASHSEED']=str(SEED)
np.random.seed(SEED)
rn.seed(SEED)
for dirname... | Titanic - Machine Learning from Disaster |
10,569,409 | with open(os.path.join(WORK_DIR, "label_num_to_disease_map.json")) as file:
print(json.dumps(json.loads(file.read()), indent=4))<load_from_csv> | train = pd.read_csv('/kaggle/input/titanic/train.csv')
display(train.head(10))
display(train.tail(10))
test = pd.read_csv('/kaggle/input/titanic/test.csv')
display(test.head(10))
sub= pd.read_csv('/kaggle/input/titanic/gender_submission.csv')
display(sub.head(3)) | Titanic - Machine Learning from Disaster |
10,569,409 | train_labels = pd.read_csv(os.path.join(WORK_DIR, "train.csv"))
train_labels.head()<define_variables> | train['Survived'].value_counts(normalize=True, dropna=False ) | Titanic - Machine Learning from Disaster |
10,569,409 | BATCH_SIZE = 8
STEPS_PER_EPOCH = len(train_labels)*0.8 / BATCH_SIZE
VALIDATION_STEPS = len(train_labels)*0.2 / BATCH_SIZE
EPOCHS = 5
TARGET_SIZE = 512<data_type_conversions> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
10,569,409 | train_labels.label = train_labels.label.astype('str')
train_datagen = ImageDataGenerator(validation_split = 0.2,
preprocessing_function = None,
rotation_range = 45,
zoom_range = 0.2,
horizontal_flip = True,
vertical_flip = True,
fill_mode = 'nearest',
shear_range = 0.1,
height_shift_range = 0.1,
width_shift_range = 0.... | train.isnull().sum() | Titanic - Machine Learning from Disaster |
10,569,409 | generator = train_datagen.flow_from_dataframe(train_labels.iloc[20:21],
directory = os.path.join(WORK_DIR, "train_images"),
x_col = "image_id",
y_col = "label",
target_size =(TARGET_SIZE, TARGET_SIZE),
batch_size = BATCH_SIZE,
class_mode = "sparse")
aug_images = [generator[0][0][0]/255 for i in range(10)]
fig, axes = ... | def null_verificator(data):
if data.isnull().any().any() :
view_info = pd.DataFrame(
pd.concat(
[data.isnull().any() ,
data.isnull().sum() ,
data.dtypes],
axis=1)
)
view_info.columns = ['Nulos', 'Cantidad', 'Tipo Col']
size = data.shape[0]
view_info['Porcentaje'] = view_info['Cantidad'].apply(
lambda x: str(np.roun... | Titanic - Machine Learning from Disaster |
10,569,409 | classes_to_predict = sorted(train_labels.label.unique())
dropout_rate = 0.3
def create_model() :
model = models.Sequential()
model.add(EfficientNetB4(include_top = False, weights = None,
input_shape =(TARGET_SIZE, TARGET_SIZE, 3)))
model.add(layers.GlobalAveragePooling2D())
model.add(Dropout(dropout_rate))
model.add... | display(null_verificator(train))
display(null_verificator(test)) | Titanic - Machine Learning from Disaster |
10,569,409 | print('Our EfficientNet CNN has %d layers' %len(model.layers))<load_pretrained> | train['Pclass'] = train['Pclass'].astype(str)
test['Pclass'] = test['Pclass'].astype(str ) | Titanic - Machine Learning from Disaster |
10,569,409 | model.load_weights('.. /input/cassava-leaf-keras-efficientnetb-baseline/best_baseline_model.h5' )<choose_model_class> | for col in ['Pclass', 'Sex', 'Embarked']:
compara = pd.concat(
[train[col].value_counts(dropna=False, normalize=True ).sort_index() ,
test[col].value_counts(dropna=False, normalize=True ).sort_index() ], axis=1
)
compara.columns = ['train-'+col, 'test-'+col]
display(compara)
del compara | Titanic - Machine Learning from Disaster |
10,569,409 | model_save = ModelCheckpoint('./EffNetB4_best_weights.h5',
save_best_only = True,
save_weights_only = True,
monitor = 'val_loss',
mode = 'min', verbose = 1)
early_stop = EarlyStopping(monitor = 'val_loss', min_delta = 0.001,
patience = 5, mode = 'min', verbose = 1,
restore_best_weights = True)
reduce_lr = ReduceLROnP... | cols_cat = ['Pclass', 'Sex', 'Embarked']
col_target = 'Survived' | Titanic - Machine Learning from Disaster |
10,569,409 | avg_acc = sum(history.history['acc'])/len(history.history['acc'])
avg_val_acc = sum(history.history['val_acc'])/len(history.history['val_acc'])
avg_loss = sum(history.history['loss'])/len(history.history['loss'])
avg_val_loss = sum(history.history['val_loss'])/len(history.history['val_loss'])
print('Training produc... | mean_age_train = train.groupby(by=['Pclass', 'Sex'])['Age'].median().reset_index()
mean_age_train.columns = ['Pclass', 'Sex', 'mean_age']
mean_age_train | Titanic - Machine Learning from Disaster |
10,569,409 | ss = pd.read_csv(os.path.join(WORK_DIR, "sample_submission.csv"))
ss<predict_on_test> | train = train.merge(mean_age_train, how='left', on=['Pclass', 'Sex'])
test = test.merge(mean_age_train, how='left', on=['Pclass', 'Sex'])
train['Age'] = train['Age'].combine_first(train['mean_age'])
test['Age'] = test['Age'].combine_first(train['mean_age'])
del train['mean_age']
del test['mean_age']
train.shape, te... | Titanic - Machine Learning from Disaster |
10,569,409 | preds = []
for image_id in ss.image_id:
image = Image.open(os.path.join(WORK_DIR, "test_images", image_id))
image = image.resize(( TARGET_SIZE, TARGET_SIZE))
image = np.expand_dims(image, axis = 0)
preds.append(np.argmax(model.predict(image)))
ss['label'] = preds
ss<save_to_csv> | mean_fare_train = train.groupby(by=['Pclass', 'Sex'])['Fare'].median().reset_index()
mean_fare_train.columns = ['Pclass', 'Sex', 'mean_fare']
test = test.merge(mean_fare_train, how='left', on=['Pclass', 'Sex'])
test['Fare'] = test['Fare'].combine_first(test['mean_fare'])
del test['mean_fare']
train.shape, test.shape | Titanic - Machine Learning from Disaster |
10,569,409 | ss.to_csv('submission.csv', index = False )<install_modules> | train['Cabin'].fillna('X', inplace=True)
test['Cabin'].fillna('X', inplace=True)
train['Cabin'].isnull().sum() , test['Cabin'].isnull().sum() | Titanic - Machine Learning from Disaster |
10,569,409 | !pip install --quiet /kaggle/input/kerasapplications
!pip install --quiet /kaggle/input/efficientnet-git<set_options> | train['Embarked'].fillna('S', inplace=True)
display(null_verificator(train))
display(null_verificator(test)) | Titanic - Machine Learning from Disaster |
10,569,409 | def seed_everything(seed=0):
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
os.environ['TF_DETERMINISTIC_OPS'] = '1'
seed = 0
seed_everything(seed)
warnings.filterwarnings('ignore' )<set_options> | train['Mr'] = train['Name'].apply(lambda _: int('Mr' in _))
test['Mr'] = test['Name'].apply(lambda _: int('Mr' in _))
train['Mrs'] = train['Name'].apply(lambda _: int('Mrs' in _))
test['Mrs'] = test['Name'].apply(lambda _: int('Mrs' in _))
train['Miss'] = train['Name'].apply(lambda _: int('Miss' in _))
test['Miss'] = t... | Titanic - Machine Learning from Disaster |
10,569,409 | try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
print(f'Running on TPU {tpu.master() }')
except ValueError:
tpu = None
if tpu:
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.experimental.initialize_tpu_system(tpu)
strategy = tf.distribute.experimental.TPUStrategy(tpu)
else:
strategy = tf.distr... | train['words_in_name'] = train['Name'].apply(lambda _: len(_.split()))
test['words_in_name'] = test['Name'].apply(lambda _: len(_.split()))
view_numeric(train, 'words_in_name', col_target ) | Titanic - Machine Learning from Disaster |
10,569,409 | BATCH_SIZE = 8 * REPLICAS
HEIGHT = 512
WIDTH = 512
CHANNELS = 3
N_CLASSES = 5
TTA_STEPS = 8<define_search_space> | del train['Name']
del test['Name'] | Titanic - Machine Learning from Disaster |
10,569,409 | def data_augment(image, label):
p_spatial = tf.random.uniform([], 0, 1.0, dtype=tf.float32)
p_rotate = tf.random.uniform([], 0, 1.0, dtype=tf.float32)
p_pixel_1 = tf.random.uniform([], 0, 1.0, dtype=tf.float32)
p_pixel_2 = tf.random.uniform([], 0, 1.0, dtype=tf.float32)
p_pixel_3 = tf.random.uniform([], 0, 1.0, dty... | display(train['Cabin'].value_counts())
display(train['Ticket'].value_counts() ) | Titanic - Machine Learning from Disaster |
10,569,409 | def get_name(file_path):
parts = tf.strings.split(file_path, os.path.sep)
name = parts[-1]
return name
def decode_image(image_data):
image = tf.image.decode_jpeg(image_data, channels=3)
image = tf.cast(image, tf.float32)/ 255.0
return image
def center_crop(image):
image = tf.reshape(image, [600, 800, CHANNELS])
h, w... | train.groupby(by=['Cabin'])['PassengerId'].size() | Titanic - Machine Learning from Disaster |
10,569,409 | model_path_list = glob.glob('/kaggle/input/cassava-leaf-disease-training-with-tpu-v2-pods/*.h5')
model_path_list.sort()
print('Models to predict:')
print(*model_path_list, sep='
' )<choose_model_class> | def decision(cabin_val, num):
if cabin_val == 'X':
return -1
elif num > 1:
return 1
else:
return 0
def detect_share(data, col_analysis, new_column):
_g = data.groupby(by=[col_analysis] ).agg({
'PassengerId': 'size',
} ).reset_index()
_g[new_column] = _g[[col_analysis, 'PassengerId']].apply(
lambda _: decision(_[0], _[... | Titanic - Machine Learning from Disaster |
10,569,409 | def model_fn(input_shape, N_CLASSES):
inputs = L.Input(shape=input_shape, name='input_image')
base_model = efn.EfficientNetB4(input_tensor=inputs,
include_top=False,
weights=None,
pooling='avg')
x = L.Dropout (.5 )(base_model.output)
output = L.Dense(N_CLASSES, activation='softmax', name='output' )(x)
model = Model... | del train['Ticket']
del test['Ticket']
del train['Cabin']
del test['Cabin'] | Titanic - Machine Learning from Disaster |
10,569,409 | files_path = f'{database_base_path}test_images/'
test_size = len(os.listdir(files_path))
test_preds = np.zeros(( test_size, N_CLASSES))
for model_path in model_path_list:
print(model_path)
K.clear_session()
model.load_weights(model_path)
if TTA_STEPS > 0:
test_ds = get_dataset(files_path, tta=True ).repeat()
ct_steps... | train['total_family'] = train['SibSp'] + train['Parch']
test['total_family'] = test['SibSp'] + test['Parch']
view_numeric(train, 'total_family', col_target ) | Titanic - Machine Learning from Disaster |
10,569,409 | submission = pd.DataFrame({'image_id': image_names, 'label': test_preds})
submission.to_csv('submission.csv', index=False)
display(submission.head() )<define_variables> | train['family_greater_than_3'] = train[['SibSp', 'Parch']].apply(lambda _: 1 if _[0] + _[1] > 3 else 0, axis=1)
test['family_greater_than_3'] = test[['SibSp', 'Parch']].apply(lambda _: 1 if _[0] + _[1] > 3 else 0, axis=1)
view_cat(train, 'family_greater_than_3', col_target ) | Titanic - Machine Learning from Disaster |
10,569,409 | Cassava_dir = ".. /input/cassava-leaf-disease-classification/"<load_pretrained> | def _range_edad(_):
if _ < 0:
return 'sin edad'
elif _ < 10:
return 'ninno'
elif _ < 20:
return 'adolescente'
elif _ < 30:
return 'joven'
elif _ < 40:
return 'adulto'
elif _ < 50:
return 'adultomayor'
else:
return 'anciano'
train['range_edad'] = train['Age'].apply(_range_edad)
test['range_edad'] = test['Age'].apply(_r... | Titanic - Machine Learning from Disaster |
10,569,409 | model = keras.models.load_model('.. /input/cassava-baseline-weights/best_weights.h5' )<create_dataframe> | y_train = train['Survived'].copy()
train = train.drop(['PassengerId', 'Survived'], axis=1)
test = test.drop(['PassengerId'], axis=1 ) | Titanic - Machine Learning from Disaster |
10,569,409 | sub = pd.DataFrame(columns=['image_id','label'] )<load_pretrained> | train = pd.get_dummies(train, drop_first=True, columns=['Sex'])
test = pd.get_dummies(test, drop_first=True, columns=['Sex'] ) | Titanic - Machine Learning from Disaster |
10,569,409 | def predict_on_batch(test_list, wpath=Cassava_dir, target_size=(380,380)) :
input_batch=[]
for IMAGE_ID in test_list:
image = tf.keras.preprocessing.image.load_img(os.path.join(wpath, "test_images",IMAGE_ID),
grayscale=False,
color_mode="rgb",
target_size=target_size,
interpolation="nearest")
input_arr = keras.preproc... | train = pd.get_dummies(train, drop_first=False)
test = pd.get_dummies(test, drop_first=False ) | Titanic - Machine Learning from Disaster |
10,569,409 | TEST_DIR = '.. /input/cassava-leaf-disease-classification/test_images/'
test_images = os.listdir(TEST_DIR)
N = len(test_images)
if N == 1:
BATCH_SIZE = 1
else:
BATCH_SIZE = 16<predict_on_test> | abs(_corr['Survived'] ).sort_values(ascending=False ) | Titanic - Machine Learning from Disaster |
10,569,409 | for batch_index in range(math.ceil(N/BATCH_SIZE)) :
if batch_index*BATCH_SIZE+BATCH_SIZE < N:
test_X = predict_on_batch(test_images[batch_index*BATCH_SIZE:batch_index*BATCH_SIZE+BATCH_SIZE])
predictions = model.predict(test_X ).argmax(axis = 1)
sub_batch = pd.DataFrame({'image_id':test_images[batch_index*BATCH_SIZE:b... | list_var_relevants = ['Age', 'SibSp', 'Fare', 'Mr', 'Mrs', 'shared_cabin', 'family_greater_than_3',
'total_family', 'words_in_name', 'Sex_male', 'Pclass_1', 'Pclass_3', 'Embarked_S',
'range_edad_joven', 'range_edad_ninno'] | Titanic - Machine Learning from Disaster |
10,569,409 | sub['label'] = sub['label'].astype('int64')
sub<save_to_csv> | c_values = list(np.logspace(-1, 0.5, 50))
print(c_values ) | Titanic - Machine Learning from Disaster |
10,569,409 | sub.to_csv('submission.csv', index = False )<define_variables> | param_grid_log = {
'penalty': ['l2'],
'C': c_values,
'class_weight': ['balanced', None],
'max_iter': [75],
'solver': ['lbfgs']
}
kfold_on_rf = StratifiedKFold(
n_splits=3,
shuffle=False,
random_state=SEED
)
model_log = LogisticRegression(random_state=SEED, n_jobs = 4 ) | Titanic - Machine Learning from Disaster |
10,569,409 | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
<import_modules> | def apply_grid(X_train, y_train, model, param_grid, kfold_):
grid = RandomizedSearchCV(
model,
{k: [v] if not isinstance(v, list)else v for k, v in param_grid.items() },
cv=kfold_,
n_jobs=-1,
scoring='accuracy',
verbose=1,
n_iter=1500
)
grid.fit(X_train, y_train)
print(grid.best_score_, end=' / ')
return grid.best... | Titanic - Machine Learning from Disaster |
10,569,409 | from glob import glob
from sklearn.model_selection import GroupKFold, StratifiedKFold
import cv2
from skimage import io
import torch
from torch import nn
import os
from datetime import datetime
import time
import random
import cv2
import torchvision
from torchvision import transforms
import pandas as pd
import numpy as... | result_0_1_train = best_model.predict(train[list_var_relevants])
acu = accuracy_score(y_train, result_0_1_train)
rec = recall_score(y_train, result_0_1_train)
print(acu, rec)
print(classification_report(y_train, result_0_1_train)) | Titanic - Machine Learning from Disaster |
10,569,409 | CFG = {
'fold_num': 5,
'seed': 719,
'model_arch': 'tf_efficientnet_b4_ns',
'img_size': 512,
'epochs': 10,
'train_bs': 32,
'valid_bs': 32,
'lr': 1e-4,
'num_workers': 4,
'accum_iter': 1,
'verbose_step': 1,
'device': 'cuda:0',
'tta': 3,
'used_epochs': [6,7,8,9],
'weights': [1,1,1,1]
}<load_from_csv> | sub['Survived'] = best_model.predict(test[list_var_relevants])
sub['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
10,569,409 | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head()<count_values> | _date = str(datetime.now() ).split('.')[0].replace('-', '_' ).replace(' ', '_' ).replace(':', '_')
sub.to_csv('result_log_lassocv_{}_{}_{}.csv'.format(
round(acu, 4),round(rec, 4),_date
), index=False ) | Titanic - Machine Learning from Disaster |
10,569,409 | train.label.value_counts()<load_from_csv> | result_prob_train = best_model.predict_proba(train[list_var_relevants])[:,1]
accuracy_score(y_train, np.array([0 if _ < 0.5 else 1 for _ in result_prob_train])) | Titanic - Machine Learning from Disaster |
10,569,409 | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head()<categorify> | optimization = differential_evolution(
lambda c: -1*accuracy_score(y_train, np.array([0 if _ < c[0] else 1 for _ in result_prob_train])) ,
[(0, 1)]
)
optimization | Titanic - Machine Learning from Disaster |
10,569,409 | class CassavaDataset(Dataset):
def __init__(
self, df, data_root, transforms=None, output_label=True
):
super().__init__()
self.df = df.reset_index(drop=True ).copy()
self.transforms = transforms
self.data_root = data_root
self.output_label = output_label
def __len__(self):
return self.df.shape[0]
def __getitem__(sel... | result_0_1_train_opt = np.array([0 if _ < optimization["x"][0] else 1 for _ in result_prob_train])
acu = accuracy_score(y_train, result_0_1_train_opt)
rec = recall_score(y_train, result_0_1_train_opt)
print(acu, rec)
print(classification_report(y_train, result_0_1_train_opt)) | Titanic - Machine Learning from Disaster |
10,569,409 | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | result_0_1_test_opt = np.array(
[0 if _ < optimization["x"][0] else 1 for _ in best_model.predict_proba(test[list_var_relevants])[:,1]]
)
sub['Survived'] = result_0_1_test_opt
sub['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
10,569,409 | <split><EOS> | _date = str(datetime.now() ).split('.')[0].replace('-', '_' ).replace(' ', '_' ).replace(':', '_')
sub.to_csv('result_loglassocv_opt_{}_{}_{}.csv'.format(
round(acu, 5),round(rec, 5),_date
), index=False ) | Titanic - Machine Learning from Disaster |
6,135,017 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | warnings.filterwarnings('ignore')
seed = 12345
np.random.seed(seed)
random.seed(seed)
pd.set_option('display.expand_frame_repr', False)
pd.set_option('max_colwidth', -1)
plt.style.use('ggplot' ) | Titanic - Machine Learning from Disaster |
6,135,017 | test['label'] = np.argmax(tst_preds, axis=1)
test.head()<save_to_csv> | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
full = train.append(test)
full.sort_values('PassengerId', inplace=True)
full.reset_index(drop=True, inplace=True ) | Titanic - Machine Learning from Disaster |
6,135,017 | test.to_csv('submission.csv', index=False )<import_modules> | full[['Last','Full']] = full['Name'].str.split(r", ",expand=True)
full[['Title','Rest']] = full['Full'].str.split(r'(?<=\.) \s',n=1, expand=True)
full[['First', 'Parenthesis', 'blank']] = full['Rest'].str.split(r"\((.*)\)", expand=True)
full['blank'].unique()
full = full.drop('blank', axis=1)
full[['drop', 'Parenth... | Titanic - Machine Learning from Disaster |
6,135,017 | import numpy as np
import pandas as pd
import os
from fastai.vision.all import *
<load_from_csv> | cab_dum = full['Cabin'].str.get_dummies(' ')
cab_occupancy =cab_dum.sum(axis=0)
occ_multiple = cab_occupancy[cab_occupancy.values>1].index
cab_cSum = cab_dum.sum(axis=1)
cab_multiple = cab_cSum[cab_cSum.values>1].index
full_cab = pd.concat([full, cab_dum.loc[:, occ_multiple]], axis=1)
df_temp = pd.DataFrame([])
fo... | Titanic - Machine Learning from Disaster |
6,135,017 | cassavaPath = '.. /input/cassava-leaf-disease-classification/'
cassavaOutputPath = './'
cassavaModelPath = '.. /input/cassavleafdiseaseclassificationpretrained/'
df = pd.read_csv(cassavaPath+'train.csv')
df['label'] = df['label'].astype(str)
df.head()<count_values> | full.Cabin = full.Cabin.str.replace('F ', 'F' ) | Titanic - Machine Learning from Disaster |
6,135,017 | df['label'].value_counts()<load_pretrained> | temp = full.groupby('Ticket' ).Cabin.nunique().sort_values(ascending=False)
print(temp.value_counts() ) | Titanic - Machine Learning from Disaster |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.