kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
1,727,523 | train_df.drop('FamilySize', axis=1, inplace=True)
test_df.drop('FamilySize', axis=1, inplace=True )<feature_engineering> | def create_dummies(df, column_name):
dummies = pd.get_dummies(df[column_name], prefix=column_name)
df = pd.concat([df,dummies], axis=1)
return df
train = create_dummies(train, "Pclass")
test = create_dummies(test, "Pclass")
train.head() | Titanic - Machine Learning from Disaster |
1,727,523 | for df in all_df:
title = df['Name'].apply(lambda x:x.split(',')[1].split('.')[0] ).copy()
df['Title'] = title.str.strip()
train_df.groupby(['Title', 'Survived'])['PassengerId'].count().sort_values(ascending=False )<categorify> | train = create_dummies(train, "Sex")
test = create_dummies(test, "Sex")
train = create_dummies(train, "Age_categories")
test = create_dummies(test, "Age_categories")
train.head() | Titanic - Machine Learning from Disaster |
1,727,523 | title_map = {"Mr": 0, "Miss": 1, "Mrs": 2, "Master": 3, "Rare": 4}
for df in all_df:
df['Title'] = df['Title'].map(title_map)
df['Title'] = df['Title'].fillna(0)
df['Title'] = df['Title'].astype(int)
all_df = [train_df, test_df]
train_df.head()<drop_column> | train["SibSp_scaled"] = minmax_scale(train[["SibSp"]])
train["Parch_scaled"] = minmax_scale(train[["Parch"]])
train["Fare_scaled"] = minmax_scale(train[["Fare"]])
train.head()
| Titanic - Machine Learning from Disaster |
1,727,523 | train_df.drop(['Name', 'Ticket'], axis=1, inplace=True)
test_df.drop(['Name', 'Ticket'], axis=1, inplace=True )<prepare_x_and_y> | test["Fare"] = test["Fare"].fillna(train["Fare"].mean())
test["Fare"].count() | Titanic - Machine Learning from Disaster |
1,727,523 | y_train = train_df['Survived']
features = ['Pclass', 'Sex', 'Age', 'Fare', 'Embarked', \
'Family', 'SibSp', 'Parch', 'Title', 'Cabin']
X_train = train_df[features]
X_test = test_df[features]<compute_test_metric> | test["SibSp_scaled"] = minmax_scale(test[["SibSp"]])
test["Parch_scaled"] = minmax_scale(test[["Parch"]])
test["Fare_scaled"] = minmax_scale(test[["Fare"]])
test.head() | Titanic - Machine Learning from Disaster |
1,727,523 | forest = RandomForestClassifier(n_estimators=153, max_depth=5, random_state=1)
forest.fit(X_train, y_train)
y_pred = forest.predict(X_train)
print('Accuracy Score: ', forest.score(X_train, y_train))
print('
Confusion Matric: ', confusion_matrix(y_train, y_pred))
print('
Classification Report: ', classification_repor... | train = create_dummies(train, "Embarked")
test = create_dummies(test, "Embarked")
train.head() | Titanic - Machine Learning from Disaster |
1,727,523 | predict = forest.predict(X_test)
report = pd.DataFrame({'PassengerId': test_df.PassengerId, 'Survived': predict})
report.to_csv('submission.csv', index=False)
print("Your submission was successfully saved!" )<import_modules> | lrColumns = ['Age_categories_Missing','Age_categories_Infant',
'Age_categories_Child', 'Age_categories_Teenager',
'Age_categories_Young Adult', 'Age_categories_Adult',
'Age_categories_Senior', 'Pclass_1', 'Pclass_2', 'Pclass_3',
'Sex_female', 'Sex_male', 'Embarked_C', 'Embarked_Q', 'Embarked_S',
'SibSp_scaled', 'Parch_... | Titanic - Machine Learning from Disaster |
1,727,523 | T = torch.Tensor
<define_variables> | logisticRegression = LogisticRegression()
logisticRegression.fit(train[lrColumns], train["Survived"])
coefficients = logisticRegression.coef_
print(coefficients ) | Titanic - Machine Learning from Disaster |
1,727,523 | SIZE = 1000
EPOCHS = 50
CONV_OUT_1 = 50
CONV_OUT_2 = 100
BATCH_SIZE = 128
TEST_PATH = Path('.. /input/abstraction-and-reasoning-challenge/')
SUBMISSION_PATH = Path('.. /input/abstraction-and-reasoning-challenge/')
TEST_PATH = TEST_PATH / 'test'
SUBMISSION_PATH = SUBMISSION_PATH / 'sample_submission.csv'<load_pretrain... | predictors = ['Age_categories_Infant', 'SibSp_scaled', 'Sex_female', 'Sex_male',
'Pclass_1', 'Pclass_3', 'Age_categories_Senior', 'Parch_scaled']
lr = LogisticRegression()
lr.fit(train[predictors], train["Survived"])
predictions = lr.predict(test[predictors])
print(predictions ) | Titanic - Machine Learning from Disaster |
1,727,523 | test_task_files = sorted(os.listdir(TEST_PATH))
test_tasks = []
for task_file in test_task_files:
with open(str(TEST_PATH / task_file), 'r')as f:
task = json.load(f)
test_tasks.append(task )<prepare_x_and_y> | scores = cross_val_score(lr, train[predictors], train["Survived"], cv=10)
print(scores ) | Titanic - Machine Learning from Disaster |
1,727,523 | Xs_test, Xs_train, ys_train = [], [], []
for task in test_tasks:
X_test, X_train, y_train = [], [], []
for pair in task["test"]:
X_test.append(pair["input"])
for pair in task["train"]:
X_train.append(pair["input"])
y_train.append(pair["output"])
Xs_test.append(X_test)
Xs_train.append(X_train)
ys_train.append(y_tra... | accuracy = scores.mean()
print(accuracy ) | Titanic - Machine Learning from Disaster |
1,727,523 | matrices = []
for X_test in Xs_test:
for X in X_test:
matrices.append(X)
values = []
for matrix in matrices:
for row in matrix:
for value in row:
values.append(value)
df = pd.DataFrame(values)
df.columns = ["values"]<define_variables> | fare_count = Counter(train["Fare"])
print(fare_count ) | Titanic - Machine Learning from Disaster |
1,727,523 | heights = [np.shape(matrix)[0] for matrix in matrices]
widths = [np.shape(matrix)[1] for matrix in matrices]<categorify> | process_fare(test, fare_cut_points, fare_label_names)
print(test["Fare_categories"] ) | Titanic - Machine Learning from Disaster |
1,727,523 | def replace_values(a, d):
return np.array([d.get(i, -1)for i in range(a.min() , a.max() + 1)])[a - a.min() ]
def repeat_matrix(a):
return np.concatenate([a]*(( SIZE // len(a)) + 1)) [:SIZE]
def get_new_matrix(X):
if len(set([np.array(x ).shape for x in X])) > 1:
X = np.array([X[0]])
return X
def get_outp(outp, diction... | train = create_dummies(train, "Fare_categories")
train.head() | Titanic - Machine Learning from Disaster |
1,727,523 | class ARCDataset(Dataset):
def __init__(self, X, y, stage="train"):
self.X = get_new_matrix(X)
self.X = repeat_matrix(self.X)
self.stage = stage
if self.stage == "train":
self.y = get_new_matrix(y)
self.y = repeat_matrix(self.y)
def __len__(self):
return SIZE
def __getitem__(self, idx):
inp = self.X[idx]
if self.st... | test = create_dummies(test, "Fare_categories")
test.head() | Titanic - Machine Learning from Disaster |
1,727,523 | class BasicCNNModel(nn.Module):
def __init__(self, inp_dim=(10, 10), outp_dim=(10, 10)) :
super(BasicCNNModel, self ).__init__()
CONV_IN = 3
KERNEL_SIZE = 3
DENSE_IN = CONV_OUT_2
self.relu = nn.ReLU()
self.softmax = nn.Softmax(dim=1)
self.dense_1 = nn.Linear(DENSE_IN, outp_dim[0]*outp_dim[1]*10)
if inp_dim[0] < 5 or ... | train["Cabin_type"] = train["Cabin"].str[0]
train["Cabin_type"] = train["Cabin_type"].fillna("Unknown")
train["Cabin_type"].head() | Titanic - Machine Learning from Disaster |
1,727,523 | def transform_dim(inp_dim, outp_dim, test_dim):
return(test_dim[0]*outp_dim[0]/inp_dim[0],
test_dim[1]*outp_dim[1]/inp_dim[1])
def resize(x, test_dim, inp_dim):
if inp_dim == test_dim:
return x
else:
return cv2.resize(flt(x), inp_dim,
interpolation=cv2.INTER_AREA)
def flt(x): return np.float32(x)
def npy(x): return ... | test["Cabin_type"] = test["Cabin"].str[0]
test["Cabin_type"] = test["Cabin_type"].fillna("Unknown")
test["Cabin_type"].head() | Titanic - Machine Learning from Disaster |
1,727,523 | idx = 0
start = time.time()
test_predictions = []
for X_train, y_train in zip(Xs_train, ys_train):
print("TASK " + str(idx + 1))
train_set = ARCDataset(X_train, y_train, stage="train")
train_loader = DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True)
inp_dim = np.array(X_train[0] ).shape
outp_dim = np.array(y... | titles = {
"Mr" : "Mr",
"Mme": "Mrs",
"Ms": "Mrs",
"Mrs" : "Mrs",
"Master" : "Master",
"Mlle": "Miss",
"Miss" : "Miss",
"Capt": "Officer",
"Col": "Officer",
"Major": "Officer",
"Dr": "Officer",
"Rev": "Officer",
"Jonkheer": "Royalty",
"Don": "Royalty",
"Sir" : "Royalty",
"Countess": "Royalty",
"Dona": "Royalty",
"Lady"... | Titanic - Machine Learning from Disaster |
1,727,523 | def flattener(pred):
str_pred = str([row for row in pred])
str_pred = str_pred.replace(', ', '')
str_pred = str_pred.replace('[[', '|')
str_pred = str_pred.replace('][', '|')
str_pred = str_pred.replace(']]', '|')
return str_pred<load_from_csv> | extracted_titles = train["Name"].str.extract('([A-Za-z]+)\.',expand=False)
train["Title"] = extracted_titles.map(titles)
train["Title"].head() | Titanic - Machine Learning from Disaster |
1,727,523 | test_predictions = [[list(pred)for pred in test_pred] for test_pred in test_predictions]
for idx, pred in enumerate(test_predictions):
test_predictions[idx] = flattener(pred)
submission = pd.read_csv(SUBMISSION_PATH)
submission["output"] = test_predictions<save_to_csv> | extracted_titles = test["Name"].str.extract('([A-Za-z]+)\.',expand=False)
test["Title"] = extracted_titles.map(titles)
test["Title"].head() | Titanic - Machine Learning from Disaster |
1,727,523 | submission.to_csv("submission.csv", index=False )<save_to_csv> | for column in ["Title","Cabin_type"]:
train = create_dummies(train,column)
test = create_dummies(test,column)
train.head() | Titanic - Machine Learning from Disaster |
1,727,523 | submission.to_csv("submission.csv", index=False )<import_modules> | predictor_columns = ['Age_categories_Missing', 'Age_categories_Infant',
'Age_categories_Child', 'Age_categories_Young Adult',
'Age_categories_Adult', 'Age_categories_Senior', 'Pclass_1', 'Pclass_3',
'Embarked_C', 'Embarked_Q', 'Embarked_S', 'SibSp_scaled',
'Parch_scaled', 'Fare_categories_0-12', 'Fare_categories_50-100... | Titanic - Machine Learning from Disaster |
1,727,523 | import numpy as np
import pandas as pd
from tqdm import tqdm<load_pretrained> | all_X = train[optimized_predictors]
all_y = train["Survived"]
lr = LogisticRegression()
lr.fit(all_X, all_y)
scores = cross_val_score(lr,all_X,all_y, cv=10)
print(scores ) | Titanic - Machine Learning from Disaster |
1,727,523 | def load_data(path):
tasks = pd.Series()
for file_path in os.listdir(path):
task_file = path_join(path, file_path)
with open(task_file, 'r')as f:
task = json.load(f)
tasks[file_path[:-5]] = task
return tasks<load_pretrained> | accuracy = scores.mean()
print(accuracy ) | Titanic - Machine Learning from Disaster |
1,727,523 | train_tasks = load_data('.. /input/abstraction-and-reasoning-challenge/training/')
evaluation_tasks = load_data('.. /input/abstraction-and-reasoning-challenge/evaluation/')
test_tasks = load_data('.. /input/abstraction-and-reasoning-challenge/test/')
train_tasks.head()<train_on_grid> | predictions = lr.predict(test[optimized_predictors] ) | Titanic - Machine Learning from Disaster |
1,727,523 | <compute_test_metric><EOS> | submission = pd.DataFrame({
"PassengerId": test["PassengerId"],
"Survived": predictions
})
submission.to_csv('submission1.csv', index=False ) | Titanic - Machine Learning from Disaster |
1,496,791 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<predict_on_test> | train_dataset = pd.read_csv('./.. /input/train.csv')
test_dataset = pd.read_csv('./.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
1,496,791 | def evaluate(tasks):
ts = TaskSolver()
result = []
predictions = []
for task in tqdm(tasks):
if input_output_shape_is_same(task):
ts.train(task['train'])
pred = ts.predict(task['test'])
score = calk_score(task['test'], pred)
else:
pred = [el['input'] for el in task['test']]
score = [0]*len(task['test'])
predictions... | print(train_dataset[["Parch", "Survived"]].groupby('Parch' ).mean().sort_values(by='Survived',ascending=False)) | Titanic - Machine Learning from Disaster |
1,496,791 | train_result, train_predictions = evaluate(train_tasks)
train_solved = [any(score)for score in train_result]
total = sum([len(score)for score in train_result])
print(f"solved : {sum(train_solved)} from {total}({sum(train_solved)/total})" )<compute_test_metric> | train_dataset.drop('Ticket',axis=1,inplace=True)
test_dataset.drop('Ticket', axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
1,496,791 | evaluation_result, evaluation_predictions = evaluate(evaluation_tasks)
evaluation_solved = [any(score)for score in evaluation_result]
total = sum([len(score)for score in evaluation_result])
print(f"solved : {sum(evaluation_solved)} from {total}({sum(evaluation_solved)/total})" )<predict_on_test> | train_dataset['Title'] = train_dataset.Name.str.extract('([A-Za-z]+)\.')
train_dataset['Title'].replace(['Lady','Countess','Capt','Col','Don','Dr','Major','Rev','Sir','Jonkheer','Dona'],'Rare',inplace=True)
test_dataset['Title'] = test_dataset.Name.str.extract('([A-Za-z]+)\.')
test_dataset['Title'].replace(['Lady','... | Titanic - Machine Learning from Disaster |
1,496,791 | def flattener(pred):
str_pred = str([row for row in pred])
str_pred = str_pred.replace(', ', '')
str_pred = str_pred.replace('[[', '|')
str_pred = str_pred.replace('][', '|')
str_pred = str_pred.replace(']]', '|')
return str_pred
def make_pediction(tasks):
ts = TaskSolver()
result = pd.Series()
for idx, task in tq... | train_dataset['Title'] = train_dataset['Title'].replace('Mlle','Miss')
train_dataset['Title'] = train_dataset['Title'].replace('Mme','Miss')
train_dataset['Title'] = train_dataset['Title'].replace('Ms','Miss')
test_dataset['Title'] = test_dataset['Title'].replace('Mlle','Miss')
test_dataset['Title'] = test_dataset[... | Titanic - Machine Learning from Disaster |
1,496,791 | submission = make_pediction(test_tasks)
submission.head()<save_to_csv> | train_dataset['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
1,496,791 | submission = submission.reset_index()
submission.columns = ['output_id', 'output']
submission.to_csv('submission.csv', index=False)
submission<import_modules> | train_dataset[train_dataset['Embarked'].isnull() ] | Titanic - Machine Learning from Disaster |
1,496,791 | import numpy as np
import pandas as pd
import os
import json
from pathlib import Path
import matplotlib.pyplot as plt
from matplotlib import colors
import numpy as np<categorify> | train_dataset[(train_dataset['Pclass'] == 1)&(train_dataset['Survived']==1)].mean() ['Fare'] | Titanic - Machine Learning from Disaster |
1,496,791 | def model_1(input, task_id=''):
input = np.asarray(input)
if input.shape !=(2,2):
return input.tolist()
output = np.zeros(( 6,6))
output[0,:] = np.array(input[0,:].tolist() *3)
output[1,:] = np.array(input[1,:].tolist() *3)
output[2,:] = np.array(input[0,:].tolist() [::-1]*3)
output[3,:] = np.array(input[1,:].tolis... | train_dataset.groupby(['Embarked','Pclass'] ).mean() | Titanic - Machine Learning from Disaster |
1,496,791 | data_path = Path('/kaggle/input/abstraction-and-reasoning-challenge/')
training_path = data_path / 'training'
evaluation_path = data_path / 'evaluation'
test_path = data_path / 'test'<create_dataframe> | train_dataset['Embarked'] = train_dataset['Embarked'].fillna('C')
train_dataset['Embarked'].isnull().sum()
| Titanic - Machine Learning from Disaster |
1,496,791 | ret = []
for file in training_tasks:
task = load_task(file, 0)
x = task['train'][0]['input']
x = np.asarray(x)
ret.append(( file, str(x.shape)))
df_shape = pd.DataFrame(ret, columns=['filename','shape'] )<count_values> | train_dataset.drop('Cabin',axis=1,inplace=True)
test_dataset.drop('Cabin',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
1,496,791 | df_shape['shape'].value_counts()<filter> | train_dataset['Age'].isnull().sum() | Titanic - Machine Learning from Disaster |
1,496,791 | file1 = df_shape[df_shape['shape']=='(2, 2)']
display(file1 )<filter> | train_dataset['Ageband'] = pd.cut(train_dataset['Age'], 5)
train_dataset.head() | Titanic - Machine Learning from Disaster |
1,496,791 | file1 = df_shape[df_shape['shape']=='(3, 3)']
display(file1 )<prepare_output> | test_dataset['Ageband'] = pd.cut(test_dataset['Age'], 5)
test_dataset.head() | Titanic - Machine Learning from Disaster |
1,496,791 | pred = model_2(task)
print(pred)
print(task['test'][0]['output'] )<load_from_csv> | print(train_dataset['Ageband'].value_counts())
print("---"*40)
print(test_dataset['Ageband'].value_counts() ) | Titanic - Machine Learning from Disaster |
1,496,791 | submission = pd.read_csv(data_path / 'sample_submission.csv', index_col='output_id')
display(submission.head() )<categorify> | train_dataset.loc[train_dataset['Age']<= 16,'Age']=0
train_dataset.loc[(train_dataset['Age']>16)&(train_dataset['Age']<=32),'Age']=1
train_dataset.loc[(train_dataset['Age']>32)&(train_dataset['Age']<=48),'Age']=2
train_dataset.loc[(train_dataset['Age']>48)&(train_dataset['Age']<=64),'Age']=3
train_dataset.loc[(train_da... | Titanic - Machine Learning from Disaster |
1,496,791 | def flattener(pred):
str_pred = str([row for row in pred])
str_pred = str_pred.replace(', ', '')
str_pred = str_pred.replace('[[', '|')
str_pred = str_pred.replace('][', '|')
str_pred = str_pred.replace(']]', '|')
return str_pred<concatenate> | train_dataset.Age = train_dataset.Age.astype(int ) | Titanic - Machine Learning from Disaster |
1,496,791 | example_grid = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
display(example_grid)
print(flattener(example_grid))<load_pretrained> | test_dataset.loc[test_dataset['Age']<= 16,'Age']=0
test_dataset.loc[(test_dataset['Age']>16)&(test_dataset['Age']<=32),'Age']=1
test_dataset.loc[(test_dataset['Age']>32)&(test_dataset['Age']<=48),'Age']=2
test_dataset.loc[(test_dataset['Age']>48)&(test_dataset['Age']<=64),'Age']=3
test_dataset.loc[(test_dataset['Age']>... | Titanic - Machine Learning from Disaster |
1,496,791 | for output_id in submission.index:
task_id = output_id.split('_')[0]
pair_id = int(output_id.split('_')[1])
f = str(test_path / str(task_id + '.json'))
with open(f, 'r')as read_file:
task = json.load(read_file)
data = task['test'][pair_id]['input']
pred_1 = model_1(data, task_id)
pred_1 = flattener(pred_1)
data = m... | test_dataset.Age = test_dataset.Age.astype(int ) | Titanic - Machine Learning from Disaster |
1,496,791 | submission.to_csv('submission.csv' )<install_modules> | train_dataset['Family']= train_dataset['SibSp']+train_dataset['Parch']+1
train_dataset.head() | Titanic - Machine Learning from Disaster |
1,496,791 | !pip install --no-deps '.. /input/timm-package/timm-0.1.26-py3-none-any.whl' > /dev/null
!pip install --no-deps '.. /input/pycocotools/pycocotools-2.0-cp37-cp37m-linux_x86_64.whl' > /dev/null<define_variables> | test_dataset['Family']= test_dataset['SibSp']+test_dataset['Parch']+1
test_dataset.head() | Titanic - Machine Learning from Disaster |
1,496,791 | sys.path.insert(0, ".. /input/effdet")
sys.path.insert(0, ".. /input/omegaconf")
sys.path.insert(0, ".. /input/weightedboxesfusion")
model_path='.. /input/model6/best.bin'<set_options> | train_dataset['IsAlone']=0
train_dataset.loc[train_dataset.Family == 1,'IsAlone']=1
test_dataset['IsAlone']=0
test_dataset.loc[test_dataset.Family == 1,'IsAlone']=1 | Titanic - Machine Learning from Disaster |
1,496,791 | 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 )<load_from_csv> | test_dataset['Fareband'] = pd.qcut(test_dataset['Fare'],4)
test_dataset.head(10 ) | Titanic - Machine Learning from Disaster |
1,496,791 | marking = pd.read_csv('.. /input/global-wheat-detection/train.csv')
bboxs = np.stack(marking['bbox'].apply(lambda x: np.fromstring(x[1:-1], sep=',')))
for i, column in enumerate(['x', 'y', 'w', 'h']):
marking[column] = bboxs[:,i]
marking.drop(columns=['bbox'], inplace=True )<init_hyperparams> | print(train_dataset['Fareband'].value_counts())
print("---"*40)
print(test_dataset['Fareband'].value_counts() ) | Titanic - Machine Learning from Disaster |
1,496,791 | warnings.filterwarnings("ignore")
class Fitter:
def __init__(self, model, device, config):
self.config = config
self.epoch = 0
self.base_dir = f'./{config.folder}'
if not os.path.exists(self.base_dir):
os.makedirs(self.base_dir)
self.log_path = f'{self.base_dir}/log.txt'
self.best_summary_loss = 10**5
self.model = mo... | train_dataset.loc[train_dataset['Fare']<=7.91,'Fare']=0
train_dataset.loc[(train_dataset['Fare']>7.91)&(train_dataset['Fare']<=14.454),'Fare']=1
train_dataset.loc[(train_dataset['Fare']>14.454)&(train_dataset['Fare']<=31),'Fare']=2
train_dataset.loc[(train_dataset['Fare']>31),'Fare']=3
train_dataset.Fare = train_datase... | Titanic - Machine Learning from Disaster |
1,496,791 | class TrainGlobalConfig:
num_workers = 2
batch_size = 5
n_epochs = 2
lr = 0.0001
folder = 'plabel_model'
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=Fa... | train_dataset.columns
test_dataset.columns
train_dataset.drop(['Name','SibSp','Parch','Ageband','Family','Fareband'],axis=1,inplace=True)
test_dataset.drop(['Name','SibSp','Parch','Ageband','Family','Fareband'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
1,496,791 | DATA_ROOT_PATH = '.. /input/global-wheat-detection/test'
class DatasetRetriever(Dataset):
def __init__(self, image_ids, transforms=None):
super().__init__()
self.image_ids = image_ids
self.transforms = transforms
def __getitem__(self, index: int):
image_id = self.image_ids[index]
image = cv2.imread(f'{DATA_ROOT_PATH}/{... | train_pid = train_dataset['PassengerId']
train_dataset.drop('PassengerId',axis=1,inplace=True)
test_pid = test_dataset['PassengerId']
test_dataset.drop('PassengerId',axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
1,496,791 | dataset = DatasetRetriever(
image_ids=np.array([path.split('/')[-1][:-4] for path in glob(f'{DATA_ROOT_PATH}/*.jpg')]),
transforms=get_test_transforms()
)
def collate_fn(batch):
return tuple(zip(*batch))
data_loader = DataLoader(
dataset,
batch_size=1,
shuffle=False,
num_workers=4,
drop_last=False,
collate_fn=colla... | label_encoder = preprocessing.LabelEncoder()
train_dataset['Title'] = label_encoder.fit_transform(train_dataset['Title'])
train_dataset['Sex'] = label_encoder.fit_transform(train_dataset['Sex'])
train_dataset['Embarked'] = label_encoder.fit_transform(train_dataset['Embarked'] ) | Titanic - Machine Learning from Disaster |
1,496,791 | def load_net(checkpoint_path):
config = get_efficientdet_config('tf_efficientdet_d5')
net = EfficientDet(config, pretrained_backbone=False)
config.num_classes = 1
config.image_size=512
net.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=dict(eps=.001, momentum=.01))
checkpoint = torch.load(che... | label_encoder = preprocessing.LabelEncoder()
test_dataset['Title'] = label_encoder.fit_transform(test_dataset['Title'])
test_dataset['Sex'] = label_encoder.fit_transform(test_dataset['Sex'])
test_dataset['Embarked'] = label_encoder.fit_transform(test_dataset['Embarked'])
test_dataset.head() | Titanic - Machine Learning from Disaster |
1,496,791 | class BaseWheatTTA:
image_size = 512
def augment(self, image):
raise NotImplementedError
def batch_augment(self, images):
raise NotImplementedError
def deaugment_boxes(self, boxes):
raise NotImplementedError
class TTAHorizontalFlip(BaseWheatTTA):
def augment(self, image):
return image.flip(1)
def batch_augment(sel... | X = train_dataset.drop('Survived',axis=1)
Y = train_dataset['Survived']
Z = test_dataset | Titanic - Machine Learning from Disaster |
1,496,791 | tta_transforms = []
for tta_combination in product([TTAHorizontalFlip() , None],
[TTAVerticalFlip() , None],
[TTARotate90() , None]):
tta_transforms.append(TTACompose([tta_transform for tta_transform in tta_combination if tta_transform]))<find_best_model_class> | X_train,X_test,Y_train,Y_test = train_test_split(X,Y,test_size=0.33,random_state=0 ) | Titanic - Machine Learning from Disaster |
1,496,791 | def make_tta_predictions(images, score_threshold=0.25):
with torch.no_grad() :
images = torch.stack(images ).float().cuda()
predictions = []
for tta_transform in tta_transforms:
result = []
det = net(tta_transform.batch_augment(images.clone()), torch.tensor([1]*images.shape[0] ).float().cuda())
for i in range(images.s... | svc = SVC(C=4,gamma='auto')
svc.fit(X_train, Y_train)
y_svc = svc.predict(X_test)
acc_svc = round(svc.score(X_train, Y_train)* 100, 2)
print("accuracy score is = {0}
f-score is = {1}".format(acc_svc,f1_score(Y_test,y_svc)))
sns.heatmap(confusion_matrix(Y_test,y_svc),annot=True,fmt='2.0f' ) | Titanic - Machine Learning from Disaster |
1,496,791 | def format_prediction_string(boxes, scores):
pred_strings = []
for j in zip(scores, boxes):
pred_strings.append("{0:.4f} {1} {2} {3} {4}".format(j[0], j[1][0], j[1][1], j[1][2], j[1][3]))
return " ".join(pred_strings )<categorify> | accuracy_kscore = []
for k in range(3,10):
knn = KNeighborsClassifier(n_neighbors = k)
knn.fit(X_train, Y_train)
Y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train)* 100, 2)
accuracy_kscore.append([k,acc_knn])
acc_knndf = pd.DataFrame(data=accuracy_kscore,columns=['k','accuracy'])
sns.barplot... | Titanic - Machine Learning from Disaster |
1,496,791 | results_plabel = []
for images, image_ids in data_loader:
predictions = make_tta_predictions(images)
for i, image in enumerate(images):
image_id = image_ids[i]
image_ = cv2.imread(f'{DATA_ROOT_PATH}/{image_id}.jpg', cv2.IMREAD_COLOR)
h,w,_ = np.shape(image_)
boxes, scores, labels = run_wbf(predictions, image_index=i... | knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)
Y_knn = knn.predict(X_test)
acc_knn = round(knn.score(X_train, Y_train)* 100, 2)
print("accuracy score is = {0}
f-score is = {1}".format(acc_knn,f1_score(Y_test,Y_knn)))
sns.heatmap(confusion_matrix(Y_test,Y_knn),annot=True,fmt='2.0f' ) | Titanic - Machine Learning from Disaster |
1,496,791 | results_df = pd.DataFrame(results_plabel, columns=['image_id', 'width','height','source','x','y','w','h'])
results_df.head()<feature_engineering> | gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
Y_gauss = gaussian.predict(X_test)
acc_gaussian = round(gaussian.score(X_train, Y_train)* 100, 2)
acc_gaussian | Titanic - Machine Learning from Disaster |
1,496,791 | results_df['image_id'] = results_df['image_id'].apply(lambda x: DATA_ROOT_PATH+'/'+ x+'.jpg' )<feature_engineering> | decision_tree = DecisionTreeClassifier(max_depth=10)
decision_tree.fit(X_train, Y_train)
Y_decision = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, Y_train)* 100, 2)
acc_decision_tree | Titanic - Machine Learning from Disaster |
1,496,791 | TRAIN_ROOT_PATH = '.. /input/global-wheat-detection/train'
marking['image_id'] = marking['image_id'].apply(lambda x: TRAIN_ROOT_PATH+'/'+ x+'.jpg' )<concatenate> | random_forest = RandomForestClassifier(n_estimators=400)
random_forest.fit(X_train, Y_train)
Y_random = random_forest.predict(X_test)
Y_Pred = random_forest.predict(Z)
random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train)* 100, 2)
acc_random_forest
| Titanic - Machine Learning from Disaster |
1,496,791 | train_data_plabel = pd.concat([results_df,marking], axis=0 )<feature_engineering> | kfold = KFold(n_splits=10,random_state=10)
classfy_mean = [];
accuracy_kfold = []
classifier = ['Logistic regression','SVC','KNN','Gaussian NB','Decision Tree','Random Forest']
models = [LogisticRegression() ,SVC(C=4,gamma='auto'),KNeighborsClassifier(n_neighbors=3),GaussianNB() ,
DecisionTreeClassifier(max_depth=10),... | Titanic - Machine Learning from Disaster |
1,496,791 | <import_modules><EOS> | submission = pd.DataFrame({
"PassengerId": test_pid,
"Survived": Y_Pred
})
submission
submission.to_csv("titanic_submission.csv", index=False ) | Titanic - Machine Learning from Disaster |
1,168,613 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<create_dataframe> | train1 = pd.read_csv('.. /input/train.csv', header = 0, dtype={'Age': np.float64})
test = pd.read_csv('.. /input/test.csv' , header = 0, dtype={'Age': np.float64})
train=train1.drop(columns=['Survived'])
allfeat = pd.concat([train, test],axis=0)
print(train.info())
print(train.shape)
print(test.shape ) | Titanic - Machine Learning from Disaster |
1,168,613 | fold_number = 0
train_dataset = DatasetRetriever(
image_ids=df_folds[df_folds['fold'] != fold_number].index.values,
marking=train_data_plabel,
transforms=get_train_transforms() ,
test=False,
)
validation_dataset = DatasetRetriever(
image_ids=df_folds[df_folds['fold'] == fold_number].index.values,
marking=train_data... | allfeat=allfeat.drop(columns=['PassengerId','Cabin','Ticket'] ) | Titanic - Machine Learning from Disaster |
1,168,613 | def collate_fn(batch):
return tuple(zip(*batch))
def run_training() :
device = torch.device('cuda:0')
net.to(device)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=TrainGlobalConfig.batch_size,
sampler=RandomSampler(train_dataset),
pin_memory=False,
drop_last=True,
num_workers=TrainGlobalConfi... | allfeat=pd.concat([allfeat,pd.get_dummies(allfeat['Pclass'])], axis=1)
allfeat=allfeat.drop(columns=['Pclass'] ) | Titanic - Machine Learning from Disaster |
1,168,613 | def get_net() :
config = get_efficientdet_config('tf_efficientdet_d5')
net = EfficientDet(config, pretrained_backbone=False)
config.num_classes = 1
config.image_size = 512
net.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=dict(eps=.001, momentum=.01))
checkpoint = torch.load(model_path)
net... | allfeat=pd.concat([allfeat,pd.get_dummies(allfeat['Sex'])], axis=1)
allfeat=allfeat.drop(columns=['Sex'] ) | Titanic - Machine Learning from Disaster |
1,168,613 | 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<train_model> | allfeat['FamilySize'] = allfeat['SibSp'] + allfeat['Parch'] + 1
allfeat=allfeat.drop(columns=['SibSp','Parch'] ) | Titanic - Machine Learning from Disaster |
1,168,613 | if len(os.listdir('.. /input/global-wheat-detection/test/')) <11:
pass
else:
run_training()<load_pretrained> | allfeat['IsAlone'] = 0
allfeat.loc[allfeat['FamilySize'] == 1, 'IsAlone'] = 1 | Titanic - Machine Learning from Disaster |
1,168,613 | weights = f'plabel_model/last-checkpoint.bin'
if not os.path.exists(weights):
weights = model_path
net = load_net(weights )<categorify> | allfeat['Embarked'] = allfeat['Embarked'].fillna('S')
allfeat=pd.concat([allfeat,pd.get_dummies(allfeat['Embarked'])],axis=1)
allfeat=allfeat.drop(columns='Embarked' ) | Titanic - Machine Learning from Disaster |
1,168,613 | results = []
for images, image_ids in data_loader:
predictions = make_tta_predictions(images)
for i, image in enumerate(images):
boxes, scores, labels = run_wbf(predictions, image_index=i)
boxes =(boxes*2 ).astype(np.int32 ).clip(min=0, max=1023)
image_id = image_ids[i]
boxes[:, 2] = boxes[:, 2] - boxes[:, 0]
boxes[... | allfeat['Fare'] = allfeat['Fare'].fillna(train['Fare'].median())
allfeat['CategoricalFare'] = pd.qcut(allfeat['Fare'], 4)
allfeat=pd.concat([allfeat,pd.get_dummies(allfeat['CategoricalFare'])],axis=1)
allfeat=allfeat.drop(columns=['Fare','CategoricalFare'] ) | Titanic - Machine Learning from Disaster |
1,168,613 | test_df = pd.DataFrame(results, columns=['image_id', 'PredictionString'])
test_df.to_csv('submission.csv', index=False)
test_df.head()<load_from_csv> | avg=allfeat['Age'].mean()
std=allfeat['Age'].std()
allfeat['Age']=allfeat['Age'].fillna(value=np.random.randint(avg-std,avg+std))
allfeat['Age'] = allfeat['Age'].astype(int)
allfeat['CategoricalAge'] = pd.cut(allfeat['Age'], 5)
allfeat=pd.concat([allfeat,pd.get_dummies(allfeat['CategoricalAge'])],axis=1)
allfeat=all... | Titanic - Machine Learning from Disaster |
1,168,613 | def load_dataset(root, path=None):
if path:
print("Dataset: ", path)
csv = pd.read_csv(path)
else:
csv = pd.read_csv(os.path.join(root, "train.csv"))
data = {}
for i in csv.index:
key = csv["image_id"][i]
bbox = json.loads(csv["bbox"][i])
bbox = [bbox[0], bbox[1], bbox[0] + bbox[2], bbox[1] + bbox[3], 0.0]
if key in... | allfeat['Title'] = allfeat['Title'].replace(['Lady', 'Countess','Capt', 'Col',\
'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
allfeat['Title'] = allfeat['Title'].replace('Mlle', 'Miss')
allfeat['Title'] = allfeat['Title'].replace('Ms', 'Miss')
allfeat['Title'] = allfeat['Title'].replace('Mme', 'M... | Titanic - Machine Learning from Disaster |
1,168,613 | def load_model(path, ctx=mx.cpu()):
net = gcv.model_zoo.yolo3_darknet53_custom(["wheat"], pretrained_base=False)
net.set_nms(post_nms=150)
net.load_parameters(path, ctx=ctx)
return net
<normalization> | allfeat.columns=['1', '2', '3', 'female', 'male', 'FamSize', 'IsAlone', 'C', 'Q', 'S', 'fare1', 'fare2', 'fare3', 'fare4', \
'age1', 'age2', 'age3', 'age4', 'age5', 'Master', 'Miss', 'Mr', 'Mrs', 'Rare']
print(list(allfeat))
X=allfeat[:][0:891]
testdf=allfeat[:][891:1309]
y=train1['Survived'] | Titanic - Machine Learning from Disaster |
1,168,613 | def inference(models, path):
raw = load_image(path)
rh, rw, _ = raw.shape
classes_list = []
scores_list = []
bboxes_list = []
for _ in range(5):
img, flips = gcv.data.transforms.image.random_flip(raw, px=0.5, py=0.5)
x, _ = gcv.data.transforms.presets.yolo.transform_test(img, short=img_s)
_, _, xh, xw = x.shape
rot ... | param_grid = [{'min_child_weight': np.arange(0.1, 10.1, 0.1)}]
i=1
kf = StratifiedKFold(n_splits=10,random_state=1,shuffle=True)
for train_index,test_index in kf.split(X,y):
print('
{} of kfold {}'.format(i,kf.n_splits))
xtr,xvl = X.loc[train_index],X.loc[test_index]
ytr,yvl = y[train_index],y[test_index]
model = Grid... | Titanic - Machine Learning from Disaster |
1,168,613 | <install_modules><EOS> | op=pd.DataFrame(data={'PassengerId':test['PassengerId'],'Survived':model.predict(testdf)})
op.to_csv('KFold_XGB_GridSearchCV_submission.csv',index=False ) | Titanic - Machine Learning from Disaster |
9,106,511 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | Image(url= "https://i.ytimg.com/vi/1PhMWUoPDsk/maxresdefault.jpg" ) | Titanic - Machine Learning from Disaster |
9,106,511 | NMS_IOU_THR = 0.6
NMS_CONF_THR = 0.25
best_iou_thr = 0.6
best_skip_box_thr = 0.43
best_final_score = 0
best_score_threshold = 0
SEED = 42
EPO = 15
WEIGHTS = '.. /input/yolov5weight60/best.pt'
CONFIG = '.. /input/modelyolov5/yolov5x.yaml'
DATA = '.. /input/configyolo5/wheat0.yaml'
is_TEST = len(os.listdir('.. /input/glo... | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Titanic - Machine Learning from Disaster |
9,106,511 | def set_seed(seed):
random.seed(seed)
np.random.seed(seed)
os.environ["PYTHONHASHSEED"] = str(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = True
set_seed(SEED )<load_from_csv> | train_df = pd.read_csv('.. /input/titanic/train.csv')
test_df = pd.read_csv('.. /input/titanic/test.csv')
survived = train_df['Survived']
passenger_id = test_df['PassengerId'] | Titanic - Machine Learning from Disaster |
9,106,511 | marking = pd.read_csv('.. /input/global-wheat-detection/train.csv')
bboxs = np.stack(marking['bbox'].apply(lambda x: np.fromstring(x[1:-1], sep=',')))
for i, column in enumerate(['x', 'y', 'w', 'h']):
marking[column] = bboxs[:,i]
marking.drop(columns=['bbox'], inplace=True )<feature_engineering> | submission = pd.read_csv('/kaggle/input/titanic/gender_submission.csv')
submission.head() | Titanic - Machine Learning from Disaster |
9,106,511 | def convertTrainLabel() :
df = pd.read_csv('.. /input/global-wheat-detection/train.csv')
bboxs = np.stack(df['bbox'].apply(lambda x: np.fromstring(x[1:-1], sep=',')))
for i, column in enumerate(['x', 'y', 'w', 'h']):
df[column] = bboxs[:,i]
df.drop(columns=['bbox'], inplace=True)
df['x_center'] = df['x'] + df['w']/2... | print(train_df.isnull().sum())
print(test_df.isnull().sum() ) | Titanic - Machine Learning from Disaster |
9,106,511 | def run_wbf(boxes, scores, image_size=1024, iou_thr=0.5, skip_box_thr=0.7, weights=None):
labels = [np.zeros(score.shape[0])for score in scores]
boxes = [box/(image_size)for box in boxes]
boxes, scores, labels = weighted_boxes_fusion(boxes, scores, labels, weights=None, iou_thr=iou_thr, skip_box_thr=skip_box_thr)
boxe... | train_test_data = [train_df, test_df]
print(train_test_data)
for dataset in train_test_data:
dataset['Title'] = dataset['Name'].str.extract('([A-Za-z]+)\.', expand=False ) | Titanic - Machine Learning from Disaster |
9,106,511 | @jit(nopython=True)
def calculate_iou(gt, pr, form='pascal_voc')-> float:
if form == 'coco':
gt = gt.copy()
pr = pr.copy()
gt[2] = gt[0] + gt[2]
gt[3] = gt[1] + gt[3]
pr[2] = pr[0] + pr[2]
pr[3] = pr[1] + pr[3]
dx = min(gt[2], pr[2])- max(gt[0], pr[0])+ 1
if dx < 0:
return 0.0
dy = min(gt[3], pr[3])- max(gt[1], pr[1... | train_df['Title'].value_counts()
| Titanic - Machine Learning from Disaster |
9,106,511 | def log(text):
print(text)
def optimize(space, all_predictions, n_calls=10):
@use_named_args(space)
def score(**params):
log('-'*10)
log(params)
final_score = calculate_final_score(all_predictions, **params)
log(f'final_score = {final_score}')
log('-'*10)
return -final_score
return gp_minimize(func=score, dimens... | test_df['Title'].value_counts()
| Titanic - Machine Learning from Disaster |
9,106,511 | def makePseudolabel() :
source = '.. /input/global-wheat-detection/test/'
weights = WEIGHTS
imagenames = os.listdir(source)
device = torch.device('cuda')if torch.cuda.is_available() else torch.device('cpu')
model = torch.load(weights, map_location=device)['model'].float()
model.to(device ).eval()
dataset = LoadImages... | title_mapping = {"Mr": 0, "Miss": 1, "Mrs": 2,
"Master": 3, "Dr": 3, "Rev": 3, "Col": 3, "Major": 3, "Mlle": 3,"Countess": 3,
"Ms": 3, "Lady": 3, "Jonkheer": 3, "Don": 3, "Dona" : 3, "Mme": 3,"Capt": 3,"Sir": 3 }
for dataset in train_test_data:
dataset['Title'] = dataset['Title'].map(title_mapping ) | Titanic - Machine Learning from Disaster |
9,106,511 | if PSEUDO or VALIDATE:
convertTrainLabel()<find_best_params> | train_df.drop('Name', axis=1, inplace=True)
test_df.drop('Name', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
9,106,511 | if VALIDATE and is_TEST:
all_predictions = validate()
for score_threshold in tqdm(np.arange(0, 1, 0.01), total=np.arange(0, 1, 0.01 ).shape[0]):
final_score = calculate_final_score(all_predictions, best_iou_thr, best_skip_box_thr, score_threshold)
if final_score > best_final_score:
best_final_score = final_score
bes... | sex_mapping = {"male": 0, "female": 1}
for dataset in train_test_data:
dataset['Sex'] = dataset['Sex'].map(sex_mapping ) | Titanic - Machine Learning from Disaster |
9,106,511 | def format_prediction_string(boxes, scores):
pred_strings = []
for j in zip(scores, boxes):
pred_strings.append("{0:.4f} {1} {2} {3} {4}".format(j[0], j[1][0], j[1][1], j[1][2], j[1][3]))
return " ".join(pred_strings)
def detect() :
source = '.. /input/global-wheat-detection/test/'
weights = 'weights/best.pt'
if not o... | train_df["Age"].fillna(train_df.groupby("Title")["Age"].transform("median"), inplace=True)
test_df["Age"].fillna(test_df.groupby("Title")["Age"].transform("median"), inplace=True ) | Titanic - Machine Learning from Disaster |
9,106,511 | results = detect()
test_df = pd.DataFrame(results, columns=['image_id', 'PredictionString'])
test_df.to_csv('submission.csv', index=False)
test_df.head()<load_from_csv> | train_df.groupby("Title")["Age"].transform("median")
| Titanic - Machine Learning from Disaster |
9,106,511 | def load_dataset(root):
csv = pd.read_csv(os.path.join(root, "train.csv"))
data = {}
for i in csv.index:
key = csv["image_id"][i]
bbox = json.loads(csv["bbox"][i])
bbox = [bbox[0], bbox[1], bbox[0] + bbox[2], bbox[1] + bbox[3], 0.0]
if key in data:
data[key].append(bbox)
else:
data[key] = [bbox]
return sorted(
[(k, ... | for dataset in train_test_data:
dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0,
dataset.loc[(dataset['Age'] > 16)&(dataset['Age'] <= 26), 'Age'] = 1,
dataset.loc[(dataset['Age'] > 26)&(dataset['Age'] <= 36), 'Age'] = 2,
dataset.loc[(dataset['Age'] > 36)&(dataset['Age'] <= 62), 'Age'] = 3,
dataset.loc[ dataset['Age'] > 6... | Titanic - Machine Learning from Disaster |
9,106,511 | def load_model(path, ctx=mx.cpu()):
net = gcv.model_zoo.yolo3_darknet53_custom(["wheat"], pretrained_base=False)
net.set_nms(post_nms=150)
net.load_parameters(path, ctx=ctx)
return net
<normalization> | Pclass1 = train_df[train_df['Pclass']==1]['Embarked'].value_counts()
Pclass2 = train_df[train_df['Pclass']==2]['Embarked'].value_counts()
Pclass3 = train_df[train_df['Pclass']==3]['Embarked'].value_counts()
df = pd.DataFrame([Pclass1, Pclass2, Pclass3])
df.index = ['1st class','2nd class', '3rd class']
df.plot(kind='b... | Titanic - Machine Learning from Disaster |
9,106,511 | def inference(models, path):
raw = load_image(path)
rh, rw, _ = raw.shape
classes_list = []
scores_list = []
bboxes_list = []
for _ in range(5):
img, flips = gcv.data.transforms.image.random_flip(raw, px=0.5, py=0.5)
x, _ = gcv.data.transforms.presets.yolo.transform_test(img, short=img_s)
_, _, xh, xw = x.shape
rot ... | for dataset in train_test_data:
dataset['Embarked'] = dataset['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
9,106,511 | amp.init()
rounds = 3
max_epochs = 5
learning_rate = 0.001
batch_size = 8
img_s = 512
threshold = 0.1
context = mx.gpu()
print("Loading pre-trained model...")
model = load_model("/kaggle/input/global-wheat-detection-private/global-wheat-yolo3-darknet53.params", ctx=context)
print("Loading training set...")
dataset =... | embarked_mapping = {"S": 0, "C": 1, "Q": 2}
for dataset in train_test_data:
dataset['Embarked'] = dataset['Embarked'].map(embarked_mapping ) | Titanic - Machine Learning from Disaster |
9,106,511 | !rm global-wheat-yolo3-darknet53.params<load_pretrained> | train_df["Fare"].fillna(train_df.groupby("Pclass")["Fare"].transform("median"), inplace=True)
test_df["Fare"].fillna(test_df.groupby("Pclass")["Fare"].transform("median"), inplace=True)
train_df.head(5 ) | Titanic - Machine Learning from Disaster |
9,106,511 | def load_image(path):
with open(path, "rb")as f:
buf = f.read()
return mx.image.imdecode(buf)
<load_pretrained> | train_df.Cabin.value_counts()
| Titanic - Machine Learning from Disaster |
9,106,511 | def load_model(path, ctx=mx.cpu()):
net = gcv.model_zoo.yolo3_darknet53_custom(["wheat"], pretrained_base=False)
net.set_nms(post_nms=150)
net.load_parameters(path, ctx=ctx)
return net
<load_pretrained> | for dataset in train_test_data:
dataset['Cabin'] = dataset['Cabin'].str[:1] | Titanic - Machine Learning from Disaster |
9,106,511 | threshold = 0.1
img_s = 512
context = mx.gpu()
print("Loading test images...")
images = [
(os.path.join(dirname, filename), os.path.splitext(filename)[0])
for dirname, _, filenames in os.walk('/kaggle/input/global-wheat-detection/test')for filename in filenames
]
print("Loading model...")
model = load_model("/kaggl... | cabin_mapping = {"A": 0, "B": 0.4, "C": 0.8, "D": 1.2, "E": 1.6, "F": 2, "G": 2.4, "T": 2.8}
for dataset in train_test_data:
dataset['Cabin'] = dataset['Cabin'].map(cabin_mapping ) | Titanic - Machine Learning from Disaster |
9,106,511 | sns.set_style('darkgrid')
warnings.filterwarnings('ignore')
<load_from_csv> | train_df["Cabin"].fillna(train_df.groupby("Pclass")["Cabin"].transform("median"), inplace=True)
test_df["Cabin"].fillna(test_df.groupby("Pclass")["Cabin"].transform("median"), inplace=True ) | 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.