kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,963,645 | train['revenue'] = train['item_price'] * train['item_cnt_day']<groupby> | name_column = 'Name'
df[name_column] = df[name_column].str.extract(', (.*?\.) ')
print(df[name_column].value_counts(dropna=False))
df = exclude_low_category(df, name_column, 10)
print(df[name_column].value_counts(dropna=False))
df, one_hot = category_to_one_hot(df, name_column)
one_hot | Titanic - Machine Learning from Disaster |
9,963,645 | cols = ['date_block_num','shop_id','item_id']
group = train.groupby(['date_block_num','shop_id','item_id'] ).agg({'item_cnt_day': ['sum']})
group.columns = ['item_cnt_month']
group.reset_index(inplace=True )<merge> | name_column = 'Sex'
print(df[name_column].value_counts(dropna=False))
df, one_hot = category_to_one_hot(df, name_column)
one_hot | Titanic - Machine Learning from Disaster |
9,963,645 | matrix = pd.merge(matrix, group, on=cols, how='left')
matrix['item_cnt_month'] =(matrix['item_cnt_month']
.astype(np.float32)
.fillna(0))<data_type_conversions> | name_column = 'Ticket'
df[name_column] = df[name_column].replace('(|^)[0-9]*', '', regex=True)
df[name_column] = df[name_column].replace('(/|\.).*', '', regex=True)
df.loc[df[name_column] == '', name_column] = None
print(df[name_column].value_counts(dropna=False))
df = exclude_low_category(df, name_column, 10)
print... | Titanic - Machine Learning from Disaster |
9,963,645 | test['date_block_num'] = 34
test['date_block_num'] = test['date_block_num'].astype(np.int8)
test['shop_id'] = test['shop_id'].astype(np.int8)
test['item_id'] = test['item_id'].astype(np.int16)
test.head()<concatenate> | name_column = 'Cabin'
df['Cabin'] = df['Cabin'].replace('.*', '', regex=True)
df['Cabin'] = df['Cabin'].replace('[0-9]*', '', regex=True)
print(df[name_column].value_counts(dropna=False))
df = exclude_low_category(df, name_column, 10)
print(df[name_column].value_counts(dropna=False))
df, one_hot = category_to_one_ho... | Titanic - Machine Learning from Disaster |
9,963,645 | matrix = pd.concat([matrix, test], ignore_index = True, keys = cols, sort = False)
matrix.fillna(0, inplace = True)
matrix.head()<merge> | name_column = 'Embarked'
print(df[name_column].value_counts(dropna=False))
df, one_hot = category_to_one_hot(df, name_column)
one_hot | Titanic - Machine Learning from Disaster |
9,963,645 | matrix = pd.merge(matrix, shop, on = 'shop_id', how = 'left')
matrix = pd.merge(matrix, item, on = 'item_id', how = 'left')
matrix = pd.merge(matrix, item_category, on = 'item_category_id', how = 'left')
matrix.head()<drop_column> | def standardize_df(df, name_column):
x = np.array(df.loc[df[name_column].notnull() , name_column])
standardized_x =(x - x.mean())/ x.std(ddof=1)
df.loc[df[name_column].notnull() , name_column] = standardized_x
df.loc[df[name_column].isnull() , name_column] = 888
return df | Titanic - Machine Learning from Disaster |
9,963,645 | matrix.drop(['ID'], axis=1, inplace=True)
matrix.head()<data_type_conversions> | name_column = 'Age'
df = standardize_df(df, name_column)
df[name_column] | Titanic - Machine Learning from Disaster |
9,963,645 | matrix['shop_city'] = matrix['shop_city'].astype(np.int8)
matrix['shop_type'] = matrix['shop_type'].astype(np.int8)
matrix['item_category_id'] = matrix['item_category_id'].astype(np.int8)
matrix['sub_name_1'] = matrix['sub_name_1'].astype(np.int16)
matrix['sub_name_2'] = matrix['sub_name_2'].astype(np.int16)
matri... | name_column = 'SibSp'
df = standardize_df(df, name_column)
df[name_column] | Titanic - Machine Learning from Disaster |
9,963,645 | matrix['month'] = matrix['date_block_num'] % 12
matrix.head()<categorify> | name_column = 'Parch'
df = standardize_df(df, name_column)
df[name_column] | Titanic - Machine Learning from Disaster |
9,963,645 | days = pd.Series([31,28,31,30,31,30,31,31,30,31,30,31])
matrix['days'] = matrix['month'].map(days ).astype(np.int8)
matrix.head()<categorify> | name_column = 'Fare'
df = standardize_df(df, name_column)
df[name_column] | Titanic - Machine Learning from Disaster |
9,963,645 | def lag_feature(df, lags, col):
tmp = df[['date_block_num','shop_id','item_id',col]]
for i in lags:
shifted = tmp.copy()
shifted.columns = ['date_block_num','shop_id','item_id', col+'_lag_'+str(i)]
shifted[col+'_lag_'+str(i)] = shifted[col+'_lag_'+str(i)].astype(np.float16)
shifted['date_block_num'] += i
df = pd.merge... | name_class = 'Survived'
y_train = np.array(df_train[name_class])
X_train = np.array(df_train.drop(name_class, axis=1))
X_test = np.array(df_test.drop(name_class, axis=1)) | Titanic - Machine Learning from Disaster |
9,963,645 | group = matrix.groupby(['date_block_num'] ).agg({'item_cnt_month': ['mean']})
group.columns = [ 'date_avg_item_cnt' ]
group.reset_index(inplace=True)
matrix = pd.merge(matrix, group, on=['date_block_num'], how='left')
matrix['date_avg_item_cnt'] = matrix['date_avg_item_cnt'].astype(np.float16)
matrix = lag_feature(... | param_grid = {
'max_depth': [5, 10, 15],
'min_samples_split': [10, 20, 30],
'n_estimators': [100, 200, 300],
'min_samples_leaf': [5, 10, 15],
'n_jobs': [4],
"bootstrap": [True],
"criterion": ["entropy"]
}
grid = GridSearchCV(estimator=RandomForestClassifier(random_state=0),
param_grid=param_grid,
scoring="accuracy",
cv... | Titanic - Machine Learning from Disaster |
9,963,645 |
<merge> | best_model = grid.best_estimator_
y_pred = best_model.predict(X_test)
y_pred = np.array(y_pred, dtype=np.int ) | Titanic - Machine Learning from Disaster |
9,963,645 | group = matrix.groupby(['date_block_num','shop_id'] ).agg({'item_cnt_month': ['mean']})
group.columns = [ 'date_shop_avg_item_cnt' ]
group.reset_index(inplace=True)
matrix = pd.merge(matrix, group, on=['date_block_num', 'shop_id'], how='left')
matrix['date_shop_avg_item_cnt'] = matrix['date_shop_avg_item_cnt'].astyp... | submission_df = pd.DataFrame({'PassengerId': id_test, 'Survived': y_pred})
submission_df.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
9,850,979 |
<merge> | %matplotlib inline
np.random.seed(0)
sns.set_palette('pastel' ) | Titanic - Machine Learning from Disaster |
9,850,979 | group = matrix.groupby(['date_block_num','item_id'] ).agg({'item_cnt_month': ['mean']})
group.columns = [ 'date_item_avg_item_cnt' ]
group.reset_index(inplace=True)
matrix = pd.merge(matrix, group, on=['date_block_num', 'item_id'], how='left')
matrix['date_item_avg_item_cnt'] = matrix['date_item_avg_item_cnt'].astyp... | train = pd.read_csv(r'/kaggle/input/titanic/train.csv')
test = pd.read_csv(r'/kaggle/input/titanic/test.csv')
train.tail() | Titanic - Machine Learning from Disaster |
9,850,979 |
<merge> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
9,850,979 |
<merge> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
9,850,979 |
<merge> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
9,850,979 |
<merge> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
9,850,979 |
<merge> | avg_age_train =(train.groupby("Sex")['Age'] ).mean()
print(avg_age_train)
avg_age_test =(test.groupby("Sex")['Age'] ).mean()
print(avg_age_test ) | Titanic - Machine Learning from Disaster |
9,850,979 |
<merge> | for i in range(len(train['Age'])) :
if train['Age'].isnull() [i] == True and train['Sex'][i] == 'male':
train['Age'][i] = np.round(avg_age_train['male'],decimals=1)
elif train['Age'].isnull() [i] == True and train['Sex'][i] == 'female':
train['Age'][i] = np.round(avg_age_train['female'],decimals=1)
for i in range(len... | Titanic - Machine Learning from Disaster |
9,850,979 |
<merge> | train = train.reset_index(drop=True)
test = test.reset_index(drop=True ) | Titanic - Machine Learning from Disaster |
9,850,979 |
<merge> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
9,850,979 |
<merge> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
9,850,979 |
<merge> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
9,850,979 |
<prepare_x_and_y> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
9,850,979 | X_train = matrix[matrix.date_block_num <= 33].drop(['item_cnt_month'], axis=1)
Y_train = matrix[matrix.date_block_num <= 33]['item_cnt_month']
X_valid = matrix[matrix.date_block_num == 33].drop(['item_cnt_month'], axis=1)
Y_valid = matrix[matrix.date_block_num == 33]['item_cnt_month']
X_test = matrix[matrix.date_bloc... | Y = train['Survived']
train = train.drop('Survived',axis=1)
data = pd.concat([train,test],axis=0)
data.head() | Titanic - Machine Learning from Disaster |
9,850,979 | model = XGBRegressor(
max_depth=8,
n_estimators=1000,
min_child_weight=300,
colsample_bytree=0.8,
subsample=0.8,
eta=0.3,
seed=42)
model.fit(
X_train,
Y_train,
eval_metric="rmse",
eval_set=[(X_train, Y_train),(X_valid, Y_valid)],
verbose=True,
early_stopping_rounds = 10 )<save_to_csv> | avg_fare = data.groupby("Sex")['Fare'].mean()
avg_fare | Titanic - Machine Learning from Disaster |
9,850,979 | Y_test = model.predict(X_test ).clip(0, 20)
submission = pd.DataFrame({
"ID": test.index,
"item_cnt_month": Y_test
})
submission.to_csv('submission.csv', index=False )<import_modules> | print("Index of the null value is: ",test[test['Fare'].isnull() ].index.tolist())
print(test['Sex'][152] ) | Titanic - Machine Learning from Disaster |
9,850,979 | def get_imports() :
for name, val in globals().items() :
if isinstance(val, types.ModuleType):
name = val.__name__.split(".")[0]
elif isinstance(val, type):
name = val.__module__.split(".")[0]
if name == "PIL":
name = "Pillow"
elif name == "sklearn":
name = "scikit-learn"
yield name
imports = list(set(get_imports()))
r... | data['Fare'][152] = avg_fare['male'] | Titanic - Machine Learning from Disaster |
9,850,979 | data = pd.read_pickle('.. /input/eda-preprocessing-feature-engineering/all_data.pkl')
data = data[data.date_block_num > 5]
test = pd.read_csv('.. /input/competitive-data-science-predict-future-sales/test.csv' ).set_index('ID')
dropcols = [
"item_cnt_month_lag_12",
"item_cnt_month_lag_12_adv",
"date_item_target_enc_la... | data.isnull().sum() | Titanic - Machine Learning from Disaster |
9,850,979 | start_time = time.time()
model = XGBRegressor(
max_depth=10,
n_estimators=1500,
min_child_weight=0.5,
colsample_bytree=0.8,
subsample=0.7,
eta=0.01,
tree_method='gpu_hist',
seed=0)
model.fit(
X_train,
Y_train,
eval_metric="rmse",
eval_set=[(X_train, Y_train),(X_valid, Y_valid)],
verbose=True,
early_stopping_rounds =... | data.isnull().sum() | Titanic - Machine Learning from Disaster |
9,850,979 | start_time = time.time()
Y_test = model.predict(X_test ).clip(0, 20)
print(f"predicting on test set took {time.time() - start_time}s")
start_time = time.time()
Y_train_pred = model.predict(X_train ).clip(0, 20)
print(f"Predicting on train set took {time.time() - start_time} s")
start_time = time.time()
Y_valid_pred... | print("Number of duplicate rows in the train dataset :",train.duplicated().sum())
print("Number of duplicate rows in the test dataset :",test.duplicated().sum() ) | Titanic - Machine Learning from Disaster |
9,850,979 | dump(model, 'xgb_model.joblib' )<import_modules> | Name_title_data = data['Name'].str.extract('([A-Za-z]+)\.', expand=False)
print(Name_title_data)
data['Name_title'] = Name_title_data
data = data.reset_index(drop=True)
data.head() | Titanic - Machine Learning from Disaster |
9,850,979 | import matplotlib.pyplot as plt
import tensorflow as tf<import_modules> | age_group_data = [None] * len(data['Age'])
for i in range(len(data['Age'])) :
if data['Age'][i] <= 3:
age_group_data[i] = 'Baby'
elif data['Age'][i] >3 and data['Age'][i] <= 13:
age_group_data[i] = 'Child'
elif data['Age'][i] >13 and data['Age'][i] <= 19:
age_group_data[i] = 'Teenager'
elif data['Age'][i] >19 and data... | Titanic - Machine Learning from Disaster |
9,850,979 | tf.__version__<load_from_csv> | data['Is_Married'] = 0
data['Is_Married'].loc[data['Name_title'] == 'Mrs'] = 1
data['FamSize'] = data['SibSp'] + data['Parch'] + 1
data['Single'] = data['FamSize'].map(lambda s: 1 if s == 1 else 0 ) | Titanic - Machine Learning from Disaster |
9,850,979 | dataset_training = pd.read_csv("/kaggle/input/sf-crime/train.csv.zip")
dataset_test = pd.read_csv("/kaggle/input/sf-crime/test.csv.zip" )<data_type_conversions> | np.unique(data['Ticket'])
tic = data.groupby('Ticket',sort=True,group_keys=True)
groups = list(tic.groups)
togther = [None] * len(data['Ticket'])
k=0
for i in range(len(groups)) :
for j in range(len(data['Ticket'])) :
if data['Ticket'][j] == groups[i]:
togther[j] = i
data['Togther'] = togther | Titanic - Machine Learning from Disaster |
9,850,979 | dataset_training_new = dataset_training.drop(['Category', 'Descript', 'Resolution'], axis=1)
dataset_test_new = dataset_test.drop('Id', axis=1)
dataset_training_new['Dates'] = pd.to_datetime(dataset_training_new['Dates'])
dataset_test_new['Dates'] = pd.to_datetime(dataset_test_new['Dates'] )<feature_engineering> | rates = [None]*len(data['Fare'])
for i in range(len(data['Fare'])) :
if data['Fare'][i]<=10:
rates[i] = 1
elif data['Fare'][i] >10 and data['Fare'][i]<=30:
rates[i] = 2
elif data['Fare'][i] >30 and data['Fare'][i]<=70:
rates[i] = 3
elif data['Fare'][i] >70 and data['Fare'][i]<=100:
rates[i] = 4
else:
rates[i] = 5
data... | Titanic - Machine Learning from Disaster |
9,850,979 | dataset_training_new['Year'] = dataset_training_new['Dates'].dt.year
dataset_test_new['Year'] = dataset_test_new['Dates'].dt.year
dataset_training_new['Month'] = dataset_training_new['Dates'].dt.month
dataset_test_new['Month'] = dataset_test_new['Dates'].dt.month
dataset_training_new['Day'] = dataset_training_new['Date... | data['Cabin_present'] = 1
data['Cabin_present'].loc[data['Cabin'].isnull() ] = 0 | Titanic - Machine Learning from Disaster |
9,850,979 | ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder() , [0])], remainder='passthrough')
X = np.array(ct.fit_transform(dataset_training_new))
X_submission = np.array(ct.transform(dataset_test_new))<categorify> | data = data.drop('Cabin',axis=1)
data = data.drop('Ticket',axis=1)
data = data.drop('Name',axis=1)
data = data.drop('PassengerId',axis=1 ) | Titanic - Machine Learning from Disaster |
9,850,979 | y = dataset_training['Category'].values
ohe = OneHotEncoder(sparse=False)
y = ohe.fit_transform(y.reshape(-1, 1))
y.shape<split> | data_ohe = pd.get_dummies(data,drop_first=True)
data_ohe.head() | Titanic - Machine Learning from Disaster |
9,850,979 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 1 )<normalization> | train['Survived'] = Y | Titanic - Machine Learning from Disaster |
9,850,979 | sc = MinMaxScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test )<train_model> | train = train.drop('Survived',axis=1 ) | Titanic - Machine Learning from Disaster |
9,850,979 | ann = tf.keras.models.Sequential()
ann.add(tf.keras.layers.Dense(units=200, activation='relu'))
ann.add(tf.keras.layers.Dense(units=200, activation='relu'))
ann.add(tf.keras.layers.Dense(units=200, activation='relu'))
ann.add(tf.keras.layers.Dense(units=200, activation='relu'))
ann.add(tf.keras.layers.Dense(units=39, a... | train_ohe = data_ohe[:train.shape[0]]
test_ohe = data_ohe[train.shape[0]:] | Titanic - Machine Learning from Disaster |
9,850,979 | X_submission = sc.transform(X_submission)
y_pred = ann.predict(X_submission)
m = np.max(y_pred, axis=1 ).reshape(-1, 1)
predicted = np.array(( y_pred == m), dtype='int32')
col_names = ohe.categories_[0]
df_submission = pd.DataFrame()
for i, entry in enumerate(col_names):
df_submission[entry] = predicted[:,i]
df_sub... | X_train,X_test,Y_train,Y_test = train_test_split(train_ohe,Y,test_size=0.2 ) | Titanic - Machine Learning from Disaster |
9,850,979 | df_submission.to_csv('Submission.csv' )<set_options> | predictions = gbdt.predict(test_ohe)
predictions.shape | Titanic - Machine Learning from Disaster |
9,850,979 | %matplotlib inline
sns.set()<load_from_csv> | submit = pd.DataFrame(test['PassengerId'],columns=['PassengerId'])
submit['Survived'] = predictions
submit.head() | Titanic - Machine Learning from Disaster |
9,850,979 | train = pd.read_csv(".. /input/sf-crime/train.csv.zip")
test = pd.read_csv(".. /input/sf-crime/test.csv.zip" )<count_missing_values> | submit.to_csv("Submissions.csv",index=False)
print("Finished saving the file" ) | Titanic - Machine Learning from Disaster |
9,163,415 | print(len(train[train['Category'].isnull() ]))
train = train[train['Category'].isnull() == False]
print(len(train[train['Category'].isnull() ]))
print(len(test))<count_missing_values> | train_data = pd.read_csv("/kaggle/input/titanic/train.csv")
train_data.head() | Titanic - Machine Learning from Disaster |
9,163,415 | train.isnull().sum()<count_missing_values> | test_data = pd.read_csv("/kaggle/input/titanic/test.csv")
test_data.head() | Titanic - Machine Learning from Disaster |
9,163,415 | train.isnull().sum()<drop_column> | missing_data=train_data.isnull().sum()
missing_data | Titanic - Machine Learning from Disaster |
9,163,415 | if 'Descript' in train:
train = train.drop(['Descript'], axis=1)
if 'Resolution' in train:
train = train.drop(['Resolution'], axis=1)
train.head()<feature_engineering> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
9,163,415 | def rebuild_datetime(df):
df['Dates'] = pd.to_datetime(df['Dates'])
df['Date'] = df['Dates'].dt.date
df['Hour'] = df['Dates'].dt.hour
df['Minute'] = df['Dates'].dt.minute
df['DayOfWeek'] = df['Dates'].dt.weekday
df['Month'] = df['Dates'].dt.month
df['Year'] = df['Dates'].dt.year
df['Block'] = df['Address'].str.contain... | train_data.drop(['Name','Ticket','Cabin'],axis=1,inplace=True)
test_data.drop(['Name','Ticket','Cabin'],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
9,163,415 | wrongxycnt = lambda df : len(df[(df['X'] == -120.5)&(df['Y'] == 90.0)])
print(wrongxycnt(train))
print(wrongxycnt(test))
def fix_gps(df):
cnt = 0
d = df[(df['X'] == -120.5)&(df['Y'] == 90.0)]
for idx, row in d.iterrows() :
district = row['PdDistrict']
xys = df[df['PdDistrict'] == district][['X', 'Y']]
df.loc[idx, ['X'... | train_data.isnull().sum()
train_data.head() | Titanic - Machine Learning from Disaster |
9,163,415 | if 'Address' in train:
train = train.drop(['Address'], axis=1)
if 'Address' in test:
test = test.drop(['Address'], axis=1 )<drop_column> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
9,163,415 | if 'Dates' in train:
train = train.drop(['Dates'], axis=1)
if 'Date' in train:
train = train.drop(['Date'], axis=1)
if 'Dates' in test:
test = test.drop(['Dates'], axis=1)
if 'Date' in test:
test = test.drop(['Date'], axis=1)
<drop_column> | train_data['Age'] = train_data['Age'].fillna(train_data['Age'].mean())
test_data['Age'] = test_data['Age'].fillna(test_data['Age'].mean())
test_data['Fare'] = test_data['Fare'].fillna(test_data['Fare'].median() ) | Titanic - Machine Learning from Disaster |
9,163,415 | if 'DoWN' in train:
train = train.drop(['DoWN'], axis=1)
if 'DoWN' in test:
test = test.drop(['DoWN'], axis=1)
if 'datetime' in train:
train = train.drop(['datetime'], axis=1)
if 'Year' in train:
train = train.drop(['Year'], axis=1)
if 'datetime' in test:
test = test.drop(['datetime'], axis=1)
if 'Year' in test:
t... | train_data.dropna(subset = ["Embarked"], inplace=True ) | Titanic - Machine Learning from Disaster |
9,163,415 | test_ids = test['Id'].astype('int' )<drop_column> | train_data = pd.get_dummies(train_data, columns=["Sex"], drop_first=True)
train_data = pd.get_dummies(train_data, columns=["Embarked"],drop_first=True ) | Titanic - Machine Learning from Disaster |
9,163,415 | if "Id" in test:
test = test.drop(['Id'], axis=1 )<define_variables> | test_data = pd.get_dummies(test_data, columns=["Sex"], drop_first=True)
test_data = pd.get_dummies(test_data, columns=["Embarked"],drop_first=True ) | Titanic - Machine Learning from Disaster |
9,163,415 | train_category = train['Category']<categorify> | y = train_data["Survived"]
X = train_data.drop(['Survived'], axis=1 ) | Titanic - Machine Learning from Disaster |
9,163,415 | if 'Category' in train:
train = train.drop(['Category'], axis=1)
train_X = train
categoricals = ["PdDistrict"]
le_pdDistrict = LabelEncoder()
train_X['PdDistrict'] = le_pdDistrict.fit_transform(train_X['PdDistrict'])
test['PdDistrict'] = le_pdDistrict.transform(test['PdDistrict'])
le_category = LabelEncoder()
train_... | sc=StandardScaler()
sc.fit(train_data.drop(['Survived', 'PassengerId'], axis = 1))
X_train = sc.transform(train_data.drop(['Survived', 'PassengerId'], axis = 1))
X_train | Titanic - Machine Learning from Disaster |
9,163,415 | def show_feature_importance(df_X, df_Y):
params = {
'n_estimators' : 3,
'learning_rate' : 0.4,
'max_delta_step' : 0.9,
'min_data_in_leaf' : 21,
'max_bin' : 465,
'num_leaves' : 41,
}
_train_X, _val_X, _train_y, _val_y = train_test_split(df_X, df_Y)
model = LGBMClassifier(objective='multiclass', num_class=num_category, ... | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.23, random_state = 5)
model_LR = LogisticRegression(max_iter=5000)
model_LR.fit(X_train, y_train)
LR_predict = model_LR.predict(X_test)
LR_score = model_LR.score(X_test,y_test)
model_X = XGBClassifier(eta=0.1, n_estimators=50,
max_depth=5, sub... | Titanic - Machine Learning from Disaster |
9,163,415 | n_splits = 8
def get_param(learning_rate, max_delta_step, min_data_in_leaf, max_bin, num_leaves):
params = {'n_estimators' : 400,
'boosting_type' : 'gbdt',
'objective' : 'multiclass',
'max_delta_step': max_delta_step,
'min_data_in_leaf': int(min_data_in_leaf),
'max_bin': int(max_bin),
'num_leaves': int(num_leaves),
'le... | gnb= GaussianNB()
gnb.fit(X_train, y_train)
prediction = gnb.predict(X_test)
cross_scores = cross_val_score(gnb,X_train,y_train,cv=8)
print(cross_scores)
sns.distplot(a=cross_scores, kde=True)
plt.legend() | Titanic - Machine Learning from Disaster |
9,163,415 | def predict(models, test):
preds = []
for model in models:
pred = model.predict(test)
preds.append(pred)
predsCnt = len(preds)
preds = np.array(preds)
preds = np.sum(preds, axis=0)/ predsCnt
return preds
pred = predict(models, test)
submission = pd.DataFrame(pred, columns=le_category.inverse_transform(np.linspace(... | neigh= KNeighborsClassifier(n_neighbors=5, leaf_size=30)
neigh.fit(X_train, y_train)
KN_predict = neigh.predict(X_test)
cross_scores = cross_val_score(neigh,X_train,y_train,cv=8)
print(cross_scores)
print(accuracy_score(KN_predict, y_test)) | Titanic - Machine Learning from Disaster |
9,163,415 | warnings.filterwarnings("ignore")
train = pd.read_csv('.. /input/train.csv', parse_dates=['Dates'])
test = pd.read_csv('.. /input/test.csv', parse_dates=['Dates'], index_col='Id')
train['Date'] = pd.to_datetime(train['Dates'].dt.date)
train['n_days'] =(train['Date'] - train['Date'].min() ).apply(lambda x: x.days)
... | predictions = model_X.predict(test_data)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('my_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
8,842,033 | import pandas as pd
import numpy as np
import torch
from torch import nn
from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA<set_options> | train = pd.read_csv(".. /input/titanic/train.csv")
train.head() | Titanic - Machine Learning from Disaster |
8,842,033 | torch.cuda.is_available()<load_from_csv> | test = pd.read_csv(".. /input/titanic/test.csv")
test.head() | Titanic - Machine Learning from Disaster |
8,842,033 | train_data = pd.read_csv('/kaggle/input/sf-crime/train.csv.zip', parse_dates=['Dates'])
test_data = pd.read_csv('/kaggle/input/sf-crime/test.csv.zip', parse_dates=['Dates'] )<feature_engineering> | all = pd.concat([train, test], sort = False)
all.info() | Titanic - Machine Learning from Disaster |
8,842,033 | all_features = pd.concat(( train_data.iloc[:, [0, 3, 4, 6, 7, 8]],
test_data.iloc[:, [1, 2, 3, 4, 5, 6]]),
sort=False)
num_train = train_data.shape[0]
train_labels = pd.get_dummies(train_data['Category'] ).values
num_outputs = train_labels.shape[1]
all_features['year'] = all_features.Dates.dt.year
all_features['month'... | all['Age'] = all['Age'].fillna(value=all['Age'].median())
all['Fare'] = all['Fare'].fillna(value=all['Fare'].median() ) | Titanic - Machine Learning from Disaster |
8,842,033 | class Residual(nn.Module):
def __init__(self, num_inputs, num_outputs):
super(Residual, self ).__init__()
self.middle_L = nn.Linear(num_inputs, num_outputs)
self.middle_R = nn.ReLU(num_outputs)
if num_inputs != num_outputs:
self.right = nn.Linear(num_inputs, num_outputs)
else:
self.right = None
self.middle_B = nn.Ba... | all.loc[ all['Age'] <= 16, 'Age'] = 0
all.loc[(all['Age'] > 16)&(all['Age'] <= 32), 'Age'] = 1
all.loc[(all['Age'] > 32)&(all['Age'] <= 48), 'Age'] = 2
all.loc[(all['Age'] > 48)&(all['Age'] <= 64), 'Age'] = 3
all.loc[ all['Age'] > 64, 'Age'] = 4 | Titanic - Machine Learning from Disaster |
8,842,033 | class build_model(nn.Module):
def __init__(self, num_inputs, num_outputs, dp=0.5):
super(build_model, self ).__init__()
self.net = nn.Sequential()
self.net.add_module('Residual1', Residual(num_inputs, 1024))
self.net.add_module('Residual2', Residual(1024, 512))
self.net.add_module('Residual3', Residual(512, 512))
self.... | all['Title'] = all['Name'].apply(get_title)
all['Title'].value_counts() | Titanic - Machine Learning from Disaster |
8,842,033 | class MultiClassLogLoss(torch.nn.Module):
def __init__(self):
super(MultiClassLogLoss, self ).__init__()
def forward(self, y_pred, y_true):
return -(y_true *
torch.log(y_pred.float() + 1.00000000e-15)) / y_true.shape[0]
loss = MultiClassLogLoss().cuda()<find_best_params> | all['Title'] = all['Title'].replace(['Capt.', 'Dr.', 'Major.', 'Rev.'], 'Officer.')
all['Title'] = all['Title'].replace(['Lady.', 'Countess.', 'Don.', 'Sir.', 'Jonkheer.', 'Dona.'], 'Royal.')
all['Title'] = all['Title'].replace(['Mlle.', 'Ms.'], 'Miss.')
all['Title'] = all['Title'].replace(['Mme.'], 'Mrs.')
all['Ti... | Titanic - Machine Learning from Disaster |
8,842,033 | def make_iter(train_features, train_labels, batch_size):
train_features = torch.tensor(train_features, dtype=torch.float ).cuda()
train_labels = torch.tensor(train_labels ).cuda()
dataset = torch.utils.data.TensorDataset(train_features, train_labels)
return torch.utils.data.DataLoader(dataset, batch_size, shuffle=True... | all['Cabin'] = all['Cabin'].fillna('Missing')
all['Cabin'] = all['Cabin'].str[0]
all['Cabin'].value_counts() | Titanic - Machine Learning from Disaster |
8,842,033 | num_epochs = 100
k_fold_num = 5
batch_size = 128
lr = 0.001
k_fold = False<choose_model_class> | all['Family_Size'] = all['SibSp'] + all['Parch'] + 1
all['IsAlone'] = 0
all.loc[all['Family_Size']==1, 'IsAlone'] = 1
all.head() | Titanic - Machine Learning from Disaster |
8,842,033 | optimizer = torch.optim.Adam(net.parameters() , lr=lr )<split> | all_1 = all.drop(['Name', 'Ticket'], axis = 1)
all_1.head() | Titanic - Machine Learning from Disaster |
8,842,033 | if k_fold:
kf = KFold(n_splits=k_fold_num, shuffle=True)
for epoch in range(num_epochs):
fold_num = 0
for train_index, test_index in kf.split(train_features):
X_train, X_test = train_features[train_index], train_features[
test_index]
y_train, y_test = train_labels[train_index], train_labels[
test_index]
print('第%d轮的第%... | all_dummies = pd.get_dummies(all_1)
all_dummies.info() | Titanic - Machine Learning from Disaster |
8,842,033 | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns<load_from_csv> | all_test = all_dummies[all_dummies['Survived'].isna() ]
all_test.info() | Titanic - Machine Learning from Disaster |
8,842,033 | train_data = pd.read_csv("/kaggle/input/sf-crime/train.csv")
test_data = pd.read_csv("/kaggle/input/sf-crime/test.csv" )<count_missing_values> | X_train, X_test, y_train, y_test = train_test_split(all_train.drop(['PassengerId','Survived'],axis=1),
all_train['Survived'], test_size=0.30,
random_state=101 ) | Titanic - Machine Learning from Disaster |
8,842,033 | print(train_data.isnull().sum())
print(test_data.isnull().sum() )<drop_column> | from sklearn.ensemble import RandomForestClassifier | Titanic - Machine Learning from Disaster |
8,842,033 | train_data = train_data.drop(["Descript", "Resolution"], axis = 1 )<feature_engineering> | RF_Model = RandomForestClassifier() | Titanic - Machine Learning from Disaster |
8,842,033 | def transformDataset(dataset):
dataset['Dates'] = pd.to_datetime(dataset['Dates'])
dataset['Date'] = dataset['Dates'].dt.date
dataset['n_days'] =(dataset['Date'] - dataset['Date'].min() ).apply(lambda x: x.days)
dataset['Year'] = dataset['Dates'].dt.year
dataset['DayOfWeek'] = dataset['Dates'].dt.dayofweek
dataset['W... | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
8,842,033 | train_data = transformDataset(train_data )<create_dataframe> | from sklearn.model_selection import GridSearchCV | Titanic - Machine Learning from Disaster |
8,842,033 | test_data = transformDataset(test_data )<categorify> | parameters = {'n_estimators' :(10,30,50,70,90,100)
, 'criterion' :('gini', 'entropy')
, 'max_depth' :(3,5,7,9,10)
, 'max_features' :('auto', 'sqrt')
, 'min_samples_split' :(2,4,6)
} | Titanic - Machine Learning from Disaster |
8,842,033 | le = LabelEncoder()
train_data["Category"] = le.fit_transform(train_data["Category"])
<prepare_x_and_y> | RF_grid = GridSearchCV(RandomForestClassifier(n_jobs = -1, oob_score= False), param_grid = parameters, cv = 3, verbose = True ) | Titanic - Machine Learning from Disaster |
8,842,033 | X = train_data.drop("Category",axis=1 ).values
y = train_data["Category"].values<split> | RF_grid_model = RF_grid.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
8,842,033 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.10 )<train_model> | RF_grid_model.best_estimator_ | Titanic - Machine Learning from Disaster |
8,842,033 | dtree = DecisionTreeClassifier()
dtree.fit(X_train,y_train )<predict_on_test> | RF_Model = RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,
criterion='gini', max_depth=7, max_features='sqrt',
max_leaf_nodes=None, max_samples=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=1, min_samples_split=6,
min_weight_fraction_leaf=0.0, n_estimators=10, n_job... | Titanic - Machine Learning from Disaster |
8,842,033 | predictions = dtree.predict(X_test)
<compute_test_metric> | RF_Model.fit(X_train, y_train ) | Titanic - Machine Learning from Disaster |
8,842,033 | print(classification_report(y_test,predictions))<train_model> | predictions = RF_Model.predict(X_test)
predictions | Titanic - Machine Learning from Disaster |
8,842,033 | rfc = RandomForestClassifier(n_estimators=40,min_samples_split=100)
rfc.fit(X_train, y_train )<predict_on_test> | print(f'Test : {RF_Model.score(X_test, y_test):.3f}')
print(f'Train : {RF_Model.score(X_train, y_train):.3f}' ) | Titanic - Machine Learning from Disaster |
8,842,033 | rfc_pred = rfc.predict(X_test)
print(classification_report(y_test,rfc_pred))<categorify> | TestForPred = all_test.drop(['PassengerId', 'Survived'], axis = 1 ) | Titanic - Machine Learning from Disaster |
8,842,033 | keys = le.classes_
values = le.transform(le.classes_)
keys<define_variables> | t_pred = RF_Model.predict(TestForPred ).astype(int ) | Titanic - Machine Learning from Disaster |
8,842,033 | dictionary = dict(zip(keys, values))
print(dictionary )<drop_column> | PassengerId = all_test['PassengerId'] | Titanic - Machine Learning from Disaster |
8,842,033 | test_data = test_data.drop('Id', 1 )<predict_on_test> | RF_Sub = pd.DataFrame({'PassengerId': PassengerId, 'Survived':t_pred })
RF_Sub.head() | Titanic - Machine Learning from Disaster |
8,842,033 | y_pred_proba = rfc.predict_proba(test_data)
y_pred_proba<prepare_output> | RF_Sub.to_csv("RF_Class_Submission.csv", index = False ) | Titanic - Machine Learning from Disaster |
10,886,131 | result = pd.DataFrame(y_pred_proba, columns=keys)
result.head()<save_to_csv> | data_train = pd.read_csv('/kaggle/input/titanic/train.csv')
data_test = pd.read_csv('/kaggle/input/titanic/test.csv')
data = pd.concat([data_train, data_test], ignore_index=True, sort=False ) | Titanic - Machine Learning from Disaster |
10,886,131 | result.to_csv(path_or_buf="rfc_predict_4.csv",index=True, index_label = 'Id' )<load_from_csv> | pClass_1 = round(
(data_train[data_train.Pclass == 1].Survived == 1 ).value_counts() [1] /
len(data_train[data_train.Pclass == 1])* 100, 2)
pClass_2 = round(
(data_train[data_train.Pclass == 2].Survived == 1 ).value_counts() [1] /
len(data_train[data_train.Pclass == 2])* 100, 2)
pClass_3 = round(
(data_train[data_tra... | Titanic - Machine Learning from Disaster |
10,886,131 |
<load_from_csv> | data['Family'] = data.Parch + data.SibSp
data['IsAlone'] = data.Family == 0
data['SmallFamily'] = data['Family'].map(lambda s: 1 if 1 <= s <= 3 else 0)
data['BigFamily'] = data['Family'].map(lambda s: 1 if 4 <= s else 0 ) | Titanic - Machine Learning from Disaster |
10,886,131 | pd.options.display.max_columns=100
train = pd.read_csv('.. /input/train.csv', parse_dates=['Dates'])
test = pd.read_csv('.. /input/test.csv', parse_dates=['Dates'], index_col='Id')
def feature_engineering(data):
data['Date'] = pd.to_datetime(data['Dates'].dt.date)
data['n_days'] =(data['Date'] - data['Date'].min() )... | data['Salutation'] = data.Name.apply(lambda name: name.split(',')[1].split('.')[0].strip())
print(data.Salutation.unique())
data.Salutation.nunique() | 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.