kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,626,598 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | import pandas as pd
import numpy as np | Titanic - Machine Learning from Disaster |
11,626,598 | cols = set(merge.columns.values)
basic_cols = {'name', 'item_condition_id', 'brand_name',
'shipping', 'item_description', 'gencat_name',
'subcat1_name', 'subcat2_name', 'name_first', 'is_train'}
cols_to_normalize = cols - basic_cols - {'price_in_name'}
other_cols = basic_cols | {'price_in_name'}<split> | train = pd.read_csv(r'/kaggle/input/titanic/train.csv')
test = pd.read_csv(r'/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
11,626,598 | df_test = merge.loc[merge['is_train'] == 0]
df_train = merge.loc[merge['is_train'] == 1]
del merge
gc.collect()
df_test = df_test.drop(['is_train'], axis=1)
df_train = df_train.drop(['is_train'], axis=1)
if SUBMIT_MODE:
y_train = y
del y
gc.collect()
else:
df_train, df_test, y_train, y_test = train_test_split(df_trai... | train.isna().sum() | Titanic - Machine Learning from Disaster |
11,626,598 | wb = wordbatch.WordBatch(normalize_text, extractor=(WordBag, {"hash_ngrams": 2,
"hash_ngrams_weights": [1.5, 1.0],
"hash_size": 2 ** 29,
"norm": None,
"tf": 'binary',
"idf": None,
}), procs=8)
wb.dictionary_freeze = True
X_name_train = wb.fit_transform(df_train['name'])
X_name_test = wb.transform(df_test['name'])
de... | dfs = [train ,test]
for df in dfs:
df['Age'].fillna(df['Age'].median() , inplace = True ) | Titanic - Machine Learning from Disaster |
11,626,598 | wb = wordbatch.WordBatch(normalize_text, extractor=(WordBag, {"hash_ngrams": 2,
"hash_ngrams_weights": [1.0, 1.0],
"hash_size": 2 ** 28,
"norm": "l2",
"tf": 1.0,
"idf": None}), procs=8)
wb.dictionary_freeze = True
X_description_train = wb.fit_transform(df_train['item_description'])
X_description_test = wb.transform(d... | train.isna().sum() | Titanic - Machine Learning from Disaster |
11,626,598 | X_train_1, X_train_2, y_train_1, y_train_2 = train_test_split(X_description_train, y_train,
test_size = 0.5,
shuffle = False)
print('[{}] Finished splitting'.format(time.time() - start_time))
model = Ridge(solver="sag", fit_intercept=True, random_state=205, alpha=3.3)
model.fit(X_train_1, y_train_1)
print('[{}] Fini... | train['Cabin'].value_counts() | Titanic - Machine Learning from Disaster |
11,626,598 | model = Ridge(solver="sag", fit_intercept=True, random_state=205, alpha=3.3)
model.fit(X_train_1, y_train_1)
print('[{}] Finished to train name ridge(1)'.format(time.time() - start_time))
name_ridge_preds1 = model.predict(X_train_2)
name_ridge_preds1f = model.predict(X_name_test)
print('[{}] Finished to predict nam... | letters = []
for i in cabins:
letter= i[0]
letters.append(letter ) | Titanic - Machine Learning from Disaster |
11,626,598 | del X_train_1
del X_train_2
del y_train_1
del y_train_2
del name_ridge_preds1
del name_ridge_preds1f
del name_ridge_preds2
del name_ridge_preds2f
del desc_ridge_preds1
del desc_ridge_preds1f
del desc_ridge_preds2
del desc_ridge_preds2f
gc.collect()
print('[{}] Finished garbage collection'.format(time.time() - start_tim... | train['Cabin'] = letters | Titanic - Machine Learning from Disaster |
11,626,598 | lb = LabelBinarizer(sparse_output=True)
X_brand_train = lb.fit_transform(df_train['brand_name'])
X_brand_test = lb.transform(df_test['brand_name'])
print('[{}] Finished label binarize `brand_name`'.format(time.time() - start_time))<categorify> | letters = []
for i in cabins:
letter = i[0]
letters.append(letter ) | Titanic - Machine Learning from Disaster |
11,626,598 | X_cat_train = lb.fit_transform(df_train['gencat_name'])
X_cat_test = lb.transform(df_test['gencat_name'])
X_cat1_train = lb.fit_transform(df_train['subcat1_name'])
X_cat1_test = lb.transform(df_test['subcat1_name'])
X_cat2_train = lb.fit_transform(df_train['subcat2_name'])
X_cat2_test = lb.transform(df_test['subca... | test['Cabin'] = letters | Titanic - Machine Learning from Disaster |
11,626,598 | X_dummies_train = csr_matrix(
pd.get_dummies(df_train[list(cols -(basic_cols - {'item_condition_id', 'shipping'})) ],
sparse=True ).values)
print('[{}] Create dummies completed - train'.format(time.time() - start_time))
X_dummies_test = csr_matrix(
pd.get_dummies(df_test[list(cols -(basic_cols - {'item_condition_id'... | train['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
11,626,598 | sparse_merge_train = hstack(( X_dummies_train, X_description_train, X_brand_train, X_cat_train,
X_cat1_train, X_cat2_train, X_name_train)).tocsr()
del X_description_train, lb, X_name_train, X_dummies_train
gc.collect()
print('[{}] Create sparse merge train completed'.format(time.time() - start_time))
sparse_merge_test ... | len(train[train['Pclass'] == 1]), len(train[train['Pclass'] == 2]), len(train[train['Pclass'] == 3] ) | Titanic - Machine Learning from Disaster |
11,626,598 | if SUBMIT_MODE:
iters = 3
else:
iters = 1
rounds = 3
model = FM_FTRL(alpha=0.035, beta=0.001, L1=0.00001, L2=0.15, D=sparse_merge_train.shape[1],
alpha_fm=0.05, L2_fm=0.0, init_fm=0.01,
D_fm=100, e_noise=0, iters=iters, inv_link="identity", threads=4)
if SUBMIT_MODE:
model.fit(sparse_merge_train, y_train)
print('[{}]... | percentages = []
first = 136 / 216
second = 87/ 184
third = 119/491
percentages.append(first)
percentages.append(second)
percentages.append(third ) | Titanic - Machine Learning from Disaster |
11,626,598 | del model
gc.collect()
if not SUBMIT_MODE:
print("FM_FTRL dev RMSLE:", rmse(predsFM, y_test))
fselect = SelectKBest(f_regression, k=48000)
train_features = fselect.fit_transform(sparse_merge_train, y_train)
test_features = fselect.transform(sparse_merge_test)
print('[{}] Select best completed'.format(time.time() - s... | percents = pd.DataFrame(percentages)
percents.index+=1 | Titanic - Machine Learning from Disaster |
11,626,598 | tv = TfidfVectorizer(max_features=250000,
ngram_range=(1, 3),
stop_words=None)
X_name_train = tv.fit_transform(df_train['name'])
print('[{}] Finished TFIDF vectorize `name`(1/2)'.format(time.time() - start_time))
X_name_test = tv.transform(df_test['name'])
print('[{}] Finished TFIDF vectorize `name`(2/2)'.format(tim... | train['Family'] = train.apply(lambda x: x['SibSp'] + x['Parch'], axis = 1)
test['Family'] = test.apply(lambda x: x['SibSp'] + x['Parch'], axis = 1 ) | Titanic - Machine Learning from Disaster |
11,626,598 | def rmsle(y, y_pred):
assert len(y)== len(y_pred)
to_sum = [(math.log(y_pred[i] + 1)- math.log(y[i] + 1)) ** 2.0 for i,pred in enumerate(y_pred)]
return(sum(to_sum)*(1.0/len(y)))** 0.5
<load_from_csv> | train.drop(['SibSp', 'Parch', 'Name', 'Ticket'], axis = 1, inplace = True)
test.drop(['SibSp', 'Parch', 'Name', 'Ticket'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
11,626,598 | print("Loading data...")
train = pd.read_table(".. /input/train.tsv")
test = pd.read_table(".. /input/test.tsv")
print(train.shape)
print(test.shape )<categorify> | test.isna().sum() | Titanic - Machine Learning from Disaster |
11,626,598 | print("Handling missing values...")
def handle_missing(dataset):
dataset.category_name.fillna(value="missing", inplace=True)
dataset.brand_name.fillna(value="missing", inplace=True)
dataset.item_description.fillna(value="missing", inplace=True)
return(dataset)
train = handle_missing(train)
test = handle_missing(t... | test['Fare'].fillna(test['Fare'].median() , inplace = True ) | Titanic - Machine Learning from Disaster |
11,626,598 | print("Handling categorical variables...")
le = LabelEncoder()
le.fit(np.hstack([train.category_name, test.category_name]))
train.category_name = le.transform(train.category_name)
test.category_name = le.transform(test.category_name)
le.fit(np.hstack([train.brand_name, test.brand_name]))
train.brand_name = le.transf... | train_df = pd.get_dummies(train)
test_df = pd.get_dummies(test ) | Titanic - Machine Learning from Disaster |
11,626,598 | print("Text to seq process...")
raw_text = np.hstack([train.item_description.str.lower() , train.name.str.lower() ])
print(" Fitting tokenizer...")
tok_raw = Tokenizer()
tok_raw.fit_on_texts(raw_text)
print(" Transforming text to seq...")
train["seq_item_description"] = tok_raw.texts_to_sequences(train.item_descri... | train_df.drop('PassengerId', axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
11,626,598 | MAX_NAME_SEQ = 10
MAX_ITEM_DESC_SEQ = 75
MAX_TEXT = np.max([np.max(train.seq_name.max())
, np.max(test.seq_name.max())
, np.max(train.seq_item_description.max())
, np.max(test.seq_item_description.max())])+2
MAX_CATEGORY = np.max([train.category_name.max() , test.category_name.max() ])+1
MAX_BRAND = np.max([train.br... | y = train_df['Survived']
train_df.drop('Survived', axis = 1, inplace = True)
train_df.drop('Cabin_T', axis = 1, inplace = True)
test_df.drop('PassengerId', axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
11,626,598 | train["target"] = np.log(train.price+1)
target_scaler = MinMaxScaler(feature_range=(-1, 1))
train["target"] = target_scaler.fit_transform(train.target.reshape(-1,1))
pd.DataFrame(train.target ).hist()<split> | X_test = test_df
X_train = train_df | Titanic - Machine Learning from Disaster |
11,626,598 | dtrain, dvalid = train_test_split(train, random_state=123, train_size=0.99)
print(dtrain.shape)
print(dvalid.shape )<categorify> | from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
11,626,598 | def get_keras_data(dataset):
X = {
'name': pad_sequences(dataset.seq_name, maxlen=MAX_NAME_SEQ)
,'item_desc': pad_sequences(dataset.seq_item_description, maxlen=MAX_ITEM_DESC_SEQ)
,'brand_name': np.array(dataset.brand_name)
,'category_name': np.array(dataset.category_name)
,'item_condition': np.array(dataset.item_c... | rfc = RandomForestClassifier() | Titanic - Machine Learning from Disaster |
11,626,598 | def get_callbacks(filepath, patience=2):
es = EarlyStopping('val_loss', patience=patience, mode="min")
msave = ModelCheckpoint(filepath, save_best_only=True)
return [es, msave]
def rmsle_cust(y_true, y_pred):
first_log = K.log(K.clip(y_pred, K.epsilon() , None)+ 1.)
second_log = K.log(K.clip(y_true, K.epsilon() , Non... | param_grid = {
'n_estimators': [200, 500, 1000],
'max_features': ['auto'],
'max_depth': [6, 7, 8],
'criterion': ['entropy']
} | Titanic - Machine Learning from Disaster |
11,626,598 | BATCH_SIZE = 20000
epochs = 5
model = get_model()
model.fit(X_train, dtrain.target, epochs=epochs, batch_size=BATCH_SIZE
, validation_data=(X_valid, dvalid.target)
, verbose=1 )<compute_train_metric> | CV = GridSearchCV(estimator = rfc, param_grid = param_grid, cv = 5)
CV.fit(X_train, y)
CV.best_estimator_ | Titanic - Machine Learning from Disaster |
11,626,598 | val_preds = model.predict(X_valid)
val_preds = target_scaler.inverse_transform(val_preds)
val_preds = np.exp(val_preds)+1
y_true = np.array(dvalid.price.values)
y_pred = val_preds[:,0]
v_rmsle = rmsle(y_true, y_pred)
print(" RMSLE error on dev test: "+str(v_rmsle))<predict_on_test> | rfc = RandomForestClassifier(criterion = 'entropy', max_depth = 8, n_estimators = 500, random_state = 42 ) | Titanic - Machine Learning from Disaster |
11,626,598 | preds = model.predict(X_test, batch_size=BATCH_SIZE)
preds = target_scaler.inverse_transform(preds)
preds = np.exp(preds)-1
submission = test[["test_id"]]
submission["price"] = preds<save_to_csv> | rfc.fit(X_train, y ) | Titanic - Machine Learning from Disaster |
11,626,598 | submission.to_csv("./myNNsubmission.csv", index=False)
submission.price.hist()
<set_options> | y_pred = rfc.predict(X_test ) | Titanic - Machine Learning from Disaster |
11,626,598 | %matplotlib inline<load_from_csv> | y_pred | Titanic - Machine Learning from Disaster |
11,626,598 | train = pd.read_csv('.. /input/mercar/train.tsv', sep='\t')
test = pd.read_csv('.. /input/mercari-price-suggestion-challenge/test_stg2.tsv', sep='\t')
print(train.shape)
print(test.shape )<compute_test_metric> | submission = y_pred.reshape(-1, 1 ) | Titanic - Machine Learning from Disaster |
11,626,598 | def rmsle(y, y_pred):
return(np.sum(( np.log(y_pred + 1)-(np.log(y + 1)))** 2)/ len(y)) ** 0.5<categorify> | sub_df = pd.DataFrame(submission ) | Titanic - Machine Learning from Disaster |
11,626,598 | def preprocessing_data(data):
data.category_name.fillna(value='missing', inplace=True)
data.brand_name.fillna(value='missing', inplace=True)
data.item_description.fillna(value='missing', inplace=True)
return data<categorify> | sub_df['PassengerId'] = test['PassengerId']
sub_df['Survived'] = submission
cols = ['PassengerId',
'Survived']
sub_df.drop(0, axis = 1, inplace = True)
sub_df.columns = [i for i in cols]
sub_df = sub_df.set_index('PassengerId' ) | Titanic - Machine Learning from Disaster |
11,626,598 | <categorify><EOS> | sub_df.to_csv(r'submission.csv' ) | Titanic - Machine Learning from Disaster |
525,838 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Titanic - Machine Learning from Disaster |
525,838 | text_raw = np.hstack([train.item_description.str.lower() , train.name.str.lower() ])
tok = Tokenizer()
tok.fit_on_texts(text_raw)
train['seq_item_description'] = tok.texts_to_sequences(train.item_description.str.lower())
test['seq_item_description'] = tok.texts_to_sequences(test.item_description.str.lower())
train[... | def get_title(data_frame):
name_data = data_frame["Name"]
data_frame["Title"] = [name.split(", ", 1)[1].split(".", 1)[0] for name in name_data]
titles = []
for title in data_frame["Title"]:
if title not in titles:
titles.append(title)
return data_frame, titles
train, titles = get_title(train)
print(titles ) | Titanic - Machine Learning from Disaster |
525,838 | max_name_seq = np.max([np.max(train.seq_name.apply(lambda x: len(x))),
np.max(test.seq_name.apply(lambda x: len(x)))])
max_seq_item_des = np.max([np.max(train.seq_item_description.apply(lambda x: len(x))),
np.max(test.seq_item_description.apply(lambda x: len(x)))] )<define_variables> | def title2int(data):
data["Title"].replace(["Major", "Capt", "Sir", "Dr", "Don", "Mlle", "Mme", "Ms", "Dona", "Lady", "the Countess", "Jonkheer", "Col", "Rev"],
["Mr", "Mr", "Mr", "Mr", "Mr", "Miss", "Miss", "Miss", "Mrs", "Mrs", "Mrs", "Other", "Other", "Other"], inplace = True)
data["Title"].replace(["Mr", "Miss", "... | Titanic - Machine Learning from Disaster |
525,838 | MAX_NAME_SEQ = 17
MAX_ITEM_DESCRIPTION = 70
MAX_TEXT = np.max([np.max(train.seq_name.max()), np.max(test.seq_name.max()),
np.max(train.seq_item_description.max()), np.max(test.seq_item_description.max())])+ 2
MAX_BRAND_NAME = np.max([train.brand_name.max() , test.brand_name.max() ])+ 1
MAX_CATEGORY_NAME = np.max([train... | train.groupby("Title")["Age"].mean() | Titanic - Machine Learning from Disaster |
525,838 | train['target'] = np.log(train.price + 1)
target_scaler = MinMaxScaler(feature_range=(-1, 1))
train['target'] = target_scaler.fit_transform(train['target'].reshape(-1, 1))
dtrain, dvalid = train_test_split(train, random_state=42, train_size = 0.95 )<prepare_x_and_y> | train.groupby("Pclass")["Fare"].mean() | Titanic - Machine Learning from Disaster |
525,838 | def get_keras_data(data):
X = {
'name': pad_sequences(data.seq_name, maxlen=MAX_NAME_SEQ),
'item_desc': pad_sequences(data.seq_item_description, maxlen=MAX_ITEM_DESCRIPTION),
'brand_name': np.array(data.brand_name),
'category_name': np.array(data.category_name),
'item_condition': np.array(data.item_condition_id),
'num_... | def fareG2int(data):
data["Fare_group"] = "NaN"
data.loc[data["Fare"] < 10, "Fare_group"] = 2
data.loc[(data["Fare"] >= 10)&(data["Fare"] < 65), "Fare_group"] = 2
data.loc[data["Fare"] >= 65, "Fare_group"] = 1
return data
train = fareG2int(train ) | Titanic - Machine Learning from Disaster |
525,838 | def def_get_callback(filepath, patience=2):
es = EarlyStopping('val_loss', partience=partience, mode='min')
msave = ModelCheckpoint(filepath, save_best_only=True)
return [es, msave]
def rmsle_cust(y_true, y_pred):
first_log = backend.log(backend.clip(y_pred, backend.epsilon() , None)+ 1)
second_log = backend.log(bac... | train["Embarked"] = train["Embarked"].fillna("S" ) | Titanic - Machine Learning from Disaster |
525,838 | batch_size = 20000
epochs = 5
model.fit(X_train, dtrain.target, epochs=epochs, batch_size=batch_size, validation_data=(X_valid, dvalid.target), verbose=1 )<predict_on_test> | train["Embarked"].replace(["S", "Q", "C"], [0, 1, 2], inplace = True ) | Titanic - Machine Learning from Disaster |
525,838 | val_preds = model.predict(X_valid)
val_preds = target_scaler.inverse_transform(val_preds)
val_preds = np.exp(val_preds)+ 1
y_true = np.array(dvalid.price.values)
y_pred = val_preds[:,0]
rmsle(y_true, y_pred )<predict_on_test> | def cab2int(data):
data.loc[data["Cabin"] == "Known", 'Cabin'] = 1
data.loc[data["Cabin"] == "Unknown", 'Cabin'] = 0
return data
train = cab2int(train ) | Titanic - Machine Learning from Disaster |
525,838 | preds_train = model.predict(X_train, batch_size=batch_size)
preds_train = target_scaler.inverse_transform(preds_train)
preds_train = np.exp(preds_train)- 1
dtrain['price_rnn'] = preds_train
preds_valid = model.predict(X_valid, batch_size=batch_size)
preds_valid = target_scaler.inverse_transform(preds_valid)
preds_v... | train["Sex"].replace(["male", "female"], [0, 1], inplace = True ) | Titanic - Machine Learning from Disaster |
525,838 | from xgboost import XGBRegressor<prepare_x_and_y> | def assign_missing_ages(data_frame, features):
age_data = data_frame[features]
known_ages = age_data[age_data.Age.notnull() ].as_matrix()
unknown_ages = age_data[age_data.Age.isnull() ].as_matrix()
target = known_ages[:, 0]
eigen_val = known_ages[:, 1:]
rfr = RandomForestRegressor(random_state = 0, n_estimators = 2000,... | Titanic - Machine Learning from Disaster |
525,838 | X_train_xgb = dtrain[['item_condition_id', 'category_name', 'brand_name', 'shipping', 'price_rnn']]
y_train_xgb = dtrain.price
X_valid_xgb = dvalid[['item_condition_id', 'category_name', 'brand_name', 'shipping', 'price_rnn']]
y_valid_xgb = dvalid.price<train_model> | train.groupby("Title")["Age"].mean() | Titanic - Machine Learning from Disaster |
525,838 | model_xgb = XGBRegressor(booster='gbtree', max_depth=13, n_estimators=250, eta=0.05, reg_lambda=4, reg_alpha=2)
model_xgb.fit(X_train_xgb, y_train_xgb)
pred = model_xgb.predict(X_valid_xgb)
print(rmsle(y_valid_xgb, pred))<predict_on_test> | def ageG2int(data):
data["Age_group"] = "NaN"
data.loc[data["Age"] <= 16, "Age_group"] = 0
data.loc[(data["Age"] > 16)&(data["Age"] <= 32), "Age_group"] = 1
data.loc[(data["Age"] > 32)&(data["Age"] <= 48), "Age_group"] = 3
data.loc[(data["Age"] > 48)&(data["Age"] <= 64), "Age_group"] = 4
data.loc[data["Age"] > 64, "Age... | Titanic - Machine Learning from Disaster |
525,838 | preds_test = model.predict(X_test, batch_size=batch_size)
preds_test = target_scaler.inverse_transform(preds_test)
preds_test = np.exp(preds_test)- 1
test['price_rnn'] = preds_test<save_to_csv> | def child2int(data):
data["Child"] = "NaN"
data.loc[data["Age"] <= 18, "Child"] = 0
data.loc[data["Age"] > 18, "Child"] = 1
return data
train = child2int(train ) | Titanic - Machine Learning from Disaster |
525,838 | test_xgb = test[['item_condition_id', 'category_name', 'brand_name', 'shipping', 'price_rnn']]
preds = model_xgb.predict(test_xgb)
index = pd.Series(np.arange(len(test_xgb)) , name='test_id')
price = pd.Series(preds, name='price')
submission = pd.concat([index, price], axis=1)
submission.to_csv('submission.csv', in... | train["FamSize"] = train["SibSp"] + train["Parch"] + 1 | Titanic - Machine Learning from Disaster |
525,838 | !pip install -q efficientnet_pytorch > /dev/null<set_options> | def famG2int(data):
data["Fam_group"] = "NaN"
data.loc[data["FamSize"] == 1, "Fam_group"] = 0
data.loc[data["FamSize"] > 1, "Fam_group"] = 1
return data
train = famG2int(train ) | Titanic - Machine Learning from Disaster |
525,838 | SEED = 512
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> | train_one = train[:] | Titanic - Machine Learning from Disaster |
525,838 |
<normalization> | test["Embarked"].replace(["S", "Q", "C"], [0, 1, 2], inplace = True)
test["Fare"] = test["Fare"].fillna(test["Fare"].median())
test, test_titles = get_title(test)
test = title2int(test)
test["Sex"].replace(["male", "female"], [0, 1], inplace = True)
test = Cabin_type(test)
test = cab2int(test)
test = fareG2int(t... | Titanic - Machine Learning from Disaster |
525,838 | 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> | def my_models(model, X_train, Y_train, X_test, Y_test):
my_model = model.fit(X_train, Y_train)
print(my_model.feature_importances_)
print(my_model.score(X_train, Y_train))
model_prediction = my_model.predict(X_test)
acc = metrics.accuracy_score(model_prediction, Y_test)
return acc, my_model | Titanic - Machine Learning from Disaster |
525,838 | 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... | final_features = ["Pclass", "Title", "Sex", "Child", "Fam_group", "Fare", "Cabin", "Embarked"]
final_data = train_one[["Survived"] + final_features]
training, testing = train_test_split(final_data, test_size = 0.3, random_state = 0, stratify = final_data["Survived"])
X_train = training[training.columns[1:]]
Y_train = ... | Titanic - Machine Learning from Disaster |
525,838 | 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(... | tree_model = tree.DecisionTreeClassifier(max_depth = 8, max_leaf_nodes = 7, min_samples_leaf = 10, random_state = 0)
forest_model = RandomForestClassifier(max_depth = 8, max_leaf_nodes = 9, n_estimators = 300, random_state = 0)
gradboost_model = GradientBoostingClassifier(learning_rate = 0.01, max_depth = 7,
max_feat... | Titanic - Machine Learning from Disaster |
525,838 | 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.... | tree_acc, my_tree = my_models(tree_model, X_train, Y_train, X_test, Y_test)
print("The accuracy of Decision Tree is", tree_acc)
forest_acc, my_forest = my_models(forest_model, X_train, Y_train, X_test, Y_test)
print("The accuracy of Random Forest is", forest_acc)
gradboost_acc, my_gradboost = my_models(gradboost_mo... | Titanic - Machine Learning from Disaster |
525,838 | <init_hyperparams><EOS> | final_test = test_one[final_features]
tree_prediction = my_tree.predict(final_test)
forest_prediction = my_forest.predict(final_test)
gradboost_prediction = my_gradboost.predict(final_test)
test_cp1 = test_one[:]
test_cp2 = test_one[:]
test_cp3 = test_one[:]
headers = ["PassengerId", "Survived"]
test_cp1["Survived"]... | Titanic - Machine Learning from Disaster |
3,614,931 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<choose_model_class> | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
3,614,931 | 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()<init_hyperparams> | passengerId = test_df.PassengerId
train_df = train_df.drop('PassengerId', axis = 1)
test_df = test_df.drop('PassengerId', axis = 1 ) | Titanic - Machine Learning from Disaster |
3,614,931 | class TrainGlobalConfig:
num_workers = 4
batch_size = 22
n_epochs = 3
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.6,
patience=1,
verbose=False,
threshold=0.001,
th... | train_df['Title'] = train_df.Name.apply(lambda name: name.split(',')[1].split('.')[0].strip())
train_df['Title'].value_counts() | Titanic - Machine Learning from Disaster |
3,614,931 | 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,
)... | norm_titles = {
"Capt": "Officer",
"Col": "Officer",
"Major": "Officer",
"Jonkheer": "Royalty",
"Don": "Royalty",
"Sir" : "Royalty",
"Dr": "Officer",
"Rev": "Officer",
"the Countess":"Royalty",
"Dona": "Royalty",
"Mme": "Mrs",
"Mlle": "Miss",
"Ms": "Mrs",
"Mr" : "Mr",
"Mrs" : "Mrs",
"Miss" : "Miss",
"Master" : "Master"... | Titanic - Machine Learning from Disaster |
3,614,931 | !nvidia-smi<train_model> | train_grouped = train_df.groupby(['Sex','Title','Pclass'])
train_grouped.Age.mean() | Titanic - Machine Learning from Disaster |
3,614,931 | run_training()<load_from_csv> | train_df.Age = train_grouped.Age.apply(lambda x: x.fillna(x.mean())) | Titanic - Machine Learning from Disaster |
3,614,931 | file = open('.. /input/alaska2-checkpoint/log.txt', 'r')
for line in file.readlines() :
print(line[:-1])
file.close()<load_pretrained> | train_df.Age.isnull().sum() | Titanic - Machine Learning from Disaster |
3,614,931 | checkpoint = torch.load('.. /input/alaska2-checkpoint/last-checkpoint.bin')
net.load_state_dict(checkpoint['model_state_dict']);
net.eval() ;<data_type_conversions> | test_df['Title'] = test_df.Name.apply(lambda name: name.split(',')[1].split('.')[0].strip())
test_df.Title = test_df.Title.map(norm_titles)
test_grouped = test_df.groupby(['Sex','Title','Pclass'])
test_df.Age = test_grouped.Age.apply(lambda x: x.fillna(x.mean()))
test_df.Age.isnull().sum()
test_df.Title.value_counts... | Titanic - Machine Learning from Disaster |
3,614,931 | 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)
... | most_embarked = train_df.Embarked.value_counts().index[0]
train_df.Embarked = train_df.Embarked.fillna(most_embarked)
train_df.Fare = train_df.Fare.fillna(train_df.Fare.median())
train_df.Cabin = train_df.Cabin.fillna('U')
train_df.Cabin = train_df.Cabin.map(lambda x: x[0])
train_df['Cabin'] = train_df.Cabin.replac... | Titanic - Machine Learning from Disaster |
3,614,931 | 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... | test_df.Cabin = test_df.Cabin.fillna('U')
most_embarked = test_df.Embarked.value_counts().index[0]
test_df.Embarked = test_df.Embarked.fillna(most_embarked)
test_df.Fare = test_df.Fare.fillna(train_df.Fare.median())
test_df['Cabin'] = test_df.Cabin.apply(lambda name: name[0])
test_df.Cabin.value_counts() | Titanic - Machine Learning from Disaster |
3,614,931 | submissions = []
for mode in range(0,4):
submission = pd.DataFrame(results[mode])
submissions.append(submission )<save_to_csv> | train_df.Sex = train_df.Sex.map({"male": 0, "female":1})
pclass_dummies = pd.get_dummies(train_df.Pclass, prefix="Pclass")
title_dummies = pd.get_dummies(train_df.Title, prefix="Title")
cabin_dummies = pd.get_dummies(train_df.Cabin, prefix="Cabin")
embarked_dummies = pd.get_dummies(train_df.Embarked, prefix="Embark... | Titanic - Machine Learning from Disaster |
3,614,931 | for mode in range(0,4):
submissions[mode].to_csv(f'submission_{mode}.csv', index=False )<save_to_csv> | test_df.Sex = test_df.Sex.map({"male": 0, "female":1})
pclass_dummies = pd.get_dummies(test_df.Pclass, prefix="Pclass")
title_dummies = pd.get_dummies(test_df.Title, prefix="Title")
cabin_dummies = pd.get_dummies(test_df.Cabin, prefix="Cabin")
embarked_dummies = pd.get_dummies(test_df.Embarked, prefix="Embarked")
... | Titanic - Machine Learning from Disaster |
3,614,931 | submissions[0]['Label'] =(submissions[0]['Label']*3 + submissions[1]['Label'] + submissions[2]['Label'] + submissions[3]['Label'])/ 6
submissions[0].to_csv(f'submission.csv', index=False )<install_modules> | import operator
import math
import random
import numpy as np
from deap import algorithms
from deap import base
from deap import creator
from deap import tools
from deap import gp | Titanic - Machine Learning from Disaster |
3,614,931 | !pip install -q efficientnet_pytorch > /dev/null<set_options> | def mydeap(mungedtrain, epochs):
inputs = mungedtrain.drop('Survived', axis = 1 ).values.tolist()
outputs = mungedtrain['Survived'].values.tolist()
def protectedDiv(left, right):
try:
return left / right
except ZeroDivisionError:
return 1
pset = gp.PrimitiveSet("MAIN", 26)
pset.addPrimitive(operator.add, 2)
pset.addP... | Titanic - Machine Learning from Disaster |
3,614,931 | <normalization><EOS> | if __name__ == "__main__":
train = train_dummies
test = test_dummies.columns
mungedtrain = train_dummies.astype(float)
GeneticFunction = mydeap(mungedtrain, epochs = 100)
mytrain = mungedtrain.drop('Survived', axis = 1 ).values.tolist()
trainPredictions = Outputs(np.array([GeneticFunction(*x)for x in mytrain]))
print... | Titanic - Machine Learning from Disaster |
12,193,009 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | import numpy as np
import pandas as pd | Titanic - Machine Learning from Disaster |
12,193,009 | 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... | train_data = pd.read_csv('.. /input/titanic/train.csv')
test_data = pd.read_csv('.. /input/titanic/test.csv')
all = [train_data,test_data] | Titanic - Machine Learning from Disaster |
12,193,009 | 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(... | for data in all:
data.drop(['PassengerId','Name','Ticket'],axis = 1,inplace=True ) | Titanic - Machine Learning from Disaster |
12,193,009 | 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.... | for data in all:
data['Sex'] = data['Sex'].map({'female': 1, 'male': 0} ).astype(int)
train_data.head() | Titanic - Machine Learning from Disaster |
12,193,009 | 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... | for data in all:
data.drop(['Cabin'],axis = 1,inplace= True ) | Titanic - Machine Learning from Disaster |
12,193,009 | 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... | for data in all:
for i in range(0,2):
for j in range(1,4):
age_mean = data[(data['Sex'] == i)&(data['Pclass'] == j)]['Age'].dropna().mean()
data.loc[(data.Age.isnull())&(data.Sex == i)&(data.Pclass == j),'Age'] = age_mean | Titanic - Machine Learning from Disaster |
12,193,009 | 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()<init_hyperparams> | train_data['Embarked'] = train_data['Embarked'].fillna(train_data.Embarked.mode(dropna=True)[0] ) | Titanic - Machine Learning from Disaster |
12,193,009 | 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,
... | test_data.loc[(data.Fare.isnull())] | Titanic - Machine Learning from Disaster |
12,193,009 | 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,
)... | test_data['Fare'].fillna(test_data[(test_data['Pclass'] == 3)]['Pclass'].dropna().mean() ,inplace = True)
| Titanic - Machine Learning from Disaster |
12,193,009 | checkpoint = torch.load('.. /input/alaska2-public-baseline/best-checkpoint-023epoch.bin')
net.load_state_dict(checkpoint['model_state_dict']);
net.eval() ;<data_type_conversions> | for data in all:
data['Family'] = data['Parch'] + data['SibSp'] + 1
data.drop(['Parch','SibSp'],axis = 1,inplace = True)
| Titanic - Machine Learning from Disaster |
12,193,009 | 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)
... | for data in all:
data['Embarked'] = data['Embarked'].map({'S': 1, 'C': 2,'Q' : 3})
train_data.head() | Titanic - Machine Learning from Disaster |
12,193,009 | 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,
)<save_to_csv> | X_train = train_data.drop(['Survived'],axis = 1)
y_train = train_data.Survived | Titanic - Machine Learning from Disaster |
12,193,009 | submission = pd.DataFrame(result)
submission.sort_values(by='Id', inplace=True)
submission.reset_index(drop=True, inplace=True)
submission.to_csv('submission_b2.csv', index=False)
submission.head()<save_to_csv> | scalerModel = StandardScaler()
X_train = scalerModel.fit_transform(X_train)
test_data = scalerModel.fit_transform(test_data ) | Titanic - Machine Learning from Disaster |
12,193,009 | sub_stack = pd.read_csv('/kaggle/input/alaska-stacking-files/stack_minmax_mean.csv')
sub_stack.sort_values(by='Id', inplace=True)
sub_stack.reset_index(drop=True, inplace=True)
sub_stack.to_csv('submission_stack.csv', index=False)
sub_stack.head()<save_to_csv> | X_train,X_test,y_train,y_test = train_test_split(X_train,y_train,test_size = 0.21,shuffle = True,random_state=33 ) | Titanic - Machine Learning from Disaster |
12,193,009 | sub = sub_stack.copy()
sub['Label'] = sub['Label']*0.5+submission['Label']*0.5
sub.to_csv('submission_ensemble.csv', index=False)
sub.head()<install_modules> | train_scores = []
test_scores = [] | Titanic - Machine Learning from Disaster |
12,193,009 | !pip install -q efficientnet_pytorch > /dev/null
<set_options> | SVCModel = SVC(kernel= 'rbf',
max_iter=3000,C=.10,gamma='auto')
SVCModel.fit(X_train, y_train)
print('train data score',SVCModel.score(X_train,y_train))
print('test data score',SVCModel.score(X_test,y_test))
train_scores.append(SVCModel.score(X_train,y_train))
test_scores.append(SVCModel.score(X_test,y_test)) | Titanic - Machine Learning from Disaster |
12,193,009 | 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 )<choose_model_class> |
RandomForestClassifierModel = RandomForestClassifier(criterion = 'entropy',n_estimators=300,max_depth=5,random_state=33,bootstrap=False,min_samples_leaf=3)
RandomForestClassifierModel.fit(X_train, y_train)
print('RandomForestClassifierModel Train Score is : ' , RandomForestClassifierModel.score(X_train, y_train))
p... | Titanic - Machine Learning from Disaster |
12,193,009 | def get_net() :
net = EfficientNet.from_pretrained('efficientnet-b4')
net._fc = nn.Linear(in_features=1792, out_features=4, bias=True)
return net
net = get_net().cuda()<load_pretrained> | LogisticRegressionModel = LogisticRegression(penalty='l2',solver='sag',C=0.5,random_state=33)
LogisticRegressionModel.fit(X_train, y_train)
print('LogisticRegressionModel Train Score is : ' , LogisticRegressionModel.score(X_train, y_train))
print('LogisticRegressionModel Test Score is : ' , LogisticRegressionModel.sc... | Titanic - Machine Learning from Disaster |
12,193,009 | checkpoint = torch.load('.. /input/alaska2-eb4-model-weights/best-checkpoint-042epoch_3_c.bin')
net.load_state_dict(checkpoint['model_state_dict']);
net.eval() ;<data_type_conversions> | DecisionTreeClassifierModel = DecisionTreeClassifier(criterion='entropy',max_depth=5,random_state=33)
DecisionTreeClassifierModel.fit(X_train, y_train)
print('DecisionTreeClassifierModel Train Score is : ' , DecisionTreeClassifierModel.score(X_train, y_train))
print('DecisionTreeClassifierModel Test Score is : ' , De... | Titanic - Machine Learning from Disaster |
12,193,009 | 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)
... | y_pred = RandomForestClassifierModel.predict(test_data ) | Titanic - Machine Learning from Disaster |
12,193,009 | <save_to_csv><EOS> | gs = pd.read_csv('.. /input/titanic/gender_submission.csv')
submission = pd.DataFrame({'PassengerId': gs.PassengerId, 'Survived': y_pred})
submission.to_csv('my_submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
554,028 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<install_modules> | warnings.filterwarnings("ignore")
%matplotlib inline
| Titanic - Machine Learning from Disaster |
554,028 | !pip install -q efficientnet_pytorch > /dev/null<set_options> | def drop_col_not_req(df, cols):
df.drop(cols, axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
554,028 | warnings.filterwarnings('ignore')
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 )<define_... | def pclass_fare_category(df, Pclass_1_mean_fare, Pclass_2_mean_fare, Pclass_3_mean_fare):
if(df['Pclass'] == 1):
if(df['Fare'] <= Pclass_1_mean_fare):
return 'Pclass_1_Low_Fare'
else:
return 'Pclass_1_High_Fare'
elif(df['Pclass'] == 2):
if(df['Fare'] <= Pclass_2_mean_fare):
return 'Pclass_2_Low_Fare'
else:
return 'Pcla... | Titanic - Machine Learning from Disaster |
554,028 | %%time
dataset = []
for label, kind in enumerate(['Cover', 'JMiPOD', 'JUNIWARD', 'UERD']):
for path in glob('.. /input/alaska2-image-steganalysis/Cover/*.jpg'):
dataset.append({
'kind': kind,
'image_name': path.split('/')[-1],
'label': label
} )<split> | def fill_missing_age(missing_age_train, missing_age_test):
missing_age_X_train = missing_age_train.drop(['Age'], axis = 1)
missing_age_y_train = missing_age_train['Age']
missing_age_X_test = missing_age_test.drop(['Age'], axis = 1)
gbm_reg = ensemble.GradientBoostingRegressor(random_state = 42)
gbm_reg_param_grid = ... | Titanic - Machine Learning from Disaster |
554,028 | dataset_small = dataset[0:5000]+dataset[75000:80000]+dataset[150000:155000]+dataset[225000:223000]
random.shuffle(dataset_small)
dataset = pd.DataFrame(dataset_small)
gkf = GroupKFold(n_splits=5)
dataset.loc[:, 'fold'] = 0
for fold_number,(train_index, val_index)in enumerate(gkf.split(X=dataset.index, y=dataset['lab... | def get_top_n_features(titanic_train_data_X, titanic_train_data_y, top_n_features):
rf_est = RandomForestClassifier(random_state = 42)
rf_param_grid = {'n_estimators' : [500], 'min_samples_split':[2, 3], 'max_depth':[20]}
rf_grid = model_selection.GridSearchCV(rf_est, rf_param_grid, n_jobs = 25, cv = 10, verbose = 1)
... | 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> | def Stacking_Ensemble(models, X_train, y_train, X_test, n_folds):
X_train = np.array(X_train)
y_train = np.array(y_train)
X_test = np.array(X_test)
Stacking_train = np.zeros(( X_train.shape[0],(len(models)* 2)))
Stacking_test = np.zeros(( X_test.shape[0],(len(models)* 2)))
Strat_KFold = model_selection.StratifiedK... | 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... | train_data_orig = pd.read_csv('.. /input/train.csv')
test_data_orig = pd.read_csv('.. /input/test.csv' ) | 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.