kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
2,012,125 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<count_values> | %matplotlib inline
warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
2,012,125 | cols = ['killPoints','rankPoints','winPoints']
querys = ['rankPoints <= 0 & killPoints != 0', 'rankPoints <= 0 & winPoints != 0',
'killPoints == 0 & rankPoints != 0', 'killPoints == 0 & winPoints != 0',
'winPoints == 0 & rankPoints != 0', 'winPoints == 0 & killPoints != 0']
for q in querys:
print('count(%s):' % q, len(... | df_titanic_train = pd.read_csv('.. /input/train.csv')
df_titanic_test = pd.read_csv('.. /input/test.csv')
PassengerId = df_titanic_test["PassengerId"] | Titanic - Machine Learning from Disaster |
2,012,125 |
<count_unique_values> | df_titanic_train = df_titanic_train.drop(outliers_to_drop, axis = 0 ).reset_index(drop=True ) | Titanic - Machine Learning from Disaster |
2,012,125 | print('match count:', train['matchId'].nunique())
maxPlacePerc = train.groupby('matchId')['winPlacePerc'].max()
print('match [not contains 1st place]:', len(maxPlacePerc[maxPlacePerc != 1]))
del maxPlacePerc
edge = train[(train['maxPlace'] > 1)&(train['numGroups'] == 1)]
print('match [maxPlace>1 & numGroups==1]:', len... | train_size = len(df_titanic_train)
df_titanic = pd.concat(objs=[df_titanic_train, df_titanic_test], axis=0 ).reset_index(drop=True)
df_titanic.head() | Titanic - Machine Learning from Disaster |
2,012,125 | pd.concat([train[train['winPlacePerc'] == 1].head(5),
train[train['winPlacePerc'] == 0].head(5)],
keys=['winPlacePerc_1', 'winPlacePerc_0'] )<concatenate> | df_titanic = df_titanic.fillna(np.nan)
df_titanic.isnull().sum() | Titanic - Machine Learning from Disaster |
2,012,125 | all_data = train.append(test, sort=False ).reset_index(drop=True)
del train, test
gc.collect()<groupby> | def absolute_relative_freq(variable):
absolute_frequency = variable.value_counts()
relative_frequency = round(variable.value_counts(normalize = True)*100, 2)
df = pd.DataFrame({'Absolute Frequency':absolute_frequency, 'Relative Frequency(%)':relative_frequency})
print('Absolute and Relative Frequency of [',variable.n... | Titanic - Machine Learning from Disaster |
2,012,125 | match = all_data.groupby('matchId')
all_data['killPlacePerc'] = match['kills'].rank(pct=True ).values<data_type_conversions> | df_titanic['Fare'] = df_titanic['Fare'].fillna(df_titanic['Fare'].median() ) | Titanic - Machine Learning from Disaster |
2,012,125 | distance =(all_data['rideDistance'] + all_data['walkDistance'] + all_data['swimDistance'])
all_data['zombi'] =(( distance == 0)&(all_data['kills'] == 0)
&(all_data['weaponsAcquired'] == 0)
&(all_data['matchType'].str.contains('solo')) ).astype(int)
all_data['cheater'] =(( all_data['kills'] / distance >= 1)
|(all_d... | df_titanic["Fare"] = df_titanic["Fare"].map(lambda i: np.log(i)if i > 0 else 0 ) | Titanic - Machine Learning from Disaster |
2,012,125 | all_data.drop(['rankPoints','killPoints','winPoints'], axis=1, inplace=True )<data_type_conversions> | df_titanic['Embarked'].value_counts() | Titanic - Machine Learning from Disaster |
2,012,125 | def fillInf(df, val):
numcols = df.select_dtypes(include='number' ).columns
cols = numcols[numcols != 'winPlacePerc']
df[df == np.Inf] = np.NaN
df[df == np.NINF] = np.NaN
for c in cols: df[c].fillna(val, inplace=True )<feature_engineering> | labelEncoder = LabelEncoder()
df_titanic['Embarked'] = labelEncoder.fit_transform(df_titanic['Embarked'] ) | Titanic - Machine Learning from Disaster |
2,012,125 | all_data['_totalDistance'] = all_data['rideDistance'] + all_data["walkDistance"] + all_data["swimDistance"]
all_data["_specialKills"] = all_data["headshotKills"] + all_data["roadKills"]
all_data['_healthItems'] = all_data['heals'] + all_data['boosts']
all_data['_headshotKillRate'] = all_data['headshotKills'] / all_data... | labelEncoder = LabelEncoder()
df_titanic['Sex'] = labelEncoder.fit_transform(df_titanic['Sex'] ) | Titanic - Machine Learning from Disaster |
2,012,125 | agg_col = list(all_data.columns)
exclude_agg_col = ['Id','matchId','groupId','matchType','matchDuration','maxPlace','numGroups','winPlacePerc']
for c in exclude_agg_col:
agg_col.remove(c)
print(agg_col )<groupby> | condition = df_titanic['Age'].isnull()
age_NaN = df_titanic['Age'][condition].index
for age in age_NaN :
condition1 = df_titanic['SibSp'] == df_titanic.iloc[age]["SibSp"]
condition2 = df_titanic['Pclass'] == df_titanic.iloc[age]["Pclass"]
condition3 = df_titanic['Parch'] == df_titanic.iloc[age]["Parch"]
condition = con... | Titanic - Machine Learning from Disaster |
2,012,125 | def grouping(df):
group = df.groupby(['matchId','groupId','matchType'])
groupCount = group.size().to_frame('member')
groupMean = group.mean()
groupMax = group[agg_col].max().rename(columns=lambda s: '_max.' + s)
groupMin = group[agg_col].min().rename(columns=lambda s: '_min.' + s)
return pd.concat([groupCount, grou... | df_titanic['Age'] =(df_titanic['Age'] - df_titanic['Age'].mean())/ df_titanic['Age'].std() | Titanic - Machine Learning from Disaster |
2,012,125 | cols = np.r_[agg_col,['matchId']]
match = all_data[cols].groupby('matchId' )<merge> | df_titanic['Title'] = df_titanic['Name'].str.extract('([A-Za-z]+)\.', expand=False)
df_titanic['Title'].unique() | Titanic - Machine Learning from Disaster |
2,012,125 |
cols = agg_col
matchSum = match[cols].sum().rename(columns=lambda s: '_sum.' + s ).reset_index()
all_data = pd.merge(all_data, matchSum)
print(all_data.shape)
del matchSum
gc.collect()
for c in cols:
all_data['_percSum.' + c] = all_data[c] / all_data['_sum.' + c]
fillInf(all_data, 0 )<categorify> | df_titanic['Title'] = df_titanic['Title'].replace(['Don', 'Rev', 'Dr', 'Major', 'Lady', 'Sir',
'Col', 'Capt', 'Countess', 'Jonkheer', 'Dona'], 'Rare' ) | Titanic - Machine Learning from Disaster |
2,012,125 |
cols = agg_col
matchMean = match[cols].mean().rename(columns=lambda s: '_matchMean.' + s ).reset_index()
all_data = pd.merge(all_data, reduce_mem_usage(matchMean))
print(all_data.shape)
del matchMean
gc.collect()
for c in cols:
all_data['_percMean.' + c] = all_data[c] / all_data['_matchMean.' + c]
all_data.drop(['_m... | df_titanic["Title"] = df_titanic['Title'].map({"Master":0, "Miss":1, "Ms" : 1, "Mme":1,
"Mlle":1, "Mrs":1, "Mr":2, "Rare":3})
df_titanic['Title'] = df_titanic["Title"].astype(int ) | Titanic - Machine Learning from Disaster |
2,012,125 |
killMinorRank = all_data[['matchId','_min.kills','_max.killPlace']].copy()
killMinorRank['_rank.minor.killPlace'] = killMinorRank.groupby(['matchId','_min.kills'] ).rank().values
all_data = pd.merge(all_data, killMinorRank)
del killMinorRank
gc.collect()<sort_values> | df_titanic['Surname'] = df_titanic['Name'].map(lambda i: i.split(',')[0] ) | Titanic - Machine Learning from Disaster |
2,012,125 | null_cnt = all_data.isnull().sum().sort_values()
print(null_cnt[null_cnt > 0])
all_data.head()<count_values> | del df_titanic['Name'] | Titanic - Machine Learning from Disaster |
2,012,125 | mapper = lambda x: 'solo' if('solo' in x)else 'duo' if('duo' in x)or('crash' in x)else 'squad'
all_data['matchTypeCat'] = all_data['matchType'].map(mapper)
print(all_data['matchTypeCat'].value_counts() )<count_unique_values> | df_titanic['Cabin'].isnull().sum() | Titanic - Machine Learning from Disaster |
2,012,125 | constant_column = [col for col in all_data.columns if all_data[col].nunique() == 1]
print('drop columns:', constant_column)
all_data.drop(constant_column, axis=1, inplace=True )<feature_engineering> | df_titanic['Ticket'] = df_titanic['Ticket'].map(
lambda i: i.replace(".","" ).replace("/","" ).strip().split(' ')[0] if not i.isdigit() else "TKT" ) | Titanic - Machine Learning from Disaster |
2,012,125 | cols = [col for col in all_data.columns if col not in ['Id','matchId','groupId']]
for i, t in all_data.loc[:, cols].dtypes.iteritems() :
if t == object:
all_data[i] = pd.factorize(all_data[i])[0]<prepare_x_and_y> | df_titanic['Family'] = df_titanic['SibSp'] + df_titanic['Parch'] + 1 | Titanic - Machine Learning from Disaster |
2,012,125 | X_train = all_data[all_data['winPlacePerc'].notnull() ].reset_index(drop=True)
X_test = all_data[all_data['winPlacePerc'].isnull() ].drop(['winPlacePerc'], axis=1 ).reset_index(drop=True)
del all_data
gc.collect()
Y_train = X_train.pop('winPlacePerc')
X_test_grp = X_test[['matchId','groupId']].copy()
X_train.drop(['... | df_titanic['Alone'] = df_titanic['Family'].map(lambda i: 1 if i == 1 else 0)
df_titanic['Small'] = df_titanic['Family'].map(lambda i: 1 if i == 2 else 0)
df_titanic['Medium'] = df_titanic['Family'].map(lambda i: 1 if 3 <= i <= 4 else 0)
df_titanic['Large'] = df_titanic['Family'].map(lambda i: 1 if i >= 5 else 0 ) | Titanic - Machine Learning from Disaster |
2,012,125 | print(pd.DataFrame([[val for val in dir() ], [sys.getsizeof(eval(val)) for val in dir() ]],
index=['name','size'] ).T.sort_values('size', ascending=False ).reset_index(drop=True)[:10] )<choose_model_class> | df_titanic['Pclass'] = df_titanic['Pclass'].astype("category")
columns = ['Title', 'Surname', 'Cabin', 'Ticket', 'Pclass']
for col in columns:
df_titanic = pd.get_dummies(df_titanic, columns=[col], prefix=col ) | Titanic - Machine Learning from Disaster |
2,012,125 | params={'learning_rate': 0.05,
'objective':'mae',
'metric':'mae',
'num_leaves': 31,
'verbose': 0,
'random_state':42,
'bagging_fraction': 0.7,
'feature_fraction': 0.7
}
mts = list()
fis = list()
pred = np.zeros(X_test.shape[0])
for mt in X_train['matchTypeCat'].unique() :
idx = X_train[X_train['matchTypeCat'] == mt].in... | df_titanic.drop(labels = ["PassengerId"], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
2,012,125 | X_test_grp['winPlacePerc'] = pred
group = X_test_grp.groupby(['matchId'])
X_test_grp['winPlacePerc'] = pred
X_test_grp['_rank.winPlacePerc'] = group['winPlacePerc'].rank(method='min')
X_test = pd.concat([X_test, X_test_grp], axis=1)
sub_match = X_test_grp[['matchId','_rank.winPlacePerc']].groupby(['matchId'])
sub_g... | df_titanic_train = df_titanic[:train_size]
df_titanic_test = df_titanic[train_size:]
df_titanic_train['Survived'] = df_titanic_train['Survived'].astype(int)
del df_titanic_test['Survived'] | Titanic - Machine Learning from Disaster |
2,012,125 | fullgroup =(X_test['numGroups'] == X_test['maxPlace'])
subset = X_test.loc[fullgroup]
X_test.loc[fullgroup, 'winPlacePerc'] =(subset['_rank.winPlacePerc'].values - 1)/(subset['maxPlace'].values - 1)
subset = X_test.loc[~fullgroup]
gap = 1.0 /(subset['maxPlace'].values - 1)
new_perc = np.around(subset['winPlacePerc']... | X_train = df_titanic_train.drop(['Survived'], axis=1)
y_train = df_titanic_train['Survived']
X_test = df_titanic_test
sc = StandardScaler()
sc.fit(X_train)
X_train = sc.transform(X_train)
X_test = sc.transform(X_test ) | Titanic - Machine Learning from Disaster |
2,012,125 | X_test.loc[~fullgroup, '_pred.winPlacePerc'] = np.around(X_test.loc[~fullgroup, 'winPlacePerc'].values / gap)+ 1
_=
X_test.loc[~fullgroup &(X_test['matchId'] == '000b598b79aa5e'),
['matchId','groupId','winPlacePerc','maxPlace','numGroups','_pred.winPlacePerc','_rank.winPlacePerc']
].sort_values(['matchId','_pred.winPla... | kfold = StratifiedKFold(n_splits=10)
seed = 20
clfs = []
clfs.append(SVC(random_state=seed))
clfs.append(DecisionTreeClassifier(random_state=seed))
clfs.append(RandomForestClassifier(random_state=seed))
clfs.append(ExtraTreesClassifier(random_state=seed))
clfs.append(GradientBoostingClassifier(random_state=seed))
clfs... | Titanic - Machine Learning from Disaster |
2,012,125 | _=<feature_engineering> | clf_results = []
for clf in clfs :
clf_results.append(cross_val_score(clf, X_train, y=y_train, scoring = "accuracy", cv=kfold, n_jobs=1)) | Titanic - Machine Learning from Disaster |
2,012,125 | X_test.loc[X_test['maxPlace'] == 0, 'winPlacePerc'] = 0
X_test.loc[X_test['maxPlace'] == 1, 'winPlacePerc'] = 1
X_test.loc[(X_test['maxPlace'] > 1)&(X_test['numGroups'] == 1), 'winPlacePerc'] = 0
X_test['winPlacePerc'].describe()<save_to_csv> | df_result = pd.DataFrame({"Means":clf_means,
"Stds": clf_std,
"Algorithm":["SVC",
"DecisionTree",
"RandomForest",
"ExtraTrees",
"GradientBoosting",
"MLPClassifier",
"KNeighboors",
"LogisticRegression",
"XGBoost"]})
df_result.sort_values(by=['Means'], ascending=False ) | Titanic - Machine Learning from Disaster |
2,012,125 | test = pd.read_csv('.. /input/test_V2.csv')
submission = pd.merge(test, X_test[['matchId','groupId','winPlacePerc']])
submission = submission[['Id','winPlacePerc']]
submission.to_csv("submission.csv", index=False )<import_modules> | extraTrees = ExtraTreesClassifier(random_state=seed)
gBoosting = GradientBoostingClassifier(random_state=seed)
randomForest = RandomForestClassifier(random_state=seed)
logReg = LogisticRegression(random_state=seed)
xgbc = XGBClassifier(random_state=seed ) | Titanic - Machine Learning from Disaster |
2,012,125 | import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt<load_from_csv> | param_grid = {"max_depth": [None],
"max_features": [1, 3, 10],
"min_samples_split": [2, 3, 10],
"min_samples_leaf": [1, 3, 10],
"bootstrap": [False],
"n_estimators" :[100,300],
"criterion": ["gini"]}
grid_result = GridSearchCV(extraTrees,
param_grid = param_grid,
cv=kfold,
scoring="accuracy",
n_jobs= -1,
verbose = 1)
... | Titanic - Machine Learning from Disaster |
2,012,125 | develop_mode = False
if develop_mode:
df_train = reduce_mem_usage(pd.read_csv('.. /input/train_V2.csv', nrows=5000))
df_test = reduce_mem_usage(pd.read_csv('.. /input/test_V2.csv'))
else:
df_train = reduce_mem_usage(pd.read_csv('.. /input/train_V2.csv'))
df_test = reduce_mem_usage(pd.read_csv('.. /input/test_V2.csv'))<... | param_grid = {'learning_rate': [0.01, 0.02],
'max_depth': [4, 5, 6],
'max_features': [0.2, 0.3, 0.4],
'min_samples_split': [2, 3, 4],
'random_state':[seed]}
grid_result = GridSearchCV(gBoosting,
param_grid=param_grid,
cv=kfold,
scoring="accuracy",
n_jobs=-1,
verbose=1)
grid_result.fit(X_train, y_train)
gBoosting_best... | Titanic - Machine Learning from Disaster |
2,012,125 | print('The sizes of the datasets are:')
print('Training Dataset: ', df_train.shape)
print('Testing Dataset: ', df_test.shape )<sort_values> | param_grid = {"max_depth": [None],
"max_features": [1, 2],
"min_samples_split": [2, 3, 10],
"min_samples_leaf": [1, 3, 10],
"bootstrap": [False],
"n_estimators" :[100,300],
"criterion": ["gini"]}
grid_result = GridSearchCV(randomForest,
param_grid=param_grid,
cv=kfold,
scoring="accuracy",
n_jobs= -1,
verbose = 1)
grid... | Titanic - Machine Learning from Disaster |
2,012,125 | group_tmp = df_train[df_train['matchId']=='df014fbee741c6']['groupId'].value_counts().sort_values(ascending=False )<set_options> | param_grid = {'penalty' : ['l1', 'l2'],
'C': np.logspace(0, 4, 10),
'solver' : ['liblinear', 'saga']
}
grid_result = GridSearchCV(logReg,
param_grid=param_grid,
cv=kfold,
scoring="accuracy",
n_jobs= -1,
verbose = 1)
grid_result.fit(X_train, y_train)
logReg_best_result = grid_result.best_estimator_
print('Best score:'... | Titanic - Machine Learning from Disaster |
2,012,125 | warnings.filterwarnings('ignore' )<load_from_csv> | param_grid = {'n_estimators': [275, 280],
'learning_rate': [0.01, 0.03],
'subsample': [0.9, 1],
'max_depth': [3, 4],
'colsample_bytree': [0.8, 0.9],
'min_child_weight': [2, 3],
'random_state':[seed]}
grid_result = GridSearchCV(xgbc,
param_grid=param_grid,
cv=kfold,
scoring="accuracy",
n_jobs= -1,
verbose = 1)
grid_res... | Titanic - Machine Learning from Disaster |
2,012,125 | def BuildFeature(is_train=True):
y = None
test_idx = None
if is_train:
print("Reading train.csv")
df = pd.read_csv('.. /input/train_V2.csv')
df = df[df['maxPlace'] > 1]
else:
print("Reading test.csv")
df = pd.read_csv('.. /input/test_V2.csv')
test_idx = df.Id
df = reduce_mem_usage(df)
print("Delete Unuseful Colu... | survived_ET = pd.Series(extraTrees_best_result.predict(X_test), name="ET")
survived_GB = pd.Series(gBoosting_best_result.predict(X_test), name="GB")
survived_RF = pd.Series(randomForest_best_result.predict(X_test), name="RF")
survived_LR = pd.Series(logReg_best_result.predict(X_test), name="LR")
survived_XB = pd.Se... | Titanic - Machine Learning from Disaster |
2,012,125 | X_train, y_train, train_columns, _ = BuildFeature(is_train=True)
X_test, _, _ , test_idx = BuildFeature(is_train=False )<drop_column> | voting = VotingClassifier(estimators=[('XB', xgbc_best_result),
('GB', gBoosting_best_result),
('RF', randomForest_best_result),
('LR', logReg_best_result),
('ET', extraTrees_best_result)],
voting='soft', n_jobs=-1)
voting.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
2,012,125 | X_train =reduce_mem_usage(X_train)
X_test = reduce_mem_usage(X_test )<train_model> | print("Score(Voting): " + str(voting.score(X_train, y_train)) ) | Titanic - Machine Learning from Disaster |
2,012,125 | LR_model = LinearRegression(n_jobs=4, normalize=True)
LR_model.fit(X_train,y_train )<compute_test_metric> | y_predict = voting.predict(X_test ) | Titanic - Machine Learning from Disaster |
2,012,125 | <predict_on_test><EOS> | solution = pd.DataFrame({
"PassengerId": PassengerId,
"Survived": y_predict.astype(int)
})
solution.to_csv('solution_final_v1.csv', index=False)
df_solution = pd.read_csv('solution_final_v1.csv' ) | Titanic - Machine Learning from Disaster |
4,803,523 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
4,803,523 | y_pred_test[y_pred_test>1] = 1
y_pred_test[y_pred_test<0] = 0<save_to_csv> | def open_data(file):
data = pd.read_csv(".. /input/"+file)
data = data.drop(["Name", "Ticket", "Cabin"], 1)
le = preprocessing.LabelEncoder()
data["Sex"] = le.fit_transform(list(data["Sex"]))
data["Embarked"] = le.fit_transform(list(data["Embarked"]))
data["Age"] = data["Age"].fillna(value = data.Age.mean())
data["F... | Titanic - Machine Learning from Disaster |
4,803,523 | df_test['winPlacePerc'] = y_pred_test
submission = df_test[['Id', 'winPlacePerc']]
submission.to_csv('submission_lr.csv', index=False )<train_model> | def param_label(data):
data = data.drop(["PassengerId"], 1)
return data.drop(["Survived"], 1), data[["Survived"]] | Titanic - Machine Learning from Disaster |
4,803,523 | GBR = GradientBoostingRegressor(loss='ls',learning_rate=0.1,
n_estimators=100,max_depth=3)
GBR.fit(X_train,y_train )<compute_test_metric> | def subset_data(X, Y, n):
return model_selection.train_test_split(X, Y, test_size = n ) | Titanic - Machine Learning from Disaster |
4,803,523 | GBR.score(X_train,y_train )<predict_on_test> | data = open_data("train.csv")
y_true = data[["Survived"]]
y_test = np.array([1 for i in range(len(y_true)) ])
print("Accuracy for survived = 1: ",metrics.accuracy_score(y_true, y_test)) | Titanic - Machine Learning from Disaster |
4,803,523 | y_pred_train = GBR.predict(X_train)
y_pred_test = GBR.predict(X_test )<save_to_csv> | data = open_data("train.csv")
y_true = data[["Survived"]]
y_test = np.array([random.choice(( 0, 1)) for i in range(len(y_true)) ])
print("Accuracy for random survival: ",metrics.accuracy_score(y_true, y_test)) | Titanic - Machine Learning from Disaster |
4,803,523 | df_test['winPlacePerc'] = y_pred_test
submission = df_test[['Id', 'winPlacePerc']]
submission.to_csv('submission_gbr.csv', index=False )<load_from_csv> | data = open_data("train.csv")
y_true = data[["Survived"]]
y_test = np.array([0 for i in range(len(y_true)) ])
print("Accuracy for survived = 1: ",metrics.accuracy_score(y_true, y_test)) | Titanic - Machine Learning from Disaster |
4,803,523 | __author__ = 'ZFTurbo: https://kaggle.com/zfturbo'
def run_solution() :
print('Preparing arrays...')
f = open(".. /input/train.csv", "r")
f.readline()
best_hotels_od_ulc = defaultdict(lambda: defaultdict(int))
best_hotels_search_dest = defaultdict(lambda: defaultdict(int))
best_hotels_search_dest1 = defaultdict(lambd... | data_test = open_data("test.csv")
solution = pd.DataFrame(np.array([[data_test.PassengerId.iloc[i], 0] for i in range(len(data_test)) ]),
columns=['PassengerId', 'Survived'])
solution.to_csv("solution_naive.csv", index=False ) | Titanic - Machine Learning from Disaster |
4,803,523 | pd.options.display.max_columns = 50
<define_variables> | from sklearn.neighbors import KNeighborsClassifier | Titanic - Machine Learning from Disaster |
4,803,523 | CAL_DTYPES = { "event_name_1": "category", "event_type_1": "category",
"weekday": "category", 'wm_yr_wk': 'int16', "wday": "int8",
"month": "int8", "year": "int16", "snap_CA": "float32", 'snap_TX': 'float32', 'snap_WI': 'float32' }
STE_DTYPES = { "item_id": "category", "dept_id": "category", "cat_id": "category", "stor... | from sklearn.neighbors import KNeighborsClassifier | Titanic - Machine Learning from Disaster |
4,803,523 | cal = pd.read_csv(".. /input/m5-forecasting-accuracy/calendar.csv", dtype = CAL_DTYPES)
ste = pd.read_csv(".. /input/m5-forecasting-accuracy/sales_train_evaluation.csv", dtype = STE_DTYPES)
pri = pd.read_csv(".. /input/m5-forecasting-accuracy/sell_prices.csv", dtype = PRICE_DTYPES )<feature_engineering> | from sklearn.neighbors import KNeighborsClassifier | Titanic - Machine Learning from Disaster |
4,803,523 |
print("canceled" )<data_type_conversions> | data = open_data("train.csv")
X, Y = param_label(data)
x_train, x_test, y_train, y_test = subset_data(X, Y, 0.2 ) | Titanic - Machine Learning from Disaster |
4,803,523 | trans_cols = ["item_id", "dept_id", "cat_id", "store_id", "state_id"]
for col in trans_cols:
ste[col] = ste[col].cat.codes.astype("int16")
trans_cols = ["item_id", "store_id"]
for col in trans_cols:
pri[col] = pri[col].cat.codes.astype("int16")
trans_cols = ["event_name_1", "event_type_1"]
for col in trans_cols:
cal[... | model = KNeighborsClassifier()
model.fit(x_train, y_train)
acc = metrics.accuracy_score(model.predict(x_test), y_test)
print("Accuracy : " + str(acc)) | Titanic - Machine Learning from Disaster |
4,803,523 | cal.drop(['weekday'], axis=1, inplace=True )<merge> | neighboors = [i for i in range(1, 101)]
averages = []
mins = []
maxs = []
for n in neighboors:
average_acc = 0
min_acc = 1
max_acc = 0
for i in range(100):
x_train, x_test, y_train, y_test = subset_data(X, Y, 0.2)
model = KNeighborsClassifier(n_neighbors = n)
model.fit(x_train, y_train)
acc = metrics.accuracy_score(... | Titanic - Machine Learning from Disaster |
4,803,523 | df = pd.melt(ste,id_vars=ste.columns.values[:6],var_name="d",value_name="sells")
df["sells"] = df["sells"].astype("float32")
df = df.merge(cal, on='d', copy = False)
df = df.merge(pri, on=["store_id", "item_id", "wm_yr_wk"],copy = False)
<drop_column> | model = KNeighborsClassifier(n_neighbors = 12)
model.fit(X, Y)
data_test = open_data("test.csv")
prediction = model.predict(data_test.drop(["PassengerId"], 1))
solution = pd.DataFrame(np.array([[data_test.PassengerId.iloc[i], prediction[i]] for i in range(len(data_test)) ]),
columns=['PassengerId', 'Survived'])
sol... | Titanic - Machine Learning from Disaster |
4,803,523 | df.drop(df.index[df["wm_yr_wk"]<=11430], inplace=True)
days_christmas = ["d_331","d_697","d_1062","d_1427","d_1792"]
for day in days_christmas:
df.drop(df.index[df["d"] == day], inplace=True )<drop_column> | data = open_data("train.csv")
X, Y = param_label(data)
X = X[["Pclass", "Sex"]]
x_train, x_test, y_train, y_test = subset_data(X, Y, 0.2)
model = KNeighborsClassifier()
model.fit(x_train, y_train)
acc = metrics.accuracy_score(model.predict(x_test), y_test)
print("Accuracy : " + str(acc)) | Titanic - Machine Learning from Disaster |
4,803,523 |
<feature_engineering> | model = KNeighborsClassifier(n_neighbors = 8)
model.fit(x_train, y_train)
acc = metrics.accuracy_score(model.predict(x_test), y_test)
print("Accuracy : " + str(acc)) | Titanic - Machine Learning from Disaster |
4,803,523 | def create_features(dt):
dt["lag_7"] = dt[["id","sells"]].groupby("id")["sells"].shift(7)
dt["lag_28"] = dt[["id","sells"]].groupby("id")["sells"].shift(28)
dt["win_7"] = dt[["id","sells"]].groupby("id")["sells"].transform(lambda x : x.rolling(7 ).mean() ).shift(1)
dt["win_28"] = dt[["id","sells"]].groupby("id")["se... | model = KNeighborsClassifier(n_neighbors = 8)
model.fit(X[["Pclass", "Sex"]], Y)
data_test = open_data("test.csv")
prediction = model.predict(data_test[["Pclass", "Sex"]])
solution = pd.DataFrame(np.array([[data_test.PassengerId.iloc[i], prediction[i]] for i in range(len(data_test)) ]),
columns=['PassengerId', 'Sur... | Titanic - Machine Learning from Disaster |
4,803,523 | create_features(df)
df.dropna(inplace = True )<prepare_x_and_y> | data["FamilyMembers"] = data["SibSp"]+data["Parch"]
X, Y = param_label(data)
X = X[["Pclass", "Sex", "FamilyMembers"]]
x_train, x_test, y_train, y_test = subset_data(X, Y, 0.2)
model = KNeighborsClassifier(n_neighbors = 8)
model.fit(x_train, y_train)
acc = metrics.accuracy_score(model.predict(x_test), y_test)
prin... | Titanic - Machine Learning from Disaster |
4,803,523 | features =['item_id', 'dept_id', 'store_id', 'cat_id', 'state_id',
'wday', 'month', 'year',
'event_name_1', 'event_name_2', 'event_type_1', 'event_type_2',
'snap_CA', 'snap_TX', 'snap_WI',
'sell_price',
'lag_7', 'lag_28', 'win_7', 'win_28', 'win_7_lag_7','win_28_lag_28',
'price_win_7', 'price_win_28']
X_train = df[feat... | model = KNeighborsClassifier(n_neighbors = 8)
model.fit(X[["Pclass", "Sex", "FamilyMembers"]], Y)
data_test = open_data("test.csv")
data_test["FamilyMembers"] = data_test["SibSp"]+data_test["Parch"]
prediction = model.predict(data_test[["Pclass", "Sex","FamilyMembers"]])
solution = pd.DataFrame(np.array([[data_test... | Titanic - Machine Learning from Disaster |
4,803,523 | np.random.seed(1000)
fake_valid_index = np.random.choice(X_train.index.values, 2000000, replace = False)
train_index = np.setdiff1d(X_train.index.values, fake_valid_index)
train_data = lgb.Dataset(X_train.loc[train_index] , label = y_train.loc[train_index],
categorical_feature=cat_features, free_raw_data=False)
fak... | data = open_data("train.csv")
X, Y = param_label(data)
x_train, x_test, y_train, y_test = subset_data(X, Y, 0.2)
model = svm.SVC()
model.fit(x_train, y_train)
y_predict = model.predict(x_test)
acc = metrics.accuracy_score(y_predict, y_test)
print("Accuracy:",acc ) | Titanic - Machine Learning from Disaster |
4,803,523 | del df, X_train, y_train, fake_valid_index, train_index
gc.collect()<init_hyperparams> | kernels = ["rbf", "linear", "sigmoid", "poly"]
for kernel in kernels:
model = svm.SVC(kernel = kernel)
model.fit(x_train, y_train)
y_predict = model.predict(x_test)
acc = metrics.accuracy_score(y_predict, y_test)
print("Accuracy with kernel =", kernel, ": ",acc ) | Titanic - Machine Learning from Disaster |
4,803,523 | params = {
"objective" : "tweedie",
"metric" : ["rmse"],
"force_row_wise" : True,
"learning_rate" : 0.07,
"bagging_freq" : 3,
"bagging_fraction" : 0.5,
"lambda_l2" : 0.1,
"num_iterations" : 1000,
"num_leaves" : 255,
"min_data_in_leaf": 128,
}<train_model> | model = svm.SVC(kernel = 'linear')
model.fit(X,Y)
data_test = open_data("test.csv")
prediction = model.predict(data_test.drop(["PassengerId"], 1))
solution = pd.DataFrame(np.array([[data_test.PassengerId.iloc[i], prediction[i]] for i in range(len(data_test)) ]),
columns=['PassengerId', 'Survived'])
solution.to_csv(... | Titanic - Machine Learning from Disaster |
4,803,523 | %%time
m_lgb = lgb.train(params, train_data, valid_sets = [fake_valid_data], verbose_eval=50 )<save_model> | cs = [1, 5, 10, 15, 20]
gammas = [0.005, 0.01, 0.02, 0.05, 0.1]
for gamma in gammas:
for c in cs:
model = svm.SVC(kernel = 'rbf', C = c, gamma = gamma)
model.fit(x_train, y_train)
acc = metrics.accuracy_score(model.predict(x_test), y_test)
print("Accuracy with gamma = ",gamma,"c = ",c,": ",acc)
print("" ) | Titanic - Machine Learning from Disaster |
4,803,523 | m_lgb.save_model("model.lgb" )<feature_engineering> | model = svm.SVC(kernel = 'rbf', gamma = 0.01, C = 10)
model.fit(X,Y)
data_test = open_data("test.csv")
prediction = model.predict(data_test.drop(["PassengerId"], 1))
solution = pd.DataFrame(np.array([[data_test.PassengerId.iloc[i], prediction[i]] for i in range(len(data_test)) ]),
columns=['PassengerId', 'Survived']... | Titanic - Machine Learning from Disaster |
4,803,523 | days = [f"d_{i}" for i in range(1942,1970)]
for day in days:
ste[day] = 0<merge> | from sklearn.ensemble import RandomForestClassifier | Titanic - Machine Learning from Disaster |
4,803,523 | df = pd.melt(ste,id_vars=ste.columns.values[:6],var_name="d",value_name="sells")
df["sells"] = df["sells"].astype("float32")
df = df.merge(cal, on='d', copy = False)
df = df.merge(pri, on=["store_id", "item_id", "wm_yr_wk"],copy = False )<drop_column> | data = open_data("train.csv")
X, Y = param_label(data)
x_train, x_test, y_train, y_test = subset_data(X, Y, 0.2 ) | Titanic - Machine Learning from Disaster |
4,803,523 | df.drop(df.index[df["wm_yr_wk"]<=11607], inplace=True )<feature_engineering> | model = RandomForestClassifier()
model.fit(x_train, y_train)
y_predict = model.predict(x_test)
y_predict
acc = metrics.accuracy_score(y_predict, y_test)
print(acc ) | Titanic - Machine Learning from Disaster |
4,803,523 | create_features(df )<predict_on_test> | trees = [5, 10, 20, 50, 100]
averages = []
mins = []
maxs = []
for tree in trees:
average_acc = 0
min_acc = 1
max_acc = 0
for i in range(100):
x_train, x_test, y_train, y_test = subset_data(X, Y, 0.2)
model = RandomForestClassifier(n_estimators = tree)
model.fit(x_train, y_train)
y_predict = model.predict(x_test)
y... | Titanic - Machine Learning from Disaster |
4,803,523 | %%time
for day in days:
X_pred = df[df["d"] == day][features]
y_pred = m_lgb.predict(X_pred)
print(day)
df.loc[df["d"] == day, "sells"] = y_pred
create_features(df )<prepare_output> | depths = [1, 2, 5, 10, 15, 20]
averages = []
mins = []
maxs = []
for depth in depths:
average_acc = 0
min_acc = 1
max_acc = 0
for i in range(100):
x_train, x_test, y_train, y_test = subset_data(X, Y, 0.2)
model = RandomForestClassifier(n_estimators = 20, max_depth = depth)
model.fit(x_train, y_train)
y_predict = mod... | Titanic - Machine Learning from Disaster |
4,803,523 | sub = df[["id","d","sells"]].pivot(index="id", columns="d", values="sells")
sub = sub.reset_index()
sub.columns.name = None<concatenate> | model = RandomForestClassifier(n_estimators = 20, max_depth = 10)
model.fit(X,Y)
data_test = open_data("test.csv")
prediction = model.predict(data_test.drop(["PassengerId"], 1))
solution = pd.DataFrame(np.array([[data_test.PassengerId.iloc[i], prediction[i]] for i in range(len(data_test)) ]),
columns=['PassengerId',... | Titanic - Machine Learning from Disaster |
4,803,523 | sub1 = pd.concat([sub.T[0:1],sub.T[-56:-28]] ).T
sub2 = pd.concat([sub.T[0:1],sub.T[-28:]] ).T<feature_engineering> | model = RandomForestClassifier(n_estimators = 20, max_depth = 10)
model.fit(X[["Sex", "Age", "Fare", "Pclass"]],Y)
data_test = open_data("test.csv")
prediction = model.predict(data_test[["Sex", "Age", "Fare", "Pclass"]])
solution = pd.DataFrame(np.array([[data_test.PassengerId.iloc[i], prediction[i]] for i in range... | Titanic - Machine Learning from Disaster |
4,803,523 | sub_columns = ["id"] + [f"F{i}" for i in range(1,29)]
sub1.columns = sub_columns
sub2.columns = sub_columns
sub1["id"] = sub1["id"].str.replace("evaluation", "validation" )<save_to_csv> | import tensorflow as tf
from tensorflow import keras | Titanic - Machine Learning from Disaster |
4,803,523 | sub = pd.concat([sub2,sub1])
sub.to_csv("submission.csv",index=False)
sub<load_from_csv> | data = open_data("train.csv")
X, Y = param_label(data)
x_train, x_test, y_train, y_test = subset_data(X, Y, 0.2 ) | Titanic - Machine Learning from Disaster |
4,803,523 | cal = pd.read_csv('/kaggle/input/m5-forecasting-accuracy/calendar.csv')
steval = pd.read_csv('/kaggle/input/m5-forecasting-accuracy/sales_train_evaluation.csv')
price = pd.read_csv('/kaggle/input/m5-forecasting-accuracy/sell_prices.csv' )<prepare_x_and_y> | def build_model() :
model = keras.Sequential()
model.add(keras.layers.Dense(32, activation='relu', kernel_initializer = 'uniform', input_shape=[len(X.keys())]))
model.add(keras.layers.Dense(12, activation='relu', kernel_initializer = 'uniform'))
model.add(keras.layers.Dense(1, activation='sigmoid', kernel_initializer =... | Titanic - Machine Learning from Disaster |
4,803,523 | id_list = sorted(list(set(steval['id'])))
d_cols = [col for col in steval.columns if 'd_' in col]
x_1 = steval.loc[steval['id'] == id_list[0]].set_index('id')[d_cols].values[0][:200]
x_2 = steval.loc[steval['id'] == id_list[12]].set_index('id')[d_cols].values[0][300:500]
x_3 = steval.loc[steval['id'] == id_list[36]].s... | model = build_model()
class PrintDot(keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs):
if epoch % 100 == 0: print('')
print('.', end='')
EPOCHS = 1000
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=50)
history = model.fit(normed_x_train, y_train, epochs=EPOCHS,
validation_split... | Titanic - Machine Learning from Disaster |
4,803,523 | for i in range(1942,1970):
col = 'd_' + str(i)
steval[col] = 0
steval[col] = steval[col].astype(np.int16 )<categorify> | y_pred = model.predict(x_test)
y_pred =(y_pred > 0.5 ).astype(int ).reshape(x_test.shape[0])
metrics.accuracy_score(y_pred, y_test ) | Titanic - Machine Learning from Disaster |
4,803,523 | sales = pd.melt(steval, id_vars=['id', 'item_id', 'dept_id', 'cat_id', 'store_id', 'state_id'], var_name='d', value_name='sold' ).dropna()<merge> | architectures = [[12, 6],
[32, 16],
[64, 32],
[12, 12, 6],
[32, 16, 8],
[64, 32, 16],
[12, 12, 6, 6],
[32, 32, 16, 8],
[64, 32, 16, 8],
[64, 64, 32, 16, 8]] | Titanic - Machine Learning from Disaster |
4,803,523 | sales = pd.merge(sales, cal, on='d', how='left')
sales = pd.merge(sales, price, on=['store_id','item_id','wm_yr_wk'], how='left' )<define_variables> | def build_model(architecture):
model = keras.Sequential()
model.add(keras.layers.Dense(architecture[0], activation='relu', kernel_initializer = 'uniform', input_shape=[len(X.keys())]))
for i in range(1, len(architecture)) :
n = architecture[i]
model.add(keras.layers.Dense(n, activation='relu', kernel_initializer = 'uni... | Titanic - Machine Learning from Disaster |
4,803,523 | d_id = dict(zip(sales.id.cat.codes, sales.id))
d_item_id = dict(zip(sales.item_id.cat.codes, sales.item_id))
d_dept_id = dict(zip(sales.dept_id.cat.codes, sales.dept_id))
d_cat_id = dict(zip(sales.cat_id.cat.codes, sales.cat_id))
d_store_id = dict(zip(sales.store_id.cat.codes, sales.store_id))
d_state_id = dict(zip(sal... | EPOCHS = 1000
averages = []
mins = []
maxs = []
for architecture in architectures:
model = build_model(architecture)
average_acc = 0
min_acc = 1
max_acc = 0
for i in range(100):
x_train, x_test, y_train, y_test = subset_data(X, Y, 0.2)
history = model.fit(normed_x_train, y_train, epochs=EPOCHS,
validation_split = 0.2... | Titanic - Machine Learning from Disaster |
4,066,562 | sales.d = sales['d'].apply(lambda x: x.split('_')[1] ).astype(np.int16)
cols = sales.dtypes.index.tolist()
types = sales.dtypes.values.tolist()
for i,type in enumerate(types):
if type.name == 'category':
sales[cols[i]] = sales[cols[i]].cat.codes<drop_column> | tra=pd.read_csv('.. /input/train.csv')
tes=pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
4,066,562 | sales.drop('date',axis=1,inplace=True )<categorify> | x=tra.drop(['Name','PassengerId','Ticket','Survived'],axis=1)
x_t=tes.drop(['Name','PassengerId','Ticket'],axis=1)
| Titanic - Machine Learning from Disaster |
4,066,562 | lags = [1,2,4,8,16,32]
for lag in lags:
sales['sold_lag_'+str(lag)] = sales.groupby(['id', 'item_id', 'dept_id', 'cat_id', 'store_id', 'state_id'],as_index=False)['sold'].shift(lag ).astype(np.float16 )<data_type_conversions> | x.isna().sum() | Titanic - Machine Learning from Disaster |
4,066,562 | sales['item_sold_avg'] = sales.groupby('item_id')['sold'].transform('mean' ).astype(np.float16)
sales['state_sold_avg'] = sales.groupby('state_id')['sold'].transform('mean' ).astype(np.float16)
sales['store_sold_avg'] = sales.groupby('store_id')['sold'].transform('mean' ).astype(np.float16)
sales['cat_sold_avg'] = s... | x_t.isna().sum() | Titanic - Machine Learning from Disaster |
4,066,562 | id_list = sorted(list(set(sales['id'])))
sold_avg_cols = [col for col in sales.columns if '_sold_avg' in col]
x_1 = sales.loc[sales['id'] == id_list[0]].set_index('id')[sold_avg_cols].values[0][:]
x_2 = sales.loc[sales['id'] == id_list[12]].set_index('id')[sold_avg_cols].values[0][:]
x_3 = sales.loc[sales['id'] == id_... | x.Age=x.Age.fillna(x.Age.mean())
x_t.Age=x_t.Age.fillna(x_t.Age.mean() ) | Titanic - Machine Learning from Disaster |
4,066,562 | sales['rolling_sold_mean'] = sales.groupby(['id', 'item_id', 'dept_id', 'cat_id', 'store_id', 'state_id'])['sold'].transform(lambda x: x.rolling(window=6 ).mean() ).astype(np.float16 )<data_type_conversions> | x.Cabin=x.Cabin.fillna('U')
x_t.Cabin=x_t.Cabin.fillna('U' ) | Titanic - Machine Learning from Disaster |
4,066,562 | sales['expanding_sold_mean'] = sales.groupby(['id', 'item_id', 'dept_id', 'cat_id', 'store_id', 'state_id'])['sold'].transform(lambda x: x.expanding(2 ).mean() ).astype(np.float16 )<set_options> | x.Embarked=x.Embarked.fillna('S')
x_t.Embarked=x_t.Embarked.fillna('S' ) | Titanic - Machine Learning from Disaster |
4,066,562 | gc.collect()<data_type_conversions> | x_t.Fare=x_t.Fare.fillna(x_t.Fare.mean() ) | Titanic - Machine Learning from Disaster |
4,066,562 | sales['daily_avg_sold'] = sales.groupby(['id', 'item_id', 'dept_id', 'cat_id', 'store_id', 'state_id','d'])['sold'].transform('mean' ).astype(np.float16)
sales['avg_sold'] = sales.groupby(['id', 'item_id', 'dept_id', 'cat_id', 'store_id', 'state_id'])['sold'].transform('mean' ).astype(np.float16)
sales['selling_trend... | x.Cabin = x.Cabin.map(lambda z: z[0])
x_t.Cabin = x_t.Cabin.map(lambda z: z[0] ) | Titanic - Machine Learning from Disaster |
4,066,562 | sales = sales[sales['d']>=32]<set_options> | Titanic - Machine Learning from Disaster | |
4,066,562 | gc.collect()<load_pretrained> | x= pd.get_dummies(x)
x_t=pd.get_dummies(x_t ) | Titanic - Machine Learning from Disaster |
4,066,562 | sales.to_pickle('salesdata.pkl')
del sales<set_options> | x=x.drop(['Cabin_T'],axis=1 ) | Titanic - Machine Learning from Disaster |
4,066,562 | gc.collect()<categorify> | y=tra['Survived'] | Titanic - Machine Learning from Disaster |
4,066,562 | data = pd.read_pickle('salesdata.pkl')
validation = data[(data['d']>=1914)&(data['d']<1942)][['id','d','sold']]
test = data[data['d']>=1942][['id','d','sold']]
eval_prediction = test['sold']
validation_prediction = validation['sold']<set_options> | x_train,x_val,y_train,y_val=train_test_split(x,y,test_size=0.2,random_state=0 ) | Titanic - Machine Learning from Disaster |
4,066,562 | gc.collect()<set_options> | reg=RandomForestClassifier(n_estimators=100000,random_state=0)
reg.fit(x_train,y_train ) | Titanic - Machine Learning from Disaster |
4,066,562 | gc.collect()<prepare_x_and_y> | Titanic - Machine Learning from Disaster | |
4,066,562 | X_train, y_train = df[df['d']<1914].drop('sold',axis=1), df[df['d']<1914]['sold']
X_valid, y_valid = df[(df['d']>=1914)&(df['d']<1942)].drop('sold',axis=1), df[(df['d']>=1914)&(df['d']<1942)]['sold']
X_test = df[df['d']>=1942].drop('sold',axis=1 )<set_options> | y_pred=reg.predict(x_val ) | Titanic - Machine Learning from Disaster |
4,066,562 | gc.collect()<define_search_space> | accuracy_score(y_val, y_pred ) | Titanic - Machine Learning from Disaster |
4,066,562 | %%time
valgrid = {'n_estimators':hp.quniform('n_estimators', 900, 1500, 100),
'learning_rate':hp.quniform('learning_rate', 0.01, 0.4, 0.01),
'max_depth':hp.quniform('max_depth', 3,10,1),
'num_leaves':hp.quniform('num_leaves', 25,100,25),
'subsample':hp.quniform('subsample', 0.5, 0.9, 0.1),
'colsample_bytree':hp.qunifor... | pred=reg.predict(x_t)
new_pred=pred.astype(int)
output=pd.DataFrame({'PassengerId':tes['PassengerId'],'Survived':new_pred})
output.to_csv('Titanic.csv', index=False ) | Titanic - Machine Learning from Disaster |
9,686,466 | gc.collect()<train_model> | train = pd.read_csv("/kaggle/input/titanic/train.csv")
test = pd.read_csv("/kaggle/input/titanic/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.