kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
972,273 | def predict(Xp, catp, thres):
pred = np.zeros(len(Xp))
for i in range(6):
bins = [-99.0] + list(np.sort(thres[i])) + [99.0]
pred[catp==i] = np.digitize(Xp[catp==i], bins)-1
return pred
def calculate_matrix(transition_matrix, states, number_processes):
for i in range(transition_matrix.shape[0]):
transition_matrix[i, i... | def load_data(train_path, test_path):
train_data = pd.read_csv(train_path)
test_data = pd.read_csv(test_path)
print("number of training examples = " + str(train_data.shape[0]))
print("number of test examples = " + str(test_data.shape[0]))
print("train shape: " + str(train_data.shape))
print("test shape: " + str(tes... | Titanic - Machine Learning from Disaster |
972,273 | def get_Ptran_cat(cat):
if cat==0:
mat = [[0 , 0.1713 , 0 , 0 ],
[0.3297, 0 , 0 , 0.01381],
[0 , 1 , 0 , 0 ],
[0 , 0.0002686, 0 , 0 ]]
elif cat==1:
mat = [[0 , 0.0121, 0 , 0 ],
[0.0424, 0 , 0.2766, 0.0101],
[0 , 0.2588, 0 , 0 ],
[0 , 0.0239, 0 , 0 ]]
elif cat<=4:
mat = [[0 , 0.0067, 0 , 0 ],
[0.0373, 0 , 0.2762, 0.0230... | def create_placeholders(input_size, output_size):
x = tf.placeholder(shape=(None, input_size), dtype=tf.float32, name="X")
y = tf.placeholder(shape=(None, output_size), dtype=tf.float32, name="Y")
return x, y
def forward_propagation(x, parameters, keep_prob=1.0, hidden_activation='relu'):
a_dropout = x
n_layers =... | Titanic - Machine Learning from Disaster |
972,273 | PATH = '/kaggle/input/ion-cleaned-data/'
Kexp = [.103,.120,.1307,.138,.267,.105]
Kexpp = [1.8, 1.8, 1.8, 1.83, 1.807, 1.8]
N_PROCESSES = [1, 1, 3, 5, 10, 1]
COEFS_BACK = [1,.9192,.9192,.8792,.9022,.9192]
COEFS_FOR = [1,.8869,.8869,.8869,.8849,.8869]
COEFS_FIN = [.618, 0.50, 0.50, 0.49, 0.509, 0.50]
COEFS_FIN3 = [0.3, 0... | def model(train_set, train_labels, validation_set, validation_labels, layers_dims, learning_rate=0.01, num_epochs=1001,
print_cost=True, plot_cost=True, l2_beta=0., keep_prob=1.0, hidden_activation='relu', return_best=False,
minibatch_size=0, lr_decay=0, print_accuracy=True, plot_accuracy=True):
ops.reset_default_gra... | Titanic - Machine Learning from Disaster |
972,273 | Yopt_test = Yopt[5000000:]
sub = pd.read_csv('/kaggle/input/liverpool-ion-switching/sample_submission.csv')
sub['open_channels'] = Yopt_test.astype(np.int8)
sub.to_csv('M318_Kha_withNewCat6.csv', index=None, float_format='%0.4f')
plt.hist(Yopt[5000000:] )<install_modules> | TRAIN_PATH = '.. /input/train.csv'
TEST_PATH = '.. /input/test.csv'
train, test = load_data(TRAIN_PATH, TEST_PATH)
CLASSES = 2
train_dataset_size = train.shape[0]
train_raw_labels = pd.get_dummies(train.Survived ).as_matrix() | Titanic - Machine Learning from Disaster |
972,273 | !!pip install tensorflow_addons==0.9.1<import_modules> | train = pre_process_data(train)
test = pre_process_data(test)
train_pre = train.drop(['Survived'], axis=1 ).as_matrix().astype(np.float)
test_pre = test.as_matrix().astype(np.float ) | Titanic - Machine Learning from Disaster |
972,273 | import tensorflow_addons as tfa<set_options> | standard_scaler = preprocessing.StandardScaler()
train_pre = standard_scaler.fit_transform(train_pre)
test_pre = standard_scaler.fit_transform(test_pre)
X_train, X_valid, Y_train, Y_valid = train_test_split(train_pre, train_raw_labels, test_size=0.3, random_state=1 ) | Titanic - Machine Learning from Disaster |
972,273 | warnings.simplefilter('ignore')
warnings.filterwarnings('ignore')
pd.set_option('display.max_columns', 1000)
pd.set_option('display.max_rows', 500)
FOLD = 4
AUG_CNT = 15
EPOCHS = 180
NNBATCHSIZE = 16
GROUP_BATCH_SIZE = 4000
SEED = 321
LR = 0.001
SPLITS = 5
def seed_everything(seed):
random.seed(seed)
np.random.see... | input_layer = train_pre.shape[1]
output_layer = 2
num_epochs = 10001
learning_rate = 0.0001
train_size = 0.8
layers_dims = [input_layer, 256, 128, 64, output_layer] | Titanic - Machine Learning from Disaster |
972,273 | warnings.filterwarnings('ignore')
train_df = pd.read_csv("/kaggle/input/scaling-3/new_train.csv")
test_df = pd.read_csv("/kaggle/input/scaling-3/new_test.csv")
train_df['batch']=(( train_df.time-0.0001)//50 ).astype(int)
test_df['batch']=(( test_df.time-0.0001)//50 ).astype(int)
train_df['mini_batch']=(( train_df.... | parameters, submission_name = model(X_train, Y_train, X_valid, Y_valid, layers_dims, num_epochs=num_epochs,
learning_rate=learning_rate, print_cost=False, plot_cost=True, l2_beta=0.1,
keep_prob=0.5, minibatch_size=0, return_best=True, print_accuracy=False,
plot_accuracy=True ) | Titanic - Machine Learning from Disaster |
972,273 | train_df.groupby(['batch','open_channels'] ).signal.agg(['mean','std'] )<import_modules> | final_prediction = predict(test_pre, parameters ) | Titanic - Machine Learning from Disaster |
972,273 | <groupby><EOS> | submission = pd.DataFrame({"PassengerId":test.index.values})
submission["Survived"] = np.argmax(final_prediction, 1)
submission.to_csv("submission.csv", index=False ) | Titanic - Machine Learning from Disaster |
4,079,040 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<groupby> | import numpy as np
import pandas as pd
import tensorflow
import featuretools as ft | Titanic - Machine Learning from Disaster |
4,079,040 | signal_means = train_df[['open_channels','signal']].groupby('open_channels' ).agg('mean')
standard_dev = {
0: 0.24069495895789328,
1: 0.24661370964721863,
2: 0.2462656210881039,
3: 0.24593499463670376,
4: 0.24285132812035926,
5: 0.26328499147888296,
6: 0.24325060224204165,
7: 0.24219770330946155,
8: 0.2428440980634650... | np.random.seed(7 ) | Titanic - Machine Learning from Disaster |
4,079,040 | class ViterbiClassifier:
def __init__(self):
self._p_trans = None
self._p_signal = None
def fit(self, mini_batch):
self._n_states = 11
self._states = list(range(self._n_states))
self._p_trans = self.markov_p_trans(mini_batch)
self._dists = []
for s in np.arange(0, 11):
self._dists.append(( signal_means.loc[s,'signal']... | train_data=pd.read_csv('.. /input/train.csv')
test_data=pd.read_csv('.. /input/test.csv' ) | Titanic - Machine Learning from Disaster |
4,079,040 | oof_probs = []
oof_predictions = []
for mini_batch in range(50):
if mini_batch in Transition_matrices:
signal = train_df[train_df.mini_batch==mini_batch].signal.values
open_channels = train_df[train_df.mini_batch==mini_batch].open_channels.values
viterbi = PosteriorDecoder().fit(mini_batch)
viterbi_predictions,viterbi... | train_data['Age']=train_data['Age'].fillna(train_data['Age'].mean())
train_data=train_data.drop(['Cabin'],axis=1 ) | Titanic - Machine Learning from Disaster |
4,079,040 | print(f1_score(train_df.open_channels,train_df.prediction,average='macro'))
pd.DataFrame(confusion_matrix(train_df.open_channels,train_df.prediction))<categorify> | train_data['Embarked']=train_data['Embarked'].fillna(method='ffill' ) | Titanic - Machine Learning from Disaster |
4,079,040 | test_probs = []
test_predictions = []
for mini_batch in tqdm(range(50,70)) :
if mini_batch in Transition_matrices:
signal = test_df[test_df.mini_batch==mini_batch].signal.values
viterbi = PosteriorDecoder().fit(mini_batch)
viterbi_predictions,viterbi_probabilities = viterbi.predict(signal)
test_probs.append(viterbi_p... | train_data['Sex']=train_data['Sex'].apply(lambda x:1 if x=='male' else 0)
train_data['Embarked']=train_data['Embarked'].apply(lambda x:1 if x=='S'else 2 if x=='C' else 3)
train_data['Fare']=train_data['Fare'].apply(lambda x: x/513)
| Titanic - Machine Learning from Disaster |
4,079,040 | submission_df = pd.read_csv('/kaggle/input/liverpool-ion-switching/sample_submission.csv')
submission_df['open_channels'] = test_predictions
submission_df.to_csv("submission.csv", float_format='%.4f', index=False)
submission_df.open_channels.value_counts()<data_type_conversions> | X=train_data[['Pclass','Sex','Age','SibSp','Parch','Fare','Embarked']]
Y=train_data[['Survived']] | Titanic - Machine Learning from Disaster |
4,079,040 | for oc in range(11):
print("Open Channels",oc)
print(f1_score(( train_df.open_channels==oc ).astype(int),(train_df.prediction==oc ).astype(int)) )<load_from_csv> | model = Sequential()
model.add(Dense(12, input_dim=7, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid')) | Titanic - Machine Learning from Disaster |
4,079,040 | def read_data(inp1, inp2):
train = pd.read_csv(inp1 + 'train.csv', dtype={'time': np.float32, 'signal': np.float32, 'open_channels':np.int32})
test = pd.read_csv(inp1 + 'test.csv', dtype={'time': np.float32, 'signal': np.float32})
Y_train_proba = np.load(inp2 + "Y_train_proba.npy")
Y_test_proba = np.load(inp2 + "Y_t... | model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'] ) | Titanic - Machine Learning from Disaster |
4,079,040 | from sklearn.metrics import f1_score
<load_from_disk> | model.fit(X, Y, epochs=75, batch_size=100 ) | Titanic - Machine Learning from Disaster |
4,079,040 | proba_tr, proba_te = read_data('/kaggle/input/liverpool-ion-switching/','/kaggle/input/ion-shifted-rfc-proba/' )<sort_values> | scores = model.evaluate(X, Y)
print("
%s: %.2f%%" %(model.metrics_names[1], scores[1]*100)) | Titanic - Machine Learning from Disaster |
4,079,040 | proba_tr.sort_values('time', ignore_index = True, inplace = True)
proba_tr_value = proba_tr[['proba_0', 'proba_1', 'proba_2','proba_3', 'proba_4', 'proba_5', 'proba_6', 'proba_7', 'proba_8','proba_9', 'proba_10']].values
proba_tr_pred = np.argmax(proba_tr_value, axis=-1 )<prepare_output> | test_data['Age']=test_data['Age'].fillna(test_data['Age'].mean())
test_data['Fare']=test_data['Fare'].fillna(test_data['Fare'].mean())
test_data['Fare']=test_data['Fare'].apply(lambda x: x/513)
test_data=test_data.drop(['Cabin'],axis=1)
test_data['Embarked']=test_data['Embarked'].fillna(method='ffill')
test_data['... | Titanic - Machine Learning from Disaster |
4,079,040 | proba_tr['pred'] = proba_tr_pred<define_search_space> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
4,079,040 | for i in [0,1],[2,6],[3,7],[5,8],[4,9]:
j1 = i[0] + 1
j2 = i[1] + 1
batch = j1; a = 500000*(batch-1); b = 500000*batch
batch = j2; c = 500000*(batch-1); d = 500000*batch
print(j1,j2)
pred_temp = np.concatenate([proba_tr.pred.values[a:b], proba_tr.pred.values[c:d]] ).reshape(( -1,1))
real_temp = np.concatenate([proba_t... | X=test_data[['Pclass','Sex','Age','SibSp','Parch','Fare','Embarked']] | Titanic - Machine Learning from Disaster |
4,079,040 | f1_score(proba_tr.pred,proba_tr.open_channels,average='macro' )<save_to_csv> | predict=model.predict(X ) | Titanic - Machine Learning from Disaster |
4,079,040 | proba_te.sort_values('time', ignore_index = True, inplace = True)
temp = proba_te[['proba_0','proba_1','proba_2','proba_3','proba_4','proba_5','proba_6','proba_7','proba_8','proba_9','proba_10']].values
temp_pred = pd.DataFrame(np.argmax(temp, axis=-1))
temp_pred.columns = ['open_channels']
x = datetime.datetime.now()... | final_out=pd.DataFrame(columns=['PassengerId','Survived'] ) | Titanic - Machine Learning from Disaster |
4,079,040 | pd.concat([test_ori[['time']],temp_pred], axis = 1 ).to_csv('sub'+x+'.csv', index = False, float_format='%.4f' )<install_modules> | final_out['PassengerId']=test_data['PassengerId'] | Titanic - Machine Learning from Disaster |
4,079,040 | !pip install tensorflow-addons<set_options> | final_out['Survived']=list(predict ) | Titanic - Machine Learning from Disaster |
4,079,040 | sns.set()
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
<load_from_csv> | final_out['Survived']=final_out['Survived'].fillna(method='ffill' ) | Titanic - Machine Learning from Disaster |
4,079,040 | train = pd.read_csv('/kaggle/input/data-without-drift/train_clean.csv')
test = pd.read_csv('/kaggle/input/data-without-drift/test_clean.csv')
NUM_CLASSES = train.open_channels.nunique()
SEQ_LENGTH = 1000
WIDTHS = np.power(2, np.arange(-4, 9), dtype=np.float32)
train.shape, test.shape<normalization> | final_out['Survived']=final_out['Survived'].apply(lambda x:int(round(x[0])) ) | Titanic - Machine Learning from Disaster |
4,079,040 | def wavelet_transform(sig, wd):
widths = wd
wt = signal.cwt(sig.values, signal.ricker, widths)
wt = wt.T
eps = np.max(wt)* 1e-2
s1 = np.log(np.abs(wt)+ eps)- np.log(eps)
wt = s1 / np.max(s1)
return wt<data_type_conversions> | final_out.reset_index()
final_out.to_csv('./final_predictions.csv',index=False ) | Titanic - Machine Learning from Disaster |
4,079,040 | <define_variables><EOS> | final_out['Survived'].value_counts() | Titanic - Machine Learning from Disaster |
11,616,439 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<categorify> | import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras.layers import Dense, Dropout, BatchNormalization
from tensorflow.keras.models import Sequential
import optuna
from optuna.samplers import TPESampler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accur... | Titanic - Machine Learning from Disaster |
11,616,439 | def macro_f1(y_true, y_pred):
y_true = tf.reshape(y_true, [-1, NUM_CLASSES])
y_pred = tf.reshape(y_pred, [-1, NUM_CLASSES])
threshold = tf.reduce_max(y_pred, axis=-1, keepdims=True)
y_pred = tf.logical_and(y_pred >= threshold,
tf.abs(y_pred)> 1e-12)
y_true = tf.cast(y_true, tf.bool)
y_pred = tf.cast(y_pred, tf.boo... | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
11,616,439 | def gated_residual_block(nb_filters, use_bias, i, x):
res_x = layers.Conv1D(nb_filters, 1, strides=1, padding='same', use_bias=use_bias )(x)
tanh_out = layers.Conv1D(nb_filters, 2, dilation_rate=2**i, padding='same',
use_bias=use_bias, activation='tanh' )(x)
sigm_out = layers.Conv1D(nb_filters, 2, dilation_rate=2**i,... | train['LastName'] = train['Name'].str.split(',', expand=True)[0]
test['LastName'] = test['Name'].str.split(',', expand=True)[0]
ds = pd.concat([train, test])
sur = []
died = []
for index, row in ds.iterrows() :
s = ds[(ds['LastName']==row['LastName'])&(ds['Survived']==1)]
d = ds[(ds['LastName']==row['LastName'])&(ds['... | Titanic - Machine Learning from Disaster |
11,616,439 | def compute_receptive_field(dilation_depth, nb_stacks):
receptive_field = nb_stacks *(2**dilation_depth * 2)-(nb_stacks - 1)
return receptive_field
compute_receptive_field(9, 1 )<find_best_params> | EPOCHS = 15
initial_keras_params = {
'layers_number': 1,
'n_units_l_0': 128,
'activation_l_0': 'relu',
'dropout_l_0': 0.5,
'lr': 0.001
} | Titanic - Machine Learning from Disaster |
11,616,439 | best_model, best_r, best_score = wavenet(9, 1, 128, 0)
print(f'Macro F1: {best_score}' )<save_to_csv> | def keras_classifier(parameters):
model = Sequential()
layers_number = int(parameters['layers_number'])
for i in range(layers_number):
model.add(Dense(int(parameters['n_units_l_' + str(i)]), activation=parameters['activation_l_' + str(i)]))
model.add(Dropout(int(parameters['dropout_l_' + str(i)])))
model.add(Dense(2,... | Titanic - Machine Learning from Disaster |
11,616,439 | preds = best_model.predict(test[cols].values.reshape(-1,SEQ_LENGTH,len(cols)))
preds = preds.reshape(-1, 11)
preds = np.argmax(preds, axis=1)
test['open_channels'] = preds
test[['time', 'open_channels']].to_csv('submission.csv', index=False, float_format='%.4f' )<load_pretrained> | model = keras_classifier(initial_keras_params ) | Titanic - Machine Learning from Disaster |
11,616,439 | archive_train=zipfile.ZipFile('/kaggle/input/whats-cooking/train.json.zip','r')
archive_train<load_from_disk> | y = train['Survived']
y = tf.keras.utils.to_categorical(y, num_classes=2, dtype='float32')
X = train.drop(['Survived', 'Cabin_T'], axis=1)
X_test = test.copy()
X, X_val, y, y_val = train_test_split(X, y, random_state=0, test_size=0.2, shuffle=False ) | Titanic - Machine Learning from Disaster |
11,616,439 | train_data=pd.read_json(archive_train.read('train.json'))
train_data.head()<load_pretrained> | model.fit(X, y, validation_split=0.2, epochs=EPOCHS, batch_size=32 ) | Titanic - Machine Learning from Disaster |
11,616,439 | archive_test=zipfile.ZipFile('/kaggle/input/whats-cooking/test.json.zip','r')
test_data=pd.read_json(archive_test.read('test.json'))
test_data.head()<count_values> | preds = model.predict(X_val)
preds = np.argmax(preds, axis=1)
print('accuracy: ', accuracy_score(np.argmax(y_val, axis=1), preds))
print('f1-score: ', f1_score(np.argmax(y_val, axis=1), preds)) | Titanic - Machine Learning from Disaster |
11,616,439 | train_data['cuisine'].value_counts()<define_variables> | def create_model(trial):
n_layers = trial.suggest_int("layers_number", 1, 2)
model = Sequential()
for i in range(n_layers):
num_hidden = trial.suggest_int("n_units_l_{}".format(i), 2, 16)
activation = trial.suggest_categorical('activation_l_{}'.format(i), ['relu', 'sigmoid', 'tanh', 'elu'])
model.add(Dense(num_hidde... | Titanic - Machine Learning from Disaster |
11,616,439 | train_ingredients_count={}
for i in range(len(train_data)) :
for j in train_data['ingredients'][i]:
if j in train_ingredients_count.keys() :
train_ingredients_count[j]+=1
else:
train_ingredients_count[j]=1<define_variables> | def objective(trial):
model = create_model(trial)
epochs = trial.suggest_int("epochs", 3, 20)
batch = trial.suggest_int("batch", 1, X.shape[0] / 4)
model.fit(
X,
y,
batch_size=batch,
epochs=epochs,
verbose=0
)
preds = model.predict(X_val)
return accuracy_score(np.argmax(y_val, axis=1), np.argmax(preds, axis=1)) ... | Titanic - Machine Learning from Disaster |
11,616,439 | test_ingredients_count={}
for i in range(len(test_data)) :
for j in test_data['ingredients'][i]:
if j in test_ingredients_count.keys() :
test_ingredients_count[j]+=1
else:
test_ingredients_count[j]=1<define_variables> | def optimize() :
sampler = TPESampler(seed=666)
study = optuna.create_study(direction="maximize", sampler=sampler)
study.optimize(objective, n_trials=80)
return study.best_params | Titanic - Machine Learning from Disaster |
11,616,439 | ingredients_missing_train=[]
for i in test_ingredients_count.keys() :
if i not in train_ingredients_count.keys() :
ingredients_missing_train.append(i)
train_ingredients_count[i]=0
print(len(ingredients_missing_train))<define_variables> | params = optimize() | Titanic - Machine Learning from Disaster |
11,616,439 | ingredients_missing_test=[]
for i in train_ingredients_count.keys() :
if i not in test_ingredients_count.keys() :
ingredients_missing_test.append(i)
test_ingredients_count[i]=0
print(len(ingredients_missing_test))<feature_engineering> | epochs = params['epochs']
batch = params['batch']
del params['epochs']
del params['batch']
opt_model = keras_classifier(params)
opt_model.fit(X, y, validation_split=0.2, epochs=epochs, batch_size=batch ) | Titanic - Machine Learning from Disaster |
11,616,439 | for i in train_ingredients_count.keys() :
train_data[i]=np.zeros(len(train_data))<feature_engineering> | preds = opt_model.predict(X_val)
preds = np.argmax(preds, axis=1)
print('accuracy: ', accuracy_score(np.argmax(y_val, axis=1), preds))
print('f1-score: ', f1_score(np.argmax(y_val, axis=1), preds)) | Titanic - Machine Learning from Disaster |
11,616,439 | for i in test_ingredients_count.keys() :
test_data[i]=np.zeros(len(test_data))<filter> | preds = opt_model.predict(X_test)
preds = np.argmax(preds, axis=1)
preds = preds.astype(np.int16 ) | Titanic - Machine Learning from Disaster |
11,616,439 | <filter><EOS> | submission = pd.read_csv('.. /input/titanic/gender_submission.csv')
submission['Survived'] = preds
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
714,742 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<drop_column> | import pandas as pd
import numpy as np
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import LabelBinarizer
from sklearn.preprocessing import normalize
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from... | Titanic - Machine Learning from Disaster |
714,742 | test_data=test_data[train_data.drop('cuisine',axis=1 ).columns]<prepare_x_and_y> | df = pd.read_csv(".. /input/train.csv")
df.head(10 ) | Titanic - Machine Learning from Disaster |
714,742 | X=train_data.drop(['id','ingredients','cuisine'],axis=1)
y=train_data['cuisine']<split> | mean_fare = np.mean(df.Fare)
df.loc[df.Fare == 0, "Fare"] = mean_fare | Titanic - Machine Learning from Disaster |
714,742 | Xtrain,Xval,ytrain,yval=train_test_split(X,y,random_state=42 )<import_modules> | Titanic - Machine Learning from Disaster | |
714,742 | from sklearn.linear_model import LogisticRegression<train_model> | Titanic - Machine Learning from Disaster | |
714,742 | lr=LogisticRegression(solver='liblinear')
lr.fit(Xtrain,ytrain )<compute_test_metric> | binar = LabelBinarizer().fit(df.loc[:, "Sex"])
df["Sex"] = binar.transform(df["Sex"])
df.head(10 ) | Titanic - Machine Learning from Disaster |
714,742 | lr.score(Xval,yval )<predict_on_test> | Titanic - Machine Learning from Disaster | |
714,742 | test_data['cuisine']=lr.predict(test_data.drop(['id','ingredients'],axis=1))<save_to_csv> | df["A_Class"] = 0
df["B_Class"] = 0
df["C_Class"] = 0
df.loc[df.Pclass == 1, "A_Class"] = 1
df.loc[df.Pclass == 2, "B_Class"] = 1
df.loc[df.Pclass == 3, "C_Class"] = 1
df.head() | Titanic - Machine Learning from Disaster |
714,742 | sub=test_data[['id','cuisine']]
sub.set_index('id',inplace=True)
sub.to_csv('subWCng.csv' )<import_modules> | df_Embarked = pd.get_dummies(df.Embarked)
df_Embarked.head() | Titanic - Machine Learning from Disaster |
714,742 | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import sklearn
import os
import json
import re
import nltk
import zipfile
from datetime import datetime
from sklearn.preprocessing import LabelEncoder
from nltk.stem import WordNetLemmatizer
from sklearn.feature_extraction.text... | df.Age.isna().sum() | Titanic - Machine Learning from Disaster |
714,742 | for t in ['train','test']:
with zipfile.ZipFile(".. /input/whats-cooking/{}.json.zip".format(t),"r")as z:
z.extractall(".")
with open('./train.json')as data_file:
data = json.load(data_file)
with open('./test.json')as test_file:
test = json.load(test_file )<prepare_output> | df.Age[df.Age.notna() ][df.Age[df.Age.notna() ] % 1 != 0].head() | Titanic - Machine Learning from Disaster |
714,742 | df = pd.DataFrame(data)
test_df = pd.DataFrame(test)
test_ids = test_df['id']
df.head()<count_missing_values> | Titanic - Machine Learning from Disaster | |
714,742 | ( df.isnull().sum() / len(df)) *100<count_missing_values> | df.groupby(["Sex", "Pclass"] ).Age.mean() | Titanic - Machine Learning from Disaster |
714,742 | ( test_df.isnull().sum() / len(test_df)) *100<categorify> | df.loc[(df.Sex == 0)&(df.Age.isna())&(df.Pclass == 1), "Age"] = 34.6
df.loc[(df.Sex == 0)&(df.Age.isna())&(df.Pclass == 2), "Age"] = 28.7
df.loc[(df.Sex == 0)&(df.Age.isna())&(df.Pclass == 3), "Age"] = 21.7
df.loc[(df.Sex == 1)&(df.Age.isna())&(df.Pclass == 1), "Age"] = 41.2
df.loc[(df.Sex == 1)&(df.Age.isna())&(df.Pcl... | Titanic - Machine Learning from Disaster |
714,742 | def preprocess_df(df):
def process_string(x):
x = [" ".join([WordNetLemmatizer().lemmatize(q)for q in p.split() ])for p in x]
x = list(map(lambda x: re.sub(r'\ (.*oz.\)|crushed|crumbles|ground|minced|powder|chopped|sliced','', x), x))
x = list(map(lambda x: re.sub("[^a-zA-Z]", " ", x), x))
x = " ".join(x)
x = x.lower(... | Titanic - Machine Learning from Disaster | |
714,742 | def get_cuisine_cumulated_ingredients(df):
cuisine_df = pd.DataFrame(columns=['ingredients'])
for cus in cuisine:
st = ""
for x in df[df.cuisine == cus]['ingredients']:
st += x
st += " "
cuisine_df.loc[cus,'ingredients'] = st
cuisine_df = cuisine_df.reset_index()
cuisine_df = cuisine_df.rename(columns ={'index':'cuisi... | for i in range(len(df)) :
if df.loc[i, "SibSp"] + df.loc[i, "Parch"] == 0:
df.loc[i, "Alone"] = 1
else:
df.loc[i, "Alone"] = 0
df.Alone = df.Alone.astype(int)
df.head() | Titanic - Machine Learning from Disaster |
714,742 | df = preprocess_df(df)
test_df = preprocess_df(test_df)
cuisine_df = get_cuisine_cumulated_ingredients(df )<prepare_x_and_y> | df_new = pd.concat([df, df_Embarked], axis=1)
df_new.head() | Titanic - Machine Learning from Disaster |
714,742 | train = df['ingredients']
target = df['cuisine']
test = test_df['ingredients']<feature_engineering> | feature_name = ["Sex", "Age", "Fare", "Alone", "A_Class", "B_Class", "C_Class", "C", "Q", "S", "SibSp", "Parch"]
dfX = df_new[feature_name]
dfY = df_new["Survived"] | Titanic - Machine Learning from Disaster |
714,742 | def count_vectorizer(train, test=None):
cv = CountVectorizer()
train = cv.fit_transform(train)
if test is not None:
test = cv.transform(test)
return train, test, cv
else:
return train, cv<feature_engineering> | scaler = MinMaxScaler() | Titanic - Machine Learning from Disaster |
714,742 | def tfidf_vectorizer(train, test=None):
tfidf = TfidfVectorizer(stop_words='english',
ngram_range =(1 , 1),analyzer="word",
max_df =.57 , binary=False , token_pattern=r'\w+' , sublinear_tf=False)
train = tfidf.fit_transform(train)
if test is not None:
test = tfidf.transform(test)
return train, test, tfidf
else:
retu... | scaler.fit(dfX ) | Titanic - Machine Learning from Disaster |
714,742 | train_tfidf, test_tfidf, tfidf = tfidf_vectorizer(train,test)
cuisine_data_tfidf, cuisine_tfidf = tfidf_vectorizer(cuisine_df['ingredients'] )<statistical_test> | dfX = scaler.transform(dfX ) | Titanic - Machine Learning from Disaster |
714,742 | red_cuisine_pca, cus_pca, var_cus_pca = get_PCA(( cuisine_data_tfidf ).toarray() ,2 )<set_options> | dfX = pd.DataFrame(dfX, columns=feature_name ) | Titanic - Machine Learning from Disaster |
714,742 | %%time
wcss_pca = get_kmeans_wcss(red_cuisine_pca,20 )<compute_train_metric> | Titanic - Machine Learning from Disaster | |
714,742 | cluster_cus_pca, km_cus_pca = kmeans(red_cuisine_pca,3)
cluster_cus_pca<set_options> | model = Sequential()
model.add(Dense(32, input_dim=12, activation="elu", kernel_initializer="he_normal"))
model.add(Dense(64, activation="elu", kernel_initializer="he_normal"))
model.add(Dense(128, activation="elu", kernel_initializer="he_normal"))
model.add(keras.layers.Dropout(0.3))
model.add(Dense(512, activation="e... | Titanic - Machine Learning from Disaster |
714,742 | %%time
wcss = get_kmeans_wcss(train_tfidf,30 )<predict_on_test> | model_result = model.fit(dfX, dfY, batch_size=100, epochs=200, validation_split=0.2, shuffle=True, verbose=2 ) | Titanic - Machine Learning from Disaster |
714,742 | cluster, km = kmeans(train_tfidf,19)
cluster_test = km.predict(test_tfidf)
cluster<categorify> | test = pd.read_csv(".. /input/test.csv")
test.head() | Titanic - Machine Learning from Disaster |
714,742 | enc = OneHotEncoder(handle_unknown='ignore')
enc.fit(cluster.reshape(-1, 1))
cluster_encoded = enc.transform(cluster.reshape(-1, 1)).toarray()<categorify> | Titanic - Machine Learning from Disaster | |
714,742 | cluster_test_encoded = enc.transform(cluster_test.reshape(-1, 1)).toarray()<concatenate> | np.mean(df.Fare), mean_fare | Titanic - Machine Learning from Disaster |
714,742 | train_tfidf_nonsparse = np.append(( train_tfidf ).toarray() , cluster_encoded, axis=1 )<concatenate> | test.loc[test.Fare == 0, "Fare"] = mean_fare | Titanic - Machine Learning from Disaster |
714,742 | test_tfidf_nonsparse = np.append(( test_tfidf ).toarray() , cluster_test_encoded, axis=1 )<train_model> | test["Sex"] = binar.transform(test["Sex"] ) | Titanic - Machine Learning from Disaster |
714,742 | train = train_tfidf
test = test_tfidf<choose_model_class> | Titanic - Machine Learning from Disaster | |
714,742 | param_grid = {'C': [0.001, 0.1, 1, 10, 50, 100, 500, 1000, 5000],
'penalty': ['l1','l2'],
'loss': ['hinge','squared hinge']}
grid = GridSearchCV(LinearSVC() , param_grid, refit = True, verbose = 3, n_jobs=-1, scoring='f1_micro' )<train_model> | test["A_Class"] = 0
test["B_Class"] = 0
test["C_Class"] = 0
test.loc[test.Pclass == 1, "A_Class"] = 1
test.loc[test.Pclass == 2, "B_Class"] = 1
test.loc[test.Pclass == 3, "C_Class"] = 1 | Titanic - Machine Learning from Disaster |
714,742 | %%time
grid.fit(train, target )<find_best_params> | test_Embarked = pd.get_dummies(test.Embarked ) | Titanic - Machine Learning from Disaster |
714,742 | grid.best_params_<find_best_score> | Titanic - Machine Learning from Disaster | |
714,742 | grid.best_score_<compute_train_metric> | test.groupby(["Sex", "Pclass"] ).Age.mean() | Titanic - Machine Learning from Disaster |
714,742 | def evalfn(C, gamma):
s = SVC(C=float(C), gamma=float(gamma), kernel='rbf', class_weight='balanced')
f = cross_val_score(s, train, target, cv=5, scoring='f1_micro')
return f.max()<choose_model_class> | Titanic - Machine Learning from Disaster | |
714,742 | new_opt = BayesianOptimization(evalfn, {'C':(0.1, 1000),
'gamma':(0.0001, 1)} )<init_hyperparams> | Titanic - Machine Learning from Disaster | |
714,742 | C = 604.5300203551828
gamma = 0.9656489284085462
clf = SVC(C=float(C), gamma=float(gamma), kernel='rbf' )<train_model> | test.loc[(test.Sex == 0)&(test.Age.isna())&(test.Pclass == 1), "Age"] = 34.6
test.loc[(test.Sex == 0)&(test.Age.isna())&(test.Pclass == 2), "Age"] = 28.7
test.loc[(test.Sex == 0)&(test.Age.isna())&(test.Pclass == 3), "Age"] = 21.7
test.loc[(test.Sex == 1)&(test.Age.isna())&(test.Pclass == 1), "Age"] = 41.2
test.loc[(te... | Titanic - Machine Learning from Disaster |
714,742 | %%time
clf.fit(train, target )<load_pretrained> | Titanic - Machine Learning from Disaster | |
714,742 | now = datetime.now()
print("MODEL SAVED AT {}".format(now))
model_name = "SVC-whats-cooking-trial-final2-{}.pickle.dat".format(now)
pickle.dump(clf, open(model_name, "wb"))<predict_on_test> | for i in range(len(test)) :
if test.loc[i, "SibSp"] + test.loc[i, "Parch"] == 0:
test.loc[i, "Alone"] = 1
else:
test.loc[i, "Alone"] = 0
test.Alone = test.Alone.astype(int ) | Titanic - Machine Learning from Disaster |
714,742 | y_pred = clf.predict(test )<save_to_csv> | test_new = pd.concat([test, test_Embarked], axis=1)
test_new.head() | Titanic - Machine Learning from Disaster |
714,742 | my_submission = pd.DataFrame({'id':test_ids})
my_submission['cuisine'] = y_pred
now = datetime.now()
my_submission.to_csv('submission_{}.csv'.format(now), index=False)
print('Saved file to disk as submission_{}.csv.'.format(now))<load_pretrained> | testX = test_new[feature_name] | Titanic - Machine Learning from Disaster |
714,742 | archive_train = zipfile.ZipFile("/kaggle/input/whats-cooking/train.json.zip",'r')
archive_train<load_from_disk> | testX = scaler.transform(testX ) | Titanic - Machine Learning from Disaster |
714,742 | train_data = pd.read_json(archive_train.read('train.json'))
train_data<load_pretrained> | testX = pd.DataFrame(testX, columns=feature_name)
testX.head() | Titanic - Machine Learning from Disaster |
714,742 | archive_test = zipfile.ZipFile("/kaggle/input/whats-cooking/test.json.zip",'r')
test_data = pd.read_json(archive_test.read("test.json"))
test_data<count_values> | predict = model.predict_classes(testX ) | Titanic - Machine Learning from Disaster |
714,742 | <feature_engineering><EOS> | my_submission = pd.DataFrame({'PassengerId': test.PassengerId, 'Survived': predict})
my_submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,296,321 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<feature_engineering> | sns.set(style = 'whitegrid')
sns.distributions._has_statsmodels = False | Titanic - Machine Learning from Disaster |
11,296,321 | test_ingr_count = {}
m = test_data.shape[0]
for i in range(m):
for j in test_data["ingredients"][i]:
if j in test_ingr_count.keys() :
test_ingr_count[j] += 1
else:
test_ingr_count[j] = 1
len(test_ingr_count )<feature_engineering> | data_train = pd.read_csv('.. /input/titanic/train.csv')
data_test = pd.read_csv('.. /input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
11,296,321 | train_ingr_missing = []
for i in test_ingr_count.keys() :
if i not in train_ingr_count.keys() :
train_ingr_missing.append(i)
print(len(train_ingr_missing))
for i in train_ingr_missing:
train_ingr_count[i] = 0
print(len(train_ingr_count))<feature_engineering> | train = data_train.copy()
test = data_test.copy() | Titanic - Machine Learning from Disaster |
11,296,321 | test_ingr_missing = []
for i in train_ingr_count.keys() :
if i not in test_ingr_count.keys() :
test_ingr_missing.append(i)
print(len(test_ingr_missing))
for i in test_ingr_missing:
test_ingr_count[i] = 0
print(len(test_ingr_count))<feature_engineering> | train['Cabin'] = train['Cabin'].str.get(0)
test['Cabin'] = test['Cabin'].str.get(0 ) | Titanic - Machine Learning from Disaster |
11,296,321 | for i in train_ingr_count.keys() :
train_data[i] = np.zeros(len(train_data))<feature_engineering> | num_data = train[['Age', 'SibSp', 'Parch', 'Fare']]
cat_data = train[['Survived', 'Pclass', 'Sex', 'Cabin', 'Embarked']] | 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.