kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
2,213,168 | embed_size = 300
max_features = 120000
maxlen = 72
batch_size = 1536
train_epochs = 8
SEED = 1029<define_variables> | X_test = np.delete(X_test, [1], 1)
print(X_test[0:5, :])
X_test.shape | Titanic - Machine Learning from Disaster |
2,213,168 | puncts = [',', '.', '"', ':', ')', '(', '-', '!', '?', '|', ';', "'", '$', '&', '/', '[', ']', '>', '%', '=', '
'·', '_', '{', '}', '©', '^', '®', '`', '<', '→', '°', '€', '™', '›', '♥', '←', '×', '§', '″', '′', 'Â', '█', '½', 'à', '…',
'“', '★', '”', '–', '●', 'â', '►', '−', '¢', '²', '¬', '░', '¶', '↑', '±', '¿', '▾'... | sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.transform(X_test ) | Titanic - Machine Learning from Disaster |
2,213,168 | def load_and_prec() :
train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv")
print("Train shape : ",train_df.shape)
print("Test shape : ",test_df.shape)
train_df["question_text"] = train_df["question_text"].progress_apply(lambda x: x.lower())
test_df["question_text"] = test_df["q... | classifier = LogisticRegression()
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
acc_log = round(classifier.score(X_train, y_train)* 100, 2)
acc_log
| Titanic - Machine Learning from Disaster |
2,213,168 | def load_glove(word_index):
EMBEDDING_FILE = '.. /input/embeddings/glove.840B.300d/glove.840B.300d.txt'
def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')
embeddings_index = dict(get_coefs(*o.split(" ")) for o in open(EMBEDDING_FILE))
all_embs = np.stack(embeddings_index.values())
emb_mean,emb_st... | svc = SVC()
svc.fit(X_train, y_train)
y_pred = svc.predict(X_test)
acc_svc = round(svc.score(X_train, y_train)* 100, 2)
acc_svc
result[:, 1] = y_pred
result | Titanic - Machine Learning from Disaster |
2,213,168 | tqdm.pandas()
start_time = time.time()
train_X, test_X, train_y, word_index = load_and_prec()
embedding_matrix_1 = load_glove(word_index)
embedding_matrix_2 = load_para(word_index)
total_time =(time.time() - start_time)/ 60
print("Took {:.2f} minutes".format(total_time))
embedding_matrix = np.mean([embedding_matrix_1... | knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
acc_knn = round(knn.score(X_train, y_train)* 100, 2)
acc_knn | Titanic - Machine Learning from Disaster |
2,213,168 | class Attention(nn.Module):
def __init__(self, feature_dim, step_dim, bias=True, **kwargs):
super(Attention, self ).__init__(**kwargs)
self.supports_masking = True
self.bias = bias
self.feature_dim = feature_dim
self.step_dim = step_dim
self.features_dim = 0
weight = torch.zeros(feature_dim, 1)
nn.init.xavier_uniform... | linear_svc = LinearSVC()
linear_svc.fit(X_train, y_train)
y_pred = linear_svc.predict(X_test)
acc_linear_svc = round(linear_svc.score(X_train, y_train)* 100, 2)
acc_linear_svc | Titanic - Machine Learning from Disaster |
2,213,168 | class NeuralNet(nn.Module):
def __init__(self):
super(NeuralNet, self ).__init__()
hidden_size = 60
self.embedding = nn.Embedding(max_features, embed_size)
self.embedding.weight = nn.Parameter(torch.tensor(embedding_matrix, dtype=torch.float32))
self.embedding.weight.requires_grad = False
self.embedding_dropout = nn.D... | decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, y_train)
y_pred = decision_tree.predict(X_test)
acc_decision_tree = round(decision_tree.score(X_train, y_train)* 100, 2)
acc_decision_tree | Titanic - Machine Learning from Disaster |
2,213,168 | splits = list(StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED ).split(train_X, train_y))<compute_test_metric> | random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, y_train)
y_pred = random_forest.predict(X_test)
random_forest.score(X_train, y_train)
acc_random_forest = round(random_forest.score(X_train, y_train)* 100, 2)
acc_random_forest
| Titanic - Machine Learning from Disaster |
2,213,168 | def sigmoid(x):
return 1 /(1 + np.exp(-x))<compute_test_metric> | submission = pd.DataFrame({'PassengerId':result[:, 0],'Survived':result[:, 1]})
submission.head() | Titanic - Machine Learning from Disaster |
2,213,168 | <categorify><EOS> | filename = 'Titanic_Survival_Trial_9.csv'
submission.to_csv(filename, index=False)
print('Saved file: ' + filename ) | Titanic - Machine Learning from Disaster |
1,003,820 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<compute_test_metric> | %matplotlib inline
| Titanic - Machine Learning from Disaster |
1,003,820 | search_result = threshold_search(train_y, train_preds)
search_result<save_to_csv> | data_train = pd.read_csv('.. /input/train.csv')
data_test = pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
1,003,820 | sub = pd.read_csv('.. /input/sample_submission.csv')
sub.prediction = test_preds > search_result['threshold']
sub.to_csv("submission.csv", index=False )<import_modules> | def simplify_ages(df):
unknow = df['Age'].isnull()
master_title = df['Title'] == 'Master'
mr_title = df['Title'] == 'Mr'
mrs_title = df['Title'] == 'Mrs'
miss_title = df['Title'] == 'Miss'
dr_title = df['Title'] == 'Dr'
df.loc[master_title & unknow,'Age'] = df[master_title]['Age'].mean()
df.loc[mr_title & unknow,'Age']... | Titanic - Machine Learning from Disaster |
1,003,820 | import numpy as np
import pandas as pd
import time
import lightgbm as lgb
from sklearn.model_selection import StratifiedKFold, KFold
from sklearn.metrics import mean_squared_error
from sklearn.metrics import log_loss<load_from_csv> | data_train = transform_features(data_train)
data_test = transform_features(data_test ) | Titanic - Machine Learning from Disaster |
1,003,820 | %%time
df_train = pd.read_csv('.. /input/predicting-outliers-to-improve-your-score/train_clean.csv')
df_test = pd.read_csv('.. /input/predicting-outliers-to-improve-your-score/test_clean.csv' )<drop_column> | data_train, data_test = encode_features(data_train, data_test ) | Titanic - Machine Learning from Disaster |
1,003,820 | df_train = df_train[df_train['outliers'] == 0]
target = df_train['target']
del df_train['target']
features = [c for c in df_train.columns if c not in ['card_id', 'first_active_month','outliers']]
categorical_feats = [c for c in features if 'feature_' in c]<init_hyperparams> | X_all = data_train.drop(['Survived', 'PassengerId'], axis=1)
y_all = data_train['Survived'] | Titanic - Machine Learning from Disaster |
1,003,820 | param = {'objective':'regression',
'num_leaves': 31,
'min_data_in_leaf': 25,
'max_depth': 7,
'learning_rate': 0.01,
'lambda_l1':0.13,
"boosting": "gbdt",
"feature_fraction":0.85,
'bagging_freq':8,
"bagging_fraction": 0.9 ,
"metric": 'rmse',
"verbosity": -1,
"random_state": 2333}<split> | def MultivariateGaussian(x,y):
k = 2
d =(x.shape)[1]
mu = np.zeros(( k,d))
sigma = np.zeros(( k,d,d))
pi = np.zeros(k)
for label in range(2):
indices =(y == label)
mu[label] = np.mean(x[indices,:], axis=0)
sigma[label] = np.cov(x[indices,:], rowvar=0, bias=1)
pi[label] = float(sum(indices)) /float(len(y))
return mu... | Titanic - Machine Learning from Disaster |
1,003,820 | %%time
folds = StratifiedKFold(n_splits=5, shuffle=True, random_state=2333)
oof = np.zeros(len(df_train))
predictions = np.zeros(len(df_test))
feature_importance_df = pd.DataFrame()
for fold_,(trn_idx, val_idx)in enumerate(folds.split(df_train,df_train['outliers'].values)) :
print("fold {}".format(fold_))
trn_data = l... | mu, sigma, pi = MultivariateGaussian(X_all.values,y_all.values ) | Titanic - Machine Learning from Disaster |
1,003,820 | model_without_outliers = pd.DataFrame({"card_id":df_test["card_id"].values})
model_without_outliers["target"] = predictions<load_from_csv> | def test_model(mu, sigma, pi, features, tx, ty):
preds = []
errors = 0
for x,y in zip(tx,ty):
piP_list = []
for label in range(2):
S = np.linalg.inv(sigma[label])
dS = np.linalg.det(sigma[label])
xTsigmax=0
for i in features:
for j in features:
xTsigmax += S[i][j]*(x[i]-mu[label][i])*(x[j]-mu[label][j])
piP_list.app... | Titanic - Machine Learning from Disaster |
1,003,820 | %%time
df_train = pd.read_csv('.. /input/predicting-outliers-to-improve-your-score/train_clean.csv')
df_test = pd.read_csv('.. /input/predicting-outliers-to-improve-your-score/test_clean.csv' )<drop_column> | errors, preds = test_model(mu, sigma, pi, [0,1,2,3,4,5,6,7], X_all.values, y_all.values)
print('Accuracy for training data:',(1-errors/len(y_all)) *100, '%' ) | Titanic - Machine Learning from Disaster |
1,003,820 | target = df_train['outliers']
del df_train['outliers']
del df_train['target']<define_variables> | def write_predictions(mu, sigma, pi, features, tx):
preds = []
for x in tx:
piP_list = []
for label in range(2):
S = np.linalg.inv(sigma[label])
dS = np.linalg.det(sigma[label])
xTsigmax=0
for i in features:
for j in features:
xTsigmax += S[i][j]*(x[i]-mu[label][i])*(x[j]-mu[label][j])
piP_list.append(pi[label]*np.e... | Titanic - Machine Learning from Disaster |
1,003,820 | features = [c for c in df_train.columns if c not in ['card_id', 'first_active_month']]
categorical_feats = [c for c in features if 'feature_' in c]<init_hyperparams> | preds = write_predictions(mu, sigma, pi, [0,1,2,3,4,5,6,7], data_test.drop('PassengerId',axis=1 ).values ) | Titanic - Machine Learning from Disaster |
1,003,820 | param = {'num_leaves': 31,
'min_data_in_leaf': 30,
'objective':'binary',
'max_depth': 6,
'learning_rate': 0.01,
"boosting": "rf",
"feature_fraction": 0.9,
"bagging_freq": 1,
"bagging_fraction": 0.9 ,
"bagging_seed": 11,
"metric": 'binary_logloss',
"lambda_l1": 0.1,
"verbosity": -1,
"random_state": 2333}<split> | data_pred = pd.DataFrame()
data_pred['PassengerId']=data_test['PassengerId']
data_pred['Survived']=preds | Titanic - Machine Learning from Disaster |
1,003,820 | <prepare_output><EOS> | data_pred.to_csv('predictions_generative_multGauss.csv', index = False ) | Titanic - Machine Learning from Disaster |
998,653 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<prepare_output> | %matplotlib inline
GradientBoostingClassifier, ExtraTreesClassifier)
warnings.filterwarnings('ignore')
df_train=pd.read_csv('.. /input/train.csv',sep=',')
df_test=pd.read_csv('.. /input/test.csv',sep=',')
df_data = df_train.append(df_test)
PassengerId = df_test['PassengerId']
Submission=pd.DataFrame()
Submission['... | Titanic - Machine Learning from Disaster |
998,653 | outlier_id = pd.DataFrame(df_outlier_prob.sort_values(by='target',ascending = False ).head(25000)['card_id'] )<load_from_csv> | df_data["Title"] = df_data.Name.str.extract('([A-Za-z]+)\.', expand=False)
df_data["Title"] = df_data["Title"].replace('Mlle', 'Miss')
df_data["Title"] = df_data["Title"].replace('Master', 'Master')
df_data["Title"] = df_data["Title"].replace(['Mme', 'Dona', 'Ms'], 'Mrs')
df_data["Title"] = df_data["Title"].replace... | Titanic - Machine Learning from Disaster |
998,653 | best_submission = pd.read_csv('.. /input/predicting-outliers-to-improve-your-score/3.695.csv' )<merge> | df_data["Embarked"]=df_data["Embarked"].fillna('S')
df_train["Embarked"] = df_data['Embarked'][:891]
df_test["Embarked"] = df_data['Embarked'][891:]
print('Missing Embarkations Added' ) | Titanic - Machine Learning from Disaster |
998,653 | most_likely_liers = best_submission.merge(outlier_id,how='right')
most_likely_liers.head()<filter> | dummies=pd.get_dummies(df_train[["Embarked"]], prefix_sep='_')
df_train = pd.concat([df_train, dummies], axis=1)
dummies=pd.get_dummies(df_test[["Embarked"]], prefix_sep='_')
df_test = pd.concat([df_test, dummies], axis=1)
print("Embarked Feature created" ) | Titanic - Machine Learning from Disaster |
998,653 | %%time
for card_id in most_likely_liers['card_id']:
model_without_outliers.loc[model_without_outliers['card_id']==card_id,'target']\
= most_likely_liers.loc[most_likely_liers['card_id']==card_id,'target'].values<save_to_csv> | df_data["Fare"]=df_data["Fare"].fillna(np.median(df_data["Fare"]))
df_train["Fare"] = df_data["Fare"][:891]
df_test["Fare"] = df_data["Fare"][891:]
print('Estimate missing Fare' ) | Titanic - Machine Learning from Disaster |
998,653 | model_without_outliers.to_csv("combining_submission.csv", index=False )<import_modules> | Pclass = [1,2,3]
for aclass in Pclass:
fare_to_impute = df_data.groupby('Pclass')['Fare'].median() [aclass]
df_data.loc[(df_data['Fare'].isnull())&(df_data['Pclass'] == aclass), 'Fare'] = fare_to_impute
df_train["Fare"] = df_data["Fare"][:891]
df_test["Fare"] = df_data["Fare"][891:]
df_train["FareBand"] = pd.qcut(df_tr... | Titanic - Machine Learning from Disaster |
998,653 | import numpy as np
import pandas as pd
import time
import lightgbm as lgb
from sklearn.model_selection import StratifiedKFold, KFold
from sklearn.metrics import mean_squared_error
from sklearn.metrics import log_loss<load_from_csv> | titles = ['Master', 'Miss', 'Mr', 'Mrs', 'Millitary','Honor']
for title in titles:
age_to_impute = df_data.groupby('Title')['Age'].median() [title]
df_data.loc[(df_data['Age'].isnull())&(df_data['Title'] == title), 'Age'] = age_to_impute
df_train["Age"] = df_data['Age'][:891]
df_test["Age"] = df_data['Age'][891:]
print... | Titanic - Machine Learning from Disaster |
998,653 | %%time
df_train = pd.read_csv('.. /input/predicting-outliers-to-improve-your-score/train_clean.csv')
df_test = pd.read_csv('.. /input/predicting-outliers-to-improve-your-score/test_clean.csv' )<drop_column> | df_train["Pclass"]=df_train["Pclass"].astype('category')
df_test["Pclass"]=df_test["Pclass"].astype('category')
dummies=pd.get_dummies(df_train[["Pclass"]], prefix_sep='_')
df_train = pd.concat([df_train, dummies], axis=1)
dummies=pd.get_dummies(df_test[["Pclass"]], prefix_sep='_')
df_test = pd.concat([df_test, du... | Titanic - Machine Learning from Disaster |
998,653 | df_train = df_train[df_train['outliers'] == 0]
target = df_train['target']
del df_train['target']
features = [c for c in df_train.columns if c not in ['card_id', 'first_active_month','outliers']]
categorical_feats = [c for c in features if 'feature_' in c]<init_hyperparams> | bins = [0,12,24,45,60,np.inf]
labels = ['Child', 'Young Adult', 'Adult','Older Adult','Senior']
df_train["AgeGroup"] = pd.cut(df_train["Age"], bins, labels = labels)
df_test["AgeGroup"] = pd.cut(df_test["Age"], bins, labels = labels)
print('Age Feature created')
dummies=pd.get_dummies(df_train[["AgeGroup"]], prefix_... | Titanic - Machine Learning from Disaster |
998,653 | param = {'objective':'regression',
'num_leaves': 31,
'min_data_in_leaf': 25,
'max_depth': 7,
'learning_rate': 0.01,
'lambda_l1':0.13,
"boosting": "gbdt",
"feature_fraction":0.85,
'bagging_freq':8,
"bagging_fraction": 0.9 ,
"metric": 'rmse',
"verbosity": -1,
"random_state": 2333}<split> | dummies=pd.get_dummies(df_train[['Sex']], prefix_sep='_')
df_train = pd.concat([df_train, dummies], axis=1)
testdummies=pd.get_dummies(df_test[['Sex']], prefix_sep='_')
df_test = pd.concat([df_test, testdummies], axis=1)
print('Gender Categories created' ) | Titanic - Machine Learning from Disaster |
998,653 | %%time
folds = StratifiedKFold(n_splits=5, shuffle=True, random_state=2333)
oof = np.zeros(len(df_train))
predictions = np.zeros(len(df_test))
feature_importance_df = pd.DataFrame()
for fold_,(trn_idx, val_idx)in enumerate(folds.split(df_train,df_train['outliers'].values)) :
print("fold {}".format(fold_))
trn_data = l... | df_data["Alone"] = np.where(df_data['SibSp'] + df_data['Parch'] + 1 == 1, 1,0)
df_train["Alone"] = df_data['Alone'][:891]
df_test["Alone"] = df_data['Alone'][891:]
print('Lone Traveller feature created' ) | Titanic - Machine Learning from Disaster |
998,653 | model_without_outliers = pd.DataFrame({"card_id":df_test["card_id"].values})
model_without_outliers["target"] = predictions<load_from_csv> | df_data["Last_Name"] = df_data['Name'].apply(lambda x: str.split(x, ",")[0])
DEFAULT_SURVIVAL_VALUE = 0.5
df_data["Family_Survival"] = DEFAULT_SURVIVAL_VALUE
for grp, grp_df in df_data[['Survived','Name', 'Last_Name', 'Fare', 'Ticket', 'PassengerId',
'SibSp', 'Parch', 'Age', 'Cabin']].groupby(['Last_Name', 'Fare']):
i... | Titanic - Machine Learning from Disaster |
998,653 | %%time
df_train = pd.read_csv('.. /input/predicting-outliers-to-improve-your-score/train_clean.csv')
df_test = pd.read_csv('.. /input/predicting-outliers-to-improve-your-score/test_clean.csv' )<drop_column> | df_data["HadCabin"] =(df_data["Cabin"].notnull().astype('int'))
df_train["HadCabin"] = df_data["HadCabin"][:891]
df_test["HadCabin"] = df_data["HadCabin"][891:]
print('HasCabin feature created' ) | Titanic - Machine Learning from Disaster |
998,653 | target = df_train['outliers']
del df_train['outliers']
del df_train['target']<define_variables> | df_data["Deck"] = df_data.Cabin.str.extract('([A-Za-z])', expand=False)
deck_mapping = {"0":0,"A": 1, "B": 2, "C": 3, "D": 4, "E": 5}
df_data['Deck'] = df_data['Deck'].map(deck_mapping)
df_data["Deck"] = df_data["Deck"].fillna("0")
df_data["Deck"]=df_data["Deck"].astype('int')
df_train["Deck"] = df_data['Deck'][:89... | Titanic - Machine Learning from Disaster |
998,653 | features = [c for c in df_train.columns if c not in ['card_id', 'first_active_month']]
categorical_feats = [c for c in features if 'feature_' in c]<init_hyperparams> | ( df_train['SibSp'])=(df_train['SibSp'] ).astype('category')
dummies=pd.get_dummies(df_train[['SibSp']], prefix_sep='_')
df_train = pd.concat([df_train, dummies], axis=1)
(df_test['SibSp'])=(df_test['SibSp'] ).astype('category')
dummies=pd.get_dummies(df_test[['SibSp']], prefix_sep='_')
df_test = pd.concat([df_test... | Titanic - Machine Learning from Disaster |
998,653 | param = {'num_leaves': 31,
'min_data_in_leaf': 30,
'objective':'binary',
'max_depth': 6,
'learning_rate': 0.01,
"boosting": "rf",
"feature_fraction": 0.9,
"bagging_freq": 1,
"bagging_fraction": 0.9 ,
"bagging_seed": 11,
"metric": 'binary_logloss',
"lambda_l1": 0.1,
"verbosity": -1,
"random_state": 2333}<split> | ( df_train['Parch'])=(df_train['Parch'] ).astype('category')
dummies=pd.get_dummies(df_train[['Parch']], prefix_sep='_')
df_train = pd.concat([df_train, dummies], axis=1)
(df_test['Parch'])=(df_test['Parch'] ).astype('category')
dummies=pd.get_dummies(df_test[['Parch']], prefix_sep='_')
df_test = pd.concat([df_test... | Titanic - Machine Learning from Disaster |
998,653 | %%time
folds = KFold(n_splits=5, shuffle=True, random_state=15)
oof = np.zeros(len(df_train))
predictions = np.zeros(len(df_test))
feature_importance_df = pd.DataFrame()
start = time.time()
for fold_,(trn_idx, val_idx)in enumerate(folds.split(df_train.values, target.values)) :
print("fold n°{}".format(fold_))
trn_data... | df_data=df_data.drop(['Cabin','Embarked','Title','Age','Sex','Name','Ticket','Deck','Fare'], axis=1)
df_train=df_train.drop(['Cabin','Embarked','Title','Age','Sex','Name','Ticket','AgeGroup','Deck','Pclass','Fare','FareBand','SibSp','Parch','Parch_7','Parch_8','Parch_9'], axis=1)
df_test=df_test.drop(['Cabin','Embark... | Titanic - Machine Learning from Disaster |
998,653 | df_outlier_prob = pd.DataFrame({"card_id":df_test["card_id"].values})
df_outlier_prob["target"] = predictions
df_outlier_prob.head()<prepare_output> | NUMERIC_COLUMNS=['Alone','Family Size','Sex','Pclass','Fare','FareBand','Age','TitleCat','Embarked']
ORIGINAL_NUMERIC_COLUMNS=['Pclass','Age','SibSp','Parch','Sex_female','Sex_male','Title_Master', 'Title_Miss','Title_Mr', 'Title_Mrs', 'Title_Millitary','Embarked']
REVISED_NUMERIC_COLUMNS=['Title_Master', 'Title_Millit... | Titanic - Machine Learning from Disaster |
998,653 | outlier_id = pd.DataFrame(df_outlier_prob.sort_values(by='target',ascending = False ).head(25000)['card_id'] )<load_from_csv> | clf = SVC()
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
acc_clf = round(accuracy_score(y_pred, y_test)* 100, 2)
print(acc_clf ) | Titanic - Machine Learning from Disaster |
998,653 | best_submission = pd.read_csv('.. /input/predicting-outliers-to-improve-your-score/3.695.csv' )<merge> | test = df_test[REVISED_NUMERIC_COLUMNS].fillna(-1000)
Submission['Survived']=clf.predict(test)
Submission.set_index('PassengerId', inplace=True)
Submission.to_csv('baselinemodel01.csv',sep=',')
print('Submission Created' ) | Titanic - Machine Learning from Disaster |
998,653 | most_likely_liers = best_submission.merge(outlier_id,how='right')
most_likely_liers.head()<filter> | REVISED_NUMERIC_COLUMNS=['Title_Master', 'Title_Millitary',
'Title_Miss', 'Title_Mr', 'Title_Mrs', 'Embarked_C', 'Embarked_Q',
'Embarked_S', 'FareBand_1', 'FareBand_2', 'FareBand_3', 'FareBand_4',
'Pclass_1', 'Pclass_2', 'Pclass_3', 'AgeGroup_Child',
'AgeGroup_Young Adult', 'AgeGroup_Adult', 'AgeGroup_Older Adult',
'Ag... | Titanic - Machine Learning from Disaster |
998,653 | %%time
for card_id in most_likely_liers['card_id']:
model_without_outliers.loc[model_without_outliers['card_id']==card_id,'target']\
= most_likely_liers.loc[most_likely_liers['card_id']==card_id,'target'].values<save_to_csv> | param_dist = {"max_depth": np.arange(1, 6),
"max_features": np.arange(1, 10),
"min_samples_leaf": np.arange(1, 6),
"criterion": ["gini","entropy"]}
tree = DecisionTreeClassifier()
tree_cv = RandomizedSearchCV(tree, param_dist, cv=30)
tree_cv.fit(X,y)
y_pred = tree_cv.predict(x_val)
print("Tuned Decision Tree Paramet... | Titanic - Machine Learning from Disaster |
998,653 | model_without_outliers.to_csv("combining_submission.csv", index=False )<import_modules> | test = df_test[REVISED_NUMERIC_COLUMNS].fillna(-1000)
tree = DecisionTreeClassifier(max_depth=5,max_features=7,min_samples_leaf=1,criterion="entropy")
tree.fit(X,y)
Submission['Survived']=tree.predict(test)
print(Submission.head(5)) | Titanic - Machine Learning from Disaster |
998,653 | import pandas as pd
import numpy as np
import seaborn as sns<load_from_csv> | Submission.to_csv('Tunedtree1submission.csv',sep=',')
print("Submission Submitted" ) | Titanic - Machine Learning from Disaster |
998,653 | df1 = pd.read_csv(".. /input/elo-blending/BlendingRLSR.csv")
df1.head()<save_to_csv> | REVISED_NUMERIC_COLUMNS=['Title_Master', 'Title_Millitary',
'Title_Miss', 'Title_Mr', 'Title_Mrs', 'Embarked_C', 'Embarked_Q',
'Embarked_S', 'FareBand_1', 'FareBand_2', 'FareBand_3', 'FareBand_4',
'Pclass_1', 'Pclass_2', 'Pclass_3', 'AgeGroup_Child',
'AgeGroup_Young Adult', 'AgeGroup_Adult', 'AgeGroup_Older Adult',
'Ag... | Titanic - Machine Learning from Disaster |
998,653 | df2 = pd.read_csv(".. /input/elo-blending/combining_submission(1 ).csv")
df2.head()
df3 = pd.read_csv(".. /input/simple-lightgbm-without-blending/submission.csv")
df3.head()
df2['target'] = df2['target'] * 0.35 + df1['target'] * 0.65
df2['target'] = df2['target'] * 0.57 + df3['target'] * 0.43
df2.to_csv("blend.csv",i... | print('Modules imported' ) | Titanic - Machine Learning from Disaster |
998,653 | import numpy as np
import pandas as p
from matplotlib import pyplot as plt
import seaborn as sns
from math import sqrt
from sklearn import metrics<load_from_csv> | model = Sequential()
model.add(Dense(units=56, input_dim=X.shape[1], activation='selu'))
model.add(Dropout(0.5))
model.add(Dense(units=27, activation='selu'))
model.add(Dropout(0.5))
model.add(Dense(units=1, activation='tanh'))
model.compile(loss='mse', optimizer='sgd')
print('Keras Model Created' ) | Titanic - Machine Learning from Disaster |
998,653 | df_base0 = p.read_csv('.. /input/elo-blending/3.695.csv',names=["card_id","target0"], skiprows=[0],header=None)
df_base1 = p.read_csv('.. /input/elo-blending/3.696.csv',names=["card_id","target1"], skiprows=[0],header=None)
df_base2 = p.read_csv('.. /input/elo-blending/3.6999.csv',names=["card_id","targe2"], skiprows... | model.fit(X.values, y.values, epochs=500, verbose=0)
print('Keras model fitted' ) | Titanic - Machine Learning from Disaster |
998,653 | df_base = p.merge(df_base12,df_base0,how='inner',on='card_id')
df_base = p.merge(df_base,df_base1,how='inner',on='card_id')
df_base = p.merge(df_base,df_base2,how='inner',on='card_id')
df_base = p.merge(df_base,df_base3,how='inner',on='card_id')
df_base = p.merge(df_base,df_base4,how='inner',on='card_id')
df_base ... | df_test=df_test.set_index('PassengerId')
p_survived = model.predict_classes(df_test)
print('Prediction Completed' ) | Titanic - Machine Learning from Disaster |
998,653 | M = np.zeros([df_base.iloc[:,1:].shape[1],df_base.iloc[:,1:].shape[1]])
for i in np.arange(M.shape[1]):
for j in np.arange(M.shape[1]):
M[i,j] = sqrt(metrics.mean_squared_error(df_base.iloc[:,i+1], df_base.iloc[:,j+1]))<save_to_csv> | submission = pd.DataFrame()
submission['PassengerId'] = df_test.index
submission['Survived'] = p_survived
print('predictions added to submission' ) | Titanic - Machine Learning from Disaster |
998,653 | df_base['target'] = df_base.iloc[:,1:].mean(axis=1)
df_base[['card_id','target']].to_csv("Bestoutput.csv",index=False )<load_from_csv> | submission.to_csv('DeepLearning03.csv', index=False)
print('csv created' ) | Titanic - Machine Learning from Disaster |
998,653 | df_base14 = p.read_csv('.. /input/simple-lightgbm-without-blending/submission.csv',names=["card_id","target14"], skiprows=[0],header=None)
df_base6 = p.read_csv('.. /input/elo-blending/3.701.csv',names=["card_id","target6"], skiprows=[0],header=None)
df_base7 = p.read_csv('.. /input/elo-blending/3.702.csv',names=["ca... | seed=70
kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
cvscores = []
for train, test in kfold.split(X, y):
model = Sequential()
model.add(Dense(54, input_dim=X.shape[1], activation='relu'))
model.add(Dropout(0.25))
model.add(Dense(54, activation='relu'))
model.add(Dropout(0.25))
model.add(Dense(... | Titanic - Machine Learning from Disaster |
998,653 | M = np.zeros([df_base.iloc[:,1:].shape[1],df_base.iloc[:,1:].shape[1]])
for i in np.arange(M.shape[1]):
for j in np.arange(M.shape[1]):
M[i,j] = sqrt(metrics.mean_squared_error(df_base.iloc[:,i+1], df_base.iloc[:,j+1]))<save_to_csv> | submission = pd.DataFrame()
submission['PassengerId'] = df_test.index
submission['Survived'] = p_survived
print('predictions added to submission' ) | Titanic - Machine Learning from Disaster |
998,653 | df_base['target'] = df_base.iloc[:,1:].mean(axis=1)
df_base[['card_id','target']].to_csv("blend2.csv",index=False )<save_to_csv> | submission.to_csv('OptimisedDeepLearning04.csv', index=False)
print('csv created' ) | Titanic - Machine Learning from Disaster |
9,649,480 | df_base['target'] = df2['target']* 0.3 + df_base['target'] * 0.7
plt.figure(figsize=(8,8))
plt.subplot(1, 2, 1)
sns.boxplot(df2['target'],orient='v')
plt.subplot(1, 2, 2)
sns.boxplot(df_base['target'], orient='v')
plt.show()
<import_modules> | train = pd.read_csv("/kaggle/input/titanic/train.csv")
test = pd.read_csv("/kaggle/input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
9,649,480 | from scipy.stats import truncnorm<save_to_csv> | train = train.drop(columns= ['Name','Ticket','Cabin'])
test = test.drop(columns= ['Name','Ticket','Cabin'] ) | Titanic - Machine Learning from Disaster |
9,649,480 | df_base['target'] = truncnorm.mean(df2['target'],df_base['target'])
df_base[['card_id','target']].to_csv("blend3.csv",index=False )<set_options> | train['Embarked_S'] =(train['Embarked'] == 'S' ).astype(int)
train['Embarked_C'] =(train['Embarked'] == 'C' ).astype(int)
train['Embarked_Q'] =(train['Embarked'] == 'Q' ).astype(int)
train['Gender'] =(train['Sex'] == 'male' ).astype(int ) | Titanic - Machine Learning from Disaster |
9,649,480 | pd.set_option('display.max_columns', None)
print('available GPU devices catboost:', get_gpu_device_count() )<define_variables> | test['Embarked_S'] =(test['Embarked'] == 'S' ).astype(int)
test['Embarked_C'] =(test['Embarked'] == 'C' ).astype(int)
test['Embarked_Q'] =(test['Embarked'] == 'Q' ).astype(int)
test['Gender'] =(test['Sex'] == 'male' ).astype(int ) | Titanic - Machine Learning from Disaster |
9,649,480 | DATA_DIR = '/kaggle/input/m5-forecasting-accuracy'
MODEL_VER = 'v0'
BACKWARD_LAGS = 60
END_D = 1913
CUT_D = END_D - int(365 * 1.2)
END_DATE = '2016-04-24'
print(datetime.strptime(END_DATE, '%Y-%m-%d'))<define_variables> | train = train.drop(columns = ['Sex'])
test = test.drop(columns = ['Sex'] ) | Titanic - Machine Learning from Disaster |
9,649,480 | CALENDAR_DTYPES = {
'date': 'str',
'wm_yr_wk': 'int16',
'weekday': 'object',
'wday': 'int16',
'month': 'int16',
'year': 'int16',
'd': 'object',
'event_name_1': 'object',
'event_type_1': 'object',
'event_name_2': 'object',
'event_type_2': 'object',
'snap_CA': 'int16',
'snap_TX': 'int16',
'snap_WI': 'int16'
}
PARSE_DATES... | train = train.drop(columns = ['Embarked'])
test = test.drop(columns = ['Embarked'] ) | Titanic - Machine Learning from Disaster |
9,649,480 | def get_df(is_train=True, backward_lags=None):
strain = pd.read_csv('{}/sales_train_validation.csv'.format(DATA_DIR))
print('read train:', strain.shape)
cat_cols = ['id', 'item_id', 'dept_id','store_id', 'cat_id', 'state_id']
last_day = int(strain.columns[-1].replace('d_', ''))
print('first day is:', CUT_D)
print('la... | train.fillna(0, inplace=True)
test.fillna(0, inplace=True ) | Titanic - Machine Learning from Disaster |
9,649,480 | def make_features(strain):
print('in dataframe:', strain.shape)
lags = [7, 28]
windows= [7, 28]
wnd_feats = ['id', 'item_id']
lag_cols = ['lag_{}'.format(lag)for lag in lags ]
for lag, lag_col in zip(lags, lag_cols):
strain[lag_col] = strain[['id', 'sales']].groupby('id')['sales'].shift(lag)
print('lag sales done')
... | X = train.drop(columns = ['Survived'])
y = train['Survived'] | Titanic - Machine Learning from Disaster |
9,649,480 | %%time
strain = get_df(is_train=True, backward_lags=None)
strain = make_features(strain )<feature_engineering> | model = XGBClassifier(learning_rate=0.01, n_estimators=1000)
model.fit(X,y ) | Titanic - Machine Learning from Disaster |
9,649,480 | drop_cols = ['id', 'sales', 'date', 'wm_yr_wk', 'weekday']
train_cols = strain.columns[~strain.columns.isin(drop_cols)]
cat_cols = [
'item_id', 'dept_id', 'store_id', 'cat_id', 'state_id',
'event_name_1', 'event_type_1', 'event_name_2', 'event_type_2'
]
strain[cat_cols] = strain[cat_cols].fillna(0 )<define_variables> | pred = model.predict(test ) | Titanic - Machine Learning from Disaster |
9,649,480 | <train_model><EOS> | result = pd.DataFrame({'PassengerId':test['PassengerId'], 'Survived':pred})
result.to_csv("submission.csv", index=False ) | Titanic - Machine Learning from Disaster |
777,941 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<save_model> | train_df=pd.read_csv(".. /input/train.csv")
test_df=pd.read_csv(".. /input/test.csv")
train_df.head() | Titanic - Machine Learning from Disaster |
777,941 | model.save_model('model_{}.cbm'.format(MODEL_VER))<define_variables> | combined_df=pd.concat([train_df,test_df] ) | Titanic - Machine Learning from Disaster |
777,941 | %%time
spred = get_df(is_train=False, backward_lags=BACKWARD_LAGS)
for pred_day in tqdm(range(1, 28 + 28 + 1)) :
pred_date = datetime.strptime(END_DATE, '%Y-%m-%d')+ timedelta(days=pred_day)
pred_date_back = pred_date - timedelta(days=BACKWARD_LAGS + 1)
print('-' * 70)
print('forecast day forward:', pred_day, '| fo... | combined_df.loc[combined_df["Age"].isnull() ].groupby(["Pclass","Sex"])["Sex"].agg(["count"] ) | Titanic - Machine Learning from Disaster |
777,941 | spred_subm = spred.loc[spred['date'] > END_DATE, ['id', 'd', 'sales']].copy()
last_d = int(spred.loc[spred['date'] == END_DATE, 'd'].unique() [0].replace('d_', ''))
print('last d num:', last_d)
spred_subm['d'] = spred_subm['d'].apply(lambda x: 'F{}'.format(int(x.replace('d_', '')) - last_d))
spred_subm.loc[spred_subm[... | combined_df.groupby(["Sex","SibSp","Parch"])["Age"].agg(["median"] ) | Titanic - Machine Learning from Disaster |
777,941 | f_cols_val = ['F{}'.format(x)for x in range(1, 28 + 1)]
f_cols_eval = ['F{}'.format(x)for x in range(28 + 1, 28 + 28 + 1)]
spred_subm_eval = spred_subm.copy()
spred_subm.drop(columns=f_cols_eval, inplace=True)
spred_subm_eval.drop(columns=f_cols_val, inplace=True)
spred_subm_eval.columns = spred_subm.columns
spred_su... | combined_df.loc[combined_df["SibSp"]==8] | Titanic - Machine Learning from Disaster |
777,941 | from datetime import datetime, timedelta
import gc
import numpy as np, pandas as pd
import lightgbm as lgb<define_variables> | combined_df["Name_key"]=""
combined_df["Name_key"]=combined_df["Name"].str.split(',',expand=True)[1].str.split(' ',expand=True)[1] | Titanic - Machine Learning from Disaster |
777,941 | CAL_DTYPES={"event_name_1": "category", "event_name_2": "category", "event_type_1": "category",
"event_type_2": "category", "weekday": "category", 'wm_yr_wk': 'int16', "wday": "int16",
"month": "int16", "year": "int16", "snap_CA": "float32", 'snap_TX': 'float32', 'snap_WI': 'float32' }
PRICE_DTYPES = {"store_id": "cate... | combined_df.groupby(["Sex","Name_key","Parch"])["Age"].agg(["median"] ) | Titanic - Machine Learning from Disaster |
777,941 | pd.options.display.max_columns = 50<define_variables> | combined_df["Fare_Group"]=pd.cut(combined_df["Fare"],range(0,350,50),right=False)
combined_df["Fare_Group"]=combined_df["Fare_Group"].astype("object")
combined_df["Fare_Group"].fillna("[300,600)",inplace=True ) | Titanic - Machine Learning from Disaster |
777,941 | h = 28
max_lags = 57
tr_last = 1913
fday = datetime(2016,4, 25)
fday<load_from_csv> | Age_values=combined_df.groupby(["Sex","Pclass","Name_key","Parch"])["Age"].agg(["median"] ).reset_index()
Age_values.loc[Age_values["median"].isnull() ] | Titanic - Machine Learning from Disaster |
777,941 | def create_dt(is_train = True, nrows = None, first_day = 1200):
prices = pd.read_csv(".. /input/m5-forecasting-accuracy/sell_prices.csv", dtype = PRICE_DTYPES)
for col, col_dtype in PRICE_DTYPES.items() :
if col_dtype == "category":
prices[col] = prices[col].cat.codes.astype("int16")
prices[col] -= prices[col].min()
... | null_age=combined_df.loc[combined_df["Age"].isnull() ][['PassengerId','Sex','Name_key','Pclass','Parch']]
Age_values_f=pd.merge(Age_values,null_age,how='inner',on=['Sex','Name_key','Pclass','Parch'])
Age_values_f=Age_values_f.rename(columns={'median':"Age"})
Age_values_f.loc[Age_values_f["Age"].isnull() ] | Titanic - Machine Learning from Disaster |
777,941 | def create_fea(dt):
lags = [7, 28]
lag_cols = [f"lag_{lag}" for lag in lags ]
for lag, lag_col in zip(lags, lag_cols):
dt[lag_col] = dt[["id","sales"]].groupby("id")["sales"].shift(lag)
wins = [7, 28]
for win in wins :
for lag,lag_col in zip(lags, lag_cols):
dt[f"rmean_{lag}_{win}"] = dt[["id", lag_col]].groupby("id")... | combined_df.loc[combined_df["PassengerId"].isin([1257,980,1234])] | Titanic - Machine Learning from Disaster |
777,941 | FIRST_DAY = 350<correct_missing_values> | combined_df.groupby(["Sex"])["Age"].agg(["median"] ) | Titanic - Machine Learning from Disaster |
777,941 | df.dropna(inplace = True)
df.shape<prepare_x_and_y> | Age_values_f.loc[(Age_values_f["Age"].isnull())&(Age_values_f["Sex"]=='female'),"Age"]=27.0
Age_values_f.loc[(Age_values_f["Age"].isnull())&(Age_values_f["Sex"]=='male'),"Age"]=28.0 | Titanic - Machine Learning from Disaster |
777,941 | cat_feats = ['item_id', 'dept_id','store_id', 'cat_id', 'state_id'] + ["event_name_1", "event_name_2", "event_type_1", "event_type_2"]
useless_cols = ["id", "date", "sales","d", "wm_yr_wk", "weekday"]
train_cols = df.columns[~df.columns.isin(useless_cols)]
X_train = df[train_cols]
y_train = df["sales"]<create_dataframe... | train_df.set_index('PassengerId',inplace=True)
Age_values_f.set_index('PassengerId',inplace=True)
train_df.update(Age_values_f)
train_df.reset_index(inplace=True)
test_df.set_index('PassengerId',inplace=True)
test_df.update(Age_values_f)
test_df.reset_index(inplace=True)
| Titanic - Machine Learning from Disaster |
777,941 |
<create_dataframe> | train_df.groupby(["Embarked"])["Embarked"].agg(["count"] ) | Titanic - Machine Learning from Disaster |
777,941 | %%time
np.random.seed(777)
fake_valid_inds = np.random.choice(X_train.index.values, 2_000_000, replace = False)
train_inds = np.setdiff1d(X_train.index.values, fake_valid_inds)
train_data = lgb.Dataset(X_train.loc[train_inds] , label = y_train.loc[train_inds],
categorical_feature=cat_feats, free_raw_data=False)
fak... | train_df.loc[train_df["PassengerId"]==62.0,"Embarked"]='S'
train_df.loc[train_df["PassengerId"]==830,"Embarked"]='S' | Titanic - Machine Learning from Disaster |
777,941 | del df, X_train, y_train, fake_valid_inds,train_inds ; gc.collect()<init_hyperparams> | train_df["Cabin_prefix"]=train_df["Cabin"].str[0:1]
train_df.groupby(["Cabin_prefix","Pclass"])["Pclass"].agg(["count"] ).reset_index() | Titanic - Machine Learning from Disaster |
777,941 | params = {
"objective" : "poisson",
"metric" :"rmse",
"force_row_wise" : True,
"learning_rate" : 0.075,
"sub_row" : 0.75,
"bagging_freq" : 1,
"lambda_l2" : 0.1,
"metric": ["rmse"],
'verbosity': 1,
'num_iterations' : 1200,
'num_leaves': 128,
"min_data_in_leaf": 100,
}<train_model> | train_df.drop(columns={"Cabin","Cabin_prefix"},inplace=True ) | Titanic - Machine Learning from Disaster |
777,941 | %%time
m_lgb = lgb.train(params, train_data, valid_sets = [fake_valid_data], verbose_eval=20 )<save_model> | test_df.loc[test_df["Fare"].isnull() ] | Titanic - Machine Learning from Disaster |
777,941 | m_lgb.save_model("model.lgb" )<count_unique_values> | train_df.loc[train_df["Pclass"]==3].loc[train_df["Age"]>50].groupby(["Age","Sex"])["Fare"].agg(["mean"] ) | Titanic - Machine Learning from Disaster |
777,941 | sub.id.nunique() , sub["id"].str.contains("validation$" ).sum()<import_modules> | train_df.loc[train_df["Pclass"]==3].loc[train_df["Age"]>50].groupby(["Sex"])["Fare"].agg(["mean"] ) | Titanic - Machine Learning from Disaster |
777,941 | from datetime import datetime, timedelta
import gc
import numpy as np, pandas as pd
import lightgbm as lgb<define_variables> | test_df.loc[test_df["Fare"].isnull() ,"Fare"]=7.518522 | Titanic - Machine Learning from Disaster |
777,941 | CAL_DTYPES={"event_name_1": "category", "event_name_2": "category", "event_type_1": "category",
"event_type_2": "category", "weekday": "category", 'wm_yr_wk': 'int16', "wday": "int16",
"month": "int16", "year": "int16", "snap_CA": "float32", 'snap_TX': 'float32', 'snap_WI': 'float32' }
PRICE_DTYPES = {"store_id": "cate... | related_people=combined_df[["PassengerId","Name","SibSp","Parch","Ticket","Embarked"]].copy()
related_people["Last_Name"]=""
related_people["Last_Name"]=related_people["Name"].str.split(",",expand=True)[0]
related_people["total_related"]=related_people["SibSp"]+related_people["Parch"]+1
X=related_people.loc[(related_pe... | Titanic - Machine Learning from Disaster |
777,941 | pd.options.display.max_columns = 50<define_variables> | Y=pd.DataFrame(related_people.loc[(related_people["SibSp"]==0)&(related_people["Parch"]==0)][["Last_Name","Ticket"]])
Y["RGroup"]=Y["Last_Name"]+'_'+Y["Ticket"]
Y.drop_duplicates(inplace=True)
Y.set_index(["Last_Name","Ticket"],inplace=True)
related_people.set_index(["Last_Name","Ticket"],inplace=True)
related_peop... | Titanic - Machine Learning from Disaster |
777,941 | h = 28
max_lags = 70
tr_last = 1913
fday = datetime(2016,4, 25)
fday<load_from_csv> | X=related_people.loc[related_people["RGroup"]==""].groupby(["Ticket","total_related"])["PassengerId"].agg(["count"])
X.reset_index(inplace=True)
Y=pd.DataFrame(X.loc[X["count"]==X["total_related"]]["Ticket"])
Y["RGroup"]=Y["Ticket"]+'_R'
Y.drop_duplicates(inplace=True)
Y.set_index("Ticket",inplace=True)
related_pe... | Titanic - Machine Learning from Disaster |
777,941 | def create_dt(is_train = True, nrows = None, first_day = 1200):
prices = pd.read_csv(".. /input/m5-forecasting-accuracy/sell_prices.csv", dtype = PRICE_DTYPES)
for col, col_dtype in PRICE_DTYPES.items() :
if col_dtype == "category":
prices[col] = prices[col].cat.codes.astype("int16")
prices[col] -= prices[col].min()
... | related_people.loc[related_people["PassengerId"]==249,"RGroup"]="Beckwith_M"
related_people.loc[related_people["PassengerId"]==872,"RGroup"]="Beckwith_M"
related_people.loc[related_people["PassengerId"]==137,"RGroup"]="Beckwith_M"
related_people.loc[related_people["PassengerId"]==572,"RGroup"]="Lamson_M"
related_people... | Titanic - Machine Learning from Disaster |
777,941 | def create_fea(dt):
lags = [7, 28]
lag_cols = [f"lag_{lag}" for lag in lags ]
for lag, lag_col in zip(lags, lag_cols):
dt[lag_col] = dt[["id","sales"]].groupby("id")["sales"].shift(lag)
wins = [7, 28]
for win in wins :
for lag,lag_col in zip(lags, lag_cols):
dt[f"rmean_{lag}_{win}"] = dt[["id", lag_col]].groupby("id")... | related_people.drop(columns={"Ticket","Last_Name","Name","SibSp","Parch","total_related"})
related_people.set_index("PassengerId",inplace=True)
train_df["RGroup"]=""
train_df.set_index("PassengerId",inplace=True)
train_df.update(related_people)
train_df.reset_index(inplace=True)
related_people.reset_index(inplace=... | Titanic - Machine Learning from Disaster |
777,941 | FIRST_DAY = 800
<correct_missing_values> | related_people.set_index("PassengerId",inplace=True)
test_df["RGroup"]=""
test_df.set_index("PassengerId",inplace=True)
test_df.update(related_people)
test_df.reset_index(inplace=True)
related_people.reset_index(inplace=True ) | Titanic - Machine Learning from Disaster |
777,941 | df.dropna(inplace = True)
df.shape<prepare_x_and_y> | train_df["Sex"]=train_df["Sex"].astype("category")
train_df["Pclass"]=train_df["Pclass"].astype("category")
train_df["Embarked"]=train_df["Embarked"].astype("category")
train_df["RGroup"]=train_df["RGroup"].astype("category")
train_df.drop(columns={"Name","Ticket","PassengerId"},inplace=True)
train_df=pd.get_dummi... | Titanic - Machine Learning from Disaster |
777,941 | cat_feats = ['item_id', 'dept_id','store_id', 'cat_id', 'state_id'] + ["event_name_1", "event_name_2", "event_type_1", "event_type_2"]
useless_cols = ["id", "date", "sales","d", "wm_yr_wk", "weekday"]
train_cols = df.columns[~df.columns.isin(useless_cols)]
X_train = df[train_cols]
y_train = df["sales"]<create_dataframe... | test_df["Sex"]=test_df["Sex"].astype("category")
test_df["Pclass"]=test_df["Pclass"].astype("category")
test_df["Embarked"]=test_df["Embarked"].astype("category")
test_df["RGroup"]=test_df["RGroup"].astype("category")
test_passengerId=test_df["PassengerId"].copy()
test_df.drop(columns={"Name","Cabin","Ticket","Pass... | Titanic - Machine Learning from Disaster |
777,941 | train_data = lgb.Dataset(X_train, label = y_train, categorical_feature=cat_feats, free_raw_data=False)
fake_valid_inds = np.random.choice(len(X_train), 1000000)
fake_valid_data = lgb.Dataset(X_train.iloc[fake_valid_inds], label = y_train.iloc[fake_valid_inds],categorical_feature=cat_feats,
free_raw_data=False )<init_... | train_df_dec=train_df.copy()
train_df_dec = train_df_dec.sample(frac=1 ).reset_index(drop=True)
row_count = train_df_dec.shape[0]
split_point = int(row_count*0.30)
cv_data, train_data = train_df_dec[:split_point].copy() , train_df_dec[split_point:].copy() | 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.