kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
3,985,857 | def format_prediction_string(image_id, result):
prediction_strings = []
for i in range(len(result['detection_scores'])) :
class_name = result['detection_class_names'][i].decode("utf-8")
YMin,XMin,YMax,XMax = result['detection_boxes'][i]
score = result['detection_scores'][i]
prediction_strings.append(
f"{class_name} {... | df_trn.drop(['Age_na'], axis =1, inplace = True)
df_test.drop(['Age_na', 'Fare_na'], axis =1, inplace = True)
df_test.head() | Titanic - Machine Learning from Disaster |
3,985,857 | sample_image_path = ".. /input/test/6beb79b52308112d.jpg"
with tf.Graph().as_default() :
image_string_placeholder = tf.placeholder(tf.string)
decoded_image = tf.image.decode_jpeg(image_string_placeholder)
decoded_image_float = tf.image.convert_image_dtype(
image=decoded_image, dtype=tf.float32
)
image_tensor = tf.... | def rmse(x,y): return math.sqrt(((x-y)**2 ).mean())
def print_score(m):
res = [rmse(m.predict(train_X), train_y), rmse(m.predict(val_X), val_y),
m.score(train_X, train_y), m.score(val_X, val_y)]
if hasattr(m, 'oob_score_'): res.append(m.oob_score_)
print(res ) | Titanic - Machine Learning from Disaster |
3,985,857 | print(image_string_placeholder)
print(decoded_image)
print(decoded_image_float)
print(image_tensor )<load_from_csv> | train_X, val_X, train_y, val_y = train_test_split(df_trn, y_trn, test_size=0.33, random_state=42 ) | Titanic - Machine Learning from Disaster |
3,985,857 | sample_submission_df = pd.read_csv('.. /input/sample_submission.csv')
image_ids = sample_submission_df['ImageId']
predictions = []
for image_id in tqdm(image_ids):
image_path = f'.. /input/test/{image_id}.jpg'
with tf.gfile.Open(image_path, "rb")as binfile:
image_string = binfile.read()
result_out = sess.run(
detecto... | %time
m = RandomForestClassifier(n_estimators=1, min_samples_leaf=10, n_jobs=-1, max_depth = 3, oob_score=True)
m.fit(train_X, train_y)
print_score(m ) | Titanic - Machine Learning from Disaster |
3,985,857 | pred_df = pd.DataFrame(predictions)
pred_df.head()<save_to_csv> | %time
m = RandomForestClassifier(n_estimators=20, min_samples_leaf=10, max_features=0.7, n_jobs=-1, oob_score=True)
m.fit(train_X, train_y)
print_score(m ) | Titanic - Machine Learning from Disaster |
3,985,857 | pred_df.to_csv('submission.csv', index=False )<load_pretrained> | perm = PermutationImportance(m, random_state=1 ).fit(val_X, val_y)
eli5.show_weights(perm, feature_names = val_X.columns.tolist() ) | Titanic - Machine Learning from Disaster |
3,985,857 | with zipfile.ZipFile(".. /input/aerial-cactus-identification/train.zip","r")as z:
z.extractall("/kaggle/temp/")
with zipfile.ZipFile(".. /input/aerial-cactus-identification/test.zip","r")as z:
z.extractall("/kaggle/temp/test/")
print(len(os.listdir(".. /temp/train")))
print(len(os.listdir(".. /temp/test/test")) )<lo... | %time
df_trn.drop(['Embarked', 'Fare', 'Cabin', 'Parch'], axis =1, inplace = True)
df_test.drop(['Embarked', 'Fare', 'Cabin', 'Parch'], axis =1, inplace = True)
train_X, val_X, train_y, val_y = train_test_split(df_trn, y_trn, test_size=0.33, random_state=42)
m = RandomForestClassifier(n_estimators=20, min_samples_le... | Titanic - Machine Learning from Disaster |
3,985,857 | train_dir = ".. /temp/train"
test_dir = ".. /temp/test"
labels = pd.read_csv('.. /input/aerial-cactus-identification/train.csv')
labels.has_cactus = labels.has_cactus.astype(str)
print(labels['has_cactus'].value_counts() )<define_variables> | submission['Survived'] = pred
submission.to_csv('rf_submission_v2.csv', index=False ) | Titanic - Machine Learning from Disaster |
454,897 | validation_split = 0.8
idxs = np.random.permutation(range(len(labels)))< validation_split*len(labels)
train_labels = labels[idxs]
val_labels = labels[~idxs]
print(len(train_labels), len(val_labels))<define_variables> | def warn(*args, **kwargs):
pass
warnings.warn = warn | Titanic - Machine Learning from Disaster |
454,897 | train_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1/255, horizontal_flip=True, vertical_flip=True)
batch_size = 128
train_generator = train_datagen.flow_from_dataframe(train_labels,directory=train_dir,x_col='id',
y_col='has_cactus',class_mode='binary',batch_size=batch_size,
target_size=(32,32))
val_... | df_train = pd.read_csv(".. /input/train.csv")
df_test = pd.read_csv(".. /input/test.csv" ) | Titanic - Machine Learning from Disaster |
454,897 | input_shape =(32, 32, 3)
model = keras.models.Sequential()
model.add(Conv2D(32,(3, 3), padding='same', activation='relu', input_shape=input_shape))
model.add(MaxPooling2D(( 2, 2)))
model.add(Conv2D(64,(3, 3), padding='same', activation='relu'))
model.add(MaxPooling2D(( 2, 2)))
model.add(Conv2D(128,(3, 3), padding='s... | cols = ['Survived', 'Sex', 'Pclass', 'SibSp', 'Parch', 'Embarked'] | Titanic - Machine Learning from Disaster |
454,897 | model.compile(loss = keras.losses.binary_crossentropy,
optimizer = 'adam',
metrics = ['acc'])
callbacks = [EarlyStopping(monitor='val_loss', patience=20, verbose=1, restore_best_weights=True),
ReduceLROnPlateau(patience=10, verbose=1),
]<train_model> | cm_surv = ["darkgrey" , "lightgreen"] | Titanic - Machine Learning from Disaster |
454,897 | epochs = 100
history = model.fit(train_generator,
epochs = epochs,
verbose = 1,
callbacks = callbacks,
validation_data = val_generator,
)<find_best_params> | for df in [df_train, df_test] :
df['FamilySize'] = df['SibSp'] + df['Parch'] +1
df['Alone']=0
df.loc[(df.FamilySize==1),'Alone'] = 1
df['NameLen'] = df.Name.apply(lambda x : len(x))
df['NameLenBin']=np.nan
for i in range(20,0,-1):
df.loc[ df['NameLen'] <= i*5, 'NameLenBin'] = i
df['Title']=0
df['Title']=df.Name.str.ext... | Titanic - Machine Learning from Disaster |
454,897 | idx = np.argmax(history.history['val_acc'])
print(history.history['val_loss'][idx], history.history['val_acc'][idx])
idx = np.argmin(history.history['val_loss'])
print(history.history['val_loss'][idx], history.history['val_acc'][idx] )<predict_on_test> | grps_namelenbin_survrate = df_train.groupby(['NameLenBin'])['Survived'].mean().to_frame()
grps_namelenbin_survrate | Titanic - Machine Learning from Disaster |
454,897 | test_datagen = keras.preprocessing.image.ImageDataGenerator(rescale = 1/255)
test_generator = test_datagen.flow_from_directory(
directory = test_dir,
target_size =(32, 32),
batch_size = 1,
class_mode = None,
shuffle = False)
probabilities = model.predict(test_generator )<save_to_csv> | grps_title_survrate = df_train.groupby(['Title'])['Survived'].mean().to_frame()
grps_title_survrate | Titanic - Machine Learning from Disaster |
454,897 | sample_submission = pd.read_csv('.. /input/aerial-cactus-identification/sample_submission.csv')
df = pd.DataFrame({'id': sample_submission['id']})
df['has_cactus'] = probabilities
df.to_csv("submission.csv", index=False )<load_from_disk> | for df in [df_train, df_test]:
df['Title'] = df['Title'].fillna(df['Title'].mode().iloc[0])
df.loc[(df.Age.isnull())&(df.Title=='Mr'),'Age']= df.Age[df.Title=="Mr"].mean()
df.loc[(df.Age.isnull())&(df.Title=='Mrs'),'Age']= df.Age[df.Title=="Mrs"].mean()
df.loc[(df.Age.isnull())&(df.Title=='Master'),'Age']= df.Age[df.T... | Titanic - Machine Learning from Disaster |
454,897 | !unzip /kaggle/input/aerial-cactus-identification/train.zip
!unzip /kaggle/input/aerial-cactus-identification/test.zip<set_options> | df_train['Embarked'] = df_train['Embarked'].fillna(df_train['Embarked'].mode().iloc[0])
df_test['Embarked'] = df_test['Embarked'].fillna(df_test['Embarked'].mode().iloc[0])
df_train['Fare'] = df_train['Fare'].fillna(df_train['Fare'].mean())
df_test['Fare'] = df_test['Fare'].fillna(df_test['Fare'].mean() ) | Titanic - Machine Learning from Disaster |
454,897 | %matplotlib inline
<import_modules> | for df in [df_train, df_test]:
df['Age_bin']=np.nan
for i in range(8,0,-1):
df.loc[ df['Age'] <= i*10, 'Age_bin'] = i
df['Fare_bin']=np.nan
for i in range(12,0,-1):
df.loc[ df['Fare'] <= i*50, 'Fare_bin'] = i
df['Title'] = df['Title'].map({'Other':0, 'Mr': 1, 'Master':2, 'Miss': 3, 'Mrs': 4 })
df['Title'] = df['Title'... | Titanic - Machine Learning from Disaster |
454,897 | print(sys.version)
print('tensorflow -> ', tf.__version__ )<define_variables> | df_train_ml = df_train.copy()
df_test_ml = df_test.copy()
passenger_id = df_test_ml['PassengerId'] | Titanic - Machine Learning from Disaster |
454,897 | np.random.seed(12)
tf.random.set_seed(12 )<load_from_csv> | df_train_ml = pd.get_dummies(df_train_ml, columns=['Sex', 'Embarked', 'Pclass'], drop_first=True)
df_test_ml = pd.get_dummies(df_test_ml, columns=['Sex', 'Embarked', 'Pclass'], drop_first=True)
df_train_ml.drop(['PassengerId','Name','Ticket', 'Cabin', 'Age', 'Fare_bin'],axis=1,inplace=True)
df_test_ml.drop(['Passeng... | Titanic - Machine Learning from Disaster |
454,897 | main_df = pd.read_csv('/kaggle/input/aerial-cactus-identification/train.csv')
sub_df = pd.read_csv('/kaggle/input/aerial-cactus-identification/sample_submission.csv')
train_dir = '/kaggle/working/train/'
test_dir = '/kaggle/working/test/'<count_values> | df_train_ml.dropna(inplace=True ) | Titanic - Machine Learning from Disaster |
454,897 | print('shape: ', main_df.shape)
print('===================================')
print(main_df['has_cactus'].value_counts() )<split> | for df in [df_train_ml, df_test_ml]:
df.drop(['NameLen'], axis=1, inplace=True)
df.drop(['SibSp'], axis=1, inplace=True)
df.drop(['Parch'], axis=1, inplace=True)
df.drop(['Alone'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
454,897 | train_df, val_df = train_test_split(main_df, test_size=0.25, stratify=main_df['has_cactus'], shuffle=True, random_state=12)
train_df = train_df.reset_index()
val_df = val_df.reset_index()
total_train = train_df.shape[0]
total_val = val_df.shape[0]
print('total_train: {}, total_val: {}'.format(total_train, total_val))<... | df_test_ml.fillna(df_test_ml.mean() , inplace=True)
df_test_ml.head() | Titanic - Machine Learning from Disaster |
454,897 | img_width, img_height = 32, 32
target_size =(img_width, img_height)
train_datagen = ImageDataGenerator(rescale=1./255)
val_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)
train_df['has_cactus'] = train_df['has_cactus'].astype(str)
val_df['has_cactus'] = val_df['has_ca... | scaler = StandardScaler()
scaler.fit(df_train_ml.drop(['Survived'],axis=1))
scaled_features = scaler.transform(df_train_ml.drop(['Survived'],axis=1))
df_train_ml_sc = pd.DataFrame(scaled_features)
df_test_ml.fillna(df_test_ml.mean() , inplace=True)
scaled_features = scaler.transform(df_test_ml)
df_test_ml_sc = pd.Da... | Titanic - Machine Learning from Disaster |
454,897 | batch_size = 32
x_col, y_col = 'id', 'has_cactus'
class_mode = 'binary'
train_gen = train_datagen.flow_from_dataframe(train_df,
train_dir,
x_col=x_col,
y_col=y_col,
class_mode=class_mode,
target_size=target_size,
batch_size=batch_size,
)
val_gen = val_datagen.flow_from_dataframe(val_df,
train_dir,
x_col=x_col,
y_col=... | X = df_train_ml.drop('Survived', axis=1)
y = df_train_ml['Survived']
X_test = df_test_ml
X_sc = df_train_ml_sc
y_sc = df_train_ml['Survived']
X_test_sc = df_test_ml_sc | Titanic - Machine Learning from Disaster |
454,897 | input_shape =(img_width, img_height, 3)
optimizer = optimizers.Adam(lr=1e-3 )<choose_model_class> | from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn import tree
from sklearn.metrics import accuracy_score
| Titanic - Machine Learning from Disaster |
454,897 | model = Sequential()
model.add(Conv2D(filters=32, kernel_size=(3,3), padding='same', activation='relu', input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, kernel_size=(3,3), padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model... | from sklearn.model_selection import cross_val_score | Titanic - Machine Learning from Disaster |
454,897 | def step_decay(epoch):
initial_rate = 0.001
drop = 0.5
epochs_drop = 10.0
lrate = initial_rate * math.pow(drop, math.floor(( epoch)/ epochs_drop))
return lrate<choose_model_class> | svc = SVC(gamma = 0.01, C = 100)
scores_svc = cross_val_score(svc, X, y, cv=10, scoring='accuracy')
print(scores_svc)
print(scores_svc.mean() ) | Titanic - Machine Learning from Disaster |
454,897 | lrate = LearningRateScheduler(step_decay)
es = EarlyStopping(monitor='val_loss', min_delta=0, patience=5)
callbacks = [lrate, es]<train_model> | svc = SVC(gamma = 0.01, C = 100)
scores_svc_sc = cross_val_score(svc, X_sc, y_sc, cv=10, scoring='accuracy')
print(scores_svc_sc)
print(scores_svc_sc.mean() ) | Titanic - Machine Learning from Disaster |
454,897 | epochs = 30
history = model.fit(
train_gen,
epochs=epochs,
steps_per_epoch=total_train//batch_size,
validation_data=val_gen,
validation_steps=total_val//batch_size,
callbacks=callbacks,
)<predict_on_test> | rfc = RandomForestClassifier(max_depth=5, max_features=6)
scores_rfc = cross_val_score(rfc, X, y, cv=10, scoring='accuracy')
print(scores_rfc)
print(scores_rfc.mean() ) | Titanic - Machine Learning from Disaster |
454,897 | def predict(model, sub_df):
pred = np.empty(( sub_df.shape[0],))
for n in tqdm(range(sub_df.shape[0])) :
image = np.array(Image.open(test_dir + sub_df.id[n]))
pred[n] = model.predict(image.reshape(( 1, 32, 32, 3)) /255.0)[0]
sub_df['has_cactus'] = pred
return sub_df<predict_on_test> | from sklearn.model_selection import RandomizedSearchCV
from sklearn.model_selection import GridSearchCV
from scipy.stats import uniform | Titanic - Machine Learning from Disaster |
454,897 | predictions = predict(model, sub_df )<install_modules> | model = SVC()
param_grid = {'C':uniform(0.1, 5000), 'gamma':uniform(0.0001, 1)}
rand_SVC = RandomizedSearchCV(model, param_distributions=param_grid, n_iter=100)
rand_SVC.fit(X_sc,y_sc)
score_rand_SVC = get_best_score(rand_SVC ) | Titanic - Machine Learning from Disaster |
454,897 | !rm -r *<save_to_csv> | param_grid = {'C': [0.1,10, 100, 1000,5000], 'gamma': [1,0.1,0.01,0.001,0.0001], 'kernel': ['rbf']}
svc_grid = GridSearchCV(SVC() , param_grid, cv=10, refit=True, verbose=1)
svc_grid.fit(X_sc,y_sc)
sc_svc = get_best_score(svc_grid ) | Titanic - Machine Learning from Disaster |
454,897 | predictions.to_csv('submission.csv', header=True, index=False )<set_options> | pred_all_svc = svc_grid.predict(X_test_sc)
sub_svc = pd.DataFrame()
sub_svc['PassengerId'] = df_test['PassengerId']
sub_svc['Survived'] = pred_all_svc
sub_svc.to_csv('svc.csv',index=False ) | Titanic - Machine Learning from Disaster |
454,897 | %matplotlib inline
random.seed(0)
<import_modules> | knn = KNeighborsClassifier()
leaf_range = list(range(3, 15, 1))
k_range = list(range(1, 15, 1))
weight_options = ['uniform', 'distance']
param_grid = dict(leaf_size=leaf_range, n_neighbors=k_range, weights=weight_options)
print(param_grid)
knn_grid = GridSearchCV(knn, param_grid, cv=10, verbose=1, scoring='accuracy')... | Titanic - Machine Learning from Disaster |
454,897 | print("python", sys.version)
for module in np, pd, tf, keras:
print(module.__name__, module.__version__ )<import_modules> | pred_all_knn = knn_grid.predict(X_test)
sub_knn = pd.DataFrame()
sub_knn['PassengerId'] = df_test['PassengerId']
sub_knn['Survived'] = pred_all_knn
sub_knn.to_csv('knn.csv',index=False ) | Titanic - Machine Learning from Disaster |
454,897 | assert sys.version_info >=(3, 5)
assert tf.__version__ >= "2.0"<load_from_csv> | dtree = DecisionTreeClassifier()
param_grid = {'min_samples_split': [4,7,10,12]}
dtree_grid = GridSearchCV(dtree, param_grid, cv=10, refit=True, verbose=1)
dtree_grid.fit(X_sc,y_sc)
print(dtree_grid.best_score_)
print(dtree_grid.best_params_)
print(dtree_grid.best_estimator_ ) | Titanic - Machine Learning from Disaster |
454,897 | train_dir = ".. /input/cactus-dataset/cactus/train.csv"
train_data = pd.read_csv(train_dir)
train_data.has_cactus = train_data.has_cactus.astype(str )<count_values> | pred_all_dtree = dtree_grid.predict(X_test_sc)
sub_dtree = pd.DataFrame()
sub_dtree['PassengerId'] = df_test['PassengerId']
sub_dtree['Survived'] = pred_all_dtree
sub_dtree.to_csv('dtree.csv',index=False ) | Titanic - Machine Learning from Disaster |
454,897 | train_data.has_cactus.value_counts()<load_pretrained> | rfc = RandomForestClassifier()
param_grid = {'max_depth': [3, 5, 6, 7, 8], 'max_features': [6,7,8,9,10],
'min_samples_split': [5, 6, 7, 8]}
rf_grid = GridSearchCV(rfc, param_grid, cv=10, refit=True, verbose=1)
rf_grid.fit(X_sc,y_sc)
sc_rf = get_best_score(rf_grid ) | Titanic - Machine Learning from Disaster |
454,897 | img = mpimg.imread(".. /input/cactus-dataset/cactus/train/000c8a36845c0208e833c79c1bffedd1.jpg")
plt.axis("off")
imgplot = mlp.imshow(img )<create_dataframe> | pred_all_rf = rf_grid.predict(X_test_sc)
sub_rf = pd.DataFrame()
sub_rf['PassengerId'] = df_test['PassengerId']
sub_rf['Survived'] = pred_all_rf
sub_rf.to_csv('rf.csv',index=False ) | Titanic - Machine Learning from Disaster |
454,897 | def generator(train_data, directory, batch_size, target_size, class_mode):
x_col = 'id'
y_col = 'has_cactus'
train_datagen = ImageDataGenerator(
rescale = 1./255,
horizontal_flip = True,
vertical_flip = True,
validation_split = 0.2)
train_generator = train_datagen.flow_from_dataframe(
train_data,
directory = directo... | extr = ExtraTreesClassifier()
param_grid = {'max_depth': [6,7,8,9], 'max_features': [7,8,9,10],
'n_estimators': [50, 100, 200]}
extr_grid = GridSearchCV(extr, param_grid, cv=10, refit=True, verbose=1)
extr_grid.fit(X_sc,y_sc)
sc_extr = get_best_score(extr_grid ) | Titanic - Machine Learning from Disaster |
454,897 | directory = ".. /input/cactus-dataset/cactus/train"
batch_size = 64
target_size =(32,32)
class_mode = 'binary'
train_generator, valid_generator = generator(train_data, directory, batch_size, target_size, class_mode )<import_modules> | pred_all_extr = extr_grid.predict(X_test_sc)
sub_extr = pd.DataFrame()
sub_extr['PassengerId'] = df_test['PassengerId']
sub_extr['Survived'] = pred_all_extr
sub_extr.to_csv('extr.csv',index=False ) | Titanic - Machine Learning from Disaster |
454,897 | from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, Dense, Flatten, Dropout, Activation
from tensorflow.keras.layers import BatchNormalization, MaxPooling2D, GlobalAveragePooling2D<choose_model_class> | gbc = GradientBoostingClassifier()
param_grid = {'n_estimators': [50, 100],
'min_samples_split': [3, 4, 5, 6, 7],
'max_depth': [3, 4, 5, 6]}
gbc_grid = GridSearchCV(gbc, param_grid, cv=10, refit=True, verbose=1)
gbc_grid.fit(X_sc,y_sc)
sc_gbc = get_best_score(gbc_grid ) | Titanic - Machine Learning from Disaster |
454,897 | model = Sequential([
Conv2D(32,(3, 3), padding = 'same', activation = 'relu', input_shape =(32,32,3)) ,
BatchNormalization() ,
Conv2D(32,(3, 3), padding = 'same', activation = 'relu', input_shape =(32,32,3)) ,
BatchNormalization() ,
MaxPooling2D() ,
Conv2D(64,(3, 3), padding = 'same', activation = 'relu'),
BatchNormali... | pred_all_gbc = gbc_grid.predict(X_test_sc)
sub_gbc = pd.DataFrame()
sub_gbc['PassengerId'] = df_test['PassengerId']
sub_gbc['Survived'] = pred_all_gbc
sub_gbc.to_csv('gbc.csv',index=False ) | Titanic - Machine Learning from Disaster |
454,897 |
<train_model> | xgb = XGBClassifier()
param_grid = {'max_depth': [5,6,7,8], 'gamma': [1, 2, 4], 'learning_rate': [0.1, 0.2, 0.3, 0.5]}
with ignore_warnings(category=DeprecationWarning):
xgb_grid = GridSearchCV(xgb, param_grid, cv=10, refit=True, verbose=1)
xgb_grid.fit(X_sc,y_sc)
sc_xgb = get_best_score(xgb_grid ) | Titanic - Machine Learning from Disaster |
454,897 | class_weights = class_weight.compute_class_weight('balanced', np.unique(train_generator.classes), train_generator.classes)
callbacks = [EarlyStopping(monitor = 'val_loss', patience = 20),
ReduceLROnPlateau(patience = 10, verbose = 1),
ModelCheckpoint(filepath = 'best_model.h5', monitor = 'val_loss', verbose = 0, save_... | with ignore_warnings(category=DeprecationWarning):
pred_all_xgb = xgb_grid.predict(X_test_sc)
sub_xgb = pd.DataFrame()
sub_xgb['PassengerId'] = df_test['PassengerId']
sub_xgb['Survived'] = pred_all_xgb
sub_xgb.to_csv('xgb.csv',index=False ) | Titanic - Machine Learning from Disaster |
454,897 | model.load_weights("best_model.h5" )<define_variables> | ada = AdaBoostClassifier()
param_grid = {'n_estimators': [30, 50, 100], 'learning_rate': [0.08, 0.1, 0.2]}
ada_grid = GridSearchCV(ada, param_grid, cv=10, refit=True, verbose=1)
ada_grid.fit(X_sc,y_sc)
sc_ada = get_best_score(ada_grid)
pred_all_ada = ada_grid.predict(X_test_sc ) | Titanic - Machine Learning from Disaster |
454,897 | def test_gen(test_dir, target_size, batch_size, class_mode):
test_datagen = ImageDataGenerator(
rescale = 1./255)
test_generator = test_datagen.flow_from_directory(
directory = test_dir,
target_size = target_size,
batch_size = batch_size,
class_mode = class_mode,
shuffle = False)
return test_generator<define_variab... | sub_ada = pd.DataFrame()
sub_ada['PassengerId'] = df_test['PassengerId']
sub_ada['Survived'] = pred_all_ada
sub_ada.to_csv('ada.csv',index=False ) | Titanic - Machine Learning from Disaster |
454,897 | test_dir = ".. /input//cactus-dataset/cactus/test/"
target_size =(32,32)
batch_size = 1
class_mode = None
test_generator = test_gen(test_dir, target_size, batch_size, class_mode )<save_to_csv> | cat=CatBoostClassifier()
param_grid = {'iterations': [100, 150], 'learning_rate': [0.3, 0.4, 0.5], 'loss_function' : ['Logloss']}
cat_grid = GridSearchCV(cat, param_grid, cv=10, refit=True, verbose=1)
cat_grid.fit(X_sc,y_sc, verbose=False)
sc_cat = get_best_score(cat_grid)
pred_all_cat = cat_grid.predict(X_test_sc ) | Titanic - Machine Learning from Disaster |
454,897 | def submission() :
sample_submission = pd.read_csv(".. /input/cactus-dataset/cactus/sample_submission.csv")
filenames = [path.split('/')[-1] for path in test_generator.filenames]
proba = list(model.predict_generator(test_generator)[:,0])
sample_submission.id = filenames
sample_submission.has_cactus = proba
sample_sub... | sub_cat = pd.DataFrame()
sub_cat['PassengerId'] = df_test['PassengerId']
sub_cat['Survived'] = pred_all_cat
sub_cat['Survived'] = sub_cat['Survived'].astype(int)
sub_cat.to_csv('cat.csv',index=False ) | Titanic - Machine Learning from Disaster |
454,897 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import keras
import os
import cv2
from PIL import Image
from IPython.display import FileLink<load_from_csv> | lgbm = lgb.LGBMClassifier(silent=False)
param_grid = {"max_depth": [8,10,15], "learning_rate" : [0.008,0.01,0.012],
"num_leaves": [80,100,120], "n_estimators": [200,250] }
lgbm_grid = GridSearchCV(lgbm, param_grid, cv=10, refit=True, verbose=1)
lgbm_grid.fit(X_sc,y_sc, verbose=True)
sc_lgbm = get_best_score(lgbm_gri... | Titanic - Machine Learning from Disaster |
454,897 | dataset = pd.read_csv(".. /input/train.csv")
dataset.head()<groupby> | sub_lgbm = pd.DataFrame()
sub_lgbm['PassengerId'] = df_test['PassengerId']
sub_lgbm['Survived'] = pred_all_lgbm
sub_lgbm.to_csv('lgbm.csv',index=False ) | Titanic - Machine Learning from Disaster |
454,897 | grouped_dataset = dataset.groupby("has_cactus")
grouped_dataset.count()<count_values> | from sklearn.ensemble import VotingClassifier | Titanic - Machine Learning from Disaster |
454,897 | dataset.count()<prepare_x_and_y> | clf1 = LogisticRegression(random_state=1)
clf2 = RandomForestClassifier(random_state=1)
clf3 = GaussianNB()
eclf = VotingClassifier(estimators=[('lr', clf1),('rf', clf2),('gnb', clf3)], voting='soft')
params = {'lr__C': [1.0, 100.0], 'rf__n_estimators': [20, 200],}
with ignore_warnings(category=DeprecationWarning):
... | Titanic - Machine Learning from Disaster |
454,897 | def datagen(dataset=dataset, path=".. /input/train/train/"):
x = np.ones(( 17500, 224, 224, 3), dtype=np.uint8)
y = np.ones(17500)
counter = 0
for rec in dataset.values:
img = cv2.imread(path + rec[0])
img = cv2.resize(img,(32, 32))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.copyMakeBorder(img, 96, 96, 96... | clf4 = GradientBoostingClassifier()
clf5 = SVC()
clf6 = RandomForestClassifier()
eclf_2 = VotingClassifier(estimators=[('gbdt', clf4),
('svc', clf5),
('rf', clf6)], voting='soft')
params = {'gbdt__n_estimators': [50], 'gbdt__min_samples_split': [3],
'svc__C': [10, 100] , 'svc__gamma': [0.1,0.01,0.001] , 'svc__kernel... | Titanic - Machine Learning from Disaster |
454,897 | densenet = keras.applications.densenet.DenseNet169(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000 )<choose_model_class> | with ignore_warnings(category=DeprecationWarning):
pred_all_vot2 = votingclf_grid_2.predict(X_test_sc)
sub_vot2 = pd.DataFrame()
sub_vot2['PassengerId'] = df_test['PassengerId']
sub_vot2['Survived'] = pred_all_vot2
sub_vot2.to_csv('vot2.csv',index=False ) | Titanic - Machine Learning from Disaster |
454,897 | base_model = densenet.layers[-2].output
prediction = keras.layers.Dense(1, activation="sigmoid" )(base_model)
densenet_model = keras.models.Model(inputs=densenet.input, outputs=prediction)
densenet_model.compile(loss="binary_crossentropy", optimizer=keras.optimizers.Adam(lr=0.00001), metrics=["accuracy"])
densenet_m... | from mlxtend.classifier import StackingClassifier | Titanic - Machine Learning from Disaster |
454,897 | densenet_model.fit(X, Y, batch_size=16, epochs=5, verbose=1, validation_split=0.2 )<train_model> | clf1 = xgb_grid.best_estimator_
clf2 = gbc_grid.best_estimator_
clf3 = rf_grid.best_estimator_
clf4 = svc_grid.best_estimator_
lr = LogisticRegression()
st_clf = StackingClassifier(classifiers=[clf1, clf1, clf2, clf3, clf4], meta_classifier=lr)
params = {'meta_classifier__C': [0.1,1.0,5.0,10.0] ,
'use_features_in_seco... | Titanic - Machine Learning from Disaster |
454,897 | densenet_model.fit(X, Y, batch_size=16, epochs=5, verbose=1, validation_split=0.2 )<prepare_output> | with ignore_warnings(category=DeprecationWarning):
pred_all_stack = st_clf_grid.predict(X_test_sc)
sub_stack = pd.DataFrame()
sub_stack['PassengerId'] = df_test['PassengerId']
sub_stack['Survived'] = pred_all_stack
sub_stack.to_csv('stack_clf.csv',index=False ) | Titanic - Machine Learning from Disaster |
454,897 | predictions = test_pred()
predictions = pd.DataFrame(predictions, columns=["id", "has_cactus"])
predictions.head()<save_to_csv> | list_scores = [sc_knn, sc_rf, sc_extr, sc_svc, sc_gbc, sc_xgb,
sc_ada, sc_cat, sc_lgbm, sc_vot2_cv, sc_st_clf]
list_classifiers = ['KNN','RF','EXTR','SVC','GBC','XGB',
'ADA','CAT','LGBM','VOT2','STACK'] | Titanic - Machine Learning from Disaster |
454,897 | predictions.to_csv("densetmodel_submissions.csv", index=False )<load_pretrained> | score_subm_svc = 0.80861
score_subm_vot2 = 0.78947
score_subm_ada = 0.78468
score_subm_lgbm = 0.78468
score_subm_rf = 0.77990
score_subm_xgb = 0.77033
score_subm_dtree = 0.76076
score_subm_extr = 0.76076
score_subm_gbc = 0.74641
score_subm_cat = 0.74162
score_subm_knn = 0.69856
score_subm_stack = 0.76076 | Titanic - Machine Learning from Disaster |
454,897 | kf = np.load(".. /input/split-dataset/GroupMultilabelStratifiedKfold.npy", allow_pickle=True )<load_from_csv> | subm_scores = [score_subm_knn, score_subm_rf, score_subm_extr, score_subm_svc,
score_subm_gbc, score_subm_xgb, score_subm_ada, score_subm_cat,
score_subm_lgbm, score_subm_vot2, score_subm_stack] | Titanic - Machine Learning from Disaster |
454,897 | <define_variables><EOS> | predictions = {'KNN': pred_all_knn, 'RF': pred_all_rf, 'EXTR': pred_all_extr,
'SVC': pred_all_svc, 'GBC': pred_all_gbc, 'XGB': pred_all_xgb,
'ADA': pred_all_ada, 'CAT': pred_all_cat, 'LGBM': pred_all_lgbm,
'VOT2': pred_all_vot2, 'STACK': pred_all_stack}
df_predictions = pd.DataFrame(data=predictions)
df_predictions.co... | Titanic - Machine Learning from Disaster |
521,447 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<compute_test_metric> | pylab.rcParams['figure.figsize'] = 14,10
sns.set(color_codes=True ) | Titanic - Machine Learning from Disaster |
521,447 | def compute_spearmanr(trues, preds):
rhos = []
for col_true, col_pred in zip(trues.T, preds.T):
rhos.append(spearmanr(col_true, col_pred + np.random.normal(0, 1e-7, col_pred.shape[0])).correlation)
return np.mean(rhos)
<load_from_csv> | raw_train = pd.read_csv(".. /input/train.csv")
raw_test = pd.read_csv(".. /input/test.csv")
df_train = raw_train.copy()
df_test = raw_test.copy()
df_total = pd.concat([df_train, df_test])
data_cleaner = [df_train, df_test] | Titanic - Machine Learning from Disaster |
521,447 | target_columns = list(sub_df.columns)
results = []
for fold_i in range(1, 6):
result_df = pd.DataFrame(index=model_names, columns=target_columns[-30:] + ["ave"])
for model_name in model_names:
for target in target_columns[-30:]:
true = train_df[target_columns].iloc[kf[fold_i-1][1]].reset_index(drop=True)
oof = pd.re... | for df in data_cleaner:
df.drop(["PassengerId"], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
521,447 | def norm_with_rankdata(df):
for col_name in target_columns[-30:]:
df[col_name] = rankdata(df[col_name].values)/ len(df)
return df
kfold = 5
model_number = len(model_names)
true_dfs = []
for i in range(5):
oof = train_df.iloc[kf[i][1]]
true_dfs.append(oof[target_columns])
model_df = defaultdict(lambda: [])
for model... | for df in data_cleaner:
df["Age"].fillna(df_train.Age.median() , inplace=True)
df["Fare"].fillna(df_train.Fare.median() , inplace=True)
df["Embarked"].fillna(df_train.Embarked.mode() [0], inplace=True)
df["Cabin"].fillna('M', inplace=True ) | Titanic - Machine Learning from Disaster |
521,447 | sub_df = pd.read_csv(".. /input/google-quest-challenge/sample_submission.csv")
submission = np.zeros(( len(sub_df), 30)).T
FOLD_NUM = 5
inf_sub = []
for fold_num in range(FOLD_NUM):
l = []
for model_num, model_name in enumerate(model_names):
sub_ = pd.read_csv(f"{model_name}/submission{fold_num+1}.csv")
sub_ = norm_w... | print('-'*20, 'Train Set')
print(df_train.isnull().any())
print('-'*20, 'Test Set')
print(df_test.isnull().any() ) | Titanic - Machine Learning from Disaster |
521,447 | for col_num, col_name in enumerate(target_columns[-30:]):
for fold_num in range(FOLD_NUM):
for model_num in range(len(model_names)) :
coef = all_coeffs[col_num][fold_num][model_num]
submission[col_num] += coef / FOLD_NUM * inf_sub[fold_num][model_num][col_name].values
sub_df.iloc[:, -30:] = submission.T
sub_df<feature_... | for df in data_cleaner:
df["FamilyName"] = df.Name.apply(extract_name)
df["Title"] = df.Name.apply(extract_title ) | Titanic - Machine Learning from Disaster |
521,447 | def norm_sub(df):
for col_name in df.columns[-30:]:
tmp_df = df[col_name].values
v_max = np.max(tmp_df)+ 0.01
v_min = np.min(tmp_df)- 0.01
df[col_name] = df[col_name].apply(lambda x:(x - v_min)/(v_max - v_min))
df[col_name] = df[col_name].values + np.random.normal(0, 1e-7, len(df))
return df
sub_df = norm_sub(sub_df )<... | df_train.FamilyName.value_counts().head(10 ) | Titanic - Machine Learning from Disaster |
521,447 |
<compute_train_metric> | df_train['FamilyName'].value_counts() | Titanic - Machine Learning from Disaster |
521,447 | def compute_actual_spearmanr(trues, preds):
rhos = []
for col_true, col_pred in zip(trues.T, preds.T):
rhos.append(spearmanr(col_true, col_pred ).correlation)
return np.mean(rhos)
class OptimizedRounder(object):
def __init__(self, n):
self.coef_ = 0
self.n = n
def _kappa_loss(self, coef, X, y):
X_p = np.copy(X)
for ... | for df in data_cleaner:
df.drop(["FamilyName"], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
521,447 | class color:
PURPLE = '\033[95m'
CYAN = '\033[96m'
DARKCYAN = '\033[36m'
BLUE = '\033[94m'
GREEN = '\033[92m'
YELLOW = '\033[93m'
RED = '\033[91m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
END = '\033[0m'
def compute_spearmanr(trues, preds, columns=None):
rhos = []
for i,(col_true, col_pred)in enumerate(zip(trues.T, preds... | titles = df_train.Title | Titanic - Machine Learning from Disaster |
521,447 | train_df = pd.read_csv('.. /input/google-quest-challenge/train.csv')
test_df = pd.read_csv('.. /input/google-quest-challenge/test.csv')
sub_df = post_process(train_df, test_df, sub_df )<compute_test_metric> | titles.value_counts() | Titanic - Machine Learning from Disaster |
521,447 | cv_score = 0
for fold_num in range(FOLD_NUM):
fold_base = model_df[model_names[0]][fold_num].copy()
fold_base.iloc[:, -30:] = oofs[fold_num]
r = compute_spearmanr(true_dfs[fold_num].iloc[:, -30:].values, fold_base.iloc[:, -30:].values)
cv_score += r / FOLD_NUM
print(cv_score )<compute_test_metric> | miss = ["Ms", "Mlle"]
mrs = ["Mme"]
for df in data_cleaner:
df["Title"] = df.Title.apply(lambda f: 'Miss' if f in miss else f)
df["Title"] = df.Title.apply(lambda f: 'Mrs' if f in mrs else f ) | Titanic - Machine Learning from Disaster |
521,447 | cv_score = 0
for fold_num in range(FOLD_NUM):
fold_base = model_df[model_names[0]][fold_num].copy()
fold_base.iloc[:, -30:] = oofs[fold_num]
fold_base = post_process(train_df, train_df.iloc[kf[fold_num][1]].reset_index(drop=True), fold_base)
r = compute_actual_spearmanr(true_dfs[fold_num].iloc[:, -30:].values, fold_ba... | titles = df_train.Title
for df in data_cleaner:
df["Title"] = df.Title.apply(lambda f: f if f in titles.unique() and
titles.value_counts() [f] > 10 else 'Rare' ) | Titanic - Machine Learning from Disaster |
521,447 | sub_df[sub_df["question_type_spelling"] > 0]<save_to_csv> | df_train['Title'].value_counts() | Titanic - Machine Learning from Disaster |
521,447 | sub_df.to_csv("submission.csv", index=False )<import_modules> | _, fare_bins = pd.qcut(df_total['Fare'], 4, retbins=True)
fare_bins[0] -= 0.001
_, age_bins = pd.cut(df_total['Age'], 5, retbins=True)
for df in data_cleaner:
df["FareBin"] = pd.cut(df['Fare'], fare_bins)
df["AgeBin"] = pd.cut(df['Age'], age_bins ) | Titanic - Machine Learning from Disaster |
521,447 | pyLDAvis.enable_notebook()
np.random.seed(2018)
warnings.filterwarnings('ignore')
np.set_printoptions(suppress=True )<define_variables> | for df in data_cleaner:
df['IsChild'] = df['Age'] < 16 | Titanic - Machine Learning from Disaster |
521,447 | input_columns = ['question_title', 'question_body', 'answer']
targets = [
'question_asker_intent_understanding',
'question_body_critical',
'question_conversational',
'question_expect_short_answer',
'question_fact_seeking',
'question_has_commonly_accepted_answer',
'question_interestingness_others',
'question_interesting... | for df in data_cleaner:
df["FamilySize"] = df.Parch + df.SibSp +1 | Titanic - Machine Learning from Disaster |
521,447 | train = pd.read_csv('/kaggle/input/google-quest-challenge/train.csv',index_col='qa_id')
test = pd.read_csv('/kaggle/input/google-quest-challenge/test.csv',index_col='qa_id')
submission = pd.read_csv('/kaggle/input/google-quest-challenge/sample_submission.csv')
train.shape,test.shape,submission.shape<groupby> | for df in data_cleaner:
df["IsAlone"] = df["FamilySize"] == 1
df["LargeFamily"] = df["FamilySize"] >= 5 | Titanic - Machine Learning from Disaster |
521,447 |
<load_pretrained> | ticket_values = pd.concat([df_train['Ticket'], df_test['Ticket']] ).value_counts()
ticket_values.head() | Titanic - Machine Learning from Disaster |
521,447 |
<load_pretrained> | for df in data_cleaner:
df['N_ticket'] = df['Ticket'].apply(lambda f: ticket_values[f] ) | Titanic - Machine Learning from Disaster |
521,447 | %%time
def fetch_vectors(string_list, batch_size=64):
DEVICE = torch.device("cuda")
tokenizer = transformers.BertTokenizer.from_pretrained(".. /input/bertbaseuncased/bert-base-uncased/")
model = transformers.BertModel.from_pretrained(".. /input/bertbaseuncased/bert-base-uncased/")
model.to(DEVICE)
fin_features = []... | for df in data_cleaner:
df["Cabin"] = df["Cabin"].apply(lambda f: f[0] ) | Titanic - Machine Learning from Disaster |
521,447 | %%time
find = re.compile(r"^[^.]*")
train['netloc'] = train['url'].apply(lambda x: re.findall(find, urlparse(x ).netloc)[0])
test['netloc'] = test['url'].apply(lambda x: re.findall(find, urlparse(x ).netloc)[0])
features = ['netloc', 'category']
merged = pd.concat([train[features], test[features]])
ohe = OneHotEnco... | for df in data_cleaner:
df['CabinMissing'] = df.Cabin == 'M' | Titanic - Machine Learning from Disaster |
521,447 |
<load_pretrained> | for df in data_cleaner:
print('-'*20)
print(df.isnull().any() ) | Titanic - Machine Learning from Disaster |
521,447 | %%time
sys.path.insert(0, "/kaggle/input/tftext/tensorflow_text/")
embed = hub.load("/kaggle/input/useqa3/USEQA3/" )<feature_engineering> | label = LabelEncoder()
for df in data_cleaner:
df['Sex_Code'] = label.fit_transform(df['Sex'])
df['Embarked_Code'] = label.fit_transform(df['Embarked'])
df['Title_Code'] = label.fit_transform(df['Title'])
df['AgeBin_Code'] = label.fit_transform(df['AgeBin'])
df['FareBin_Code'] = label.fit_transform(df['FareBin'])
... | Titanic - Machine Learning from Disaster |
521,447 | %%time
embeddings_train = {}
embeddings_test = {}
print("preparing embeddings for train data.... ")
train['question_title']=train['question_title'].apply(lambda x:x.strip('
'))
train['question_body']=train['question_body'].apply(lambda x:x.strip('
'))
train['answer']=train['answer'].apply(lambda x:x.strip('
'))
train_... | target = ['Survived']
data_pretty = ['Age', 'Pclass', 'Title', 'Sex', 'SibSp', 'Parch', 'Fare', 'Cabin', 'Embarked',
'FamilySize', 'FareBin', 'AgeBin', 'IsAlone', 'IsChild', 'LargeFamily',
'N_ticket', 'CabinMissing']
data_numbers = ['Age', 'SibSp', 'Parch', 'Fare', 'FamilySize', 'N_ticket']
data_bins = ['AgeBin_Code', ... | Titanic - Machine Learning from Disaster |
521,447 | l2_dist = lambda x, y: np.power(x - y, 2 ).sum(axis=1)
cos_dist = lambda x, y:(x*y ).sum(axis=1)
dist_features_train = np.array([
l2_dist(embeddings_train['question_title_embedding'], embeddings_train['answer_embedding']),
l2_dist(embeddings_train['question_body_embedding'], embeddings_train['answer_embedding']),
l2_... | dummy_train = pd.get_dummies(df_train[data_pretty + target])
dummy_test = pd.get_dummies(df_test[data_pretty])
dummy_labels = dummy_test.columns.tolist()
dummy = [dummy_train, dummy_test] | Titanic - Machine Learning from Disaster |
521,447 | X_train = np.hstack(( X_train, train_question_body_dense, train_answer_dense))
X_test = np.hstack(( X_test, test_question_body_dense, test_answer_dense))
X_train.shape,X_test.shape,y_train.shape
<save_to_csv> | for x in data_pretty:
if df_train[x].dtype != 'float64' :
print('Survival Correlation by:', x)
print(df_train[[x, target[0]]].groupby(x, as_index=False ).mean())
print('-'*10, '
' ) | Titanic - Machine Learning from Disaster |
521,447 | pd.DataFrame(X_train ).to_csv('X_train_USEQA_BERTuncased.csv')
pd.DataFrame(y_train ).to_csv('y_train_USEQA_BERTuncased.csv')
pd.DataFrame(X_test ).to_csv('X_test_USEQA_BERTuncased.csv' )<prepare_x_and_y> | dummy_test['Cabin_T'] = 0 | Titanic - Machine Learning from Disaster |
521,447 | class SpearmanRhoCallback(Callback):
def __init__(self, training_data, validation_data, patience, model_name):
self.x = training_data[0]
self.y = training_data[1]
self.x_val = validation_data[0]
self.y_val = validation_data[1]
self.patience = patience
self.value = -1
self.bad_epochs = 0
self.model_name = model_name
def... | features = ['IsChild',
'IsAlone',
'LargeFamily',
'SibSp', 'Parch',
'FamilySize',
'N_ticket',
'Title_Rare',
'Sex_female',
'Age',
'Fare',
"Pclass_1", "Pclass_2",
"Embarked_C", "Embarked_S",
'AgeBin_(16.136, 32.102]', 'AgeBin_(32.102, 48.068]',
'AgeBin_(48.068, 64.034]', 'AgeBin_(64.034, 80.0]',
"FareBin_(7.896, 14.454]",... | Titanic - Machine Learning from Disaster |
521,447 | def create_model(n_dense1=256,dropout1=0.30,lr_rate=0.00003):
model = Sequential()
model.add(Dense(n_dense1, input_dim=X_train.shape[1], activation='elu'))
model.add(Dropout(dropout1))
model.add(Dense(y_train.shape[1], activation='sigmoid'))
model.compile(optimizer=tf.keras.optimizers.Adam(lr=lr_rate),loss=tf.keras.los... | train_set = dummy_train[features + target].copy()
test_set = dummy_test[features].copy()
for e in train_set.columns:
if e in data_numbers:
test_set[e] = StandardScaler().fit_transform(test_set[e].values.reshape(-1,1)).ravel()
| Titanic - Machine Learning from Disaster |
521,447 | %%time
all_predictions = []
kf = KFold(n_splits=5, random_state=42, shuffle=True)
for ind,(tr, val)in enumerate(kf.split(X_train)) :
X_tr = X_train[tr]
y_tr = y_train[tr]
X_vl = X_train[val]
y_vl = y_train[val]
model = create_model()
print(X_tr.shape,y_tr.shape,X_vl.shape,y_vl.shape)
model.fit(
X_tr, y_tr, epochs=10... | stats.chisqprob = lambda chisq, df: stats.chi2.sf(chisq, df)
for f in feature_options:
print("
", "Features: ", f)
logit_model=sm.Logit(train_set[target], train_set[f])
result=logit_model.fit()
print(result.summary())
print("-"*20)
| Titanic - Machine Learning from Disaster |
521,447 | model = create_model()
model.fit(X_train, y_train, epochs=33, batch_size=32, verbose=False)
all_predictions.append(model.predict(X_test))<train_on_grid> | features_ = features2
logit_model=sm.Logit(train_set[target], train_set[features_])
result=logit_model.fit()
print(result.summary())
print("-"*20 ) | Titanic - Machine Learning from Disaster |
521,447 | %%time
kf = KFold(n_splits=5, random_state=2019, shuffle=True)
for ind,(tr, val)in enumerate(kf.split(X_train)) :
X_tr = X_train[tr]
y_tr = y_train[tr]
X_vl = X_train[val]
y_vl = y_train[val]
model = MultiTaskElasticNet(alpha=0.001, random_state=42, l1_ratio=0.5)
model.fit(X_tr, y_tr)
all_predictions.append(model.pr... | logreg = LogisticRegression()
rfe = RFECV(logreg, 1, 10, verbose=3)
X_rfe = rfe.fit_transform(train_set[features], train_set[target] ) | Titanic - Machine Learning from Disaster |
521,447 | %%time
model = MultiTaskElasticNet(alpha=0.001, random_state=42, l1_ratio=0.5)
model.fit(X_train, y_train)
all_predictions.append(model.predict(X_test))
len(all_predictions )<prepare_output> | logit_model=sm.Logit(train_set[target], train_set[features_rfe])
result=logit_model.fit()
print(result.summary())
print("-"*20 ) | Titanic - Machine Learning from Disaster |
521,447 | %%time
test_preds = np.array([np.array([rankdata(c)for c in p.T] ).T for p in all_predictions] ).mean(axis=0)
max_val = test_preds.max() + 1
test_preds = test_preds/max_val + 1e-12<string_transform> | logit_model=sm.Logit(train_set[target], train_set[features2])
result=logit_model.fit()
print(result.summary())
print("-"*20 ) | Titanic - Machine Learning from Disaster |
521,447 | def _get_masks(tokens, max_seq_length):
if len(tokens)>max_seq_length:
raise IndexError("Token length more than max seq length!")
return [1]*len(tokens)+ [0] *(max_seq_length - len(tokens))
def _get_segments(tokens, max_seq_length):
if len(tokens)>max_seq_length:
raise IndexError("Token length more than max seq le... | X, X_test, y, y_test = train_test_split(train_set[features_].values, train_set[target].values,
test_size=0.25, stratify=train_set[target].values, random_state=42)
X.shape, X_test.shape, y.shape, y_test.shape | Titanic - Machine Learning from Disaster |
521,447 | class CustomCallback(tf.keras.callbacks.Callback):
def __init__(self, valid_data, test_data, batch_size=16, fold=None):
self.valid_inputs = valid_data[0]
self.valid_outputs = valid_data[1]
self.test_inputs = test_data
self.batch_size = batch_size
self.fold = fold
def on_train_begin(self, logs={}):
self.valid_prediction... | grid.fit(X, y.ravel() ) | 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.