kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,984,731 | scaler = MinMaxScaler(feature_range=(-1, 1)).fit(features.values)
train_features = scaler.transform(train_features)
val_features = scaler.transform(val_features )<train_model> | best_model = best_models[np.argmax(model_accuracy)]
best_model | Titanic - Machine Learning from Disaster |
11,984,731 | model = CatBoostRegressor(iterations=250, learning_rate=0.1, eval_metric='MAE', max_depth=8)
model.fit(train_features, train_targets, eval_set=(val_features, val_targets))<groupby> | final_model = Pipeline([('pre_process', pre_process),
('best_model', best_model)])
final_model.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
11,984,731 | mean_match_features = test_data_df.groupby(['matchId'])[train_data_df.columns[3:-1]].agg('mean' ).reset_index().loc[:, 'assists':'winPoints']
size_match_features = pd.DataFrame(test_data_df.groupby(['matchId'])[train_data_df.columns[3]].agg('size' ).reset_index() [train_data_df.columns[3]])
size_match_features.columns... | test_data = pd.read_csv(".. /input/titanic/test.csv")
test_data.info() | Titanic - Machine Learning from Disaster |
11,984,731 | mean_group_features = test_data_df.groupby(['matchId','groupId'])[train_data_df.columns[3:-1]].agg('mean' ).reset_index().loc[:, 'assists':'winPoints']
max_group_features = test_data_df.groupby(['matchId','groupId'])[train_data_df.columns[3:-1]].agg('max' ).reset_index().loc[:, 'assists':'winPoints']
min_group_features... | predictions = final_model.predict(test_data ) | Titanic - Machine Learning from Disaster |
11,984,731 | features_three = mean_group_features.join(max_group_features, lsuffix='_group_mean', rsuffix='_group_max')
features_four = min_group_features.join(size_group_features, lsuffix='_group_min', rsuffix='_group_size')
features_2 = features_three.join(features_four)
features_2['matchId'] = test_data_df.groupby(['matchId',... | test_predictions = pd.DataFrame(test_data['PassengerId'])
test_predictions['Survived'] = predictions.copy()
test_predictions.head() | Titanic - Machine Learning from Disaster |
11,984,731 | <groupby><EOS> | test_predictions.to_csv("./submission.csv", index=False ) | Titanic - Machine Learning from Disaster |
12,462,474 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<groupby> | %matplotlib inline
rcParams['figure.figsize'] = 20,5
rcParams['xtick.labelsize'] = 9
rcParams['ytick.labelsize'] = 9
rcParams['axes.labelsize'] = 10
| Titanic - Machine Learning from Disaster |
12,462,474 | groups = test_data_df.groupby(['matchId', 'groupId'])['groupId'].agg('mean' ).values<drop_column> | train = pd.read_csv(".. /input/titanic/train.csv")
test = pd.read_csv(".. /input/titanic/test.csv")
df = pd.concat([train,test] ) | Titanic - Machine Learning from Disaster |
12,462,474 | features = features.drop(['matchId'], axis=1 )<normalization> | df.Survived.value_counts() | Titanic - Machine Learning from Disaster |
12,462,474 | test_features = features.values
test_features = scaler.transform(test_features )<predict_on_test> | eda, df_test = train_test_split(train, test_size=0.25, random_state=42)
eda.head() | Titanic - Machine Learning from Disaster |
12,462,474 | predictions = model.predict(test_features )<groupby> | df_fill = df.copy()
df_fill['Fare'].fillna(df_fill['Fare'].median() , inplace = True)
df_fill['Embarked'].fillna(df_fill['Embarked'].mode().iloc[0], inplace = True)
df_fill.head() | Titanic - Machine Learning from Disaster |
12,462,474 | features['winPlacePercPred'] = predictions
features['matchId'] = matches
features['groupId'] = groups
group_preds = features.groupby(['matchId', 'groupId'])['winPlacePercPred'].agg('mean' ).groupby(['matchId'] ).rank(pct=True )<sort_values> | df_index = df_fill.set_index('PassengerId')
df_index.head() | Titanic - Machine Learning from Disaster |
12,462,474 | test_data_df = test_data_df.sort_values(['matchId', 'groupId'] )<define_variables> | df_cut = df_split_name.copy()
df_cut['FareBin'] = pd.qcut(df_cut.Fare, 5)
label = LabelEncoder()
df_cut['FareBin_Code'] = label.fit_transform(df_cut['FareBin'])
df_cut.drop(['FareBin'], 1, inplace=True ) | Titanic - Machine Learning from Disaster |
12,462,474 | dictionary = dict(zip(features['groupId'].values, group_preds.values))<prepare_output> | df_cut['AgeBin'] = pd.qcut(df_cut.Age, 5)
label = LabelEncoder()
df_cut['AgeBin_code'] = label.fit_transform(df_cut['AgeBin'])
df_cut.drop(['Age','AgeBin'], 1, inplace=True)
df_cut.head() | Titanic - Machine Learning from Disaster |
12,462,474 | new_ranking_preds = []
for i in test_data_df['groupId'].values:
new_ranking_preds.append(dictionary[i])
test_data_df['winPlacePercPred'] = new_ranking_preds<prepare_output> | df_comb = df_cut.copy()
df_comb['Family_members_aboard'] = df_comb['SibSp'] + df_comb['Parch']
df_comb.drop(['SibSp','Parch'], axis=1, inplace=True)
df_comb.head() | Titanic - Machine Learning from Disaster |
12,462,474 | predictions = pd.DataFrame(np.transpose(np.array([test_data_df.loc[:, 'Id'], test_data_df['winPlacePercPred']])))
predictions.columns = ['Id', 'winPlacePerc']
predictions['Id'] = np.int32(predictions['Id'])
predictions = predictions.sort_values(by=['Id'])
predictions.head(20 )<sort_values> | df_extr_family = df_comb.copy()
df_extr_family.insert(2,'Surname',df_extr_family['Name'].str.extract('([A-Za-z]+)\,', expand=True)[0])
DEFAULT_SURVIVAL_VALUE = 0.5
df_extr_family['Family_Survival'] = DEFAULT_SURVIVAL_VALUE
df_extr_family.reset_index(inplace=True)
for surname, sur_group in df_extr_family[df_extr_famil... | Titanic - Machine Learning from Disaster |
12,462,474 | maxPlaces = test_data_df.sort_values(by=['Id'])['maxPlace'].values
numGroups = test_data_df.sort_values(by=['Id'])['numGroups'].values
new_predictions = predictions['winPlacePerc'].values
for i in range(0, len(test_data_df)) :
gap = 1.0 /(maxPlaces[i] - 1.0)
new_predictions[i] = round(new_predictions[i]/gap)*gap<prepa... | df_enc = df_extr_family.copy()
label = LabelEncoder()
df_enc['Embarked_code'] = label.fit_transform(df_enc['Embarked'])
label = LabelEncoder()
df_enc['Sex_code'] = label.fit_transform(df_enc['Sex'])
df_enc.drop(['Sex', 'Embarked'], 1, inplace=True)
df_enc.head() | Titanic - Machine Learning from Disaster |
12,462,474 | predictions['winPlacePerc'] = new_predictions<save_to_csv> | def drop_cols(cols):
return df_enc.drop(cols, axis=1)
attr_to_drop = ['Title', 'Surname', 'Name', 'Ticket', 'Cabin', 'Fare']
df_prepared = drop_cols(attr_to_drop)
df_prepared.set_index('PassengerId',inplace=True)
train_ready = df_prepared[:891]
submission = df_prepared[891:]
train_ready | Titanic - Machine Learning from Disaster |
12,462,474 | predictions.to_csv('PUBG_preds.csv', index=False )<import_modules> | X = train_ready.drop('Survived',1)
y = train_ready['Survived']
X_submission = submission.drop('Survived',1 ) | Titanic - Machine Learning from Disaster |
12,462,474 |
<categorify> | std_scaler = StandardScaler()
X = std_scaler.fit_transform(X)
X_submission = std_scaler.transform(X_submission ) | Titanic - Machine Learning from Disaster |
12,462,474 | train = pd.get_dummies(train,columns=['matchType'] )<correct_missing_values> | def compare_clf(classifiers):
rows = []
for clf in classifiers:
start = time.time()
score_arr = cross_val_score(clf,X,y,cv=5,scoring='roc_auc')
end = time.time()
for i, score in enumerate(score_arr):
score_dict = {
'fold':i+1,
'Classifier':clf.__class__.__name__,
'Score':score,
'Time(sec)':end-start
}
rows.append(scor... | Titanic - Machine Learning from Disaster |
12,462,474 | train =train.dropna()<categorify> | compare_clf(classifiers ).groupby('Classifier' ).agg({'mean','median','std'} ).drop('fold',1 ).sort_values(( 'Score','mean'),ascending=False ) | Titanic - Machine Learning from Disaster |
12,462,474 | test = pd.get_dummies(test,columns=['matchType'] )<prepare_x_and_y> | n_neighbors = [6,7,8,9,10,11,12,14,16,18,20,22]
algorithm = ['auto']
weights = ['uniform', 'distance']
leaf_size = list(range(1,50,5))
hyperparams = {'algorithm': algorithm, 'weights': weights, 'leaf_size': leaf_size,
'n_neighbors': n_neighbors}
gd=GridSearchCV(estimator = KNeighborsClassifier() , param_grid = hyperpar... | Titanic - Machine Learning from Disaster |
12,462,474 | y_train =train['winPlacePerc']
x_train =train.drop(['Id','groupId','matchId','winPlacePerc'],axis=1 )<prepare_x_and_y> | gd.best_estimator_.fit(X, y)
y_pred = gd.best_estimator_.predict(X_submission ) | Titanic - Machine Learning from Disaster |
12,462,474 | X_train = x_train.values
Y_train = y_train.values<choose_model_class> | submit=pd.DataFrame(data=y_pred, index=submission.index, columns=['Survived'], dtype='int')
submit.to_csv('submission.csv' ) | Titanic - Machine Learning from Disaster |
12,094,919 | def build_model() :
model = Sequential()
model.add(Dense(80,input_dim=X_train.shape[1],activation='relu'))
model.add(Dense(160,activation='relu'))
model.add(Dense(320,activation='relu'))
model.add(Dropout(0.1))
model.add(Dense(160,activation='relu'))
model.add(Dense(80,activation='relu'))
model.add(Dense(40,activation=... | titanic_data = pd.read_csv('.. /input/titanic/train.csv')
titanic_data.head() | Titanic - Machine Learning from Disaster |
12,094,919 | k = 4
num_val_samples = len(X_train)// k
<drop_column> | features = [x for x in titanic_data.columns if x not in ['Survived']]
X = titanic_data[features]
y = titanic_data['Survived'] | Titanic - Machine Learning from Disaster |
12,094,919 | K.clear_session()<define_variables> | X_initial = X.copy()
X_initial['family_size'] = X_initial['SibSp'] + X_initial['Parch'] + 1
X_initial['embarked_class'] = X_initial['Embarked'] + '_' + X_initial['Pclass'].astype(str)
X_initial = X_initial.drop(columns=['Name', 'Cabin', 'Ticket'], axis=1)
numerical_cols = [cname for cname in X_initial.columns if
X_in... | Titanic - Machine Learning from Disaster |
12,094,919 | <define_variables><EOS> | X_test = pd.read_csv('.. /input/titanic/test.csv')
X_test['family_size'] = X_test['SibSp'] + X_test['Parch'] + 1
X_test['embarked_class'] = X_initial['Embarked'] + '_' + X_test['Pclass'].astype(str)
X_test = X_test.drop(columns=['Name', 'Cabin', 'Ticket'], axis=1)
preds = clf.predict(X_test)
output = pd.DataFrame({... | Titanic - Machine Learning from Disaster |
11,929,785 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<drop_column> | warnings.filterwarnings("ignore")
| Titanic - Machine Learning from Disaster |
11,929,785 | x_test = test.drop(['Id','groupId','matchId'],axis=1 )<prepare_x_and_y> | df_train = pd.read_csv("/kaggle/input/titanic/train.csv")
df_test = pd.read_csv("/kaggle/input/titanic/test.csv")
df_sample_sub = pd.read_csv("/kaggle/input/titanic/gender_submission.csv")
df_all = df_train.append(df_test, ignore_index=True)
print("Titanic Dataset Summary:")
display(df_all.head())
print("Stats of... | Titanic - Machine Learning from Disaster |
11,929,785 | X_test = x_test.values<train_model> | df_all['Title'] = df_all.Name.apply(lambda name: name.split(',')[1].split('.')[0].strip())
display(df_all.Title)
new_titles = {
"Capt": "Officer",
"Col": "Officer",
"Major": "Officer",
"Jonkheer": "Royalty",
"Don": "Royalty",
"Sir" : "Royalty",
"Dr": "Officer",
"Rev": "Officer",
"the Countess":"Royalty",
"Dona": "Roy... | Titanic - Machine Learning from Disaster |
11,929,785 | model = build_model()
model.fit(train_data, train_targets,epochs=70, batch_size=16, verbose=1)
test_mse_score, test_mae_score = model.evaluate(test_data, test_targets )<predict_on_test> | most_embarked = df_all.Embarked.value_counts().index[0]
df_all.Embarked = df_all.Embarked.fillna(most_embarked)
df_all.Fare = df_all.Fare.fillna(df_all.Fare.median())
| Titanic - Machine Learning from Disaster |
11,929,785 | prediction = model.predict(X_test )<prepare_output> | print('Number of missing values in',m, 'examples')
display(df_all.isnull().sum() ) | Titanic - Machine Learning from Disaster |
11,929,785 | sample['winPlacePerc'] = prediction<save_to_csv> | df_all.drop('Name', axis =1, inplace=True)
df_all.drop('Ticket', axis =1, inplace=True)
df_all.drop('PassengerId', axis=1, inplace = True)
display(df_all ) | Titanic - Machine Learning from Disaster |
11,929,785 | sample.to_csv('sample_submission_v1.csv', index=False )<load_from_csv> | Sex = {"male": 0, "female":1}
df_all["Sex"] = df_all.Sex.map(Sex)
df_all['Partner'] = df_all['SibSp'] + df_all['Parch']
df_all.drop(['SibSp', 'Parch'], axis=1, inplace=True)
df_all = pd.get_dummies(df_all, columns = ['Title','Embarked'])
display(df_all.head() ) | Titanic - Machine Learning from Disaster |
11,929,785 | train_data_df = pd.read_csv('.. /input/train.csv')
test_data_df = pd.read_csv('.. /input/test.csv' )<groupby> | def logistic_regression(X, y, alpha=1e-3, num_iter=30,random_state=42):
np.random.seed(random_state)
d, m = X.shape
K = np.max(y)+ 1
w = np.random.randn(d, K)
def softmax(x):
s = np.exp(x)/ np.sum(np.exp(x))
return s
def one_hot(y, k):
y_one_hot = np.eye(k)[y]
return y_one_hot
def h(x, w):
p = softmax(w.T @ x)
retur... | Titanic - Machine Learning from Disaster |
11,929,785 | mean_group_features = train_data_df.groupby(['matchId','groupId'])[train_data_df.columns[3:-1]].agg('mean' ).reset_index().loc[:, 'assists':'winPoints']
max_group_features = train_data_df.groupby(['matchId','groupId'])[train_data_df.columns[3:-1]].agg('max' ).reset_index().loc[:, 'assists':'winPoints']
min_group_featur... | def ridge_classifier(X, y, lambd=1e-4):
d, m = X.shape
k = np.max(y)+ 1
w = np.linalg.inv(X @ X.T + lambd * np.eye(d)) @ X @ np.eye(k)[y]
return w | Titanic - Machine Learning from Disaster |
11,929,785 | features_one = mean_group_features.join(max_group_features, lsuffix='_mean', rsuffix='_max')
features_two = min_group_features.join(std_group_features, lsuffix='_min', rsuffix='_std')
features = features_one.join(features_two)
features = features.fillna(0.0)
features<groupby> | def error(X, y, w):
m = np.shape(y)
y_pred = w.T @ X
y_pred = np.argmax(y_pred, axis=0)
err = np.sum(y_pred == y)/ m
return err | Titanic - Machine Learning from Disaster |
11,929,785 | targets = train_data_df.groupby(['matchId', 'groupId'])['winPlacePerc'].agg('mean' ).reset_index() ['winPlacePerc']
targets<define_variables> | mms = MinMaxScaler()
X = df_all.drop('Survived', axis=1 ).iloc[:891].values
y =(df_all["Survived"].iloc[:891].values ).astype(int)
X = mms.fit_transform(X)
X_test = df_all.drop('Survived', axis=1 ).iloc[891:].values
X_test = mms.fit_transform(X_test ) | Titanic - Machine Learning from Disaster |
11,929,785 |
<import_modules> | scores_lr = []
scores_ls = []
fold =1
for tr, val in KFold(n_splits=5, random_state=42 ).split(X,y):
X_train = X[tr]
X_val = X[val]
y_train = y[tr]
y_val = y[val]
best_W_LR = logistic_regression(X_train.T, y_train, alpha=1e-3, num_iter=300,random_state=42)
val_acc_LR = error(X_val.T, y_val, best_W_LR)
scores_lr.appen... | Titanic - Machine Learning from Disaster |
11,929,785 | import sklearn<normalization> | y_preds_LS =(np.argmax(W_LS.T @ X_test.T, axis=0)).astype(int)
df_sample_sub.loc[:, 'Survived'] = y_preds_LS
df_sample_sub.to_csv('submission0.csv', index=False)
display(df_sample_sub.head())
| Titanic - Machine Learning from Disaster |
11,929,785 | scaler = MinMaxScaler(feature_range=(-1, 1)).fit(features.values)
<choose_model_class> | def test_clfs(clfs):
for clf in clfs:
print('------------------------------------------')
start = time()
clf = clf(random_state=42)
scores = cross_val_score(clf, X, y, cv=5)
print(str(clf), 'results:')
print("Accuracy: %0.2f(+/- %0.2f)" %(scores.mean() , scores.std() * 2))
end = time()
print('Processing time', end-... | Titanic - Machine Learning from Disaster |
11,929,785 | bayes_cv_tuner = BayesSearchCV(
estimator = CatBoostRegressor(iterations = 1500, eval_metric='MAE')
,
search_spaces = {
'learning_rate': [0.05, 0.1, 0.15, 0.2, 0.25, 0.3],
'max_depth':(4, 6),
},
scoring = 'neg_mean_absolute_error',
cv = KFold(
n_splits=5,
shuffle=True,
random_state=42
),
n_jobs = 1,
n_iter = 6,
ver... | from sklearn.model_selection import GridSearchCV
| Titanic - Machine Learning from Disaster |
11,929,785 | %env JOBLIB_TEMP_FOLDER=/tmp<train_model> | clf1 = RandomForestClassifier(max_depth=9, min_samples_leaf=4, min_samples_split=2,
n_estimators=9, random_state=42, n_jobs=-1)
clf1.fit(X, y)
y_preds_RF = clf1.predict(X_test ).astype(int)
df_sample_sub.loc[:, 'Survived'] = y_preds_RF
df_sample_sub.to_csv('submission1.csv', index=False)
display(df_sample_sub.head(... | Titanic - Machine Learning from Disaster |
11,929,785 | bayes_cv_tuner.fit(scaler.transform(features.values), targets.values )<find_best_params> | clf2 = LogisticRegression(C=48, class_weight='None', fit_intercept= False, penalty='l2', solver='lbfgs')
clf2.fit(X, y)
y_preds_LR = clf2.predict(X_test ).astype(int)
df_sample_sub.loc[:, 'Survived'] = y_preds_LR
df_sample_sub.to_csv('submission2.csv', index=False)
display(df_sample_sub.head())
| Titanic - Machine Learning from Disaster |
11,929,785 | model = bayes_cv_tuner.best_estimator_<groupby> | clf3 = XGBClassifier(booster='gbtree', colsample_bytree= 0.6,
gamma=1, max_depth=5, min_child_weight=1, n_estimators=100, subsample=0.8)
clf3.fit(X, y)
y_preds_xgb = clf3.predict(X_test ).astype(int)
df_sample_sub.loc[:, 'Survived'] = y_preds_xgb
df_sample_sub.to_csv('submission3.csv', index=False)
display(df_sampl... | Titanic - Machine Learning from Disaster |
11,929,785 | mean_group_features = test_data_df.groupby(['matchId','groupId'])[train_data_df.columns[3:-1]].agg('mean' ).reset_index().loc[:, 'assists':'winPoints']
max_group_features = test_data_df.groupby(['matchId','groupId'])[train_data_df.columns[3:-1]].agg('max' ).reset_index().loc[:, 'assists':'winPoints']
min_group_features... | def create_model(hid_layers ,dropout_rate, lr):
inp1 = tf.keras.layers.Input(shape =(X.shape[1],))
x1 = tf.keras.layers.BatchNormalization()(inp1)
for i, units in enumerate(hid_layers):
x1 = tf.keras.layers.Dense(units, activation='relu' )(x1)
x1 = tf.keras.layers.Dropout(dropout_rate )(x1)
x1 = tf.keras.layers.Dens... | Titanic - Machine Learning from Disaster |
11,929,785 | features_one = mean_group_features.join(max_group_features, lsuffix='_mean', rsuffix='_max')
features_two = min_group_features.join(std_group_features, lsuffix='_min', rsuffix='_std')
features = features_one.join(features_two)
features = features.fillna(0.0)
features<groupby> | df_sub_copy = df_sample_sub.copy()
df_sub_copy.loc[:, 'Survived'] = 0.0
scores=[]
fold = 0
for tr, val in KFold(n_splits=5, random_state=42 ).split(X,y):
X_train = X[tr]
X_val = X[val]
y_train = y[tr]
y_val = y[val]
rlr = ReduceLROnPlateau(monitor = 'val_loss', factor = 0.2, patience = 3, verbose = 0,
min_delta = 1e-4,... | Titanic - Machine Learning from Disaster |
11,929,785 | matches = test_data_df.groupby(['matchId', 'groupId'])['matchId'].agg('mean' ).values<groupby> | df_sample_sub.loc[:, 'Survived'] =(np.round(df_sub_copy.loc[:,'Survived']/ 5)).astype(int)
display(df_sample_sub.head())
df_sample_sub.to_csv('submission4.csv', index=False)
| Titanic - Machine Learning from Disaster |
11,929,785 | <normalization><EOS> | sub0= pd.read_csv('submission0.csv')
sub1 = pd.read_csv('submission1.csv')
sub2 = pd.read_csv('submission2.csv')
sub3 = pd.read_csv('submission3.csv')
sub4 = pd.read_csv('submission4.csv')
sub_vot = np.round(( sub0['Survived']+sub1['Survived']+sub2['Survived']+sub3['Survived']+sub4['Survived'])/5 ).astype(int)
df... | Titanic - Machine Learning from Disaster |
11,287,080 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<predict_on_test> | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
| Titanic - Machine Learning from Disaster |
11,287,080 | predictions = model.predict(test_features )<groupby> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
test_data = pd.read_csv('/kaggle/input/titanic/test.csv')
train_data.head(10 ) | Titanic - Machine Learning from Disaster |
11,287,080 | features['winPlacePercPred'] = predictions
features['matchId'] = matches
features['groupId'] = groups
group_preds = features.groupby(['matchId', 'groupId'])['winPlacePercPred'].agg('mean' ).groupby('matchId' ).rank(pct=True ).reset_index()
group_preds = group_preds['winPlacePercPred']<sort_values> | obj_imputer = SimpleImputer(missing_values = np.nan,strategy = 'most_frequent')
train_data['Embarked'] = obj_imputer.fit_transform(train_data[['Embarked']])
train_data | Titanic - Machine Learning from Disaster |
11,287,080 | test_data_df = test_data_df.sort_values(['matchId', 'groupId'] )<define_variables> | split_one = train_data['Name'].str.split('.', n=1, expand = True)
train_data['Name'] = split_one[0]
split_two = train_data['Name'].str.split(',', n=1, expand = True)
train_data['Name'] = split_two[1]
train_data['Title'] = train_data['Name'].apply(set_title)
train_data | Titanic - Machine Learning from Disaster |
11,287,080 | dictionary = dict(zip(features['groupId'].values, group_preds))<prepare_output> | col_names = ['Female','Male','St_C','St_Q','St_S']
col_names.extend(( list(train_data.columns)))
col_names.remove('Embarked')
col_names.remove('Sex')
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder() , [2,7])],
remainder='passthrough')
train_data = pd.DataFrame(data = np.array(ct.fit_transform(train_... | Titanic - Machine Learning from Disaster |
11,287,080 | new_ranking_preds = []
for i in test_data_df['groupId'].values:
new_ranking_preds.append(dictionary[i])
test_data_df['winPlacePercPred'] = new_ranking_preds<prepare_output> | missing_val_data = train_data[train_data['Age'].isnull() ]
nonmissing_val_data = train_data[train_data['Age'].notnull() ]
missing_val_data.info() | Titanic - Machine Learning from Disaster |
11,287,080 | predictions = pd.DataFrame(np.transpose(np.array([test_data_df.loc[:, 'Id'], test_data_df['winPlacePercPred']])))
predictions.columns = ['Id', 'winPlacePerc']
predictions['Id'] = np.int32(predictions['Id'])
predictions = predictions.sort_values(by=['Id'])
predictions.head(10 )<save_to_csv> | X_MD = missing_val_data.drop(['Survived','Age'], axis = 1 ).values
y_MD = missing_val_data['Survived'].values.astype('int')
r_state = 3
md_colnames = missing_val_data.drop(['Survived','Age'], axis = 1 ).columns
X_train, X_test, y_train, y_test = train_test_split(X_MD,
y_MD,
test_size = 0.3,
random_state = r_state)
X_... | Titanic - Machine Learning from Disaster |
11,287,080 | predictions.to_csv('PUBG_preds.csv', index=False )<import_modules> | pd.DataFrame(X_train ) | Titanic - Machine Learning from Disaster |
11,287,080 | import pandas as pd
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt
import statsmodels.formula.api as sm
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
from sklearn.ensemble import RandomForestRegressor
from sklearn import preprocessing
from scipy impo... | sc_MD = StandardScaler()
X_train[:, 5:] = sc_MD.fit_transform(X_train[:, 5:])
X_test[:, 5:] = sc_MD.transform(X_test[:, 5:])
X_train = pd.DataFrame(X_train)
X_test = pd.DataFrame(X_test)
print(X_train.head(3))
print(X_test.head(3)) | Titanic - Machine Learning from Disaster |
11,287,080 | train_init= pd.read_csv('.. /input/train.csv' )<drop_column> | classifier_LR = LogisticRegression(random_state = r_state)
classifier_LR.fit(X_train, y_train)
y_pred_LR = classifier_LR.predict(X_test)
accuracy_score(y_test, y_pred_LR ) | Titanic - Machine Learning from Disaster |
11,287,080 | list_largest_corr = train_init.drop(['matchId','groupId','teamKills',u'winPlacePerc'],axis=1 ).columns<merge> | classifier_KNN = KNeighborsClassifier(n_neighbors = 5,
metric = 'minkowski',
p = 2)
classifier_KNN.fit(X_train, y_train)
y_pred_KNN = classifier_KNN.predict(X_test)
accuracy_score(y_test, y_pred_KNN ) | Titanic - Machine Learning from Disaster |
11,287,080 | train_without_out = train_init[(np.abs(stats.zscore(train_init)) < 6 ).all(axis=1)]
del train_init
gc.collect()
def add_means(train_without_out,list_largest_corr,isSampleTest=False):
agg = train_without_out.groupby(['matchId','groupId'])[list_largest_corr].agg('mean')
agg_rank = agg.groupby('matchId')[list_largest_cor... | knn_prams = [{'n_neighbors': [1 , 2, 3, 4, 5, 6, 7],
'metric': ['minkowski'],
'p': [2]}]
grid_search_KNN = GridSearchCV(estimator = classifier_KNN,
param_grid = knn_prams,
scoring = 'accuracy',
cv = 10,
n_jobs = -1)
grid_search_KNN.fit(X_train, y_train)
best_accuracy_KNN = grid_search_KNN.best_score_
best_parameters_... | Titanic - Machine Learning from Disaster |
11,287,080 | d_train = lgb.Dataset(x, y)
iterations = 2000
watchlist = [d_train]
params = {
'learning_rate': 0.1,
'max_depth': -1,
'num_leaves': 30,
'feature_fraction': 0.9,
'min_data_in_leaf': 100,
'lambda_l2': 4,
'objective': 'regression_l2',
'metric': 'mae',
'seed': 123}
model = lgb.train(params, train_set=d_train, num_boost_ro... | classifier_KNN = KNeighborsClassifier(n_neighbors = 2,
metric = 'minkowski',
p = 2)
classifier_KNN.fit(X_train, y_train)
y_pred_KNN = classifier_KNN.predict(X_test)
accuracy_score(y_test, y_pred_KNN ) | Titanic - Machine Learning from Disaster |
11,287,080 | test = pd.read_csv('.. /input/test.csv')
x_test = add_means(test,list_largest_corr,True)
predict = model.predict(x_test )<save_to_csv> | classifier_SVM = SVC(kernel = 'linear',
random_state = r_state)
classifier_SVM.fit(X_train, y_train)
y_pred_SVM = classifier_SVM.predict(X_test)
accuracy_score(y_test, y_pred_SVM ) | Titanic - Machine Learning from Disaster |
11,287,080 | test['winPlacePerc'] = predict
test[['Id','winPlacePerc']].to_csv("submission.csv", index = False )<set_options> | svm_params = [{'C': [0.25, 0.5, 0.75, 0.85, 1.0],
'kernel': ['rbf'],
'gamma': [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]}]
grid_search_SVM = GridSearchCV(estimator = classifier_SVM,
param_grid = svm_params,
scoring = 'accuracy',
cv = 10,
n_jobs = -1)
grid_search_SVM.fit(X_train, y_train)
best_accuracy_SVM = grid_s... | Titanic - Machine Learning from Disaster |
11,287,080 | %pylab inline
<load_from_csv> | classifier_NB = GaussianNB()
classifier_NB.fit(X_train, y_train)
y_pred_NB = classifier_NB.predict(X_test)
accuracy_score(y_test, y_pred_NB ) | Titanic - Machine Learning from Disaster |
11,287,080 | data = pd.read_csv('.. /input/train.csv')
parent_data = data.copy()
ID = data.pop('id' )<categorify> | classifier_DT = DecisionTreeClassifier(criterion = 'gini',
random_state = r_state)
classifier_DT.fit(X_train, y_train)
y_pred_DT = classifier_DT.predict(X_test)
accuracy_score(y_test, y_pred_DT ) | Titanic - Machine Learning from Disaster |
11,287,080 | y = data.pop('species')
y = LabelEncoder().fit(y ).transform(y)
y_cat = to_categorical(y)
X = StandardScaler().fit(data ).transform(data)
<train_model> | classifier_RF = RandomForestClassifier(n_estimators = 10,
criterion = 'gini',
random_state = r_state)
classifier_RF.fit(X_train, y_train)
y_pred_RF = classifier_RF.predict(X_test)
accuracy_score(y_test, y_pred_RF ) | Titanic - Machine Learning from Disaster |
11,287,080 | model = Sequential()
model.add(Dense(250, input_dim=192, init='uniform', activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(150, activation='relu'))
model.add(Dropout(0.4))
model.add(Dense(99, activation='softmax'))
model.compile(loss='categorical_crossentropy',optimizer='rmsprop', metrics = ["accuracy"])
his... | classifier_XGB = XGBClassifier()
classifier_XGB.fit(X_train.to_numpy() , y_train)
y_pred_XGB = classifier_XGB.predict(X_test.to_numpy())
accuracy_score(y_test, y_pred_XGB)
| Titanic - Machine Learning from Disaster |
11,287,080 | test = pd.read_csv('.. /input/test.csv')
index = test.pop('id')
test = StandardScaler().fit(test ).transform(test)
yPred = model.predict_proba(test)
yPred = pd.DataFrame(yPred,index=index,columns=sort(parent_data.species.unique()))
fp = open('submission_nn_kernel.csv','w')
fp.write(yPred.to_csv() )<import_modules> | classifier_GB = GradientBoostingClassifier()
classifier_GB.fit(X_train, y_train)
y_pred_GB = classifier_GB.predict(X_test)
accuracy_score(y_test, y_pred_GB ) | Titanic - Machine Learning from Disaster |
11,287,080 | import numpy as np
import pandas as pd
import tensorflow as tf
import math<init_hyperparams> | classifier_NN = MLPClassifier(random_state = r_state)
classifiers = [classifier_LR,
classifier_KNN,
classifier_SVM,
classifier_KSVM,
classifier_NB,
classifier_DT,
classifier_RF,
classifier_XGB,
classifier_GB,
classifier_NN]
classifiers_names = ['Linear Regression',
'KNN',
'SVM',
'Kernel SVM',
'Naive Bayes',
'Decision ... | Titanic - Machine Learning from Disaster |
11,287,080 | flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_integer('num_classes', 99, 'Number of classes.')
flags.DEFINE_integer('num_variables', 192, 'Number of variables.')
flags.DEFINE_integer('hidden1', 2048, 'Number of units in hidden layer 1.')
flags.DEFINE_integer('hidden2', 1024, 'Number of units in hidden layer ... | age_missing_model1 = classifier_KSVM
age_missing_model1.fit(X_train, y_train)
age_missing_model2 = classifier_SVM
age_missing_model2.fit(X_train, y_train)
age_missing_model3 = classifier_NB
age_missing_model3.fit(X_train, y_train)
voting_cl_MD = VotingClassifier(estimators = [('KSVM', age_missing_model1),
('SVM',ag... | Titanic - Machine Learning from Disaster |
11,287,080 | def inference(data, data_size, keep_prob):
with tf.name_scope('hidden1'):
weights = tf.Variable(tf.truncated_normal([data_size, FLAGS.hidden1],
stddev=1.0 / math.sqrt(float(data_size))), name='weights1')
biases = tf.Variable(tf.zeros([FLAGS.hidden1]), name='biases1')
hidden1 = tf.nn.relu(tf.matmul(data, weights)+ bia... | X_NMD = nonmissing_val_data.drop(['Survived'], axis = 1 ).values
y_NMD = nonmissing_val_data['Survived'].values.astype('int')
r_state = 3
md_colnames = nonmissing_val_data.drop(['Survived'], axis = 1 ).columns
X_train, X_test, y_train, y_test = train_test_split(X_NMD,
y_NMD,
test_size = 0.3,
random_state = r_state)
X... | Titanic - Machine Learning from Disaster |
11,287,080 | def loss(logits, labels):
labels = tf.to_int64(labels)
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits, labels, name='xentropy')
loss = tf.reduce_mean(cross_entropy, name='xentropy_mean')
return loss<train_model> | pd.DataFrame(X_train ) | Titanic - Machine Learning from Disaster |
11,287,080 | def training(loss):
tf.summary.scalar(loss.op.name, loss)
optimizer = tf.train.AdamOptimizer(FLAGS.learning_rate)
global_step = tf.Variable(0, name='global_step', trainable=False)
train_op = optimizer.minimize(loss, global_step=global_step)
return train_op<compute_test_metric> | sc_NMD = StandardScaler()
X_train[:, 5:] = sc_NMD.fit_transform(X_train[:, 5:])
X_test[:, 5:] = sc_NMD.transform(X_test[:, 5:])
X_train = pd.DataFrame(X_train,
columns = md_colnames)
X_test = pd.DataFrame(X_test,
columns = md_colnames)
print(X_train.head(3))
print(X_test.head(3)) | Titanic - Machine Learning from Disaster |
11,287,080 | def evaluation(logits, labels):
correct = tf.nn.in_top_k(logits, labels, 1)
return tf.reduce_sum(tf.cast(correct, tf.int32))<data_type_conversions> | classifier_NN = MLPClassifier(random_state = r_state)
classifiers = [classifier_LR,
classifier_KNN,
classifier_SVM,
classifier_KSVM,
classifier_NB,
classifier_DT,
classifier_RF,
classifier_XGB,
optimal_GB_classifier,
classifier_NN]
classifiers_names = ['Linear Regression',
'KNN',
'SVM',
'Kernel SVM',
'Naive Bayes',
'D... | Titanic - Machine Learning from Disaster |
11,287,080 | def preprocess_data(data):
_data = data.copy()
del _data['id']
for column in _data:
if _data[column].dtypes == float:
_data[column] = z_score_normalization(_data[column])
if 'species' in _data.columns:
_data.insert(2, 'species_cat', _data['species'].astype('category' ).cat.codes)
_data.drop('species', axis=1, inplace... | test_data = pd.read_csv('/kaggle/input/titanic/test.csv')
test_data = test_data.drop(['Ticket','Cabin'], axis = 1)
test_data.info() | Titanic - Machine Learning from Disaster |
11,287,080 | def load_data_and_labels(file, is_labels_exist=True):
df = pd.read_csv(file)
processed_df, variables_size = preprocess_data(df)
print('Reading %s' % file)
print('N=%d' % len(df))
if is_labels_exist is True:
labels = list(processed_df['species_cat'])
else:
labels = None
if is_labels_exist is True:
del processed_df['... | obj_imputer_test = SimpleImputer(missing_values = np.nan,
strategy = 'most_frequent')
fare_imputer_test = SimpleImputer(missing_values = np.nan,
strategy = 'mean')
test_data['Embarked'] = obj_imputer.fit_transform(test_data[['Embarked']])
test_data['Fare'] = fare_imputer_test.fit_transform(test_data[['Fare']])
test... | Titanic - Machine Learning from Disaster |
11,287,080 | def z_score_normalization(series_of_values):
_series_of_values =(series_of_values - series_of_values.mean())/ series_of_values.std()
return _series_of_values<create_dataframe> | split_one = test_data['Name'].str.split('.', n=1, expand = True)
test_data['Name'] = split_one[0]
split_two = test_data['Name'].str.split(',', n=1, expand = True)
test_data['Name'] = split_two[1]
test_data['Title'] = test_data['Name'].apply(set_title)
test_data | Titanic - Machine Learning from Disaster |
11,287,080 | def shuffle_data(data, labels):
new_df = pd.DataFrame(data)
new_df['__labels__'] = labels
new_df = new_df.reindex(np.random.permutation(new_df.index))
new_labels = list(new_df['__labels__'])
del new_df['__labels__']
new_row = []
for index, row in new_df.iterrows() :
_list_row = []
for col in new_df:
_list_row.append(... | col_names = ['Female','Male','St_C','St_Q','St_S']
col_names.extend(( list(test_data.columns)))
col_names.remove('Embarked')
col_names.remove('Sex')
ct_test = ColumnTransformer(transformers=[('encoder', OneHotEncoder() , [2,7])],
remainder='passthrough')
test_data = pd.DataFrame(data = np.array(ct_test.fit_transfor... | Titanic - Machine Learning from Disaster |
11,287,080 | def run_training(data, labels):
with tf.Graph().as_default() :
data_size = FLAGS.num_variables
num_classes = FLAGS.num_classes
data_placeholder = tf.placeholder("float", shape=(None, data_size))
labels_placeholder = tf.placeholder("int32", shape=None)
keep_prob = tf.placeholder("float")
logits = inference(data_placeh... | missing_val_data_test = test_data[test_data['Age'].isnull() ]
nonmissing_val_data_test = test_data[test_data['Age'].notnull() ]
nonmissing_val_data_test.info() | Titanic - Machine Learning from Disaster |
11,287,080 | <train_model><EOS> | MD_ID = missing_val_data_test['PassengerId']
NMD_ID = nonmissing_val_data_test['PassengerId']
X_MD_test = missing_val_data_test.drop(['Age','PassengerId'], axis = 1 ).values
X_NMD_test = nonmissing_val_data_test.drop(['PassengerId'], axis = 1 ).values
X_MD_test[:, 5:] = sc_MD.transform(X_MD_test[:, 5:])
X_NMD_test[:, ... | Titanic - Machine Learning from Disaster |
10,536,929 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | %matplotlib inline | Titanic - Machine Learning from Disaster |
10,536,929 | def run_classifier(data):
with tf.Graph().as_default() :
data_size = FLAGS.num_variables
num_classes = FLAGS.num_classes
data_placeholder = tf.placeholder("float", shape=(None, data_size))
logits = inference(data_placeholder, data_size, 1.0)
init_op = tf.group(tf.global_variables_initializer() , tf.local_variables_ini... | train = pd.read_csv('.. /input/titanic/train.csv', index_col=0)
test = pd.read_csv('.. /input/titanic/test.csv', index_col=0)
train | Titanic - Machine Learning from Disaster |
10,536,929 | def make_output(class_list):
result_df = pd.DataFrame(class_list)
train_df =(pd.read_csv('.. /input/train.csv'))
test_df =(pd.read_csv('.. /input/test.csv'))
cat_label_list = train_df['species'].astype('category' ).cat.categories
new_columns = ['id']
new_columns.extend(list(cat_label_list))
result_df.insert(0, 'id', t... | freq = train['Embarked'].value_counts().index[0]
train['Embarked'].fillna(freq, inplace=True ) | Titanic - Machine Learning from Disaster |
10,536,929 | test_data = load_data_and_labels('.. /input/test.csv', is_labels_exist=False)
result_list = run_classifier(test_data)
make_output(result_list )<set_options> | train.drop(['Ticket', 'Cabin'], axis=1, inplace=True)
train | Titanic - Machine Learning from Disaster |
10,536,929 | %matplotlib inline
<set_options> | train = pd.get_dummies(train, columns=['Embarked', 'Sex'], prefix=['Embarked', 'Sex'], prefix_sep=' - ')
train | Titanic - Machine Learning from Disaster |
10,536,929 | rcParams['figure.figsize'] = 10,10<load_from_csv> | list_handling = train['Name'].apply(lambda x: x.split(',')[1].split('.')[0] ).value_counts()
list_handling | Titanic - Machine Learning from Disaster |
10,536,929 | data = pd.read_csv('.. /input/train.csv')
parent_data = data.copy()
ID = data.pop('id' )<categorify> | for elem in list_handling.index:
cond1 = train['Name'].str.contains(elem + '.', regex=False)
cond2 = train['Age'].isnull()
train.loc[cond1 & cond2, 'Age'] = train.loc[cond1, 'Age'].mean() | Titanic - Machine Learning from Disaster |
10,536,929 | y = data.pop('species')
y = LabelEncoder().fit(y ).transform(y)
print(y.shape )<normalization> | nans = train.isnull().sum()
nans[nans != 0] | Titanic - Machine Learning from Disaster |
10,536,929 | X = StandardScaler().fit(data ).transform(data)
print(X.shape )<categorify> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
10,536,929 | y_cat = to_categorical(y)
print(y_cat.shape )<choose_model_class> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
10,536,929 | model = Sequential()
model.add(Dense(1024,input_dim=192))
model.add(Dropout(0.2))
model.add(Activation('sigmoid'))
model.add(Dense(512))
model.add(Dropout(0.3))
model.add(Activation('sigmoid'))
model.add(Dense(99))
model.add(Activation('softmax'))<choose_model_class> | test = pd.get_dummies(test, columns=['Embarked', 'Sex'], prefix=['Embarked', 'Sex'], prefix_sep=' - ')
test.drop(['Cabin', 'Ticket'], axis=1, inplace=True)
test | Titanic - Machine Learning from Disaster |
10,536,929 | model.compile(loss='categorical_crossentropy', optimizer='rmsprop' )<train_model> | for elem in list_handling.index:
cond1 = test['Name'].str.contains(elem + '.', regex=False)
cond2 = test['Age'].isnull()
test.loc[cond1 & cond2, 'Age'] = train.loc[train['Name'].str.contains(elem + '.', regex=False), 'Age'].mean()
cond3 = test['Fare'].isnull()
test.loc[cond3, 'Fare'] = train.loc[train['Name'].str.cont... | Titanic - Machine Learning from Disaster |
10,536,929 | history = model.fit(X, y_cat, batch_size=128, nb_epoch=100, verbose=1 )<load_from_csv> | train.drop(['Name'], axis=1, inplace=True)
test.drop(['Name'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
10,536,929 | test = pd.read_csv('.. /input/test.csv' )<drop_column> | Y_train = train['Survived'].values
X_train = train.drop(['Survived'], axis=1 ).values
X_test = test.values | Titanic - Machine Learning from Disaster |
10,536,929 | index = test.pop('id' )<normalization> | import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout | Titanic - Machine Learning from Disaster |
10,536,929 | test = StandardScaler().fit_transform(test )<predict_on_test> | mean = X_train.mean(axis=0)
std = X_train.std(axis=0)
X_train -= mean
X_train /= std
X_test -= mean
X_test /= std | Titanic - Machine Learning from Disaster |
10,536,929 | yPred = model.predict_proba(test )<save_to_csv> | model = Sequential()
model.add(Dense(40, kernel_initializer='uniform', activation='relu', input_shape=(X_train.shape[1],)))
model.add(Dropout(0.5))
model.add(Dense(100, kernel_initializer='uniform', activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(40, kernel_initializer='uniform', activation='relu'))
model.... | 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.