kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,918,480 | %%bash
cd PM-LKH
mv submission.csv.. /submission.csv
mv post4.tour.. /post4.tour
rm -r DIV
rm -r DIV_TOURS
<train_model> | rf_model = RandomForestClassifier(criterion= 'gini', n_estimators = 100 ,max_depth = 6, random_state = 0)
rf_model.fit(X_train, y_train)
y_pred = rf_model.predict(X_test)
Random_forest_acc= accuracy_score(y_test, y_pred)
print('acc = ', Random_forest_acc)
| Titanic - Machine Learning from Disaster |
9,918,480 | Final run of the linkern-based code to search for global impprovemnts .<import_modules> | model = LogisticRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
LogisticReg_acc= accuracy_score(y_test, y_pred)
print('acc = ', LogisticReg_acc ) | Titanic - Machine Learning from Disaster |
9,918,480 | import numba
import numpy as np
import pandas as pd
from math import sqrt
from functools import lru_cache
from sklearn.neighbors import KDTree
from sympy import isprime, primerange
from tqdm import tqdm_notebook as tqdm
from ortools.constraint_solver import pywrapcp
from itertools import combinations, permutations
from... | model = SVC(kernel = 'rbf', random_state = 0)
model.fit(X, y)
y_pred = model.predict(X_test)
SVC_acc = accuracy_score(y_test, y_pred)
print('acc = ', SVC_acc ) | Titanic - Machine Learning from Disaster |
9,918,480 | cities = pd.read_csv('.. /input/reeindeer/cities.csv', index_col=['CityId'])
XY = np.stack(( cities.X.astype(np.float32), cities.Y.astype(np.float32)) , axis=1)
is_not_prime = np.array([0 if isprime(i)else 1 for i in cities.index], dtype=np.int32 )<choose_model_class> | model = GaussianNB()
model.fit(X, y)
y_pred = model.predict(X_test)
Gaussian_acc = accuracy_score(y_test, y_pred)
print('acc = ', Gaussian_acc ) | Titanic - Machine Learning from Disaster |
9,918,480 | kdt = KDTree(XY )<load_from_csv> | model = DecisionTreeClassifier(criterion = 'entropy', random_state = 0)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
DT_acc = accuracy_score(y_test, y_pred)
print('acc = ', DT_acc)
| Titanic - Machine Learning from Disaster |
9,918,480 | path = np.array(pd.read_csv('.. /input/reeindeer/path1515413.csv' ).Path)
<compute_test_metric> | gbc=GradientBoostingClassifier()
parameters= {'n_estimators':[ 50,100,200,300, ],
'max_depth':[3,4,6,7]
}
gbreg=GridSearchCV(gbc, param_grid=parameters, cv = 5)
gbreg.fit(X_train,y_train)
print("The best value of leanring rate is: ",gbreg.best_params_, ) | Titanic - Machine Learning from Disaster |
9,918,480 | @numba.jit('f8(i8, i8, i8)', nopython=True, parallel=False)
def cities_distance(offset, id_from, id_to):
xy_from, xy_to = XY[id_from], XY[id_to]
dx, dy = xy_from[0] - xy_to[0], xy_from[1] - xy_to[1]
distance = sqrt(dx * dx + dy * dy)
if offset % 10 == 9 and is_not_prime[id_from]:
return 1.1 * distance
return distance... | model_gb = GradientBoostingClassifier(n_estimators = 100, max_depth =4, random_state = 42)
model_gb.fit(X_train, y_train)
y_pred = model_gb.predict(X_test)
GB_acc = accuracy_score(y_test, y_pred)
print('acc = ', GB_acc ) | Titanic - Machine Learning from Disaster |
9,918,480 | trees = get_uplets(3, 5, 5 )<sort_values> | classifier = XGBClassifier()
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
xgb_acc = accuracy_score(y_pred, y_test)
print('acc=',xgb_acc ) | Titanic - Machine Learning from Disaster |
9,918,480 | path_index = np.argsort(path[:-1])
print(f'Total score is {score_path(path):.2f}.')
for ids in tqdm(trees):
i1, i2, i3 = np.sort(path_index[ids])
head, tail = path[i1-1], path[i3+1]
all_chunks = [[path[i1:i1+1], path[i1+1:i2], path[i2:i2+1], path[i2+1:i3], path[i3:i3+1]],
[path[i1:i1+1], path[i1+1:i2][::-1], path[i2... | print('RF_acc=', Random_forest_acc)
print('Logistic_acc=', LogisticReg_acc)
print('SVC_acc=', SVC_acc)
print('Gaussian_acc=', Gaussian_acc)
print('DecisionTree_acc=', DT_acc)
print('GradBoost_acc=', GB_acc)
print('XGBoost_acc=', xgb_acc)
| Titanic - Machine Learning from Disaster |
9,918,480 | fours = get_uplets(4, 5, 0 )<sort_values> | rf_model = RandomForestClassifier(criterion= 'gini', n_estimators = 100 ,max_depth = 6, random_state = 0)
rf_model.fit(X, y)
final_pred = rf_model.predict(test_set)
final_pred | Titanic - Machine Learning from Disaster |
9,918,480 | path_index = np.argsort(path[:-1])
print(f'Total score is {score_path(path):.2f}.')
for ids in tqdm(fours):
i1, i2, i3, i4 = np.sort(path_index[ids])
head, tail = path[i1-1], path[i4+1]
all_chunks = [[path[i1:i1+1], path[i1+1:i2], path[i2:i2+1], path[i2+1:i3], path[i3:i3+1], path[i3+1:i4], path[i4:i4+1]],
[path[i1:i... | survivors = pd.DataFrame(final_pred, columns = ['Survived'])
len(survivors)
survivors.insert(0, 'PassengerId', test['PassengerId'], True)
survivors | Titanic - Machine Learning from Disaster |
9,918,480 | <define_variables><EOS> | survivors.to_csv('Submission.csv', index = False ) | Titanic - Machine Learning from Disaster |
9,250,742 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<features_selection> | %matplotlib inline
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename)) | Titanic - Machine Learning from Disaster |
9,250,742 | m = 40
run_opt(path_df, m)
path = path_df['Path'].values<save_to_csv> | test = pd.read_csv("/kaggle/input/titanic/test.csv")
train = pd.read_csv("/kaggle/input/titanic/train.csv" ) | Titanic - Machine Learning from Disaster |
9,250,742 | def make_submission(name, path):
pd.DataFrame({'Path': path} ).to_csv(f'{name}.csv', index=False )<compute_test_metric> | total = train.isnull().sum().sort_values(ascending=False)
percent = round(train.isnull().sum() /train.isnull().count() *100, 1 ).sort_values(ascending=False)
missing_data = pd.concat([total, percent], axis=1, keys=['Total', '%'])
missing_data.head(5 ) | Titanic - Machine Learning from Disaster |
9,250,742 | make_submission("path" + str(int(score_path(path))), path )<define_search_space> | train_ml = train.drop(['PassengerId', 'Name', 'Ticket', 'Cabin'], axis=1)
train_ml["Embarked"] = train_ml["Embarked"].fillna("S")
mean = train_ml["Age"].mean()
std = train_ml["Age"].std()
is_null = train_ml["Age"].isnull().sum()
rand_age = np.random.randint(mean - std, mean + std, size = is_null)
age_slice = train_m... | Titanic - Machine Learning from Disaster |
9,250,742 | %%sh
cat > main.cpp <<'EOF'
using namespace std;
constexpr int maxShift = 25; //5
constexpr int cntNeighbors = 100;
constexpr int cntCities = 197769;
class GlobalIndex {
public:
array<double, 10> penalty_coefficients{1.1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
vector<vector<int>> neighbors;
bitset<cntCities> primes;
array<double,... | train_ml.loc[train_ml["Sex"] == "male", "Sex"] = 0
train_ml.loc[train_ml["Sex"] == "female", "Sex"] = 1
train_ml["Sex"] = train_ml["Sex"].astype(int)
train_ml.loc[train_ml["Embarked"] == "S", "Embarked"] = 0
train_ml.loc[train_ml["Embarked"] == "C", "Embarked"] = 1
train_ml.loc[train_ml["Embarked"] == "Q", "Embarked"]... | Titanic - Machine Learning from Disaster |
9,250,742 | !g++ -pthread --std=c++17 -Ofast -o main main.cpp<define_variables> | train_ml['family_members'] = train_ml.SibSp + train_ml.Parch | Titanic - Machine Learning from Disaster |
9,250,742 | %%bash
time./main.. /input/gpu-shuffle-numba-cuda/submission_1515558.3917849772.csv./submission.csv<feature_engineering> | total = test.isnull().sum().sort_values(ascending=False)
percent = round(test.isnull().sum() /test.isnull().count() *100, 1 ).sort_values(ascending=False)
missing_data = pd.concat([total, percent], axis=1, keys=['Total', '%'])
missing_data.head(5 ) | Titanic - Machine Learning from Disaster |
9,250,742 | def factorial(n):
return int(scipy.special.gamma(n+1))<define_variables> | test_ml = test.drop(['Name', 'Ticket', 'Cabin'], axis=1)
mean = test_ml["Age"].mean()
std = test_ml["Age"].std()
is_null = test_ml["Age"].isnull().sum()
rand_age = np.random.randint(mean - std, mean + std, size = is_null)
age_slice = test_ml["Age"].copy()
age_slice[np.isnan(age_slice)] = rand_age
test_ml["Age"] = age... | Titanic - Machine Learning from Disaster |
9,250,742 | for k in range(8, 21): print(k, factorial(k))<set_options> | test_ml[test_ml.isnull().any(axis=1)]
test_ml["Fare"] = test_ml["Fare"].fillna(test_ml.groupby('Pclass' ).mean() ['Fare'][3])
test_ml.info() | Titanic - Machine Learning from Disaster |
9,250,742 | !g++ --std=c++17 -Wall -g -Ofast -mtune=native -march=native -fopenmp -DNDEBUG -o dp dp.cc<load_from_csv> | test_ml.loc[test_ml["Sex"] == "male", "Sex"] = 0
test_ml.loc[test_ml["Sex"] == "female", "Sex"] = 1
test_ml["Sex"] = test_ml["Sex"].astype(int)
test_ml.loc[test_ml["Embarked"] == "S", "Embarked"] = 0
test_ml.loc[test_ml["Embarked"] == "C", "Embarked"] = 1
test_ml.loc[test_ml["Embarked"] == "Q", "Embarked"] = 2
test_ml... | Titanic - Machine Learning from Disaster |
9,250,742 | %%bash
time./dp 18 <.. /input/not-a-3-and-3-halves-opt/1515562.8360910178.csv > submission.csv<import_modules> | test_ml['age_categories'] = pd.cut(test_ml.Age, [0, 11, 18, 23, 27, 33, 40, 50, np.inf],
labels=[0, 1, 2, 3, 4, 5, 6,7], include_lowest=True, right=False ).astype(int)
test_ml['fare_categories'] = pd.cut(test_ml.Fare, [0, 8, 14, 31, 99, 250, np.inf],
labels=[0, 1, 2, 3, 4, 5], include_lowest=True, right=False ).astype... | Titanic - Machine Learning from Disaster |
9,250,742 | import numpy as np
import pandas as pd
import numba
from sympy import isprime, primerange
from math import sqrt
from sklearn.neighbors import KDTree
from tqdm import tqdm_notebook as tqdm
from itertools import combinations, permutations
from functools import lru_cache<load_from_csv> | test_ml['family_members'] = test_ml.SibSp + test_ml.Parch | Titanic - Machine Learning from Disaster |
9,250,742 | cities = pd.read_csv('.. /input/traveling-santa-2018-prime-paths/cities.csv', index_col=['CityId'])
XY = np.stack(( cities.X.astype(np.float32), cities.Y.astype(np.float32)) , axis=1)
is_not_prime = np.array([0 if isprime(i)else 1 for i in cities.index], dtype=np.int32 )<compute_test_metric> | X_test = test_final.drop('PassengerId', axis=1 ) | Titanic - Machine Learning from Disaster |
9,250,742 | @numba.jit('f8(i8, i8, i8)', nopython=True, parallel=False)
def cities_distance(offset, id_from, id_to):
xy_from, xy_to = XY[id_from], XY[id_to]
dx, dy = xy_from[0] - xy_to[0], xy_from[1] - xy_to[1]
distance = sqrt(dx * dx + dy * dy)
if offset % 10 == 9 and is_not_prime[id_from]:
return 1.1 * distance
return distance... | X_train = train_ml[['Pclass', 'Sex', 'Embarked', 'age_categories', 'fare_categories', 'family_members']]
Y_train = train_ml.Survived | Titanic - Machine Learning from Disaster |
9,250,742 | @numba.jit('f8(i8, i8, i8[:], i8[:], i8[:], i8, f8[:,:], i8[:])', nopython=True, parallel=False)
def score_compound_chunk(offset, head, firsts, lasts, lens, tail, scores, indexes):
score = 0.0
last_city_id = head
for i in numba.prange(len(indexes)) :
index = indexes[i]
first, last, chunk_len = firsts[index], lasts[ind... | log_reg = LogisticRegression()
log_reg.fit(X_train, Y_train)
log_reg_acc = round(cross_val_score(log_reg, X_train, Y_train, cv=10, scoring = "accuracy" ).mean() *100, 4)
predictions = log_reg.predict(X_test ) | Titanic - Machine Learning from Disaster |
9,250,742 | kdt = KDTree(XY)
fives = set()
for i in tqdm(cities.index):
dists, neibs = kdt.query([XY[i]], 9)
for comb in combinations(neibs[0], 5):
if all(comb):
fives.add(tuple(sorted(comb)))
neibs = kdt.query_radius([XY[i]], 10, count_only=False, return_distance=False)
for comb in combinations(neibs[0], 5):
if all(comb):
fiv... | knn = KNeighborsClassifier()
knn.fit(X_train, Y_train)
knn_acc = round(cross_val_score(knn, X_train, Y_train, cv=10, scoring = "accuracy" ).mean() *100, 4)
predictions = knn.predict(X_test ) | Titanic - Machine Learning from Disaster |
9,250,742 | path = np.array(pd.read_csv('.. /input/shame-on-me/1515656.5970491648.csv' ).Path )<statistical_test> | gaussian_nb = GaussianNB()
gaussian_nb.fit(X_train, Y_train)
gaussian_nb_acc = round(cross_val_score(gaussian_nb, X_train, Y_train, cv=10, scoring = "accuracy" ).mean() *100, 4)
predictions = gaussian_nb.predict(X_test ) | Titanic - Machine Learning from Disaster |
9,250,742 | @lru_cache(maxsize=None)
def indexes_permutations(n):
return np.array(list(map(list, permutations(range(n)))))
path_index = np.argsort(path[:-1])
print(f'Total score is {score_path(path):.2f}.')
for _ in range(2):
for ids in tqdm(fives[:2 * 10**6]):
i1, i2, i3, i4, i5 = np.sort(path_index[ids])
head, tail = path[i... | decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
decision_tree_acc = round(cross_val_score(decision_tree, X_train, Y_train, cv=10, scoring = "accuracy" ).mean() *100, 4)
predictions = decision_tree.predict(X_test ) | Titanic - Machine Learning from Disaster |
9,250,742 | def make_submission(name, path):
pd.DataFrame({'Path': path} ).to_csv(f'{name}.csv', index=False)
make_submission(score_path(path), path )<import_modules> | random_forest = RandomForestClassifier()
random_forest.fit(X_train, Y_train)
random_forest_acc = round(cross_val_score(random_forest, X_train, Y_train, cv=10, scoring = "accuracy" ).mean() *100, 4)
predictions = random_forest.predict(X_test ) | Titanic - Machine Learning from Disaster |
9,250,742 | import numpy as np
import pandas as pd
import numba
from sympy import isprime, primerange
from math import sqrt
from sklearn.neighbors import KDTree
from tqdm import tqdm
from itertools import combinations<load_from_csv> | model_score = pd.DataFrame({'Model': ['Logistic regression', 'K-nearest Neighbors', 'Gaussian Naïve Bayes', 'Decision Tree', 'Random Forest'],
'Score': [log_reg_acc, knn_acc, gaussian_nb_acc, decision_tree_acc, random_forest_acc]})
model_score.sort_values(by='Score', ascending=False ).reset_index().drop('index', axis=... | Titanic - Machine Learning from Disaster |
9,250,742 | cities = pd.read_csv('.. /input/traveling-santa-2018-prime-paths/cities.csv', index_col=['CityId'])
XY = np.stack(( cities.X.astype(np.float32), cities.Y.astype(np.float32)) , axis=1)
is_not_prime = np.array([0 if isprime(i)else 1 for i in cities.index], dtype=np.int32 )<compute_test_metric> | feature_importance = pd.DataFrame({'Feature':X_train.columns,'Importance':np.round(random_forest.feature_importances_,3)})
feature_importance.sort_values('Importance',ascending=False ).reset_index().drop('index', axis=1 ) | Titanic - Machine Learning from Disaster |
9,250,742 | @numba.jit('f8(i8, i8, i8)', nopython=True, parallel=False)
def cities_distance(offset, id_from, id_to):
xy_from, xy_to = XY[id_from], XY[id_to]
dx, dy = xy_from[0] - xy_to[0], xy_from[1] - xy_to[1]
distance = sqrt(dx * dx + dy * dy)
if offset % 10 == 9 and is_not_prime[id_from]:
return 1.1 * distance
return distance... | random_forest.get_params() | Titanic - Machine Learning from Disaster |
9,250,742 | kdt = KDTree(XY )<load_from_csv> | n_estimators = [int(x)for x in np.linspace(start = 100, stop = 1000, num = 10)]
max_features = ['auto', 'sqrt', 'log2']
max_depth = [int(x)for x in np.linspace(10, 110, num = 11)]
max_depth.append(None)
min_samples_split = [2, 5, 10]
min_samples_leaf = [1, 2, 4]
bootstrap = [True, False]
random_grid = {'n_estimators':... | Titanic - Machine Learning from Disaster |
9,250,742 | path = np.array(pd.read_csv('.. /input/traveling-santa-lkh-solution/pure1502650.csv' ).Path)
initial_score = score_path(path )<compute_test_metric> | random_forest_random = RandomizedSearchCV(estimator = random_forest, param_distributions = random_grid, n_iter = 100, verbose=2, cv = 3, random_state=42, n_jobs = -1)
random_forest_random.fit(X_train, Y_train ) | Titanic - Machine Learning from Disaster |
9,250,742 | path_index = np.argsort(path[:-1])
total_score = initial_score
print(f'Total score is {total_score:.2f}.')
for _ in range(3):
for step,(id1, id2)in enumerate(tqdm(pairs), 1):
if step % 10**6 == 0:
new_total_score = score_path(path)
print(f'Score: {new_total_score:.2f}; improvement over last 10^6 steps: {total_score ... | random_forest_random.best_params_ | Titanic - Machine Learning from Disaster |
9,250,742 | print(f'Total improvement is {initial_score - total_score:.2f}.' )<save_to_csv> | random_forest_2 = random_forest_random.best_estimator_
random_forest_2.fit(X_train, Y_train)
random_forest_acc_2 = round(cross_val_score(random_forest_2, X_train, Y_train, cv=10, scoring = "accuracy" ).mean() *100, 4)
model_score = model_score.append(pd.DataFrame({'Model': ['Random Forest 2'], 'Score': [random_forest... | Titanic - Machine Learning from Disaster |
9,250,742 | def make_submission(name, path):
pd.DataFrame({'Path': path} ).to_csv(f'{name}.csv', index=False )<compute_test_metric> | param_grid = {
'bootstrap': [True],
'max_depth': [20, 40, 60, 80, 100],
'max_features': ['log2'],
'min_samples_leaf': [3, 4, 5],
'min_samples_split': [4, 5, 6],
'n_estimators': [100, 200, 300, 700, 1000]
}
random_forest_grid_search = GridSearchCV(estimator = random_forest, param_grid = param_grid, cv = 3, n_jobs = -1, ... | Titanic - Machine Learning from Disaster |
9,250,742 | make_submission(score_path(path), path )<import_modules> | random_forest_grid_search.best_params_ | Titanic - Machine Learning from Disaster |
9,250,742 | import numpy as np
import pandas as pd
import numba
from sympy import isprime, primerange
from math import sqrt
from sklearn.neighbors import KDTree
from tqdm import tqdm
from itertools import combinations<load_from_csv> | random_forest_3 = random_forest_grid_search.best_estimator_
random_forest_3.fit(X_train, Y_train)
random_forest_acc_3 = round(cross_val_score(random_forest_3, X_train, Y_train, cv=10, scoring = "accuracy" ).mean() *100, 4)
model_score = model_score.append(pd.DataFrame({'Model': ['Random Forest 3'], 'Score': [random_f... | Titanic - Machine Learning from Disaster |
9,250,742 | cities = pd.read_csv('.. /input/traveling-santa-2018-prime-paths/cities.csv', index_col=['CityId'])
XY = np.stack(( cities.X.astype(np.float32), cities.Y.astype(np.float32)) , axis=1)
is_not_prime = np.array([0 if isprime(i)else 1 for i in cities.index], dtype=np.int32 )<compute_test_metric> | predictions = cross_val_predict(random_forest_3, X_train, Y_train, cv=3)
confusion_matrix(Y_train, predictions ) | Titanic - Machine Learning from Disaster |
9,250,742 | @numba.jit('f8(i8, i8, i8)', nopython=True, parallel=False)
def cities_distance(offset, id_from, id_to):
xy_from, xy_to = XY[id_from], XY[id_to]
dx, dy = xy_from[0] - xy_to[0], xy_from[1] - xy_to[1]
distance = sqrt(dx * dx + dy * dy)
if offset % 10 == 9 and is_not_prime[id_from]:
return 1.1 * distance
return distance... | print("Precision:", precision_score(Y_train, predictions))
print("Recall:",recall_score(Y_train, predictions)) | Titanic - Machine Learning from Disaster |
9,250,742 | kdt = KDTree(XY )<load_from_csv> | y_scores = random_forest_3.predict_proba(X_train)
y_scores = y_scores[:,1]
r_a_score = roc_auc_score(Y_train, y_scores)
print("ROC-AUC-Score:", r_a_score ) | Titanic - Machine Learning from Disaster |
9,250,742 | path = np.array(pd.read_csv('.. /input/gpu-shuffle-numba-cuda/submission.csv' ).Path)
initial_score = score_path(path )<compute_test_metric> | final_predictions = random_forest_3.predict(X_test)
output = pd.DataFrame({'PassengerId': test_final.PassengerId, 'Survived': final_predictions})
output.to_csv('random_forest_model.csv', index=False ) | Titanic - Machine Learning from Disaster |
8,973,640 | path_index = np.argsort(path[:-1])
total_score = initial_score
print(f'Total score is {total_score:.2f}.')
for _ in range(3):
for step,(id1, id2)in enumerate(tqdm(pairs), 1):
if step % 10**6 == 0:
new_total_score = score_path(path)
print(f'Score: {new_total_score:.2f}; improvement over last 10^6 steps: {total_score ... | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
8,973,640 | print(f'Total improvement is {initial_score - total_score:.2f}.' )<save_to_csv> | print("
print("
print()
print("Train Features = ", train_data.columns.values)
print("Test Features = ", test_data.columns.values)
print()
print("NaNs in each training Feature")
print(train_data.isnull().sum())
print()
print("NaNs in each testing Feature")
print(test_data.isnull().sum() ) | Titanic - Machine Learning from Disaster |
8,973,640 | def make_submission(name, path):
pd.DataFrame({'Path': path} ).to_csv(f'{name}.csv', index=False )<compute_test_metric> | train_data.drop(columns='Cabin', inplace=True)
train_data.drop(columns='Ticket', inplace=True ) | Titanic - Machine Learning from Disaster |
8,973,640 | make_submission(score_path(path), path )<load_from_csv> | def detect_outliers(df,n,features):
outlier_indices = []
for col in features:
Q1 = np.percentile(df[col], 25)
Q3 = np.percentile(df[col],75)
IQR = Q3 - Q1
outlier_step = 1.5 * IQR
outlier_list_col = df[(df[col] < Q1 - outlier_step)|(df[col] > Q3 + outlier_step)].index
outlier_indices.extend(outlier_list_col)
outlier... | Titanic - Machine Learning from Disaster |
8,973,640 | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv(".. /input/test.csv")
base_features = [x for x in train_df.columns.values.tolist() if x.startswith('var_')]<feature_engineering> | train_data['Embarked'].fillna('S', inplace=True ) | Titanic - Machine Learning from Disaster |
8,973,640 | train_df['real'] = 1
for col in base_features:
test_df[col] = test_df[col].map(test_df[col].value_counts())
a = test_df[base_features].min(axis=1)
test_df = pd.read_csv('.. /input/test.csv')
test_df['real'] =(a == 1 ).astype('int')
train = train_df.append(test_df ).reset_index(drop=True)
del test_df, train_df; gc.... | meanAges = train_data.groupby(['Pclass'])['Age'].mean()
print(meanAges ) | Titanic - Machine Learning from Disaster |
8,973,640 | for col in tqdm(base_features):
train[col + 'size'] = train[col].map(train.loc[train.real==1, col].value_counts())
cnt_features = [col + 'size' for col in base_features]<feature_engineering> | train_data['newGender'] = train_data['Sex']
train_data.loc[train_data['Age']<16., 'newGender'] = 'child'
train_data.drop(columns='Sex', inplace=True)
print(train_data.head(8)) | Titanic - Machine Learning from Disaster |
8,973,640 | for col in tqdm(base_features):
train.loc[train[col+'size']>1,col+'no_noise'] = train.loc[train[col+'size']>1,col]
noise1_features = [col + 'no_noise' for col in base_features]<data_type_conversions> | train_data['Title'] = train_data['Name']
for name_string in train_data['Name']:
train_data['Title'] = train_data['Name'].str.extract('([A-Za-z]+)\.', expand=True)
mapping = {'Mlle': 'Miss', 'Major': 'Rare', 'Col': 'Rare', 'Sir': 'Rare', 'Don': 'Rare', 'Mme': 'Miss',
'Jonkheer': 'Rare', 'Lady': 'Rare', 'Capt': 'Rare', ... | Titanic - Machine Learning from Disaster |
8,973,640 | train[noise1_features] = train[noise1_features].fillna(train[noise1_features].mean() )<feature_engineering> | train_data['familyNumber'] = train_data['SibSp'] + train_data['Parch']
print(train_data.head(8))
Outliers_to_drop = detect_outliers(train_data,1,["Age","familyNumber","Fare"])
train_data = train_data.drop(Outliers_to_drop, axis = 0 ).reset_index(drop=True)
train_data['familySize'] = np.nan
train_data.loc[train_data['... | Titanic - Machine Learning from Disaster |
8,973,640 | for col in tqdm(base_features):
train.loc[train[col+'size']>2,col+'no_noise2'] = train.loc[train[col+'size']>2,col]
noise2_features = [col + 'no_noise2' for col in base_features]<data_type_conversions> | train_data['newPclass'] = np.nan
train_data.loc[train_data['Pclass']==1, 'newPclass'] = 'first'
train_data.loc[train_data['Pclass']==2, 'newPclass'] = 'second'
train_data.loc[train_data['Pclass']==3, 'newPclass'] = 'third'
train_data.drop(columns='Pclass', inplace=True)
columns = ['newGender', 'Embarked', 'Title', 'fa... | Titanic - Machine Learning from Disaster |
8,973,640 | train[noise2_features] = train[noise2_features].fillna(train[noise2_features].mean() )<split> | from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifie... | Titanic - Machine Learning from Disaster |
8,973,640 | train_df = train[train['target'].notnull() ]
test_df = train[train['target'].isnull() ]
all_features = base_features + noise1_features + noise2_features<prepare_x_and_y> | trainScaler = StandardScaler()
trainScaler.fit(train_data.drop(['Survived', 'PassengerId'], axis = 1))
X_train_scaled = trainScaler.transform(train_data.drop(['Survived', 'PassengerId'], axis = 1))
X_train = train_data.drop(['Survived', 'PassengerId'], axis = 1)
y_train = train_data['Survived'] | Titanic - Machine Learning from Disaster |
8,973,640 | scaler = preprocessing.StandardScaler().fit(train_df[all_features].values)
df_trn = pd.DataFrame(scaler.transform(train_df[all_features].values), columns=all_features)
df_tst = pd.DataFrame(scaler.transform(test_df[all_features].values), columns=all_features)
y = train_df['target'].values<prepare_x_and_y> | grid_params = {
'n_neighbors': [3, 5, 7, 9, 11, 13],
'weights': ['uniform', 'distance'],
'metric':['euclidean', 'manhattan']
}
KNN_CV = GridSearchCV(estimator = KNeighborsClassifier() , param_grid=grid_params, cv = 3)
KNN_CV.fit(X_train_scaled, y_train)
print(KNN_CV.best_score_)
weights = KNN_CV.best_params_.get('we... | Titanic - Machine Learning from Disaster |
8,973,640 | def get_keras_data(dataset, cols_info):
X = {}
base_feats, noise_feats, noise2_feats = cols_info
X['base'] = np.reshape(np.array(dataset[base_feats].values),(-1, len(base_feats), 1))
X['noise1'] = np.reshape(np.array(dataset[noise_feats].values),(-1, len(noise_feats), 1))
X['noise2'] = np.reshape(np.array(dataset[noise... | param_grid = {
'criterion' : ['gini'],
'n_estimators': [70, 80, 90, 100, 110, 120],
'max_features': ['auto', 'log2'],
'max_depth' : [5, 7, 9, 11, 13]
}
randomForest_CV = GridSearchCV(estimator = RandomForestClassifier() , param_grid = param_grid, cv = 3)
randomForest_CV.fit(X_train, y_train)
print(randomForest_CV.bes... | Titanic - Machine Learning from Disaster |
8,973,640 | cols_info = [base_features, noise1_features, noise2_features]
X_test = get_keras_data(df_tst[all_features], cols_info )<choose_model_class> | for i in range(3):
test_data.loc[test_data['Pclass']==int(i+1), 'Age'] = test_data.loc[test_data['Pclass']==int(i+1), 'Age'].fillna(meanAges.values[i])
meanFare = test_data['Fare'].median()
test_data['Fare'].fillna(meanFare, inplace=True ) | Titanic - Machine Learning from Disaster |
8,973,640 | def Convnet(cols_info, classes=1):
base_feats, noise1_feats, noise2_feats = cols_info
X_base_input = Input(shape=(len(base_feats), 1), name='base')
X_base = Dense(16 )(X_base_input)
X_base = Activation('relu' )(X_base)
X_base = Flatten(name='base_last' )(X_base)
X_noise1_input = Input(shape=(len(noise1_feats), 1), ... | test_data['newGender'] = test_data['Sex']
test_data.loc[test_data['Age']<18., 'newGender'] = 'child'
test_data.drop(columns='Sex', inplace=True)
test_data['Title'] = test_data['Name']
for name_string in test_data['Name']:
test_data['Title'] = test_data['Name'].str.extract('([A-Za-z]+)\.', expand=True)
mapping = {'Mll... | Titanic - Machine Learning from Disaster |
8,973,640 | try:
del df_tst
except:
pass
gc.collect()<choose_model_class> | test_data.drop(columns=['Cabin', 'Ticket'], inplace=True)
one_hot = pd.get_dummies(test_data.loc[:, columns], drop_first=True)
test_data.drop(columns=columns, inplace=True)
test_data = test_data.join(one_hot)
print("NaNs in each testing Feature")
print(test_data.isnull().sum() ) | Titanic - Machine Learning from Disaster |
8,973,640 | SEED = 2019
n_folds = 5
debug_flag = True
folds = 5
skf = StratifiedKFold(n_splits=n_folds, shuffle=True, random_state=SEED )<split> | X_test_scaled = trainScaler.transform(test_data.drop(['PassengerId'], axis = 1))
X_test = test_data.drop(columns='PassengerId')
testPredictionsKNN = bestKNN.predict(X_test_scaled)
testPredictionsRF = bestRF.predict(X_test)
outputKNN = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': testPredictionsKNN... | Titanic - Machine Learning from Disaster |
8,973,640 | i = 0
result = pd.DataFrame({"ID_code": test_df.ID_code.values})
val_aucs = []
valid_X = train_df[['target']]
valid_X['predict'] = 0
for train_idx, val_idx in skf.split(df_trn, y):
if i == folds:
break
i += 1
X_train, y_train = df_trn.iloc[train_idx], y[train_idx]
X_valid, y_valid = df_trn.iloc[val_idx], y[val_idx]
X_... | param_grid = {
'learning_rate' : [0.1, 0.2],
'n_estimators': [90, 100, 110],
'loss': ['deviance', 'exponential']
}
gradBoost_CV = GridSearchCV(estimator = GradientBoostingClassifier() , param_grid = param_grid, cv = 3)
gradBoost_CV.fit(X_train, y_train)
print(gradBoost_CV.best_score_)
learning = gradBoost_CV.best_pa... | Titanic - Machine Learning from Disaster |
8,973,640 | for i in range(len(val_aucs)) :
print('Fold_%d AUC: %.6f' %(i+1, val_aucs[i]))<compute_test_metric> | param_grid = {
'learning_rate' : [0.1, 0.2],
'max_depth': [3, 5, 7],
}
xgBoost_CV = GridSearchCV(estimator = XGBClassifier() , param_grid = param_grid, cv = 3)
xgBoost_CV.fit(X_train, y_train)
print(xgBoost_CV.best_score_)
learning = xgBoost_CV.best_params_.get('learning_rate')
depth = xgBoost_CV.best_params_.get('... | Titanic - Machine Learning from Disaster |
8,973,640 | auc_mean = np.mean(val_aucs)
auc_std = np.std(val_aucs)
auc_all = roc_auc_score(valid_X.target, valid_X.predict)
print('%d-fold auc mean: %.9f, std: %.9f.All auc: %6f.' %(n_folds, auc_mean, auc_std, auc_all))<save_to_csv> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
8,973,640 | y_all = result.values[:, 1:]
result['target'] = np.mean(y_all, axis = 1)
to_submit = result[['ID_code', 'target']]
to_submit.to_csv('NN_submission.csv', index=None)
result.to_csv('NN_all_prediction.csv', index=None)
valid_X['ID_code'] = train_df['ID_code']
valid_X = valid_X[['ID_code', 'target', 'predict']].to_csv('... | print("
print("
print()
print("Train Features = ", train_data.columns.values)
print("Test Features = ", test_data.columns.values)
print()
print("NaNs in each training Feature")
print(train_data.isnull().sum())
print()
print("NaNs in each testing Feature")
print(test_data.isnull().sum() ) | Titanic - Machine Learning from Disaster |
8,973,640 | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv' )<drop_column> | train_data.drop(columns='Cabin', inplace=True)
train_data.drop(columns='Ticket', inplace=True ) | Titanic - Machine Learning from Disaster |
8,973,640 | train_features = train_df.drop(['target','ID_code'], axis = 1)
test_features = test_df.drop(['ID_code'],axis = 1)
train_target = train_df['target']<count_unique_values> | def detect_outliers(df,n,features):
outlier_indices = []
for col in features:
Q1 = np.percentile(df[col], 25)
Q3 = np.percentile(df[col],75)
IQR = Q3 - Q1
outlier_step = 1.5 * IQR
outlier_list_col = df[(df[col] < Q1 - outlier_step)|(df[col] > Q3 + outlier_step)].index
outlier_indices.extend(outlier_list_col)
outlier... | Titanic - Machine Learning from Disaster |
8,973,640 | df_test = test_features.values
unique_samples = []
unique_count = np.zeros_like(df_test)
basic_features = [c for c in train_df.columns if c not in ['ID_code', 'target']]
for feature in range(df_test.shape[1]):
_, index_, count_ = np.unique(df_test[:, feature], return_counts=True, return_index=True)
unique_count[index... | train_data['Embarked'].fillna('S', inplace=True ) | Titanic - Machine Learning from Disaster |
8,973,640 | def process_data(train_df, test_df):
idx = [c for c in train_df.columns if c not in ['ID_code', 'target']]
df = pd.concat([train_df,test_df.ix[real_samples_indexes]])
for feat in idx:
temp = df[feat].value_counts(dropna=True)
train_df["count_"+feat] = train_df[feat].map(temp)
test_df["count_"+feat] = test_df[feat].m... | meanAges = train_data.groupby(['Pclass'])['Age'].mean()
print(meanAges ) | Titanic - Machine Learning from Disaster |
8,973,640 | train_features , test_features = process_data(train_features,test_features )<prepare_output> | train_data['newGender'] = train_data['Sex']
train_data.loc[train_data['Age']<16., 'newGender'] = 'child'
train_data.drop(columns='Sex', inplace=True)
print(train_data.head(8)) | Titanic - Machine Learning from Disaster |
8,973,640 | train_features = train_features[feature_name]
test_features = test_features[feature_name]
gc.collect()<normalization> | train_data['Title'] = train_data['Name']
for name_string in train_data['Name']:
train_data['Title'] = train_data['Name'].str.extract('([A-Za-z]+)\.', expand=True)
mapping = {'Mlle': 'Miss', 'Major': 'Rare', 'Col': 'Rare', 'Sir': 'Rare', 'Don': 'Rare', 'Mme': 'Miss',
'Jonkheer': 'Rare', 'Lady': 'Rare', 'Capt': 'Rare', ... | Titanic - Machine Learning from Disaster |
8,973,640 | sc = StandardScaler()
train_features = sc.fit_transform(train_features)
test_features = sc.transform(test_features )<split> | train_data['familyNumber'] = train_data['SibSp'] + train_data['Parch']
print(train_data.head(8))
Outliers_to_drop = detect_outliers(train_data,1,["Age","familyNumber","Fare"])
train_data = train_data.drop(Outliers_to_drop, axis = 0 ).reset_index(drop=True)
train_data['familySize'] = np.nan
train_data.loc[train_data['... | Titanic - Machine Learning from Disaster |
8,973,640 | n_splits = 10
splits = list(StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=4590 ).split(train_features, train_target))<choose_model_class> | train_data['newPclass'] = np.nan
train_data.loc[train_data['Pclass']==1, 'newPclass'] = 'first'
train_data.loc[train_data['Pclass']==2, 'newPclass'] = 'second'
train_data.loc[train_data['Pclass']==3, 'newPclass'] = 'third'
train_data.drop(columns='Pclass', inplace=True)
columns = ['newGender', 'Embarked', 'Title', 'fa... | Titanic - Machine Learning from Disaster |
8,973,640 | class CyclicLR(object):
def __init__(self, optimizer, base_lr=1e-3, max_lr=6e-3,
step_size=2000, mode='triangular', gamma=1.,
scale_fn=None, scale_mode='cycle', last_batch_iteration=-1):
if not isinstance(optimizer, Optimizer):
raise TypeError('{} is not an Optimizer'.format(
type(optimizer ).__name__))
self.optimizer... | from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifie... | Titanic - Machine Learning from Disaster |
8,973,640 | class Simple_NN(nn.Module):
def __init__(self ,input_dim ,hidden_dim, dropout = 0.5):
super(Simple_NN, self ).__init__()
self.inpt_dim = input_dim
self.hidden_dim = hidden_dim
self.relu = nn.ReLU()
self.dropout = nn.Dropout(dropout)
self.fc1 = nn.Linear(1, hidden_dim)
self.fc2 = nn.Linear(int(hidden_dim*input_dim), 1... | trainScaler = StandardScaler()
trainScaler.fit(train_data.drop(['Survived', 'PassengerId'], axis = 1))
X_train_scaled = trainScaler.transform(train_data.drop(['Survived', 'PassengerId'], axis = 1))
X_train = train_data.drop(['Survived', 'PassengerId'], axis = 1)
y_train = train_data['Survived'] | Titanic - Machine Learning from Disaster |
8,973,640 | def sigmoid(x):
return 1 /(1 + np.exp(-x))<train_model> | grid_params = {
'n_neighbors': [3, 5, 7, 9, 11, 13],
'weights': ['uniform', 'distance'],
'metric':['euclidean', 'manhattan']
}
KNN_CV = GridSearchCV(estimator = KNeighborsClassifier() , param_grid=grid_params, cv = 3)
KNN_CV.fit(X_train_scaled, y_train)
print(KNN_CV.best_score_)
weights = KNN_CV.best_params_.get('we... | Titanic - Machine Learning from Disaster |
8,973,640 | class EarlyStopping:
def __init__(self, patience=2, verbose=False):
self.patience = patience
self.verbose = verbose
self.counter = 0
self.best_score = None
self.early_stop = False
self.val_auc_min = 0
def __call__(self, val_auc, model):
score = val_auc
if self.best_score is None:
self.best_score = score
self.save_c... | param_grid = {
'criterion' : ['gini'],
'n_estimators': [70, 80, 90, 100, 110, 120],
'max_features': ['auto', 'log2'],
'max_depth' : [5, 7, 9, 11, 13]
}
randomForest_CV = GridSearchCV(estimator = RandomForestClassifier() , param_grid = param_grid, cv = 3)
randomForest_CV.fit(X_train, y_train)
print(randomForest_CV.bes... | Titanic - Machine Learning from Disaster |
8,973,640 | def augment(x,y,t=2):
xs,xn = [],[]
for i in range(t):
mask = y>0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
np.random.shuffle(ids)
x1[:,c] = x1[ids][:,c]
xs.append(x1)
for i in range(t//2):
mask = y==0
x1 = x[mask].copy()
ids = np.arange(x1.shape[0])
for c in range(x1.shape[1]):
... | for i in range(3):
test_data.loc[test_data['Pclass']==int(i+1), 'Age'] = test_data.loc[test_data['Pclass']==int(i+1), 'Age'].fillna(meanAges.values[i])
meanFare = test_data['Fare'].median()
test_data['Fare'].fillna(meanFare, inplace=True ) | Titanic - Machine Learning from Disaster |
8,973,640 | n_epochs = 20000
batch_size = 256
train_preds = np.zeros(( len(train_features)))
test_preds = np.zeros(( len(test_features)))
x_test = np.array(test_features)
x_test_cuda = torch.tensor(x_test, dtype=torch.float ).cuda()
test = torch.utils.data.TensorDataset(x_test_cuda)
test_loader = torch.utils.data.DataLoader(te... | test_data['newGender'] = test_data['Sex']
test_data.loc[test_data['Age']<18., 'newGender'] = 'child'
test_data.drop(columns='Sex', inplace=True)
test_data['Title'] = test_data['Name']
for name_string in test_data['Name']:
test_data['Title'] = test_data['Name'].str.extract('([A-Za-z]+)\.', expand=True)
mapping = {'Mll... | Titanic - Machine Learning from Disaster |
8,973,640 | test_ID = test_df['ID_code'].values
submission_nn = pd.DataFrame({ "ID_code": test_ID, "target": test_preds})
submission_nn.to_csv('test_preds_submission_nn_10fold.csv', index=False )<save_to_csv> | test_data.drop(columns=['Cabin', 'Ticket'], inplace=True)
one_hot = pd.get_dummies(test_data.loc[:, columns], drop_first=True)
test_data.drop(columns=columns, inplace=True)
test_data = test_data.join(one_hot)
print("NaNs in each testing Feature")
print(test_data.isnull().sum() ) | Titanic - Machine Learning from Disaster |
8,973,640 | train_ID = train_df['ID_code'].values
submission_nn = pd.DataFrame({ "ID_code": train_ID, "target": train_preds})
submission_nn.to_csv('train_preds_submission_nn_10fold.csv', index=False )<set_options> | X_test_scaled = trainScaler.transform(test_data.drop(['PassengerId'], axis = 1))
X_test = test_data.drop(columns='PassengerId')
testPredictionsKNN = bestKNN.predict(X_test_scaled)
testPredictionsRF = bestRF.predict(X_test)
outputKNN = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': testPredictionsKNN... | Titanic - Machine Learning from Disaster |
8,973,640 | debug = False
warnings.simplefilter('ignore')
plt.style.use('seaborn')
random_state = 333<load_from_csv> | param_grid = {
'learning_rate' : [0.1, 0.2],
'n_estimators': [90, 100, 110],
'loss': ['deviance', 'exponential']
}
gradBoost_CV = GridSearchCV(estimator = GradientBoostingClassifier() , param_grid = param_grid, cv = 3)
gradBoost_CV.fit(X_train, y_train)
print(gradBoost_CV.best_score_)
learning = gradBoost_CV.best_pa... | Titanic - Machine Learning from Disaster |
8,973,640 | train_df = pd.read_csv('.. /input/santander-customer-transaction-prediction/train.csv', index_col='ID_code')
test_df = pd.read_csv('.. /input/santander-customer-transaction-prediction/test.csv', index_col='ID_code')
public = np.load('.. /input/helpingdata/public_LB.npy')
private = np.load('.. /input/helpingdata/priv... | param_grid = {
'learning_rate' : [0.1, 0.2],
'max_depth': [3, 5, 7],
}
xgBoost_CV = GridSearchCV(estimator = XGBClassifier() , param_grid = param_grid, cv = 3)
xgBoost_CV.fit(X_train, y_train)
print(xgBoost_CV.best_score_)
learning = xgBoost_CV.best_params_.get('learning_rate')
depth = xgBoost_CV.best_params_.get('... | Titanic - Machine Learning from Disaster |
8,262,215 | train_df, test_df = reverse(train_df, test_df )<concatenate> | pd.set_option('display.max_columns', 500)
pd.set_option('display.max_rows', 50)
| Titanic - Machine Learning from Disaster |
8,262,215 | real_idx = np.sort(np.concatenate(( public, private)))
real_idx<filter> | import plotly.express as px
import plotly.graph_objects as go
import plotly.figure_factory as ff
from plotly.colors import n_colors
from plotly.subplots import make_subplots
from sklearn.preprocessing import MinMaxScaler | Titanic - Machine Learning from Disaster |
8,262,215 | test_real = test_df.iloc[real_idx]
test_real.head()<feature_engineering> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
train_data["Age"] = train_data["Age"].fillna(train_data.describe() ["Age"]["mean"])
test_data["Age"] = test_data["Age"].fillna(test_data.describe() ["Age"]["mean"])
train_data['Age']=train_data['Age... | Titanic - Machine Learning from Disaster |
8,262,215 | %%time
concat_df = pd.concat(( train_df, test_real))
features = train_df.columns[1:]
if debug:
features = features[:3]
for i, feature in enumerate(features):
print('Calculating var_{}'.format(i), end='\r')
n_dups_dict = concat_df.loc[:, feature].value_counts().to_dict()
train_df.loc[:, 'count_{}'.format(feature)] = [n... | women = train_data[train_data.Sex == 'female']["Survived"]
men = train_data[train_data.Sex == 'male']["Survived"]
print("Survival rate for women is {:.2f} and for men is {:.2f}".format(( sum(women)/len(women)) *100,(sum(men)/len(men)) *100)) | Titanic - Machine Learning from Disaster |
8,262,215 | gc.collect()<init_hyperparams> | data = train_data
data['Died'] = 1 - data['Survived'] | Titanic - Machine Learning from Disaster |
8,262,215 | lgb_params = {
"objective" : "binary",
"metric" : "auc",
"boosting": 'gbdt',
"max_depth" : -1,
"num_leaves" : 7,
"learning_rate" : 0.01,
"bagging_freq": 5,
"bagging_fraction" : 1,
"feature_fraction" : 0.3,
"min_data_in_leaf": 80,
"min_sum_hessian_in_leaf" : 10,
"tree_learner": "serial",
"boost_from_average": "false",
"... | x_train = train_data.drop(['Survived', 'Died'], axis=1)
y_train = train_data['Survived']
x_test = test_data
df_combined = x_train.append(x_test)
df_combined.shape | Titanic - Machine Learning from Disaster |
8,262,215 | %%time
df_train = train_df.reset_index()
df_test = test_df.reset_index()
if debug:
df_train = df_train[:1000]
df_test = df_test[:1000]
target = target[:1000]
skf = StratifiedKFold(n_splits = 5, shuffle=True, random_state=random_state)
oof = df_train[['ID_code', 'target']]
oof['predict'] = 0
predictions = df_test[['ID_... | def family_size() :
global df_combined
df_combined['FamilySize'] = df_combined['Parch'] + df_combined['SibSp'] + 1
df_combined['Singleton'] = df_combined['FamilySize'].map(lambda s: 1 if s == 1 else 0)
df_combined['SmallFamily'] = df_combined['FamilySize'].map(lambda s: 1 if 2 <= s <= 4 else 0)
df_combined['LargeFami... | Titanic - Machine Learning from Disaster |
8,262,215 | gc.collect()<compute_test_metric> | def embarked() :
global df_combined
df_combined['Embarked'].fillna('S', inplace=True)
df_dummies = pd.get_dummies(df_combined['Embarked'], prefix='Embarked')
df_combined = pd.concat([df_combined, df_dummies], axis=1)
df_combined.drop('Embarked', axis=1, inplace=True)
return df_combined | Titanic - Machine Learning from Disaster |
8,262,215 | mean_auc = np.mean(val_aucs)
std_auc = np.std(val_aucs)
all_auc = roc_auc_score(oof['target'], oof['predict'])
print("Mean auc: %.5f, std: %.5f.All auc: %.5f." %(mean_auc, std_auc, all_auc))<save_to_csv> | def cabin() :
global df_combined
df_combined['Cabin'].fillna('U', inplace=True)
df_combined['Cabin'] = df_combined['Cabin'].map(lambda ca: ca[0])
cabin_dummies = pd.get_dummies(df_combined['Cabin'], prefix='Cabin')
df_combined = pd.concat([df_combined, cabin_dummies], axis=1)
df_combined.drop('Cabin', inplace=True,... | Titanic - Machine Learning from Disaster |
8,262,215 | predictions['target'] = np.mean(predictions[[col for col in predictions.columns if col not in ['ID_code', 'target']]].values, axis=1)
predictions.to_csv('lgb_all_predictions.csv', index=None)
sub_df = pd.DataFrame({"ID_code":df_test["ID_code"].values})
sub_df["target"] = predictions['target']
sub_df.to_csv("submissi... | df_combined['Age'] = df_combined['Age'].astype(int)
df_combined.loc[df_combined['Age'] <= 11, 'Age'] = 0
df_combined.loc[(df_combined['Age'] > 11)&(df_combined['Age'] <= 18), 'Age'] = 1
df_combined.loc[(df_combined['Age'] > 18)&(df_combined['Age'] <= 22), 'Age'] = 2
df_combined.loc[(df_combined['Age'] > 22)&(df_combin... | Titanic - Machine Learning from Disaster |
8,262,215 | train_df = pd.read_csv('.. /input/santander-customer-transaction-prediction/train.csv')
test_df = pd.read_csv('.. /input/santander-customer-transaction-prediction/test.csv' )<drop_column> | df_combined.loc[df_combined['Fare'] <= 7, 'Fare'] = 0
df_combined.loc[(df_combined['Fare'] > 7)&(df_combined['Fare'] <= 14), 'Fare'] = 1
df_combined.loc[(df_combined['Fare'] > 14)&(df_combined['Fare'] <= 31), 'Fare'] = 2
df_combined.loc[(df_combined['Fare'] > 31)&(df_combined['Fare'] <= 99), 'Fare'] = 3
df_combined.loc... | Titanic - Machine Learning from Disaster |
8,262,215 | train_features = train_df.drop(['target','ID_code'], axis = 1)
test_features = test_df.drop(['ID_code'],axis = 1)
train_target = train_df['target']<set_options> | common_titles = ["Mr", "Mrs", "Miss", "Master"]
titles = []
for name in df_combined['Name']:
title = name.split(',')[1].split('.')[0].strip()
if title in common_titles:
titles.append(title)
elif title=="Mlle":
titles.append("Miss")
elif title=="Mme":
titles.append("Mrs")
else:
titles.append("Rare")
df_titles = pd.D... | Titanic - Machine Learning from Disaster |
8,262,215 | gc.collect()<concatenate> | gender_dummies = pd.get_dummies(df_combined['Sex'])
df_combined = pd.concat([df_combined, gender_dummies], axis=1)
df_combined.drop('Sex', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
8,262,215 | train_all = pd.concat(( train_features,test_features),axis = 0 )<data_type_conversions> | df_combined.drop(['PassengerId',"Name","Ticket"], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
8,262,215 | for f in train_all.columns:
train_all[f+'_duplicate'] = train_all.duplicated(f,False ).astype(int)
<feature_engineering> | x_train = df_combined[:891].copy()
x_test = df_combined[891:].copy()
x_test.reset_index(inplace=True, drop=True)
x_train.shape, x_test.shape | 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.