kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
554,028 | fold_number = 0
train_dataset = DatasetRetriever(
kinds=dataset[dataset['fold'] != fold_number].kind.values,
image_names=dataset[dataset['fold'] != fold_number].image_name.values,
labels=dataset[dataset['fold'] != fold_number].label.values,
transforms=get_train_transforms() ,
)
validation_dataset = DatasetRetriever(... | print(combined_train_test.groupby(['Survived', 'Embarked'])['Survived'].count())
print(combined_train_test['PassengerId'].groupby(by = combined_train_test['Embarked'] ).count().sort_values(ascending = False))
print(combined_train_test['Fare'].groupby(by = combined_train_test['Embarked'] ).mean().sort_values(ascending ... | Titanic - Machine Learning from Disaster |
554,028 | class AverageMeter(object):
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def alaska_weighted_auc(y_true, y_valid):
tpr_thresholds = [0.0, 0.4, 1.... | print(combined_train_test['Sex'].groupby(by = combined_train_test['Sex'] ).count().sort_values(ascending = False))
print(combined_train_test.groupby(['Survived', 'Sex'])['Survived'].count())
sex_dummies_df = pd.get_dummies(combined_train_test['Sex'],
prefix = combined_train_test[['Sex']].columns[0])
combined_train_te... | Titanic - Machine Learning from Disaster |
554,028 | class LabelSmoothing(nn.Module):
def __init__(self, smoothing = 0.05):
super(LabelSmoothing, self ).__init__()
self.confidence = 1.0 - smoothing
self.smoothing = smoothing
def forward(self, x, target):
if self.training:
x = x.float()
target = target.float()
logprobs = torch.nn.functional.log_softmax(x, dim = -1)
nll_l... | title_Dict = {}
title_Dict.update(dict.fromkeys(["Capt", "Col", "Major", "Dr", "Rev"], "Officer"))
title_Dict.update(dict.fromkeys(["Jonkheer", "Don", "Sir", "the Countess", "Dona", "Lady"], "Royalty"))
title_Dict.update(dict.fromkeys(["Mme", "Ms", "Mrs"], "Mrs"))
title_Dict.update(dict.fromkeys(["Mlle", "Miss"], "Miss... | Titanic - Machine Learning from Disaster |
554,028 | warnings.filterwarnings("ignore")
class Fitter:
def __init__(self, model, device, config):
self.config = config
self.epoch = 0
self.base_dir = './'
self.log_path = f'{self.base_dir}/log.txt'
self.best_summary_loss = 10**5
self.model = model
self.device = device
param_optimizer = list(self.model.named_parameters())
no... | combined_train_test['Title'] = combined_train_test['Title'].map(title_Dict)
print(combined_train_test['Title'].groupby(by = combined_train_test['Title'] ).count().sort_values(ascending = False))
title_dummies_df = pd.get_dummies(combined_train_test['Title'],
prefix = combined_train_test[['Title']].columns[0])
combine... | Titanic - Machine Learning from Disaster |
554,028 | def get_net() :
net = EfficientNet.from_pretrained('efficientnet-b2')
net._fc = nn.Linear(in_features=1408, out_features=4, bias=True)
return net
net = get_net().cuda()<train_model> | combined_train_test['Name_Length'] = combined_train_test['Name'].str.len()
print(combined_train_test['Name_Length'].groupby(by = combined_train_test['Name_Length'] ).count().sort_values(ascending = False)[:5] ) | Titanic - Machine Learning from Disaster |
554,028 | class TrainGlobalConfig:
num_workers = 4
batch_size = 16
n_epochs = 25
lr = 0.001
verbose = True
verbose_step = 1
step_scheduler = False
validation_scheduler = True
SchedulerClass = torch.optim.lr_scheduler.ReduceLROnPlateau
scheduler_params = dict(
mode='min',
factor=0.5,
patience=1,
verbose=False,
threshold=0.0001,
... | combined_train_test['Name_Length_Category'] = combined_train_test['Name_Length'].map(name_len_category)
print(combined_train_test['Name_Length_Category'].groupby(by = combined_train_test['Name_Length_Category'] ).count().sort_values(ascending = False))
le_fare = LabelEncoder()
le_fare.fit(np.array(['Very_Short_Name', ... | Titanic - Machine Learning from Disaster |
554,028 | def run_training() :
device = torch.device('cuda:0')
train_loader = torch.utils.data.DataLoader(
train_dataset,
sampler=BalanceClassSampler(labels=train_dataset.get_labels() , mode="downsampling"),
batch_size=TrainGlobalConfig.batch_size,
pin_memory=False,
drop_last=True,
num_workers=TrainGlobalConfig.num_workers,
)... | combined_train_test['First_Name'] = combined_train_test['Name'].str.extract('^ (.+?),' ).str.strip()
print(combined_train_test['First_Name'].groupby(by = combined_train_test['First_Name'] ).count().sort_values(ascending = False)[:5])
first_name_dummies_df = pd.get_dummies(combined_train_test['First_Name'],
prefix = co... | Titanic - Machine Learning from Disaster |
554,028 | run_training()<install_modules> | combined_train_test['Last_Name'] = combined_train_test['Name'].str.split("\." ).str[1].str.strip()
combined_train_test['Last_Name'] = combined_train_test['Last_Name'].str.strip("\([^)]*\)")
combined_train_test['Last_Name'].fillna(combined_train_test['Name'].str.split("\." ).str[1].str.strip())
print(combined_train_te... | Titanic - Machine Learning from Disaster |
554,028 | !pip install -q efficientnet_pytorch > /dev/null<set_options> | combined_train_test['Original_Name'] = combined_train_test['Name'].str.split("\((.*?)\)" ).str[1].str.strip ( | Titanic - Machine Learning from Disaster |
554,028 | SEED = 42
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
seed_everything(SEED )<normalization> | if(combined_train_test['Fare'].isnull().sum() != 0):
combined_train_test['Fare'] = combined_train_test[['Fare']].fillna(combined_train_test.groupby('Pclass' ).transform('mean'))
combined_train_test.info() | Titanic - Machine Learning from Disaster |
554,028 | def get_train_transforms() :
return A.Compose([
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Resize(height=512, width=512, p=1.0),
ToTensorV2(p=1.0),
], p=1.0)
def get_valid_transforms() :
return A.Compose([
A.Resize(height=512, width=512, p=1.0),
ToTensorV2(p=1.0),
], p=1.0 )<categorify> | combined_train_test['Group_Ticket'] = combined_train_test['Fare'].groupby(by = combined_train_test['Ticket'] ).transform('count')
combined_train_test['Fare'] = combined_train_test['Fare']/combined_train_test['Group_Ticket']
combined_train_test.drop(['Group_Ticket'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
554,028 | DATA_ROOT_PATH = '.. /input/alaska2-image-steganalysis'
def onehot(size, target):
vec = torch.zeros(size, dtype=torch.float32)
vec[target] = 1.
return vec
class DatasetRetriever(Dataset):
def __init__(self, kinds, image_names, labels, transforms=None):
super().__init__()
self.kinds = kinds
self.image_names = image_na... | if(sum(n == 0 for n in combined_train_test.Fare.values.flatten())> 0):
combined_train_test.loc[combined_train_test.Fare == 0, 'Fare'] = np.nan
combined_train_test['Fare'] = combined_train_test[['Fare']].fillna(combined_train_test.groupby('Pclass' ).transform('mean'))
combined_train_test['Fare'].describe() | Titanic - Machine Learning from Disaster |
554,028 | fold_number = 0
train_dataset = DatasetRetriever(
kinds=dataset[dataset['fold'] != fold_number].kind.values,
image_names=dataset[dataset['fold'] != fold_number].image_name.values,
labels=dataset[dataset['fold'] != fold_number].label.values,
transforms=get_train_transforms() ,
)
validation_dataset = DatasetRetriever(... | combined_train_test['Fare_Category'] = combined_train_test['Fare'].map(fare_category)
le_fare = LabelEncoder()
le_fare.fit(np.array(['Very_Low_Fare', 'Low_Fare', 'Med_Fare', 'High_Fare', 'Very_High_Fare']))
combined_train_test['Fare_Category'] = le_fare.transform(combined_train_test['Fare_Category'])
fare_cat_dummies... | Titanic - Machine Learning from Disaster |
554,028 | class AverageMeter(object):
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def alaska_weighted_auc(y_true, y_valid):
tpr_thresholds = [0.0, 0.4, 1.... | print(combined_train_test['Fare'].groupby(by = combined_train_test['Pclass'] ).mean())
Pclass_1_mean_fare = combined_train_test['Fare'].groupby(by = combined_train_test['Pclass'] ).mean().get([1] ).values[0]
Pclass_2_mean_fare = combined_train_test['Fare'].groupby(by = combined_train_test['Pclass'] ).mean().get([2] ).... | Titanic - Machine Learning from Disaster |
554,028 | class LabelSmoothing(nn.Module):
def __init__(self, smoothing = 0.05):
super(LabelSmoothing, self ).__init__()
self.confidence = 1.0 - smoothing
self.smoothing = smoothing
def forward(self, x, target):
if self.training:
x = x.float()
target = target.float()
logprobs = torch.nn.functional.log_softmax(x, dim = -1)
nll_l... | combined_train_test['Pclass_Fare_Category'] = combined_train_test.apply(pclass_fare_category, args=(Pclass_1_mean_fare, Pclass_2_mean_fare, Pclass_3_mean_fare), axis = 1)
print(combined_train_test['Pclass_Fare_Category'].groupby(by = combined_train_test['Pclass_Fare_Category'] ).count().sort_values(ascending = False))... | Titanic - Machine Learning from Disaster |
554,028 | warnings.filterwarnings("ignore")
class Fitter:
def __init__(self, model, device, config):
self.config = config
self.epoch = 0
self.base_dir = './'
self.log_path = f'{self.base_dir}/log.txt'
self.best_summary_loss = 10**5
self.model = model
self.device = device
param_optimizer = list(self.model.named_parameters())
no... | print(combined_train_test['Fare'].groupby(by = combined_train_test['Pclass'] ).mean().sort_values(ascending = True))
combined_train_test['Pclass'].replace([1, 2, 3],[Pclass_1_mean_fare, Pclass_2_mean_fare, Pclass_3_mean_fare], inplace = True ) | Titanic - Machine Learning from Disaster |
554,028 | def get_net() :
net = EfficientNet.from_pretrained('efficientnet-b2')
net._fc = nn.Linear(in_features=1408, out_features=4, bias=True)
return net
net = get_net().cuda()<train_model> | combined_train_test['Family_Size'] = combined_train_test['Parch'] + combined_train_test['SibSp'] + 1
print(combined_train_test['Family_Size'].groupby(by = combined_train_test['Family_Size'] ).count().sort_values(ascending = False))
combined_train_test['Family_Size_Category'] = combined_train_test['Family_Size'].map(fam... | Titanic - Machine Learning from Disaster |
554,028 | class TrainGlobalConfig:
num_workers = 4
batch_size = 16
n_epochs = 25
lr = 0.001
verbose = True
verbose_step = 1
step_scheduler = False
validation_scheduler = True
SchedulerClass = torch.optim.lr_scheduler.ReduceLROnPlateau
scheduler_params = dict(
mode='min',
factor=0.5,
patience=1,
verbose=False,
threshold=0.0001,
... | print(combined_train_test['Age'].groupby(by = combined_train_test['Title'] ).mean().sort_values(ascending = True)) | Titanic - Machine Learning from Disaster |
554,028 | def run_training() :
device = torch.device('cuda:0')
train_loader = torch.utils.data.DataLoader(
train_dataset,
sampler=BalanceClassSampler(labels=train_dataset.get_labels() , mode="downsampling"),
batch_size=TrainGlobalConfig.batch_size,
pin_memory=False,
drop_last=True,
num_workers=TrainGlobalConfig.num_workers,
)... | combined_train_test['Age_Null'] = combined_train_test['Age'].apply(lambda x: 1 if(pd.notnull(x)) else 0 ) | Titanic - Machine Learning from Disaster |
554,028 | file = open('.. /input/alaska2-public-baseline/log.txt', 'r')
for line in file.readlines() :
print(line[:-1])
file.close()<load_pretrained> | missing_age_df = pd.DataFrame(combined_train_test[['Age', 'Parch', 'Sex', 'SibSp', 'Family_Size', 'Family_Size_Category', 'Title', 'Fare']])
missing_age_df = pd.get_dummies(missing_age_df, columns = ['Title', 'Family_Size_Category', 'Sex'])
missing_age_df.shape
missing_age_df.info()
missing_age_train = missing_age_df... | Titanic - Machine Learning from Disaster |
554,028 | checkpoint = torch.load('.. /input/alaska2-public-baseline/best-checkpoint-033epoch.bin')
net.load_state_dict(checkpoint['model_state_dict']);
net.eval() ;<data_type_conversions> | combined_train_test.loc[(combined_train_test.Age.isnull()), 'Age'] = fill_missing_age(missing_age_train, missing_age_test ) | Titanic - Machine Learning from Disaster |
554,028 | class DatasetSubmissionRetriever(Dataset):
def __init__(self, image_names, transforms=None):
super().__init__()
self.image_names = image_names
self.transforms = transforms
def __getitem__(self, index: int):
image_name = self.image_names[index]
image = cv2.imread(f'{DATA_ROOT_PATH}/Test/{image_name}', cv2.IMREAD_COLOR)
... | if(sum(n < 0 for n in combined_train_test.Age.values.flatten())> 0):
combined_train_test.loc[combined_train_test.Age < 0, 'Age'] = np.nan
combined_train_test['Age'] = combined_train_test[['Age']].fillna(combined_train_test.groupby('Title' ).transform('mean')) | Titanic - Machine Learning from Disaster |
554,028 | dataset = DatasetSubmissionRetriever(
image_names=np.array([path.split('/')[-1] for path in glob('.. /input/alaska2-image-steganalysis/Test/*.jpg')]),
transforms=get_valid_transforms() ,
)
data_loader = DataLoader(
dataset,
batch_size=8,
shuffle=False,
num_workers=2,
drop_last=False,
)<prepare_output> | print(combined_train_test['Age'].groupby(by = combined_train_test['Title'] ).mean().sort_values(ascending = True)) | Titanic - Machine Learning from Disaster |
554,028 | submission_1 = pd.DataFrame(result)
submission_1.head(5 )<train_model> | combined_train_test['Age_Category'] = combined_train_test['Age'].map(age_group_cat)
le_age = LabelEncoder()
le_age.fit(np.array(['Baby', 'Toddler', 'Child', 'Teenager', 'Adult', 'Middle_Aged', 'Senior_Citizen', 'Old']))
combined_train_test['Age_Category'] = le_age.transform(combined_train_test['Age_Category'])
age_ca... | Titanic - Machine Learning from Disaster |
554,028 | class TrainGlobalConfig_2:
num_workers = 4
batch_size = 8
n_epochs = 25
lr = 0.002
verbose = True
verbose_step = 1
step_scheduler = False
validation_scheduler = True
SchedulerClass = torch.optim.lr_scheduler.ReduceLROnPlateau
scheduler_params = dict(
mode='min',
factor=0.5,
patience=1,
verbose=False,
threshold=0.0001,... | combined_train_test['Ticket_Letter'] = combined_train_test['Ticket'].str.split().str[0]
combined_train_test['Ticket_Letter'] = combined_train_test['Ticket_Letter'].apply(lambda x: np.NaN if x.isnumeric() else x)
combined_train_test['Ticket_Number'] = combined_train_test['Ticket'].apply(lambda x: pd.to_numeric(x, error... | Titanic - Machine Learning from Disaster |
554,028 | def run_training_2() :
device = torch.device('cuda:0')
train_loader = torch.utils.data.DataLoader(
train_dataset,
sampler=BalanceClassSampler(labels=train_dataset.get_labels() , mode="downsampling"),
batch_size=TrainGlobalConfig_2.batch_size,
pin_memory=False,
drop_last=True,
num_workers=TrainGlobalConfig_2.num_worke... | combined_train_test['Cabin_Letter'] = combined_train_test['Cabin'].apply(lambda x: str(x)[0] if(pd.notnull(x)) else x)
combined_train_test = pd.get_dummies(combined_train_test, columns = ['Cabin', 'Cabin_Letter'])
combined_train_test.shape | Titanic - Machine Learning from Disaster |
554,028 | results = []
for mode in range(0, 4):
dataset = DatasetSubmissionRetriever(
image_names=np.array([path.split('/')[-1] for path in glob('.. /input/alaska2-image-steganalysis/Test/*.jpg')]),
transforms=get_test_transforms(mode),
)
data_loader = DataLoader(
dataset,
batch_size=8,
shuffle=False,
num_workers=2,
drop_las... | scale_age_fare = preprocessing.StandardScaler().fit(combined_train_test[['Age', 'Fare']])
combined_train_test[['Age', 'Fare']] = scale_age_fare.transform(combined_train_test[['Age', 'Fare']] ) | Titanic - Machine Learning from Disaster |
554,028 | y_pred = net(images.cuda())
y_pred = 1 - nn.functional.softmax(y_pred, dim=1 ).data.cpu().numpy() [:,0]
result['Id'].extend(image_names)
result['Label'].extend(y_pred )<create_dataframe> | combined_train_test.drop(['Name', 'PassengerId', 'Embarked', 'Sex', 'Title', 'Fare_Category', 'Family_Size_Category', 'Age_Category', 'First_Name', 'Last_Name', 'Original_Name', 'Name_Length_Category'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
554,028 | submissions_2 = []
for mode in range(0,4):
submission = pd.DataFrame(results[mode])
submissions_2.append(submission )<save_to_csv> | train_data = combined_train_test[:891]
test_data = combined_train_test[891:]
titanic_train_data_X = train_data.drop(['Survived'], axis = 1)
titanic_train_data_y = train_data['Survived']
titanic_test_data_X = test_data.drop(['Survived'], axis = 1 ) | Titanic - Machine Learning from Disaster |
554,028 | for mode in range(0,4):
submissions_2[mode].to_csv(f'submission_{mode}.csv', index=False )<feature_engineering> | base_models = [ensemble.RandomForestClassifier(n_estimators = 750, criterion = 'gini', max_features = 'sqrt', max_depth = 3, min_samples_split = 4, min_samples_leaf = 2, n_jobs = 15, random_state = 42, verbose = 1),
ensemble.GradientBoostingClassifier(n_estimators = 900, learning_rate = 0.001, loss = 'exponential', min... | Titanic - Machine Learning from Disaster |
554,028 | submissions_2[0]['Label'] =(submissions_2[0]['Label']*3 + submissions_2[1]['Label'] + submissions_2[2]['Label'] + submissions_2[3]['Label'])/ 6<feature_engineering> | rf_est = ensemble.RandomForestClassifier(n_estimators = 750, criterion = 'gini', max_features = 'sqrt', max_depth = 3, min_samples_split = 4, min_samples_leaf = 2, n_jobs = 15, random_state = 42, verbose = 1)
gbm_est = ensemble.GradientBoostingClassifier(n_estimators = 900, learning_rate = 0.001, loss = 'exponential',... | Titanic - Machine Learning from Disaster |
554,028 | submissions_2[0]['Label'] =(submissions_2[0]['Label'] * 0.72289157 + submission_1['Label'] * 0.27710843)
submissions_2[0].head(5 )<save_to_csv> | titanic_test_data_X['Survived'] = voting_est.predict(Stacked_test ) | Titanic - Machine Learning from Disaster |
554,028 | submissions_2[0].to_csv(f'submission.csv', index=False )<import_modules> | Stacked_train_df = pd.DataFrame(Stacked_train)
Stacked_test_df = pd.DataFrame(Stacked_test)
titanic_comb_X = pd.concat([Stacked_train_df, Stacked_test_df])
titanic_comb_y = pd.concat([titanic_train_data_y, titanic_test_data_X['Survived']] ) | Titanic - Machine Learning from Disaster |
554,028 | !pip install -q efficientnet_pytorch
Compose, HorizontalFlip,
ToFloat, VerticalFlip
)
<define_variables> | rf_est = ensemble.RandomForestClassifier(n_estimators = 750, criterion = 'gini', max_features = 'sqrt', max_depth = 3, min_samples_split = 4, min_samples_leaf = 2, n_jobs = 35, random_state = 42)
gbm_est = ensemble.GradientBoostingClassifier(n_estimators = 900, learning_rate = 0.001, loss = 'exponential', min_samples_... | Titanic - Machine Learning from Disaster |
554,028 | <load_from_csv><EOS> | submission = pd.DataFrame({'PassengerId': test_data_orig.loc[:, 'PassengerId'],
'Survived': titanic_test_data_X.loc[:, 'Survived_new']})
submission.to_csv(".. /working/submission.csv", index = False ) | Titanic - Machine Learning from Disaster |
10,914,282 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
10,914,282 | class Alaska2Dataset(Dataset):
def __init__(self, df, augmentations=None, test = False):
self.data = df
self.augment = augmentations
self.test = test
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
if self.test:
fn = self.data.loc[idx][0]
else:
fn, label = self.data.loc[idx]
im = imread(fn)
if se... | train = pd.read_csv('.. /input/titanic/train.csv')
test = pd.read_csv('.. /input/titanic/test.csv')
dataset = pd.concat([train, test], ignore_index = True)
PassengerId = test['PassengerId'] | Titanic - Machine Learning from Disaster |
10,914,282 | batch_size = 24
num_workers = 8
train_dataset = Alaska2Dataset(train_df, augmentations=AUGMENTATIONS_TRAIN)
valid_dataset = Alaska2Dataset(val_df.sample(5000 ).reset_index(drop=True), augmentations=AUGMENTATIONS_TEST)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
num_workers=num_wor... | dataset = dataset.fillna(np.nan)
dataset.isnull().sum() | Titanic - Machine Learning from Disaster |
10,914,282 | class Net(nn.Module):
def __init__(self, num_classes):
super().__init__()
self.model = EfficientNet.from_name('efficientnet-b0')
self.dense_output = nn.Linear(1280, num_classes)
def forward(self, x):
feat = self.model.extract_features(x)
feat = F.avg_pool2d(feat, feat.size() [2:] ).reshape(-1, 1280)
return self.den... | dataset['Title'] = dataset['Name'].apply(lambda x:x.split(',')[1].split('.')[0].strip())
Title_Dict = {}
Title_Dict.update(dict.fromkeys(['Capt', 'Col', 'Major', 'Dr', 'Rev'], 'Officer'))
Title_Dict.update(dict.fromkeys(['Don', 'Sir', 'the Countess', 'Dona', 'Lady'], 'Royalty'))
Title_Dict.update(dict.fromkeys(['Mme',... | Titanic - Machine Learning from Disaster |
10,914,282 | loaders = {
"train": train_loader,
"valid": valid_loader
}
model = Net(num_classes=len(class_labels))
model.load_state_dict(torch.load('.. /input/alaska2trainvalsplit/epoch_5_val_loss_3.75_auc_0.833.pth'))
optimizer = torch.optim.AdamW(model.parameters() , lr=0.0003)
criterion = torch.nn.CrossEntropyLoss()
callbacks =... | age = dataset[['Age','Pclass','Sex','Title']]
age = pd.get_dummies(age)
known_age = age[age.Age.notnull() ].values
null_age = age[age.Age.isnull() ].values
x = known_age[:, 1:]
y = known_age[:, 0]
rf = RandomForestRegressor(n_jobs=-1)
rf.fit(x, y)
predictedAge = rf.predict(null_age[:, 1:])
dataset.loc[(dataset.Age.... | Titanic - Machine Learning from Disaster |
10,914,282 | runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
loaders=loaders,
num_epochs=5,
verbose=True,
callbacks=callbacks,
logdir="logs",
main_metric="auc/class_0",
minimize_metric = False,
)<create_dataframe> | dataset[dataset['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
10,914,282 | test_filenames = sorted(glob(f"{data_dir}/Test/*.jpg"))
test_df = pd.DataFrame({'ImageFileName': list(
test_filenames)}, columns=['ImageFileName'])
batch_size = 16
num_workers = 4
test_dataset = Alaska2Dataset(test_df, augmentations=AUGMENTATIONS_TEST, test=True)
test_loader = torch.utils.data.DataLoader(test_datase... | C = dataset[(dataset['Embarked']=='C')&(dataset['Pclass'] == 1)]['Fare'].median()
print(C)
S = dataset[(dataset['Embarked']=='S')&(dataset['Pclass'] == 1)]['Fare'].median()
print(S)
Q = dataset[(dataset['Embarked']=='S')&(dataset['Pclass'] == 1)]['Fare'].median()
print(Q)
dataset['Embarked'] = dataset['Embarked'].fi... | Titanic - Machine Learning from Disaster |
10,914,282 | model.load_state_dict(torch.load('logs/checkpoints/best.pth')["model_state_dict"])
model.cuda()
preds = []
for outputs in tqdm(runner.predict_loader(loader=test_loader, model=model)) :
preds.append(softmax(outputs))
preds = np.array(preds)
test_df['Id'] = test_df['ImageFileName'].apply(lambda x: x.split(os.sep)[-1])
... | dataset[dataset['Fare'].isnull() ] | Titanic - Machine Learning from Disaster |
10,914,282 | !pip install -q efficientnet_pytorch
Compose, HorizontalFlip, CLAHE, HueSaturationValue,
RandomBrightness, RandomContrast, RandomGamma, OneOf, Resize,
ToFloat, ShiftScaleRotate, GridDistortion, RandomRotate90, Cutout,
RGBShift, RandomBrightness, RandomContrast, Blur, MotionBlur, MedianBlur, GaussNoise, CoarseDropout,
I... | fare=dataset[(dataset['Embarked'] == "S")&(dataset['Pclass'] == 3)].Fare.median()
dataset['Fare']=dataset['Fare'].fillna(fare ) | Titanic - Machine Learning from Disaster |
10,914,282 | seed = 42
print(f'setting everything to seed {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<define_variables> | dataset['Surname']=dataset['Name'].apply(lambda x:x.split(',')[0].strip())
Surname_Count = dict(dataset['Surname'].value_counts())
dataset['FamilyGroup'] = dataset['Surname'].apply(lambda x:Surname_Count[x])
Female_Child_Group=dataset.loc[(dataset['FamilyGroup']>=2)&(( dataset['Age']<=12)|(dataset['Sex']=='female'))... | Titanic - Machine Learning from Disaster |
10,914,282 | data_dir = '.. /input/alaska2-image-steganalysis'
folder_names = ['JMiPOD/', 'JUNIWARD/', 'UERD/']
class_names = ['Normal', 'JMiPOD_75', 'JMiPOD_90', 'JMiPOD_95',
'JUNIWARD_75', 'JUNIWARD_90', 'JUNIWARD_95',
'UERD_75', 'UERD_90', 'UERD_95']
class_labels = { name: i for i, name in enumerate(class_names)}<load_from_csv> | Female_Child=pd.DataFrame(Female_Child_Group.groupby('Surname')['Survived'].mean().value_counts())
Female_Child.columns=['GroupCount']
Female_Child | Titanic - Machine Learning from Disaster |
10,914,282 | train_df = pd.read_csv('.. /input/alaska2trainvalsplit/alaska2_train_df.csv')
val_df = pd.read_csv('.. /input/alaska2trainvalsplit/alaska2_val_df.csv')
print(train_df.sample(10))
train_df.Label.hist()
plt.title('Distribution of Classes' )<normalization> | Male_Adult=pd.DataFrame(Male_Adult_Group.groupby('Surname')['Survived'].mean().value_counts())
Male_Adult.columns=['GroupCount']
Male_Adult | Titanic - Machine Learning from Disaster |
10,914,282 | class Alaska2Dataset(Dataset):
def __init__(self, df, augmentations=None):
self.data = df
self.augment = augmentations
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
fn, label = self.data.loc[idx]
im = cv2.imread(fn)[:, :, ::-1]
if self.augment:
im = self.augment(image=im)
return im, label
img_s... | Female_Child_Group=Female_Child_Group.groupby('Surname')['Survived'].mean()
Dead_List=set(Female_Child_Group[Female_Child_Group.apply(lambda x:x==0)].index)
print(Dead_List)
Male_Adult_List=Male_Adult_Group.groupby('Surname')['Survived'].mean()
Survived_List=set(Male_Adult_List[Male_Adult_List.apply(lambda x:x==1)].i... | Titanic - Machine Learning from Disaster |
10,914,282 | temp_df = train_df.sample(64 ).reset_index(drop=True)
train_dataset = Alaska2Dataset(temp_df, augmentations=AUGMENTATIONS_TEST)
batch_size = 64
num_workers = 0
temp_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
num_workers=num_workers, shuffle=False)
images, labels = next(iter(temp_loade... | train=dataset.loc[dataset['Survived'].notnull() ]
test=dataset.loc[dataset['Survived'].isnull() ]
test.loc[(test['Surname'].apply(lambda x:x in Dead_List)) ,'Sex'] = 'male'
test.loc[(test['Surname'].apply(lambda x:x in Dead_List)) ,'Age'] = 60
test.loc[(test['Surname'].apply(lambda x:x in Dead_List)) ,'Title'] = 'Mr'
t... | Titanic - Machine Learning from Disaster |
10,914,282 | train_dataset = Alaska2Dataset(temp_df, augmentations=AUGMENTATIONS_TRAIN)
batch_size = 64
num_workers = 0
temp_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
num_workers=num_workers, shuffle=False)
images, labels = next(iter(temp_loader))
images = images['image'].permute(0, 2, 3, 1)
max_... | dataset = pd.concat([train, test])
dataset=dataset[['Survived','Pclass','Sex','Age','Fare','Embarked','Title','FamilyLabel','Deck','TicketGroup']]
dataset=pd.get_dummies(dataset)
trainset=dataset[dataset['Survived'].notnull() ]
testset=dataset[dataset['Survived'].isnull() ].drop('Survived',axis=1)
X = trainset.value... | Titanic - Machine Learning from Disaster |
10,914,282 | class Net(nn.Module):
def __init__(self, num_classes):
super().__init__()
self.model = EfficientNet.from_pretrained('efficientnet-b0')
self.dense_output = nn.Linear(1280, num_classes)
def forward(self, x):
feat = self.model.extract_features(x)
feat = F.avg_pool2d(feat, feat.size() [2:] ).reshape(-1, 1280)
return se... | pipe=Pipeline([('select',SelectKBest(k=20)) ,
('classify', RandomForestClassifier(random_state = 10, max_features = 'sqrt')) ])
param_test = {'classify__n_estimators':list(range(20,50,2)) ,
'classify__max_depth':list(range(3,60,3)) }
gsearch = GridSearchCV(estimator = pipe, param_grid = param_test, scoring='accuracy'... | Titanic - Machine Learning from Disaster |
10,914,282 | batch_size = 8
num_workers = 8
train_dataset = Alaska2Dataset(train_df, augmentations=AUGMENTATIONS_TRAIN)
valid_dataset = Alaska2Dataset(val_df.sample(1000 ).reset_index(drop=True), augmentations=AUGMENTATIONS_TEST)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
num_workers=num_work... | select = SelectKBest(k = 20)
clf = RandomForestClassifier(random_state = 10, warm_start = True,
n_estimators = 30,
max_depth = 6,
max_features = 'sqrt')
pipeline = make_pipeline(select, clf)
pipeline.fit(X, Y ) | Titanic - Machine Learning from Disaster |
10,914,282 | def alaska_weighted_auc(y_true, y_valid):
tpr_thresholds = [0.0, 0.4, 1.0]
weights = [2, 1]
fpr, tpr, thresholds = metrics.roc_curve(y_true, y_valid, pos_label=1)
areas = np.array(tpr_thresholds[1:])- np.array(tpr_thresholds[:-1])
normalization = np.dot(areas, weights)
competition_metric = 0
for idx, weight in enume... | cv_score = model_selection.cross_val_score(pipeline, X, Y, cv= 10)
print("CV Score : Mean - %.7g | Std - %.7g " %(np.mean(cv_score), np.std(cv_score)) ) | Titanic - Machine Learning from Disaster |
10,914,282 | <create_dataframe><EOS> | predictions = pipeline.predict(testset)
submission = pd.DataFrame({"PassengerId": PassengerId, "Survived": predictions.astype(np.int32)})
submission.to_csv("submission.csv", index=False ) | Titanic - Machine Learning from Disaster |
8,651,233 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<find_best_params> | train_df = pd.read_csv('/kaggle/input/titanic/train.csv')
test_df = pd.read_csv('/kaggle/input/titanic/test.csv')
print(train_df.shape)
print(test_df.shape ) | Titanic - Machine Learning from Disaster |
8,651,233 | model.eval()
preds = []
tk0 = tqdm(test_loader)
with torch.no_grad() :
for i, im in enumerate(tk0):
inputs = im["image"].to(device)
im = inputs.flip(2)
outputs = model(im)
im = inputs.flip(3)
outputs =(0.25*outputs + 0.25*model(im))
outputs =(outputs + 0.5*model(inputs))
preds.extend(F.softmax(outputs, 1 ).cpu().n... | train_df['Dependent'] = train_df.Parch + train_df.SibSp
test_df['Dependent'] = test_df.Parch + test_df.SibSp
train_df = train_df.replace(['female','male'],[20,10])
test_df = test_df.replace(['female','male'],[20,10])
test_PassengerId = test_df.PassengerId
train_df.drop(columns=['Ticket', 'Fare', 'Cabin', 'Embarked','... | Titanic - Machine Learning from Disaster |
8,651,233 | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' )<import_modules> | train_label = train_df.Survived.to_numpy()
train_label = train_label.reshape(train_label.shape[0],1)
train_df.drop(columns=['Survived'], inplace=True ) | Titanic - Machine Learning from Disaster |
8,651,233 | from sklearn.model_selection import train_test_split<import_modules> | train_set = train_df.to_numpy()
test_set = test_df.to_numpy()
print("Training data Size : ", train_set.shape)
print("Test data Size : ", test_set.shape ) | Titanic - Machine Learning from Disaster |
8,651,233 | from sklearn.model_selection import train_test_split<prepare_x_and_y> | K.set_image_data_format('channels_last' ) | Titanic - Machine Learning from Disaster |
8,651,233 | X = train.drop('label',axis=1)
y = train['label']<feature_engineering> | def FCModel(input_shape):
X_input = Input(input_shape)
X = X_input
X = Dense(32, activation='relu', kernel_initializer=initializers.glorot_uniform(seed=0), kernel_regularizer=l2(0.001), bias_regularizer=l2(0.001))(X)
X = Dense(16, activation='relu', kernel_initializer=initializers.glorot_uniform(seed=0), kernel_regul... | Titanic - Machine Learning from Disaster |
8,651,233 | X = X/255
test = test/255<import_modules> | MyModel = FCModel(train_set.shape[1:])
MyModel.compile(optimizer = 'adam', loss = "sparse_categorical_crossentropy", metrics = ["accuracy"])
taining_result = MyModel.fit(x = train_set*0.01, y = train_label, epochs = 150, validation_split= 0.1, batch_size = 20 ) | Titanic - Machine Learning from Disaster |
8,651,233 | from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dropout, Dense, Flatten
from tensorflow.keras.callbacks import EarlyStopping<choose_model_class> | MyModel.save('TitanicPredict_SimpleNeuralNetwork.h5' ) | Titanic - Machine Learning from Disaster |
8,651,233 | early_stop = EarlyStopping(monitor='accuracy',mode='max',min_delta=0.005,verbose=7,patience=5 )<choose_model_class> | predictions = np.argmax(MyModel.predict(test_set*0.01), axis = -1 ) | Titanic - Machine Learning from Disaster |
8,651,233 | model = Sequential()
model.add(Conv2D(64, 3, activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D(( 2, 2)))
model.add(Dropout(0.5))
model.add(Conv2D(32, 3, activation='relu'))
model.add(MaxPooling2D(( 2, 2)))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(128,activation='relu'))
model.a... | myTitanicPreiction_df = pd.DataFrame()
myTitanicPreiction_df['PassengerId'] = test_PassengerId
myTitanicPreiction_df['Survived'] = pd.DataFrame(predictions)
myTitanicPreiction_df.Survived.value_counts() | Titanic - Machine Learning from Disaster |
8,651,233 | <predict_on_test><EOS> | myTitanicPreiction_df.to_csv('MyPrediction_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,481,021 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | %matplotlib inline
warnings.filterwarnings(action='once')
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Titanic - Machine Learning from Disaster |
11,481,021 | df = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv' )<feature_engineering> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
11,481,021 | df['Label'] = predictions<save_to_csv> | train_data['PassengerId'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | df.to_csv('submission.csv',line_terminator='\r
', index=False )<import_modules> | test_data['PassengerId'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Conv2D, MaxPool2D, Flatten, BatchNormalization, Dropout
from keras.callbacks import EarlyStopping, ReduceLROnPlateau
from keras.preprocessing.... | train_data['Survived'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' )<prepare_x_and_y> | train_data['Pclass'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | X_train = train.iloc[:,1:]
y_train = train.iloc[:,0]<categorify> | test_data['Pclass'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | X_train = X_train.values.reshape(-1, 28, 28, 1)/255.
test = test.values.reshape(-1, 28, 28, 1)/255.
y_train = to_categorical(y_train, 10 )<split> | train_data['Sex'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | random_seed = 0
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.1, random_state=random_seed )<choose_model_class> | test_data['Sex'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | datagen = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1
)<choose_model_class> | train_data['Age'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | model = Sequential()
model.add(Conv2D(32,(5,5), padding='same', input_shape=X_train.shape[1:], activation='relu'))
model.add(Conv2D(32,(5,5), padding='same', activation='relu'))
model.add(MaxPool2D(2,2))
model.add(Conv2D(64,(3,3), padding='same', activation='relu'))
model.add(Conv2D(64,(3,3), padding='same', activation... | test_data['Age'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'] )<train_model> | mean = train_data['Age'].mean()
train_data['Age'] = train_data['Age'].replace(np.NAN,mean ) | Titanic - Machine Learning from Disaster |
11,481,021 | EPOCHS = 20
BATCH_SIZE = 20
callback_list = [
ReduceLROnPlateau(monitor='val_loss', factor=0.25, patience=1, verbose=1, mode='auto',
min_delta=0.0001)
]
history = model.fit(datagen.flow(X_train, y_train, batch_size=BATCH_SIZE),
epochs=EPOCHS,
callbacks=callback_list,
validation_data=(X_val, y_val),
steps_per_epoch=X_t... | mean = test_data['Age'].mean()
test_data['Age'] = test_data['Age'].replace(np.NAN,mean ) | Titanic - Machine Learning from Disaster |
11,481,021 | results = model.predict(test)
results = np.argmax(results, axis=1)
results = pd.Series(results, name='Label')
submission = pd.concat([pd.Series(range(1,28001), name='ImageID'), results], axis=1)
submission.to_csv('submission.csv', index=False )<load_from_csv> | train_data['SibSp'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | pd.set_option('display.max_rows', 1000)
warnings.filterwarnings("ignore")
dftrain = pd.read_csv('.. /input/digit-recognizer/train.csv')
dftest = pd.read_csv('.. /input/digit-recognizer/test.csv' )<prepare_x_and_y> | test_data['SibSp'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | IMG_SIZE = 28
x_train = dftrain.iloc[:,1:]
x_train = x_train.values.reshape(-1, IMG_SIZE, IMG_SIZE, 1)
y_train = dftrain.iloc[:,0]
x_test = dftest
x_test = x_test.values.reshape(-1, IMG_SIZE, IMG_SIZE, 1)
x_train = x_train/255.0
x_test = x_test/255.0<split> | train_data['Parch'].isnull().sum() | 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, random_state = 42)
datagen = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1)
datagen.fit(X_train )<choose_model_class> | test_data['Parch'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | earlystopping = EarlyStopping(monitor ="val_accuracy",
mode = 'auto', patience = 30,
restore_best_weights = True)
model = Sequential()
model.add(Conv2D(128,(3, 3), input_shape = x_train.shape[1:]))
model.add(BatchNormalization())
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2), padding='same'))
... | train_data['Cabin'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True )<train_model> | test_data['Cabin'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | model.compile(optimizer = 'adam',
loss = 'sparse_categorical_crossentropy',
metrics = ['accuracy'])
EPOCHS = 1000
BATCH_SIZE=64
history = model.fit(datagen.flow(X_train, y_train), epochs=EPOCHS, batch_size=BATCH_SIZE, validation_data=(X_val, y_val), callbacks=[earlystopping] )<compute_test_metric> | train_data['Embarked'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | print("Max.Validation Accuracy: {}%".format(round(100*max(history.history['val_accuracy']), 2)) )<predict_on_test> | test_data['Embarked'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | predictions = model.predict([x_test])
solutions = []
for i in range(len(predictions)) :
solutions.append(np.argmax(predictions[i]))<save_to_csv> | train_data['Cabin'].value_counts().to_frame() | Titanic - Machine Learning from Disaster |
11,481,021 | final = pd.DataFrame()
final['ImageId']=[i+1 for i in dftest.index]
final['Label']=solutions
final.to_csv('submission.csv', index=False )<define_variables> | test_data['Cabin'].value_counts().to_frame() | Titanic - Machine Learning from Disaster |
11,481,021 | sample_sub = '.. /input/digit-recognizer/sample_submission.csv'
test = '.. /input/digit-recognizer/test.csv'
train = '.. /input/digit-recognizer/train.csv'<set_options> | train_data['Embarked'].value_counts().to_frame() | Titanic - Machine Learning from Disaster |
11,481,021 | %matplotlib inline
<load_from_csv> | new_train_data = train_data.copy() | Titanic - Machine Learning from Disaster |
11,481,021 | train_data = pd.read_csv(train)
test_data = pd.read_csv(test )<prepare_x_and_y> | new_train_data.drop('Name',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
11,481,021 | y_train = train_data ['label']
X_train = train_data.drop(labels = ["label"], axis = 1)
X_test = test_data<feature_engineering> | new_train_data['Embarked'] = new_train_data['Embarked'].replace(np.NAN,"S")
new_train_data['Embarked'].isnull().sum() | Titanic - Machine Learning from Disaster |
11,481,021 | X_train = X_train/255
X_test = X_test/255<categorify> | new_train_data['Sex'] = pd.get_dummies(new_train_data['Sex'] ) | Titanic - Machine Learning from Disaster |
11,481,021 | y_train = to_categorical(y_train, num_classes = 10 )<choose_model_class> | lb = LabelEncoder()
new_train_data['Embarked'] = lb.fit_transform(new_train_data['Embarked'])
onehotencode = OneHotEncoder(handle_unknown='ignore')
encf = pd.DataFrame(onehotencode.fit_transform(new_train_data[['Embarked']] ).toarray())
new_train_data = new_train_data.join(encf)
new_train_data.head() | 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 )<choose_model_class> | new_train_data.rename(columns={0:"C",1:"Q",2:"S"},inplace=True ) | Titanic - Machine Learning from Disaster |
11,481,021 | model = Sequential()
model.add(Conv2D(32,kernel_size=3, activation='relu', input_shape=(28,28,1)))
model.add(BatchNormalization())
model.add(Conv2D(32,kernel_size=3, activation='relu'))
model.add(BatchNormalization())
model.add(Conv2D(32,kernel_size=5, strides=2, padding='same', activation='relu'))
model.add(BatchNo... | new_train_data = new_train_data[new_train_data.Fare > 0]
new_train_data = new_train_data[new_train_data.Fare <= 300] | Titanic - Machine Learning from Disaster |
11,481,021 | model.compile(optimizer = "adam", loss = "categorical_crossentropy", metrics = ["accuracy"] )<split> | missingno.matrix(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.2, random_state = 64 )<train_model> | new_train_data['Cabin'].value_counts() | Titanic - Machine Learning from Disaster |
11,481,021 | history = model.fit_generator(datagen.flow(X_train, Y_train, batch_size = 64),
epochs = 50, steps_per_epoch = X_train.shape[0]//64, validation_data =(X_val, Y_val), verbose=1 )<predict_on_test> | test_data['Cabin'].value_counts() | Titanic - Machine Learning from Disaster |
11,481,021 | predictions = model.predict(X_test)
predictions = np.argmax(predictions, axis = 1)
predictions = pd.Series(predictions, name = "Label" )<save_to_csv> | new_train_data_cabin = new_train_data.copy() | 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.