kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
624,751 | <load_pretrained><EOS> | submission = pd.DataFrame({
"PassengerId": test_df["PassengerId"],
"Survived": best_XGB.predict(test[BestFeat_XGB])
})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
543,500 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_pretrained> | %matplotlib inline
sns.set() | Titanic - Machine Learning from Disaster |
543,500 | device = torch.device(flags.device)
if flags.pred_mode == "multi":
predictor = LyftMultiModel(cfg)
else:
raise ValueError(f"[ERROR] Unexpected value flags.pred_mode={flags.pred_mode}")
pt_path = "/kaggle/input/lyft-prediction-public-models/multi_mode_448px.pth"
print(f"Loading from {pt_path}")
state_dict = torch.lo... | df_train = pd.read_csv('.. /input/train.csv')
df_test = pd.read_csv('.. /input/test.csv')
df_train.head() | Titanic - Machine Learning from Disaster |
543,500 | timestamps, track_ids, coords, confs = run_prediction(predictor, test_loader )<save_to_csv> | print(df_train[df_train.Sex == 'female'].Survived.sum() /df_train[df_train.Sex == 'female'].Survived.count())
print(df_train[df_train.Sex == 'male'].Survived.sum() /df_train[df_train.Sex == 'male'].Survived.count() ) | Titanic - Machine Learning from Disaster |
543,500 | csv_path = "submission.csv"
write_pred_csv(
csv_path,
timestamps=timestamps,
track_ids=track_ids,
coords=coords,
confs=confs)
print(f"Saved to {csv_path}" )<install_modules> | data['Age'] = data.Age.fillna(data.Age.median())
data['Fare'] = data.Fare.fillna(data.Fare.median())
data.info() | Titanic - Machine Learning from Disaster |
543,500 | !pip install pytorch-pfn-extras==0.3.1<set_options> | data = pd.get_dummies(data, columns=['Sex'], drop_first=True)
data.head() | Titanic - Machine Learning from Disaster |
543,500 | py.init_notebook_mode(connected=True)
pio.templates.default = "plotly_dark"
pd.set_option('max_columns', 50 )<import_modules> | data_train = data.iloc[:891]
data_test = data.iloc[891:]
X = data_train.values
test = data_test.values
y = survived_train.values | Titanic - Machine Learning from Disaster |
543,500 | rc('animation', html='jshtml')
print("l5kit version:", l5kit.__version__ )<import_modules> | clf = tree.DecisionTreeClassifier(max_depth=3)
clf.fit(X, y ) | Titanic - Machine Learning from Disaster |
543,500 | import torch
from pathlib import Path
import pytorch_pfn_extras as ppe
from math import ceil
from pytorch_pfn_extras.training import IgniteExtensionsManager
from pytorch_pfn_extras.training.triggers import MinValueTrigger
from torch import nn, optim
from torch.utils.data import DataLoader
from torch.utils.data.dataset ... | Y_pred = clf.predict(test)
df_test['Survived'] = Y_pred
df_test[['PassengerId', 'Survived']].to_csv('1st_dec_tree.csv', index=False ) | Titanic - Machine Learning from Disaster |
543,500 | class LyftMultiModel(nn.Module):
def __init__(self, cfg: Dict, num_modes=3):
super().__init__()
backbone = resnet18(pretrained=True, progress=True)
self.backbone = backbone
num_history_channels =(cfg["model_params"]["history_num_frames"] + 1)* 2
num_in_channels = 3 + num_history_channels
self.backbone.conv1 = nn.Conv2... | df_train = pd.read_csv('.. /input/train.csv')
df_test = pd.read_csv('.. /input/test.csv')
survived_train = df_train.Survived
data = pd.concat([df_train.drop(['Survived'], axis=1), df_test])
data['Title'] = data.Name.apply(lambda x: re.search('([A-Z][a-z]+)\.', x ).group(1))
sns.countplot(x='Title', data=data);
plt.x... | Titanic - Machine Learning from Disaster |
543,500 | def save_yaml(filepath, content, width=120):
with open(filepath, 'w')as f:
yaml.dump(content, f, width=width)
def load_yaml(filepath):
with open(filepath, 'r')as f:
content = yaml.safe_load(f)
return content
class DotDict(dict):
__getattr__ = dict.get
__setattr__ = dict.__setitem__
__delattr__ = dict.__delitem__
<... | data['Has_Cabin'] = ~data.Cabin.isnull()
data.drop(['Cabin', 'Name', 'PassengerId', 'Ticket'], axis=1, inplace=True)
data.head() | Titanic - Machine Learning from Disaster |
543,500 | def run_prediction(predictor, data_loader):
predictor.eval()
pred_coords_list = []
confidences_list = []
timestamps_list = []
track_id_list = []
with torch.no_grad() :
dataiter = tqdm(data_loader)
for data in dataiter:
image = data["image"].to(device)
pred, confidences = predictor(image)
pred_coords_list.append(pred... | data['Age'] = data.Age.fillna(data.Age.median())
data['Fare'] = data.Fare.fillna(data.Fare.median())
data['Embarked'] = data['Embarked'].fillna('S')
data.info() | Titanic - Machine Learning from Disaster |
543,500 | cfg = {
'format_version': 4,
'model_params': {
'model_architecture': 'resnet50',
'history_num_frames': 10,
'history_step_size': 1,
'history_delta_time': 0.1,
'future_num_frames': 50,
'future_step_size': 1,
'future_delta_time': 0.1
},
'raster_params': {
'raster_size': [224, 224],
'pixel_size': [0.5, 0.5],
'ego_center': ... | data['CatAge'] = pd.qcut(data.Age, q=4, labels=False)
data['CatFare']= pd.qcut(data.Fare, q=4, labels=False)
data.head() | Titanic - Machine Learning from Disaster |
543,500 | flags_dict = {
"debug": False,
"l5kit_data_folder": "/kaggle/input/lyft-motion-prediction-autonomous-vehicles",
"pred_mode": "multi",
"device": "cuda:0",
"out_dir": "results/multi_train",
"epoch": 2,
"snapshot_freq": 50,
}<load_pretrained> | data = data.drop(['Age', 'Fare','SibSp','Parch'], axis=1)
data.head() | Titanic - Machine Learning from Disaster |
543,500 | flags = DotDict(flags_dict)
out_dir = Path(flags.out_dir)
os.makedirs(str(out_dir), exist_ok=True)
print(f"flags: {flags_dict}")
save_yaml(out_dir / 'flags.yaml', flags_dict)
save_yaml(out_dir / 'cfg.yaml', cfg)
debug = flags.debug<load_pretrained> | data_dum = pd.get_dummies(data, drop_first=True)
data_dum.head() | Titanic - Machine Learning from Disaster |
543,500 | l5kit_data_folder = "/kaggle/input/lyft-motion-prediction-autonomous-vehicles"
os.environ["L5KIT_DATA_FOLDER"] = l5kit_data_folder
dm = LocalDataManager(None)
print("Load dataset...")
default_test_cfg = {
'key': 'scenes/test.zarr',
'batch_size': 32,
'shuffle': False,
'num_workers': 4
}
test_cfg = cfg.get("test_data_l... | data_train = data_dum.iloc[:891]
data_test = data_dum.iloc[891:]
X = data_train.values
test = data_test.values
y = survived_train.values
dep = np.arange(1,9)
param_grid = {'max_depth' : dep}
clf = tree.DecisionTreeClassifier()
clf_cv = GridSearchCV(clf, param_grid=param_grid, cv=5)
clf_cv.fit(X, y)
print("Tuned Deci... | Titanic - Machine Learning from Disaster |
543,500 | device = torch.device(flags.device)
if flags.pred_mode == "multi":
predictor = LyftMultiModel(cfg)
else:
raise ValueError(f"[ERROR] Unexpected value flags.pred_mode={flags.pred_mode}")
pt_path = "/kaggle/input/lyft-resnet18-baseline/0918_predictor_full.pt"
print(f"Loading from {pt_path}")
predictor.load_state_dict(... | Y_pred = clf_cv.predict(test)
df_test['Survived'] = Y_pred
df_test[['PassengerId', 'Survived']].to_csv('dec_tree_feat_eng.csv', index=False ) | Titanic - Machine Learning from Disaster |
543,500 | timestamps, track_ids, coords, confs = run_prediction(predictor, test_loader )<save_to_csv> | logreg = LogisticRegression()
logreg.fit(X,y)
Y_pred = logreg.predict(test)
df_test['Survived'] = Y_pred
df_test[['PassengerId', 'Survived']].to_csv('log_reg_feat_eng.csv', index=False)
| Titanic - Machine Learning from Disaster |
543,500 | csv_path = "submission.csv"
write_pred_csv(
csv_path,
timestamps=timestamps,
track_ids=track_ids,
coords=coords,
confs=confs)
print(f"Saved to {csv_path}" )<normalization> | c_space = np.logspace(-5, 8, 15)
param_grid = {'C': c_space, 'penalty': ['l1', 'l2']}
logreg_cv = GridSearchCV(logreg,param_grid,cv=5)
logreg_cv.fit(X,y)
print("Tuned Logistic Regression Parameter: {}".format(logreg_cv.best_params_))
print("Tuned Logistic Regression Accuracy: {}".format(logreg_cv.best_score_))
Y_pre... | Titanic - Machine Learning from Disaster |
543,500 | random.seed(2016)
def create_feature_map(features):
outfile = open('xgb.fmap', 'w')
for i, feat in enumerate(features):
outfile.write('{0}\t{1}\tq
'.format(i, feat))
outfile.close()
def get_importance(gbm, features):
create_feature_map(features)
importance = gbm.get_fscore(fmap='xgb.fmap')
importance = sorted(impor... | rf_clf = RandomForestClassifier()
rf_clf.fit(X,y)
Y_pred = rf_clf.predict(test)
df_test['Survived'] = Y_pred
df_test[['PassengerId', 'Survived']].to_csv('random_forest_feat_eng.csv', index=False ) | Titanic - Machine Learning from Disaster |
543,500 | items=pd.read_csv("/kaggle/input/competitive-data-science-predict-future-sales/items.csv")
shops=pd.read_csv("/kaggle/input/competitive-data-science-predict-future-sales/shops.csv")
cats=pd.read_csv("/kaggle/input/competitive-data-science-predict-future-sales/item_categories.csv")
train=pd.read_csv("/kaggle/input/co... | n_estimators = np.arange(10,50)
params_grid = {'n_estimators':n_estimators}
rf_clf = RandomForestClassifier()
rf_clf_cv = GridSearchCV(rf_clf,params_grid,cv=5)
rf_clf_cv.fit(X,y)
print("Tuned Random Forest Classifier Parameter: {}".format(rf_clf_cv.best_params_))
print("Tuned Random Forest Classifier Accuracy: {}".f... | Titanic - Machine Learning from Disaster |
543,500 | train = train[(train.item_price < 300000)&(train.item_cnt_day < 1000)]<feature_engineering> | knn = KNeighborsClassifier()
knn.fit(X,y)
Y_pred = knn.predict(test)
df_test['Survived'] = Y_pred
df_test[['PassengerId', 'Survived']].to_csv('knn_feat_eng.csv', index=False ) | Titanic - Machine Learning from Disaster |
543,500 | <feature_engineering><EOS> | n_neighbors = np.arange(1,20)
params_grid = {'n_neighbors':n_neighbors}
knn = KNeighborsClassifier()
knn_cv = GridSearchCV(knn,params_grid,cv=5)
knn_cv.fit(X,y)
print("Tuned KNN Classifier Parameter: {}".format(knn_cv.best_params_))
print("Tuned KNN Classifier Accuracy: {}".format(knn_cv.best_score_))
Y_pred = knn_c... | Titanic - Machine Learning from Disaster |
494,334 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | %matplotlib inline
warnings.filterwarnings('ignore')
sns.set_palette('cool' ) | Titanic - Machine Learning from Disaster |
494,334 | shops.loc[ shops.shop_name == 'Сергиев Посад ТЦ "7Я"',"shop_name" ] = 'СергиевПосад ТЦ "7Я"'
shops["city"] = shops.shop_name.str.split(" " ).map(lambda x: x[0])
shops["category"] = shops.shop_name.str.split(" " ).map(lambda x: x[1])
shops.loc[shops.city == "!Якутск", "city"] = "Якутск"<categorify> | training_data = pd.read_csv('.. /input/train.csv')
test_data = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
494,334 | shops["shop_category"] = LabelEncoder().fit_transform(shops.category)
shops["shop_city"] = LabelEncoder().fit_transform(shops.city)
shops = shops[["shop_id", "shop_category", "shop_city"]]<feature_engineering> | training_data.isnull().sum() | Titanic - Machine Learning from Disaster |
494,334 | cats["type_code"] = cats.item_category_name.apply(lambda x: x.split(" ")[0] ).astype(str)
cats.loc[(cats.type_code == "Игровые")|(cats.type_code == "Аксессуары"), "category" ] = "Игры"<categorify> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
494,334 | cats.type_code = LabelEncoder().fit_transform(cats.type_code)
cats["split"] = cats.item_category_name.apply(lambda x: x.split("-"))
cats["subtype"] = cats.split.apply(lambda x: x[1].strip() if len(x)> 1 else x[0].strip())
cats["subtype_code"] = LabelEncoder().fit_transform(cats["subtype"])
cats = cats[["item_categor... | training_data.PassengerId.nunique()
passengerId = test_data['PassengerId'] | Titanic - Machine Learning from Disaster |
494,334 | def name_correction(x):
x = x.lower()
x = x.partition('[')[0]
x = x.partition('(')[0]
x = re.sub('[^A-Za-z0-9А-Яа-я]+', ' ', x)
x = x.replace(' ', ' ')
x = x.strip()
return x<feature_engineering> | training_data.drop(labels='PassengerId', axis=1, inplace=True)
test_data.drop(labels='PassengerId', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
494,334 | items["name1"], items["name2"] = items.item_name.str.split("[", 1 ).str
items["name1"], items["name3"] = items.item_name.str.split("(", 1 ).str
items["name2"] = items.name2.str.replace('[^A-Za-z0-9А-Яа-я]+', " " ).str.lower()
items["name3"] = items.name3.str.replace('[^A-Za-z0-9А-Яа-я]+', " " ).str.lower()
items = item... | print(training_data[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
494,334 | items["type"] = items.name2.apply(lambda x: x[0:8] if x.split(" ")[0] == "xbox" else x.split(" ")[0])
items.loc[(items.type == "x360")|(items.type == "xbox360")|(items.type == "xbox 360"),"type"] = "xbox 360"
items.loc[ items.type == "", "type"] = "mac"
items.type = items.type.apply(lambda x: x.replace(" ", ""))
items... | Titanic - Machine Learning from Disaster | |
494,334 | group_sum = items.groupby(["type"] ).agg({"item_id": "count"})
group_sum = group_sum.reset_index()
drop_cols = []
for cat in group_sum.type.unique() :
if group_sum.loc[(group_sum.type == cat), "item_id"].values[0] <40:
drop_cols.append(cat)
items.name2 = items.name2.apply(lambda x: "other" if(x in drop_cols)else x)
... | Titanic - Machine Learning from Disaster | |
494,334 | items.name2 = LabelEncoder().fit_transform(items.name2)
items.name3 = LabelEncoder().fit_transform(items.name3)
items.drop(["item_name", "name1"],axis = 1, inplace= True)
items.head()<data_type_conversions> | training_data.Name.nunique() | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
matrix = []
cols = ["date_block_num", "shop_id", "item_id"]
for i in range(34):
sales = train[train.date_block_num == i]
matrix.append(np.array(list(product([i], sales.shop_id.unique() , sales.item_id.unique())) , dtype = np.int16))
matrix = pd.DataFrame(np.vstack(matrix), columns = cols)
matrix["date... | training_data['Title'] = training_data['Name'].apply(lambda x: x.split(',')[1] ).apply(lambda x: x.split() [0])
test_data['Title'] = test_data['Name'].apply(lambda x: x.split(',')[1] ).apply(lambda x: x.split() [0])
training_data['Name_Len'] = training_data['Name'].apply(lambda x: len(x))
test_data['Name_Len'] = test... | Titanic - Machine Learning from Disaster |
494,334 | train["revenue"] = train["item_cnt_day"] * train["item_price"]<merge> | test_data.Name_Len =(test_data.Name_Len/10 ).astype(np.int64)+1
training_data.Name_Len =(training_data.Name_Len/10 ).astype(np.int64)+1 | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
group = train.groupby(["date_block_num", "shop_id", "item_id"] ).agg({"item_cnt_day": ["sum"]})
group.columns = ["item_cnt_month"]
group.reset_index(inplace = True)
matrix = pd.merge(matrix, group, on = cols, how = "left")
matrix["item_cnt_month"] = matrix["item_cnt_month"].fillna(0 ).astype(np.floa... | print(training_data[['Title', 'Survived']].groupby(['Title'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
494,334 | test["date_block_num"] = 34
test["date_block_num"] = test["date_block_num"].astype(np.int8)
test["shop_id"] = test.shop_id.astype(np.int8)
test["item_id"] = test.item_id.astype(np.int16 )<concatenate> | print(training_data[['Name_Len', 'Survived']].groupby(['Name_Len'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
matrix = pd.concat([matrix, test.drop(["ID"],axis = 1)], ignore_index=True, sort=False, keys=cols)
matrix.fillna(0, inplace = True)
time.time() - ts<data_type_conversions> | print(training_data[['Sex', 'Survived']].groupby(['Sex'], as_index = False ).mean() ) | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
matrix = pd.merge(matrix, shops, on = ["shop_id"], how = "left")
matrix = pd.merge(matrix, items, on = ["item_id"], how = "left")
matrix = pd.merge(matrix, cats, on = ["item_category_id"], how = "left")
matrix["shop_city"] = matrix["shop_city"].astype(np.int8)
matrix["shop_category"] = matrix["shop... | Titanic - Machine Learning from Disaster | |
494,334 | def lag_feature(df,lags, cols):
for col in cols:
print(col)
tmp = df[["date_block_num", "shop_id","item_id",col ]]
for i in lags:
shifted = tmp.copy()
shifted.columns = ["date_block_num", "shop_id", "item_id", col + "_lag_"+str(i)]
shifted.date_block_num = shifted.date_block_num + i
df = pd.merge(df, shifted, on=['dat... | training_data.Age.isnull().sum()
training_age_n = training_data.Age.dropna(axis=0 ) | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
group = matrix.groupby(["date_block_num"] ).agg({"item_cnt_month" : ["mean"]})
group.columns = ["date_avg_item_cnt"]
group.reset_index(inplace = True)
matrix = pd.merge(matrix, group, on = ["date_block_num"], how = "left")
matrix.date_avg_item_cnt = matrix["date_avg_item_cnt"].astype(np.float16)
ma... | full_data = pd.concat([training_data, test_data] ) | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
group = matrix.groupby(['date_block_num', 'item_id'] ).agg({'item_cnt_month': ['mean']})
group.columns = [ 'date_item_avg_item_cnt' ]
group.reset_index(inplace=True)
matrix = pd.merge(matrix, group, on=['date_block_num','item_id'], how='left')
matrix.date_item_avg_item_cnt = matrix['date_item_avg_it... | train_age_mean = full_data.Age.mean()
train_age_std = full_data.Age.std()
train_age_null = training_data.Age.isnull().sum()
rand_tr_age = np.random.randint(train_age_mean - train_age_std, train_age_mean + train_age_std, size=train_age_null)
training_data['Age'][np.isnan(training_data['Age'])] = rand_tr_age
training_da... | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
group = matrix.groupby(["date_block_num","shop_id"] ).agg({"item_cnt_month" : ["mean"]})
group.columns = ["date_shop_avg_item_cnt"]
group.reset_index(inplace = True)
matrix = pd.merge(matrix, group, on = ["date_block_num","shop_id"], how = "left")
matrix.date_avg_item_cnt = matrix["date_shop_avg_ite... | print(training_data[['Age', 'Survived']].groupby(['Age'], as_index = False ).mean() ) | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
group = matrix.groupby(["date_block_num","shop_id","item_id"] ).agg({"item_cnt_month" : ["mean"]})
group.columns = ["date_shop_item_avg_item_cnt"]
group.reset_index(inplace = True)
matrix = pd.merge(matrix, group, on = ["date_block_num","shop_id","item_id"], how = "left")
matrix.date_avg_item_cnt = ... | Titanic - Machine Learning from Disaster | |
494,334 | ts = time.time()
group = matrix.groupby(['date_block_num', 'shop_id', 'subtype_code'] ).agg({'item_cnt_month': ['mean']})
group.columns = ['date_shop_subtype_avg_item_cnt']
group.reset_index(inplace=True)
matrix = pd.merge(matrix, group, on=['date_block_num', 'shop_id', 'subtype_code'], how='left')
matrix.date_shop_... | print(training_data[['FamilySize', 'Survived']].groupby(training_data['FamilySize'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
group = matrix.groupby(['date_block_num', 'shop_city'] ).agg({'item_cnt_month': ['mean']})
group.columns = ['date_city_avg_item_cnt']
group.reset_index(inplace=True)
matrix = pd.merge(matrix, group, on=['date_block_num', "shop_city"], how='left')
matrix.date_city_avg_item_cnt = matrix['date_city_avg... | training_data['isAlone'] = training_data['FamilySize'].map(lambda x: 1 if x == 1 else 0)
test_data['isAlone'] = test_data['FamilySize'].map(lambda x: 1 if x == 1 else 0 ) | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
group = matrix.groupby(['date_block_num', 'item_id', 'shop_city'] ).agg({'item_cnt_month': ['mean']})
group.columns = [ 'date_item_city_avg_item_cnt' ]
group.reset_index(inplace=True)
matrix = pd.merge(matrix, group, on=['date_block_num', 'item_id', 'shop_city'], how='left')
matrix.date_item_city_av... | training_data.drop(labels=['SibSp', 'Parch'], axis=1, inplace=True)
test_data.drop(labels=['SibSp', 'Parch'], axis=1, inplace=True)
training_data.head() | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
group = train.groupby(["item_id"] ).agg({"item_price": ["mean"]})
group.columns = ["item_avg_item_price"]
group.reset_index(inplace = True)
matrix = matrix.merge(group, on = ["item_id"], how = "left")
matrix["item_avg_item_price"] = matrix.item_avg_item_price.astype(np.float16)
group = train.groupb... | training_data['Ticket_Len'] = training_data['Ticket'].apply(lambda x: len(x))
test_data['Ticket_Len'] = test_data['Ticket'].apply(lambda x: len(x)) | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
group = train.groupby(["date_block_num","shop_id"] ).agg({"revenue": ["sum"] })
group.columns = ["date_shop_revenue"]
group.reset_index(inplace = True)
matrix = matrix.merge(group , on = ["date_block_num", "shop_id"], how = "left")
matrix['date_shop_revenue'] = matrix['date_shop_revenue'].astype(np.... | print(training_data[['Ticket_Len', 'Survived']].groupby(training_data['Ticket_Len'], as_index=False ).mean() ) | Titanic - Machine Learning from Disaster |
494,334 | matrix["month"] = matrix["date_block_num"] % 12
days = pd.Series([31,28,31,30,31,30,31,31,30,31,30,31])
matrix["days"] = matrix["month"].map(days ).astype(np.int8 )<feature_engineering> | training_data.drop(labels='Ticket', axis=1, inplace=True)
test_data.drop(labels='Ticket', axis=1, inplace=True)
training_data.head() | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
matrix["item_shop_first_sale"] = matrix["date_block_num"] - matrix.groupby(["item_id","shop_id"])["date_block_num"].transform('min')
matrix["item_first_sale"] = matrix["date_block_num"] - matrix.groupby(["item_id"])["date_block_num"].transform('min')
time.time() - ts<feature_engineering> | training_data.Fare =(training_data.Fare /20 ).astype(np.int64)+ 1
test_data.Fare =(test_data.Fare /20 ).astype(np.int64)+ 1 | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
matrix = matrix[matrix["date_block_num"] > 3]
time.time() - ts<set_options> | print(training_data[['Fare','Survived']].groupby(['Fare'], as_index = False ).mean() ) | Titanic - Machine Learning from Disaster |
494,334 | rcParams['figure.figsize'] = 12, 4<drop_column> | Titanic - Machine Learning from Disaster | |
494,334 | data = matrix.copy()
del matrix
gc.collect()<prepare_x_and_y> | cabin_null = float(test_data.Cabin.isnull().sum())
print(cabin_null/len(test_data)*100 ) | Titanic - Machine Learning from Disaster |
494,334 | X_train = data[data.date_block_num < 33].drop(['item_cnt_month'], axis=1)
Y_train = data[data.date_block_num < 33]['item_cnt_month']
X_valid = data[data.date_block_num == 33].drop(['item_cnt_month'], axis=1)
Y_valid = data[data.date_block_num == 33]['item_cnt_month']
X_test = data[data.date_block_num == 34].drop(['it... | cabin_null = float(training_data.Cabin.isnull().sum())
print(cabin_null/len(training_data)*100 ) | Titanic - Machine Learning from Disaster |
494,334 | del data
gc.collect() ;<train_model> | training_data['hasCabin'] = training_data.Cabin.notnull().astype(int)
test_data['hasCabin'] = test_data.Cabin.notnull().astype(int ) | Titanic - Machine Learning from Disaster |
494,334 | ts = time.time()
model = XGBRegressor(
max_depth=10,
n_estimators=1000,
min_child_weight=0.5,
colsample_bytree=0.8,
subsample=0.8,
eta=0.1,
seed=42)
model.fit(
X_train,
Y_train,
eval_metric="rmse",
eval_set=[(X_train, Y_train),(X_valid, Y_valid)],
verbose=True,
early_stopping_rounds = 20)
time.time() - ts<save_to_c... | training_data.drop(labels='Cabin', axis=1, inplace=True)
training_data.head() | Titanic - Machine Learning from Disaster |
494,334 | Y_pred = model.predict(X_valid ).clip(0, 20)
Y_test = model.predict(X_test ).clip(0, 20)
submission = pd.DataFrame({
"ID": test.index,
"item_cnt_month": Y_test
})
submission.to_csv('xgb_submission.csv', index=False )<load_from_csv> | test_data.drop(labels='Cabin', axis=1, inplace=True)
test_data.head() | Titanic - Machine Learning from Disaster |
494,334 | test = pd.read_csv('/kaggle/input/competitive-data-science-predict-future-sales/test.csv')
item_cat = pd.read_csv('/kaggle/input/competitive-data-science-predict-future-sales/item_categories.csv')
items = pd.read_csv('/kaggle/input/competitive-data-science-predict-future-sales/items.csv')
train = pd.read_csv('/kaggl... | Titanic - Machine Learning from Disaster | |
494,334 | train['item_id'].value_counts(ascending=False)[:10]<filter> | training_data['Embarked'] = training_data['Embarked'].fillna('S' ) | Titanic - Machine Learning from Disaster |
494,334 | items.loc[items['item_id']==20949]<sort_values> | print(training_data[['Embarked', 'Survived']].groupby(['Embarked'], as_index = False ).mean() ) | Titanic - Machine Learning from Disaster |
494,334 | train['item_cnt_day'].sort_values(ascending=False)[:10]<filter> | print(training_data[['Embarked', 'Fare']].groupby(['Embarked'], as_index = False ).mean() ) | Titanic - Machine Learning from Disaster |
494,334 | train[train['item_cnt_day'] == 2169]<filter> | Titanic - Machine Learning from Disaster | |
494,334 | train[train['item_cnt_day'] == 1000]<filter> | training_data.head() | Titanic - Machine Learning from Disaster |
494,334 | items[items['item_id'] == 11373]<filter> | X = training_data.iloc[:, 1:12].values
y = training_data.iloc[:, 0].values | Titanic - Machine Learning from Disaster |
494,334 | train = train[train['item_cnt_day'] < 2000]<sort_values> | label_encoder_sex_tr = LabelEncoder()
label_encoder_title_tr = LabelEncoder()
label_encoder_embarked_tr = LabelEncoder()
X[:, 1] = label_encoder_sex_tr.fit_transform(X[:, 1])
X[:, 5] = label_encoder_title_tr.fit_transform(X[:, 5])
X[:, 4] = label_encoder_embarked_tr.fit_transform(X[:, 4])
| Titanic - Machine Learning from Disaster |
494,334 | train['item_price'].sort_values(ascending=False)[:10]<filter> | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.17 ) | Titanic - Machine Learning from Disaster |
494,334 | train[train['item_price'] == 307980]<filter> | scaler_x = MinMaxScaler(( -1,1))
X_train = scaler_x.fit_transform(X_train)
X_test = scaler_x.transform(X_test)
| Titanic - Machine Learning from Disaster |
494,334 | items[items['item_id'] == 6066]<filter> | accuracies = [] | Titanic - Machine Learning from Disaster |
494,334 | train = train[train['item_price'] < 300000]<sort_values> | classifier = LogisticRegression()
classifier.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
494,334 | train['item_price'].sort_values() [:5]<filter> | lr_score = classifier.score(X_test, y_test)
accuracies.append(lr_score)
print(lr_score ) | Titanic - Machine Learning from Disaster |
494,334 | train[train['item_price'] == -1]<filter> | svm = SVC(kernel='linear')
svm.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
494,334 | items[items['item_id'] == 2973]<feature_engineering> | svm_score = svm.score(X_test, y_test)
accuracies.append(svm_score)
print(svm_score ) | Titanic - Machine Learning from Disaster |
494,334 | price_correction = train[(train['shop_id'] == 32)&(train['item_id'] == 2973)&(train['date_block_num'] == 4)&(train['item_price'] > 0)].item_price.median()
train.loc[train['item_price'] < 0, 'item_price'] = price_correction<sort_values> | k_svm = SVC(kernel='rbf')
k_svm.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
494,334 | train['item_price'].sort_values(ascending=False )<count_values> | k_svm_score = k_svm.score(X_test, y_test)
accuracies.append(k_svm_score)
print(k_svm_score ) | Titanic - Machine Learning from Disaster |
494,334 | test['item_id'].value_counts(ascending=False)[:5]<count_unique_values> | knn = KNeighborsClassifier(p=2, n_neighbors=10)
knn.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
494,334 | shop_train = train['shop_id'].nunique()
shop_test = test['shop_id'].nunique()<feature_engineering> | knn_score = knn.score(X_test, y_test)
accuracies.append(knn_score)
print(knn_score ) | Titanic - Machine Learning from Disaster |
494,334 | train.loc[train['shop_id'] == 0, 'shop_id'] = 57
test.loc[test['shop_id'] == 0, 'shop_id'] = 57
train.loc[train['shop_id'] == 1, 'shop_id'] = 58
test.loc[test['shop_id'] == 1, 'shop_id'] = 58
train.loc[train['shop_id'] == 10, 'shop_id'] = 11
test.loc[test['shop_id'] == 10, 'shop_id'] = 11<string_transform> | rdmf = RandomForestClassifier(n_estimators=20, criterion='entropy')
rdmf.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
494,334 | cities = shop['shop_name'].str.split(' ' ).map(lambda row: row[0] )<feature_engineering> | rdmf_score = rdmf.score(X_test, y_test)
rdmf_score_tr = rdmf.score(X_train, y_train)
accuracies.append(rdmf_score)
print(rdmf_score)
print(rdmf_score_tr ) | Titanic - Machine Learning from Disaster |
494,334 | shop['city'] = shop['shop_name'].str.split(' ' ).map(lambda row: row[0])
shop.loc[shop.city == '!Якутск', 'city'] = 'Якутск'<categorify> | xgb = XGBClassifier()
xgb.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
494,334 | pr = preprocessing.LabelEncoder()
pr.fit_transform(shop['city'] )<categorify> | xgb_score = xgb.score(X_test, y_test)
accuracies.append(xgb_score)
print(xgb_score ) | Titanic - Machine Learning from Disaster |
494,334 | shop['cities_label'] = pr.fit_transform(shop['city'])
shop.drop(['shop_name', 'city'], axis = 1, inplace=True )<count_unique_values> | myLabels = ['Logistic Regression', 'SVM', 'Kernel SVM', 'KNN', 'Random Forest', 'Xgboost'] | Titanic - Machine Learning from Disaster |
494,334 | item_train = train['item_id'].nunique()
item_test = test['item_id'].nunique()<concatenate> | test_data['Title'] = test_data['Title'].replace('Dona.', 'Mrs.')
test_data.head() | Titanic - Machine Learning from Disaster |
494,334 | len(set(item_test_list ).difference(item_train_list))<filter> | titanic_test = test_data.iloc[:, 0:11].values | Titanic - Machine Learning from Disaster |
494,334 | items.loc[~items['item_category_id'].isin(items_in_test)].T<categorify> | titanic_test[:, 1] = label_encoder_sex_tr.transform(titanic_test[:, 1])
titanic_test[:, 5] = label_encoder_title_tr.transform(titanic_test[:, 5])
titanic_test[:, 4] = label_encoder_embarked_tr.transform(titanic_test[:, 4] ) | Titanic - Machine Learning from Disaster |
494,334 | le = preprocessing.LabelEncoder()
main_items = item_cat['item_category_name'].str.split('-')
item_cat['main_category_id'] = main_items.map(lambda row: row[0].strip())
item_cat['main_category_id'] = le.fit_transform(item_cat['main_category_id'] )<categorify> | titanic_test = scaler_x.transform(titanic_test ) | Titanic - Machine Learning from Disaster |
494,334 | item_cat['sub_category_id'] = main_items.map(lambda row: row[1].strip() if len(row)> 1 else row[0].strip())
item_cat['sub_category_id'] = le.fit_transform(item_cat['sub_category_id'] )<data_type_conversions> | y_pred = rdmf.predict(titanic_test ) | Titanic - Machine Learning from Disaster |
494,334 | train['date'] = pd.to_datetime(train['date'], format='%d.%m.%Y' )<import_modules> | titanic_submission = pd.DataFrame({'PassengerId':passengerId, 'Survived':y_pred} ) | Titanic - Machine Learning from Disaster |
494,334 | <concatenate><EOS> | titanic_submission.to_csv('rdmf_Titanic.csv', index=False ) | Titanic - Machine Learning from Disaster |
449,069 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<concatenate> | print("Python version: {}".format(sys.version))
print("pandas version: {}".format(pd.__version__))
print("matplotlib version: {}".format(matplotlib.__version__))
print("NumPy version: {}".format(np.__version__))
print("SciPy version: {}".format(sp.__version__))
print("IPython version: {}".format(IPython.__version__))
p... | Titanic - Machine Learning from Disaster |
449,069 | cartesian_test = []
cartesian_test.append(np.array(jan))
cartesian_test.append(np.array(feb))<concatenate> | %matplotlib inline
mpl.style.use('ggplot')
sns.set_style('white')
pylab.rcParams['figure.figsize'] = 12,8 | Titanic - Machine Learning from Disaster |
449,069 | cartesian_test = np.vstack(cartesian_test )<create_dataframe> | data_raw = pd.read_csv('.. /input/train.csv')
data_val = pd.read_csv('.. /input/test.csv')
data1 = data_raw.copy(deep = True)
data_cleaner = [data1, data_val]
print(data_raw.info())
data_raw.sample(10 ) | Titanic - Machine Learning from Disaster |
449,069 | cartesian_test_df = pd.DataFrame(cartesian_test, columns = ['shop_id', 'item_id', 'date_block_num'] )<data_type_conversions> | for dataset in data_cleaner:
dataset['Age'].fillna(dataset['Age'].median() , inplace = True)
dataset['Embarked'].fillna(dataset['Embarked'].mode() [0], inplace = True)
dataset['Fare'].fillna(dataset['Fare'].median() , inplace = True)
drop_column = ['PassengerId','Cabin', 'Ticket']
data1.drop(drop_column, axis=1, inp... | Titanic - Machine Learning from Disaster |
449,069 | def downcast_dtypes(df):
float_cols = [c for c in df if df[c].dtype == "float64"]
int_cols = [c for c in df if df[c].dtype == "int64"]
df[float_cols] = df[float_cols].astype(np.float16)
df[int_cols] = df[int_cols].astype(np.int16)
return df<create_dataframe> | for dataset in data_cleaner:
dataset['FamilySize'] = dataset ['SibSp'] + dataset['Parch'] + 1
dataset['IsAlone'] = 1
dataset['IsAlone'].loc[dataset['FamilySize'] > 1] = 0
dataset['Title'] = dataset['Name'].str.split(", ", expand=True)[1].str.split(".", expand=True)[0]
dataset['FareBin'] = pd.qcut(dataset['Fare'], 4)
d... | Titanic - Machine Learning from Disaster |
449,069 | cartesian_df = pd.DataFrame(np.vstack(cartesian), columns = ['shop_id', 'item_id', 'date_block_num'], dtype=np.int32 )<groupby> | label = LabelEncoder()
for dataset in data_cleaner:
dataset['Sex_Code'] = label.fit_transform(dataset['Sex'])
dataset['Embarked_Code'] = label.fit_transform(dataset['Embarked'])
dataset['Title_Code'] = label.fit_transform(dataset['Title'])
dataset['AgeBin_Code'] = label.fit_transform(dataset['AgeBin'])
dataset['Far... | Titanic - Machine Learning from Disaster |
449,069 | x = train.groupby(['shop_id', 'item_id', 'date_block_num'])['item_cnt_day'].sum().rename('item_cnt_month' ).reset_index()<merge> | train1_x, test1_x, train1_y, test1_y = model_selection.train_test_split(data1[data1_x_calc], data1[Target], random_state = 0)
train1_x_bin, test1_x_bin, train1_y_bin, test1_y_bin = model_selection.train_test_split(data1[data1_x_bin], data1[Target] , random_state = 0)
train1_x_dummy, test1_x_dummy, train1_y_dummy, tes... | Titanic - Machine Learning from Disaster |
449,069 | new_train = pd.merge(cartesian_df, x, on=['shop_id', 'item_id', 'date_block_num'], how='left' ).fillna(0 )<feature_engineering> | plt.figure(figsize=[16,12])
plt.subplot(231)
plt.boxplot(x=data1['Fare'], showmeans = True, meanline = True)
plt.title('Fare Boxplot')
plt.ylabel('Fare($)')
plt.subplot(232)
plt.boxplot(data1['Age'], showmeans = True, meanline = True)
plt.title('Age Boxplot')
plt.ylabel('Age(Years)')
plt.subplot(233)
plt.boxp... | Titanic - Machine Learning from Disaster |
449,069 | new_train['item_cnt_month'] = np.clip(new_train['item_cnt_month'], 0, 20 )<sort_values> | MLA = [
ensemble.AdaBoostClassifier() ,
ensemble.BaggingClassifier() ,
ensemble.ExtraTreesClassifier() ,
ensemble.GradientBoostingClassifier() ,
ensemble.RandomForestClassifier() ,
gaussian_process.GaussianProcessClassifier() ,
linear_model.LogisticRegressionCV() ,
linear_model.PassiveAggressiveClassifier() ,
linear_mo... | Titanic - Machine Learning from Disaster |
449,069 | new_train.sort_values(['date_block_num','shop_id','item_id'], inplace = True)
new_train.head()<prepare_output> | for index, row in data1.iterrows() :
if random.random() >.5:
data1.set_value(index, 'Random_Predict', 1)
else:
data1.set_value(index, 'Random_Predict', 0)
data1['Random_Score'] = 0
data1.loc[(data1['Survived'] == data1['Random_Predict']), 'Random_Score'] = 1
print('Coin Flip Model Accuracy: {:.2f}%'.format(data1['Ran... | Titanic - Machine Learning from Disaster |
449,069 | test.insert(loc=3, column='date_block_num', value=34 )<feature_engineering> | pivot_female = data1[data1.Sex=='female'].groupby(['Sex','Pclass', 'Embarked','FareBin'])['Survived'].mean()
print('Survival Decision Tree w/Female Node:
',pivot_female)
pivot_male = data1[data1.Sex=='male'].groupby(['Sex','Title'])['Survived'].mean()
print('
Survival Decision Tree w/Male Node:
',pivot_male ) | 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.