kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
8,662,763 | def get_mat(rotation, shear, height_zoom, width_zoom, height_shift, width_shift):
rotation = math.pi * rotation / 180.
shear = math.pi * shear / 180.
c1 = tf.math.cos(rotation)
s1 = tf.math.sin(rotation)
one = tf.constant([1],dtype='float32')
zero = tf.constant([0],dtype='float32')
rotation_matrix = tf.reshape(tf... | epochs_num = 100
batch_size = 20
input_dim = len(x_train[0] ) | Titanic - Machine Learning from Disaster |
8,662,763 | def binary_focal_loss(gamma=2., alpha=.25):
def binary_focal_loss_fixed(y_true, y_pred):
pt_1 = tf.where(tf.equal(y_true, 1), y_pred, tf.ones_like(y_pred))
pt_0 = tf.where(tf.equal(y_true, 0), y_pred, tf.zeros_like(y_pred))
epsilon = K.epsilon()
pt_1 = K.clip(pt_1, epsilon, 1.- epsilon)
pt_0 = K.clip(pt_0, epsilon... | def get_model(input_dim):
model = models.Sequential()
model.add(layers.Dense(units = 7, kernel_initializer = 'lecun_uniform', activation = 'relu', input_dim = input_dim))
model.add(layers.Dense(units = 5, kernel_initializer = 'lecun_uniform', activation = 'relu'))
model.add(layers.Dense(units = 1, kernel_initializer = ... | Titanic - Machine Learning from Disaster |
8,662,763 | roc_auc = metrics.roc_auc_score(oof_target, oof_prediction)
print('Our out of folds roc auc score is: ', roc_auc )<set_options> | model = get_model(input_dim)
history = model.fit(x_train, y_train, epochs=epochs_num, batch_size=batch_size, verbose=1)
| Titanic - Machine Learning from Disaster |
8,662,763 | warnings.filterwarnings('ignore')
<load_from_csv> | predict = model.predict(x_test ) | Titanic - Machine Learning from Disaster |
8,662,763 | def seed_everything(seed):
random.seed(seed)
np.random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
SEED = 22
seed_everything(SEED)
def read_data() :
train = pd.read_csv('/kaggle/input/siim-isic-melanoma-classification/train.csv')
test = pd.read_csv('/kaggle/input/siim-isic-melanoma-classification/test.csv'... | my_submission = pd.DataFrame({
'PassengerId': test.PassengerId,
'Survived': pd.Series(predict.reshape(( 1,-1)) [0] ).round().astype(int)
})
my_submission.head() | Titanic - Machine Learning from Disaster |
8,662,763 | <install_modules><EOS> | my_submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
9,033,381 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<import_modules> | %%markdown
Titanic competition in Kaggle *https://www.kaggle.com/c/titanic/*
| Titanic - Machine Learning from Disaster |
9,033,381 | import random
import numpy as np
import pandas as pd
import torch
import PIL.Image as pil
import matplotlib.pyplot as plt
from fastai.vision import *
from efficientnet_pytorch import EfficientNet
from sklearn.model_selection import StratifiedKFold
import os<set_options> | %matplotlib inline | Titanic - Machine Learning from Disaster |
9,033,381 | warnings.filterwarnings("ignore", category=UserWarning, module="torch.nn.functional" )<install_modules> | input_path = '/kaggle/input/titanic/'
train_set = pd.read_csv(input_path+'train.csv')
test_set = pd.read_csv(input_path+'test.csv')
dataset = [train_set, test_set] | Titanic - Machine Learning from Disaster |
9,033,381 | !pip install torch==1.4.0 torchvision==0.5.0<set_options> | %%markdown
| Titanic - Machine Learning from Disaster |
9,033,381 | %reload_ext autoreload
%autoreload 2
%matplotlib inline<set_options> | def missing_values_df(df):
missing_values = df.isnull().sum().sort_values(ascending = False)
missing_values = missing_values[missing_values>0]
ratio = missing_values/len(df)*100
output_df= pd.concat([missing_values, ratio], axis=1, keys=['Total missing values', 'Percentage'])
return output_df
print('Missing values ... | Titanic - Machine Learning from Disaster |
9,033,381 | seed = 42
def random_seed(seed_value):
random.seed(seed_value)
np.random.seed(seed_value)
torch.manual_seed(seed_value)
os.environ['PYTHONHASHSEED'] = str(seed_value)
if torch.cuda.is_available() :
torch.cuda.manual_seed(seed_value)
torch.cuda.manual_seed_all(seed_value)
torch.backends.cudnn.deterministic = True
... | %%markdown
1)fill the *NaN* values with mean(*Age feature*)our more frequent values(*Embarked feature*)
2)Add *titles* of passengers from names then delete names
3)Encode categorical features into integers
4)make 4 bins of age to categorize it
5)Normalize our datasets(training_set and test_set)
6)Split our training s... | Titanic - Machine Learning from Disaster |
9,033,381 | path = '/kaggle/input/siim-isic-melanoma-classification'
path<define_variables> | for i in range(len(dataset)) :
freq_port = dataset[i]['Embarked'].dropna().mode() [0]
dataset[i]['Embarked'] = dataset[i]['Embarked'].fillna(freq_port)
dataset[i] = dataset[i].fillna(dataset[i].mean() ) | Titanic - Machine Learning from Disaster |
9,033,381 | img_path = '/kaggle/input/melanoma-merged-external-data-512x512-jpeg'
img_path<load_from_csv> | print("Titels of passengers by sex")
dataset[0]['Title'] = dataset[0].Name.str.extract('([A-Za-z]+)\.', expand=False)
display(pd.crosstab(dataset[0]['Sex'], dataset[0]['Title'])) | Titanic - Machine Learning from Disaster |
9,033,381 | train_df = pd.read_csv(img_path + '/folds_13062020.csv')
train_df.head()<load_from_csv> | for i, data in enumerate(dataset):
dataset[i]['Title'] = data.Name.str.extract('([A-Za-z]+)\.', expand=False)
dataset[i]['Title'] = data['Title'].replace(['Lady', 'Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev',
'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset[i]['Title'] = data['Title'].replace(['Mlle', 'Ms'], 'Miss... | Titanic - Machine Learning from Disaster |
9,033,381 | test_df = pd.read_csv(path + '/test.csv')
test_df.head()<load_from_csv> | encoder = LabelEncoder()
categoricalFeatures = dataset[0].select_dtypes(include=['object'] ).columns
for i, data in enumerate(dataset):
data[categoricalFeatures]=data[categoricalFeatures].astype(str)
encoded = data[categoricalFeatures].apply(encoder.fit_transform)
for j in categoricalFeatures:
dataset[i][j]=encoded[j... | Titanic - Machine Learning from Disaster |
9,033,381 | sample_df = pd.read_csv(path + '/sample_submission.csv')
sample_df.head()<feature_engineering> | bins = [0,18,60,80]
labels = [1,2,3]
for i, data in enumerate(dataset):
dataset[i] = dataset[i].drop(['PassengerId', 'Name', 'Ticket', 'Cabin'], axis=1)
dataset[i]['Age']=pd.cut(dataset[i]['Age'],bins=bins ,labels=labels)
dataset[i]['Age']=dataset[i]['Age'].astype('int64')
print('training dataset:')
display(dataset... | Titanic - Machine Learning from Disaster |
9,033,381 | tfms = get_transforms(flip_vert=True, max_rotate=15, max_zoom=1.2, max_lighting=0.3, max_warp=0, p_affine=0, p_lighting=0.8 )<compute_train_metric> | X=dataset[0].iloc[:, 1:]
Y=dataset[0].iloc[:, 0]
x_test=dataset[1].iloc[:, 0:]
normalized_data = X
normalized_data=normalized_data.append(x_test)
normalized_x_train = normalized_data.values
normalized_x_train /= np.max(np.abs(normalized_x_train),axis=0)
X = pd.DataFrame(normalized_x_train[:891,:],
columns=['Pclass', ... | Titanic - Machine Learning from Disaster |
9,033,381 | class FocalLoss(nn.Module):
def __init__(self, gamma=2., reduction='mean'):
super().__init__()
self.gamma = gamma
self.reduction = reduction
def forward(self, inputs, targets):
CE_loss = nn.CrossEntropyLoss(reduction='none' )(inputs, targets)
pt = torch.exp(-CE_loss)
F_loss =(( 1 - pt)**self.gamma)* CE_loss
if self.r... | X_train, X_val, y_train, y_val = train_test_split(X, Y, test_size = 0.20)
print("Training set shape: "+str(X_train.shape))
print("Validation set shape: "+str(X_val.shape)) | Titanic - Machine Learning from Disaster |
9,033,381 | submission_ver = '0002'
arch = [EfficientNet.from_pretrained('efficientnet-b0', num_classes=2)]
fc_size = 1280
lin_size = 1000
n_folds = 5
size = [256]
bs = 32
stage_1_epochs = 3
lr1 = [1e-1]
lr_eff_1 = [1e-3]
is_stage_2 = False
stage_2_epochs = 4
lr2 = [slice(1e-7, 1e-4)]
lr_eff_2 = [slice(1e-4, 1e-3)]
custom_loss = T... | %%markdown
1)Logistic Regression
2)Decision Tree
3)Random Forest
4)XGBoost
| Titanic - Machine Learning from Disaster |
9,033,381 | num_classes = len(np.unique(train_df['target']))
num_classes<feature_engineering> | accuracies_list = list()
accuracies = namedtuple('accuracies',('Model', 'accuracy')) | Titanic - Machine Learning from Disaster |
9,033,381 | test_df['image_name'] = '512x512-test/512x512-test/' + test_df['image_name'] + '.jpg'<create_dataframe> | %%markdown
| Titanic - Machine Learning from Disaster |
9,033,381 | test_data = ImageList.from_df(test_df, img_path)
test_data<prepare_output> | logreg = LogisticRegression()
logreg.fit(X_train, y_train)
Y_pred = logreg.predict(X_val)
acc_log = round(logreg.score(X_train, y_train)* 100, 2)
print('accuracy: {}'.format(acc_log))
accuracies_list.append(accuracies('Logistic Regression', acc_log)) | Titanic - Machine Learning from Disaster |
9,033,381 | labels_df = train_df[['image_id', 'target']].copy()
labels_df.head()<categorify> | %%markdown
| Titanic - Machine Learning from Disaster |
9,033,381 | def k_fold(df, num_fld, seed = seed):
for fold in range(num_fld):
df.loc[df.fold == fold, f'is_valid_{fold}'] = True
df.loc[df.fold != fold, f'is_valid_{fold}'] = False<concatenate> | decisiontree = DecisionTreeClassifier()
decisiontree.fit(X_train, y_train)
y_pred = decisiontree.predict(X_val)
acc_decisiontree = round(accuracy_score(y_pred, y_val)* 100, 2)
print('accuracy: {}'.format(acc_decisiontree))
accuracies_list.append(accuracies('Decision Tree', acc_decisiontree)) | Titanic - Machine Learning from Disaster |
9,033,381 | k_fold(train_df, n_folds, seed )<filter> | %%markdown
| Titanic - Machine Learning from Disaster |
9,033,381 | def oversample(fld, df, os_size, num_fld=5):
train_df_fld = df.loc[df['fold'] != fld]
valid_df_fld = df.loc[df['fold'] == fld]
train_df_md = train_df_fld.loc[train_df_fld['target'] == 1]
if os_size == 'auto':
os_size = int(np.floor(train_df_fld.loc[train_df_fld['target'] == 0]['target'].value_counts() [0]/train_df_fld.... | clf = RandomForestClassifier(max_depth=10, max_leaf_nodes =20,random_state=0)
clf.fit(X_train,y_train)
y_pred=clf.predict(X_val)
acc_random_forest = round(accuracy_score(y_pred, y_val)* 100, 2)
print('accuracy: {}'.format(acc_random_forest))
accuracies_list.append(accuracies('Random Forest', acc_random_forest)) | Titanic - Machine Learning from Disaster |
9,033,381 | def get_data(fold, size, bs, padding_mode='reflection'):
return(globals() ['src_%s' %fold].label_from_df(cols='target')
.add_test(test_data)
.transform(tfms, size=size, padding_mode=padding_mode)
.databunch(bs=bs, num_workers = num_wkrs ).normalize(imagenet_stats))<categorify> | %%markdown
| Titanic - Machine Learning from Disaster |
9,033,381 | def preds_smoothing(encodings , alpha):
K = encodings.shape[1]
y_ls =(1 - alpha)* encodings + alpha / K
return y_ls<compute_test_metric> | xgb = xgboost.XGBClassifier(random_state=5,learning_rate=0.01)
xgb.fit(X_train, y_train)
y_pred = xgb.predict(X_val)
acc_xgb = round(accuracy_score(y_pred, y_val)* 100, 2)
print('accuracy: {}'.format(acc_xgb))
accuracies_list.append(accuracies('XGBoost', acc_xgb)) | Titanic - Machine Learning from Disaster |
9,033,381 | def print_metrics(val_preds, val_labels):
targs, preds = LongTensor([]), Tensor([])
val_preds = F.softmax(val_preds, dim=1)[:,-1]
preds = torch.cat(( preds, val_preds.cpu()))
targs = torch.cat(( targs, val_labels.cpu().long()))
print('AUCROC = ' + str(auc_roc_score(preds, targs ).item()))<set_options> | %%markdown
1)Declare consts
2)Training Set && Testing Set preparation for pytorch
3)Define our DL model class
4)Instantiate our model, loss and optimizer
5)Define fit function
6)Training process
7)Define Predict Function
8)Preprare for submission
| Titanic - Machine Learning from Disaster |
9,033,381 | gc.collect()<feature_engineering> | BATCH_SIZE = 1
LEARNING_RATE = 0.001
EPOCHS = 800
INPUT_NODES = 8 | Titanic - Machine Learning from Disaster |
9,033,381 | for model in arch:
if hasattr(model, '__name__'):
model_name = model.__name__
else:
model_name = "EfficientNet"
globals() [model_name + '___val_preds'] = []
globals() [model_name + '___val_labels'] = []
globals() [model_name + '___test_preds'] = []
print(f'/////////////////////////////////////////////////////')
print(... | X_train_torch = torch.from_numpy(X_train.values ).type(torch.FloatTensor)
y_train_torch = torch.from_numpy(y_train.values ).type(torch.LongTensor)
X_val_torch = torch.from_numpy(X_val.values ).type(torch.FloatTensor)
y_val_torch = torch.from_numpy(y_val.values ).type(torch.LongTensor)
x_test_torch = torch.from_nump... | Titanic - Machine Learning from Disaster |
9,033,381 | sns.set()
sns.set_style('dark')
<define_variables> | %%markdown
Input Features --> Fully Connected layer(512 nodes)--> Dropout(50%)--> Fully Connected layer(256 nodes)--> Dropout(50%)--> Fully Connected layer(128 nodes)--> Dropout(50%)--> Fully Connected layer(1 node ) | Titanic - Machine Learning from Disaster |
9,033,381 | IS_LOCAL = False
USE_REDUCED = False
data_index = 2*int(IS_LOCAL)+ int(USE_REDUCED)
train_path =('.. /input/santander-customer-transaction-prediction/train.csv',
'.. /input/santandersmall/train_small.csv',
'train.csv',
'train_small.csv')[data_index]
test_path =('.. /input/santander-customer-transaction-prediction/test... | class Titanic_NN(nn.Module):
def __init__(self, INPUT_NODES):
super(Titanic_NN, self ).__init__()
self.fc1 = nn.Linear(INPUT_NODES,512)
self.fc2 = nn.Linear(512,256)
self.dropout = nn.Dropout(0.5)
self.fc3 = nn.Linear(256, 128)
self.fc4 = nn.Linear(128,1)
def forward(self, x):
x = self.fc1(x)
x = F.relu(x)
x =... | Titanic - Machine Learning from Disaster |
9,033,381 | features = [col for col in train_df.columns if col not in ['target', 'ID_code']]
if not 'target' in test_df:
test_df['target'] = -1
all_df = pd.concat([train_df, test_df], sort=False )<count_unique_values> | model = Titanic_NN(INPUT_NODES)
try:
model.load_state_dict(torch.load(input_path+'titanic_model_4layers'))
except:
pass
error = nn.BCELoss()
optimizer = torch.optim.SGD(model.parameters() , lr=LEARNING_RATE)
print(model ) | Titanic - Machine Learning from Disaster |
9,033,381 | unique_count = np.zeros(( test_df.shape[0], len(features)))
for f, feature in tqdm(enumerate(features), total=len(features)) :
_, i, c = np.unique(test_df[feature], return_counts=True, return_index=True)
unique_count[i[c == 1], f] += 1
real_sample_indices = np.argwhere(np.sum(unique_count, axis=1)> 0)[:, 0]
synthetic... | def fit(model, data, phase='training', batch_size = 1, is_cuda=False, input_dim = 8):
if phase == 'training':
model.train()
elif phase == 'validation':
model.eval()
loss_values = 0.0
correct_values = 0
for _,(features, label)in enumerate(data):
if is_cuda:
features, label = features.cuda() , label.cuda()
features, la... | Titanic - Machine Learning from Disaster |
9,033,381 | all_real_df = pd.concat([train_df, test_df.iloc[real_sample_indices, :]], sort=False)
for feature in tqdm(features):
real_series = all_real_df[feature]
counts = real_series.groupby(real_series ).count()
full_series = all_df[feature]
all_df[f'{feature}_count'] = full_series.map(counts)
del all_real_df
del real_series
... | train_loss_list, val_loss_list = [], []
train_accuracy_list, val_accuracy_list = [], []
for epoch in range(EPOCHS):
train_epoch_loss, train_epoch_accuracy = fit(model, data_loader, batch_size=BATCH_SIZE, input_dim=INPUT_NODES)
val_epoch_loss, val_epoch_accuracy = fit(model, val_loader, phase='validation', batch_size=B... | Titanic - Machine Learning from Disaster |
9,033,381 | for feature in tqdm(features):
all_df[feature] = StandardScaler().fit_transform(all_df[feature].values.reshape(-1, 1))
all_df[f'{feature}_count'] = MinMaxScaler().fit_transform(all_df[f'{feature}_count'].values.reshape(-1, 1))<count_values> | accuracies_list.append(accuracies('Neural Network __Validation_Set__', val_accuracy_list[-1])) | Titanic - Machine Learning from Disaster |
9,033,381 | for f in range(len(features)) :
features.append(f'{features[f]}_count' )<split> | def predict(model, data):
model.eval()
test_predictions = list()
for _,(feature,)in enumerate(data):
feature = Variable(feature.view(1, 1, INPUT_NODES))
output = model(feature)
if output[0] > 0.5:
prediction = 1
else:
prediction = 0
test_predictions.append(prediction)
return test_predictions | Titanic - Machine Learning from Disaster |
9,033,381 | train_df = all_df.iloc[:train_df.shape[0], :]
test_df = all_df.iloc[train_df.shape[0]:, :]
del all_df<choose_model_class> | pred_df = pd.DataFrame(np.c_[np.arange(892, len(test_set)+892)[:,None], predict(model, test_loader)],
columns=['PassengerId', 'Survived'])
pred_df.to_csv('titanic_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
10,543,398 | N_SPLITS = 5
BATCH_SIZE = 256
EPOCHS = 100
EARLY_STOPPING_PATIENCE = 15
OPTIMIZER = tf.keras.optimizers.Nadam()
LOSS='binary_crossentropy'
METRICS=[tf.keras.metrics.AUC() ]<choose_model_class> | data_test = pd.read_csv('.. /input/titanic/test.csv',index_col='PassengerId')
data_train = pd.read_csv('.. /input/titanic/train.csv',index_col='PassengerId')
data_train | Titanic - Machine Learning from Disaster |
10,543,398 | def get_cnn_model_1() :
model = tf.keras.models.Sequential([
tf.keras.layers.Reshape(( len(features)* 1, 1), input_shape=(len(features)* 1,)) ,
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.BatchNormalization() ,
tf.keras.layers.Dense(256, activation='relu'),
tf.keras.layers.BatchNormalization() ,
tf.ke... | data_train.isnull().sum()
| Titanic - Machine Learning from Disaster |
10,543,398 | kfold = StratifiedKFold(n_splits=N_SPLITS, shuffle=True, random_state=42)
models = []
histories = []
for fold_num,(train_index, val_index)in tqdm(enumerate(kfold.split(train_df[features].values, train_df['target'].values)) , total=N_SPLITS):
print(f'Fold {fold_num+1}/{N_SPLITS}:')
X_train = train_df.loc[train_index, ... | for i in data_train.columns:
print(i ,': ',len(data_train[i].unique()))
| Titanic - Machine Learning from Disaster |
10,543,398 | train_preds = np.zeros(train_df.shape)
test_preds = np.zeros(test_df.shape)
for model in models:
pred_train = model.predict(train_df[features].values)
pred_test = model.predict(test_df[features].values)
train_preds += pred_train
test_preds += pred_test
train_preds /= len(models)
test_preds /= len(models )<split> | columnsForDrop = ['Name', 'Cabin','Ticket','SibSp','Parch']
data_train.drop(columns=columnsForDrop, inplace=True)
data_test.drop(columns=columnsForDrop, inplace=True)
data_train | Titanic - Machine Learning from Disaster |
10,543,398 | train_preds = train_preds[:, 0]
test_preds = test_preds[:, 0]<compute_test_metric> | print(data_train.Sex.value_counts())
print('----------------------------------------------')
print(data_train.Embarked.value_counts() ) | Titanic - Machine Learning from Disaster |
10,543,398 | train_auc = roc_auc_score(train_df['target'], train_preds)
print(f'Train AUC: {train_auc}' )<load_from_csv> | y = data_train.Survived
X = data_train.drop(columns=['Survived'] ) | Titanic - Machine Learning from Disaster |
10,543,398 | test_df = pd.read_csv('test_small_with_targets.csv' )<compute_test_metric> | X_train, X_test, y_train, y_test = train_test_split(X, y)
| Titanic - Machine Learning from Disaster |
10,543,398 | if test_df['target'][0] != -1:
test_auc = roc_auc_score(test_df['target'], test_preds)
print(f'Test AUC: {test_auc}' )<save_to_csv> | my_imputer = SimpleImputer()
imputed_X_train = pd.DataFrame(my_imputer.fit_transform(X_train))
imputed_X_test = pd.DataFrame(my_imputer.transform(X_test))
imputed_X_train.columns = X_train.columns
imputed_X_test.columns = X_test.columns
| Titanic - Machine Learning from Disaster |
10,543,398 | sub = pd.DataFrame({'ID_code': test_df['ID_code'], 'target': test_preds})
sub.to_csv('submission.csv', index=False )<import_modules> | from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report, f1_score
from sklearn.neighbors import KNeighborsClassifier
| Titanic - Machine Learning from Disaster |
10,543,398 | FileLink('submission.csv' )<load_from_csv> |
parameters = {'max_depth': list(range(6, 30, 10)) ,
'max_leaf_nodes': list(range(50, 500, 100)) ,
'n_estimators': list(range(50, 1001, 150)) }
gsearch = GridSearchCV(estimator=RandomForestClassifier() ,
param_grid = parameters,
scoring='f1',
n_jobs=4,cv=5,verbose=7)
gsearch.fit(imputed_X_train, y_train ) | Titanic - Machine Learning from Disaster |
10,543,398 | train = pd.read_csv(r".. /input/train.csv")
test = pd.read_csv(r".. /input/test.csv" )<prepare_x_and_y> | print(gsearch.best_params_.get('max_leaf_nodes'))
print(gsearch.best_params_.get('max_depth')) | Titanic - Machine Learning from Disaster |
10,543,398 | cols = train.columns.values.tolist() [2: ]
predictors = train[cols]
target = train[['target']]
pre_test = test[cols]<split> | data_test.Age.fillna(X.Age.mean() , inplace=True)
data_test.Fare.fillna(X.Fare.mean() , inplace=True)
data_test.isna().sum() | Titanic - Machine Learning from Disaster |
10,543,398 | %%time
sfl = StratifiedKFold(n_splits = 3, shuffle=True)
pred_test_y = np.zeros(( test.shape[0]))
seed = 2019
N = 0
for train_indices, test_indices in sfl.split(predictors, target):
params = {
'num_leaves': 15,
'max_bin': 119,
'min_data_in_leaf': 11,
'learning_rate': 0.02,
'min_sum_hessian_in_leaf': 0.00245,
'bagging_... | preds = final_model.predict(data_test)
print(preds.shape)
print(data_test.shape ) | Titanic - Machine Learning from Disaster |
10,543,398 | <split><EOS> | test_out = pd.DataFrame({
'PassengerId': data_test.index,
'Survived': preds
})
test_out.to_csv('submission.csv', index=False)
print('Done' ) | Titanic - Machine Learning from Disaster |
10,537,096 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | import pandas as pd
import matplotlib.pyplot as plt
import numpy as np | Titanic - Machine Learning from Disaster |
10,537,096 | predictions = pred_test*0.5 + pred_test2*0.5<save_to_csv> | data = pd.read_csv('.. /input/titanic/train.csv',index_col = "PassengerId")
test = pd.read_csv('.. /input/titanic/test.csv',index_col = "PassengerId")
| Titanic - Machine Learning from Disaster |
10,537,096 | predictions = pd.DataFrame(predictions, columns =['target'])
sub = pd.concat([test[['ID_code']], predictions[['target']]], axis = 1)
sub.to_csv('submission.csv', index=False )<set_options> | indexs= test.index | Titanic - Machine Learning from Disaster |
10,537,096 | %reload_ext autoreload
%autoreload 2
%matplotlib inline<import_modules> | X = data.iloc[:,1:]
y = data.iloc[:,0] | Titanic - Machine Learning from Disaster |
10,537,096 | from fastai import *
from fastai.vision import *<define_variables> | X['Ticket'].mode | Titanic - Machine Learning from Disaster |
10,537,096 | path = Path('.. /input/aerial-cactus-identification/')
<load_from_csv> | X =X.drop(columns =['Name'] ) | Titanic - Machine Learning from Disaster |
10,537,096 | train = pd.read_csv('.. /input/aerial-cactus-identification/train.csv')
test = pd.read_csv('.. /input/aerial-cactus-identification/sample_submission.csv' )<define_variables> | imputer_no = SimpleImputer(missing_values= np.nan ,strategy = 'mean')
imputer_no.fit(X[['Pclass','Age','SibSp','Fare','Parch']])
X[['Pclass','Age','SibSp','Fare','Parch']] = imputer_no.transform(X[['Pclass','Age','SibSp','Fare','Parch']])
| Titanic - Machine Learning from Disaster |
10,537,096 | np.random.seed(50)
<feature_engineering> | imputer_cat = SimpleImputer(missing_values= np.nan ,strategy = 'most_frequent')
imputer_cat.fit(X[['Sex','Cabin','Embarked','Ticket']])
X[['Sex','Cabin','Embarked','Ticket']]=imputer_cat.transform(X[['Sex','Cabin','Embarked','Ticket']] ) | Titanic - Machine Learning from Disaster |
10,537,096 | tfms = get_transforms(do_flip = True, )<define_variables> | from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder | Titanic - Machine Learning from Disaster |
10,537,096 | data.show_batch(rows = 3,figsize=(7,8))<choose_model_class> | ct = ColumnTransformer(transformers= [('encoder',OneHotEncoder(handle_unknown='ignore'),[1,5,7,8])],remainder = 'passthrough')
X= ct.fit_transform(X ) | Titanic - Machine Learning from Disaster |
10,537,096 | learn = cnn_learner(data , models.resnet50 , metrics = error_rate )<train_model> | train_X,test_X,train_y,test_y = train_test_split(X,y ) | Titanic - Machine Learning from Disaster |
10,537,096 | learn.fit_one_cycle(4)
<create_dataframe> | for i in range(10,300,10):
classifier = RandomForestClassifier(n_estimators= i,criterion='gini')
classifier.fit(train_X, train_y)
y_predict = classifier.predict(test_X)
print('for {} estimators and {}'.format({i},{accuracy_score(y_true=test_y,y_pred=y_predict)}))
| Titanic - Machine Learning from Disaster |
10,537,096 | test_data = ImageList.from_df(test, path=path/'test', folder='test')
data.add_test(test_data )<predict_on_test> | test =test.drop(columns =['Name'] ) | Titanic - Machine Learning from Disaster |
10,537,096 | preds, _ = learn.get_preds(ds_type=DatasetType.Test)
test.has_cactus = preds.numpy() [:, 0]<save_to_csv> | imputer_no.fit(test[['Pclass','Age','SibSp','Fare','Parch']])
test[['Pclass','Age','SibSp','Fare','Parch']] = imputer_no.transform(test[['Pclass','Age','SibSp','Fare','Parch']])
imputer_cat.fit(test[['Sex','Cabin','Embarked','Ticket']])
test[['Sex','Cabin','Embarked','Ticket']]=imputer_cat.transform(test[['Sex','Cab... | Titanic - Machine Learning from Disaster |
10,537,096 | test.to_csv("submit.csv", index=False )<load_from_csv> | classifier = RandomForestClassifier(n_estimators= 150,criterion='gini')
classifier.fit(X, y)
y_predict = classifier.predict(test)
pd.DataFrame(y_predict,index=indexs,columns=['Survived'] ).to_csv('output.csv' ) | Titanic - Machine Learning from Disaster |
10,537,096 | train_dir=".. /input/train/train"
test_dir=".. /input/test/test"
train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv(".. /input/sample_submission.csv")
data_folder = Path(".. /input")
<choose_model_class> | Titanic - Machine Learning from Disaster | |
10,537,096 | learn = cnn_learner(train_img, models.densenet161, metrics=[error_rate, accuracy])
<find_best_params> | Titanic - Machine Learning from Disaster | |
10,513,115 | learn.lr_find()
<train_model> | t_data= pd.read_csv('/kaggle/input/titanic/train.csv',index_col='PassengerId')
t_data.head() | Titanic - Machine Learning from Disaster |
10,513,115 | lr = 1e-02
learn.fit_one_cycle(10, slice(lr))
<predict_on_test> | t_data.drop(columns=['Name','Ticket','Fare','Cabin'],inplace=True ) | Titanic - Machine Learning from Disaster |
10,513,115 | preds,_ = learn.get_preds(ds_type=DatasetType.Test )<filter> | for col in range(len(t_data.columns)) :
print(t_data[t_data.columns[col]].value_counts() ) | Titanic - Machine Learning from Disaster |
10,513,115 | test.has_cactus = preds.numpy() [:, 0]<save_to_csv> | t_data.isna().sum() | Titanic - Machine Learning from Disaster |
10,513,115 | test.to_csv('submission.csv', index=False )<import_modules> | t_data.Age.value_counts().mode() | Titanic - Machine Learning from Disaster |
10,513,115 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import glob
import scipy
import cv2
import keras<import_modules> | from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
10,513,115 | import random<load_from_csv> | target_col="Survived"
y = t_data[target_col]
X = t_data[['Pclass','Sex','Age','SibSp','Parch','Embarked']]
X = pd.get_dummies(X)
train_X, val_X, train_y, val_y = train_test_split(X, y)
val_X
| Titanic - Machine Learning from Disaster |
10,513,115 | train_data = pd.read_csv('.. /input/train.csv' )<count_values> | cols_with_missing = [col for col in train_X.columns if train_X[col].isnull().any() ]
red_X_train=train_X.drop(columns=cols_with_missing)
red_X_val=val_X.drop(columns=cols_with_missing ) | Titanic - Machine Learning from Disaster |
10,513,115 | train_data.has_cactus.value_counts()<define_search_model> | def get_accuracy(n_estimators,max_depth,train_X, val_X, train_y, val_y):
model = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth ,random_state=1)
model.fit(train_X,train_y)
preds = model.predict(val_X)
lr_accuracy = accuracy_score(val_y,preds)
return lr_accuracy | Titanic - Machine Learning from Disaster |
10,513,115 | def image_generator(batch_size = 16, all_data=True, shuffle=True, train=True, indexes=None):
while True:
if indexes is None:
if train:
if all_data:
indexes = np.arange(train_data.shape[0])
else:
indexes = np.arange(train_data[:15000].shape[0])
if shuffle:
np.random.shuffle(indexes)
else:
indexes = np.arange(train_da... | accuracy=get_accuracy(200,10,red_X_train,red_X_val,train_y,val_y)
print("Validation accurcy for Random Forest Model: {}".format(accuracy)) | Titanic - Machine Learning from Disaster |
10,513,115 | model = keras.models.Sequential()
model.add(keras.layers.Conv2D(64,(5, 5), input_shape=(32, 32, 3)))
model.add(keras.layers.BatchNormalization())
model.add(keras.layers.LeakyReLU(alpha=0.3))
model.add(keras.layers.Conv2D(64,(5, 5)))
model.add(keras.layers.BatchNormalization())
model.add(keras.layers.LeakyReLU(alpha... | my_imputer = SimpleImputer()
imputed_X_train = pd.DataFrame(my_imputer.fit_transform(train_X))
imputed_X_valid = pd.DataFrame(my_imputer.transform(val_X))
imputed_X_train.columns =train_X.columns
imputed_X_valid.columns = val_X.columns
| Titanic - Machine Learning from Disaster |
10,513,115 | opt = keras.optimizers.Adam(0.0001)
model.compile(optimizer=opt, loss='binary_crossentropy', metrics=['accuracy'] )<train_model> | accuracy=get_accuracy(1000,10,imputed_X_train,imputed_X_valid,train_y,val_y)
print("Validation accurcy for Random Forest Model: {}".format(accuracy)) | Titanic - Machine Learning from Disaster |
10,513,115 | model.fit_generator(image_generator() , steps_per_epoch= train_data.shape[0] / 16, epochs=30 )<find_best_params> | max_accur=.5
max_dep=0
best_tree_size=0
for maxDepth in range(1,11):
for i in range(10,101,10):
accuracy=get_accuracy(i,maxDepth,imputed_X_train,imputed_X_valid,train_y,val_y)
if accuracy>max_accur:
max_accur=accuracy
max_dep=maxDepth
best_tree_size=i
print("max accuracy = {} max depth={} best tree size={}".format(max... | Titanic - Machine Learning from Disaster |
10,513,115 | keras.backend.eval(model.optimizer.lr.assign(0.00001))<train_model> | max_accur=.5
max_dep=0
best_tree_size=0
for maxDepth in range(1,11):
for i in range(10,101,10):
accuracy=get_accuracy(i,maxDepth,red_X_train,red_X_val,train_y,val_y)
if accuracy>max_accur:
max_accur=accuracy
max_dep=maxDepth
best_tree_size=i
print("max accuracy = {} max depth={} best tree size={}".format(max_accur,max... | Titanic - Machine Learning from Disaster |
10,513,115 | model.fit_generator(image_generator() , steps_per_epoch= train_data.shape[0] / 16, epochs=15 )<load_pretrained> | pd.get_dummies(df, prefix=['col1', 'col2'] ) | Titanic - Machine Learning from Disaster |
10,513,115 | indexes = np.arange(train_data.shape[0])
N = int(len(indexes)/ 64)
batch_size = 64
wrong_ind = []
for i in range(N):
current_indexes = indexes[i*64:(i+1)*64]
batch_input = []
batch_output = []
for index in current_indexes:
img = mpimg.imread('.. /input/train/train/' + train_data.id[index])
batch_input += [img]
batch... | accuracy=get_accuracy(60,4,red_X_train,red_X_val,train_y,val_y)
accuracy | Titanic - Machine Learning from Disaster |
10,513,115 | indexes = np.arange(train_data.shape[0])
N = int(len(indexes)/ 64)
batch_size = 64
wrong_ind = []
for i in range(N):
current_indexes = indexes[i*64:(i+1)*64]
batch_input = []
batch_output = []
for index in current_indexes:
img = mpimg.imread('.. /input/train/train/' + train_data.id[index])
batch_input += [img[::-1, ... | test_data= pd.read_csv('/kaggle/input/titanic/test.csv')
test_data.info()
| Titanic - Machine Learning from Disaster |
10,513,115 | indexes = np.arange(train_data.shape[0])
N = int(len(indexes)/ 64)
batch_size = 64
wrong_ind = []
for i in range(N):
current_indexes = indexes[i*64:(i+1)*64]
batch_input = []
batch_output = []
for index in current_indexes:
img = mpimg.imread('.. /input/train/train/' + train_data.id[index])
batch_input += [img[:, ::-... | model = RandomForestClassifier(n_estimators=60, max_depth=10 ,random_state=1)
model.fit(imputed_X_train,train_y)
preds = model.predict(imputed_X_valid)
model_accuracy = accuracy_score(val_y,preds)
print("Accarany = {}:".format(model_accuracy)) | Titanic - Machine Learning from Disaster |
10,513,115 | test_files = os.listdir('.. /input/test/test/' )<predict_on_test> | test=test_data[['Pclass','Sex','Age','SibSp','Parch','Embarked']]
final_X_test = pd.get_dummies(test)
X_test.info() | Titanic - Machine Learning from Disaster |
10,513,115 | batch = 40
all_out = []
for i in range(int(4000/batch)) :
images = []
for j in range(batch):
img = mpimg.imread('.. /input/test/test/'+test_files[i*batch + j])
images += [img]
out = model.predict(np.array(images))
all_out += [out]<create_dataframe> | final_X_test = pd.DataFrame(my_imputer.transform(final_X_test)) | Titanic - Machine Learning from Disaster |
10,513,115 | sub_file = pd.DataFrame(data = {'id': test_files, 'has_cactus': all_out.reshape(-1 ).tolist() } )<save_to_csv> | predictions = model.predict(final_X_test)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!")
| Titanic - Machine Learning from Disaster |
9,770,354 | sub_file.to_csv('sample_submission.csv', index=False )<set_options> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
| Titanic - Machine Learning from Disaster |
9,770,354 | pd.set_option('display.float_format', lambda x: '%.3f' % x)
RSEED = 100
%matplotlib inline
plt.style.use('fivethirtyeight')
plt.rcParams['font.size'] = 18
palette = sns.color_palette('Paired', 10 )<load_from_csv> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
| Titanic - Machine Learning from Disaster |
9,770,354 | data = pd.read_csv('.. /input/train.csv', nrows = 5_000_000,
parse_dates = ['pickup_datetime'] ).drop(columns = 'key')
data = data.dropna()
data.head()<filter> | all_data['Embarked'].fillna(all_data['Embarked'].mode() [0], inplace = True)
all_data['Fare'].fillna(all_data['Fare'].median() , inplace = True ) | Titanic - Machine Learning from Disaster |
9,770,354 | print(f"There are {len(data[data['fare_amount'] < 0])} negative fares.")
print(f"There are {len(data[data['fare_amount'] == 0])} $0 fares.")
print(f"There are {len(data[data['fare_amount'] > 100])} fares greater than $100." )<filter> | all_data['Title'] = all_data.Name.str.extract('([A-Za-z]+)\.', expand=False)
all_data['Title'].value_counts()
frequent_titles = all_data['Title'].value_counts() [:5].index.tolist()
frequent_titles
all_data['Title'] = all_data['Title'].apply(lambda x: x if x in frequent_titles else 'Other')
all_data['Title'] | Titanic - Machine Learning from Disaster |
9,770,354 | data = data[data['fare_amount'].between(left = 2.5, right = 100)]<compute_test_metric> | median_ages = {}
for title in frequent_titles:
median_ages[title] = all_data.loc[all_data['Title'] == title]['Age'].median()
median_ages['Other'] = all_data['Age'].median()
all_data.loc[all_data['Age'].isnull() , 'Age'] = all_data[all_data['Age'].isnull() ]['Title'].map(median_ages)
all_data['Age'] | Titanic - Machine Learning from Disaster |
9,770,354 | def ecdf(x):
x = np.sort(x)
n = len(x)
y = np.arange(1, n + 1, 1)/ n
return x, y<filter> | Cat_Features = ['Sex', 'Embarked', 'Title']
for feature in Cat_Features:
label = LabelEncoder()
all_data[feature] = label.fit_transform(all_data[feature])
all_data[Cat_Features] | Titanic - Machine Learning from Disaster |
9,770,354 | data = data.loc[data['passenger_count'] < 6]<train_model> | Cont_Features = ['Age', 'Fare']
num_bins = 5
for feature in Cont_Features:
bin_feature = feature + 'Bin'
all_data[bin_feature] = pd.qcut(all_data[feature], num_bins)
label = LabelEncoder()
all_data[bin_feature] = label.fit_transform(all_data[bin_feature])
all_data.head(10 ) | Titanic - Machine Learning from Disaster |
9,770,354 | print(f'Initial Observations: {data.shape[0]}' )<define_variables> | all_data['Surname'] = all_data.Name.str.extract(r'([A-Za-z]+),', expand=False)
all_data['TicketPrefix'] = all_data.Ticket.str.extract(r' (.*\d)', expand=False)
all_data['Surname_Ticket'] = all_data['Surname'] + all_data['TicketPrefix']
all_data['IsFamily'] = all_data.Surname_Ticket.duplicated(keep=False ).astype(int)... | 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.