kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,296,321 | for i in test_ingr_count.keys() :
test_data[i] = np.zeros(len(test_data))<feature_engineering> | print('Train :
',train.isnull().sum())
print('
')
print('Test :
', test.isnull().sum() ) | Titanic - Machine Learning from Disaster |
11,296,321 | for i in range(len(train_data)) :
for j in train_data['ingredients'][i]:
train_data[j].iloc[i] = 1<feature_engineering> | train['Age'].fillna(train['Age'].median() , inplace = True)
test['Age'].fillna(train['Age'].median() , inplace = True)
train['Fare'].fillna(train['Fare'].median() , inplace = True)
test['Fare'].fillna(train['Fare'].median() , inplace = True)
train.dropna(subset=['Embarked'] , inplace = True ) | Titanic - Machine Learning from Disaster |
11,296,321 | for i in range(len(test_data)) :
for j in test_data['ingredients'][i]:
test_data[j].iloc[i] = 1<drop_column> | train.drop(['Cabin'], axis = 1, inplace = True)
test.drop(['Cabin'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
11,296,321 | train_data.drop('ingredients',axis=1,inplace=True)
test_data.drop('ingredients',axis=1,inplace=True )<drop_column> | print('Train :
',train.isnull().sum())
print('
')
print('Test :
', test.isnull().sum() ) | Titanic - Machine Learning from Disaster |
11,296,321 | test_data = test_data[train_data.drop('cuisine',axis=1 ).columns]<split> | train['LastName'] = train['Name'].str.split(',', expand=True)[0]
test['LastName'] = test['Name'].str.split(',', expand=True)[0] | Titanic - Machine Learning from Disaster |
11,296,321 | X = train_data.drop(['id','cuisine'],axis=1)
y = train_data['cuisine']
X_train,X_test,y_train,y_test = train_test_split(X,y)
print(X_test.shape,y_test.shape)
print(X_train.shape,y_train.shape )<train_model> | train['Train'] = 1
test['Train'] = 0
alldata = pd.concat(( train, test), sort = False ).reset_index(drop = True)
sur_data = []
died_data = []
for index, row in alldata.iterrows() :
s = alldata[(alldata['LastName']==row['LastName'])&(alldata['Survived']==1)]
d = alldata[(alldata['LastName']==row['LastName'])&(alldata['... | Titanic - Machine Learning from Disaster |
11,296,321 | lr = LogisticRegression()
lr.fit(X_train,y_train)
lr.score(X_test,y_test )<predict_on_test> | train = alldata[alldata['Train'] == 1]
test = alldata[alldata['Train'] == 0]
| Titanic - Machine Learning from Disaster |
11,296,321 | pred = lr.predict(test_data.drop('id',axis=1))<create_dataframe> | train['Fare'] = np.log1p(train['Fare'])
test['Fare'] = np.log1p(test['Fare'] ) | Titanic - Machine Learning from Disaster |
11,296,321 | submission = pd.DataFrame(data=pred,columns=['cuisine'])
submission['id'] = test_data['id']
submission.set_index("id",inplace=True )<save_to_csv> | le = LabelEncoder()
le.fit(train['Pclass'])
train['Pclass'] = le.transform(train['Pclass'])
ohe = OneHotEncoder(sparse = False, drop = 'first', categories = 'auto')
ohe.fit(train[['Sex', 'Embarked']])
ohecategory_train = ohe.transform(train[['Sex', 'Embarked']])
ohecategory_test = ohe.transform(test[['Sex', 'Embar... | Titanic - Machine Learning from Disaster |
11,296,321 | submission.to_csv('submission.csv' )<import_modules> | sc = StandardScaler()
sc.fit(train[['Age', 'SibSp', 'Parch', 'Fare']])
train[['Age', 'SibSp', 'Parch', 'Fare']] = sc.transform(train[['Age', 'SibSp', 'Parch', 'Fare']])
test[['Age', 'SibSp', 'Parch', 'Fare']] = sc.transform(test[['Age', 'SibSp', 'Parch', 'Fare']])
| Titanic - Machine Learning from Disaster |
11,296,321 | import pandas as pd
import json
from sklearn.preprocessing import LabelEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.feature_extraction.text import CountVectorizer<load_from_disk> | train.drop(['PassengerId', 'Name', 'Sex', 'Ticket', 'Embarked', 'LastName', 'Train'], axis = 1, inplace = True)
test.drop(['PassengerId', 'Name', 'Sex', 'Ticket', 'Embarked', 'LastName', 'Train'], axis = 1, inplace = True ) | Titanic - Machine Learning from Disaster |
11,296,321 | with open('.. /input/train.json')as train_data:
data = json.load(train_data )<define_variables> | X_train = train.iloc[:, 1:].values
y_train = train.iloc[:, 0].values
X_test = test.iloc[:, 1:].values
y_test = test.iloc[:, 0].values
print('X_train :
', X_train[0:5])
print('y_train :
', y_train[0:5] ) | Titanic - Machine Learning from Disaster |
11,296,321 | features = [x['ingredients'] for x in data]<define_variables> | clf = KNeighborsClassifier(leaf_size = 1, metric = 'minkowski', n_neighbors = 12, p = 1, weights = 'distance')
accuracies = cross_val_score(clf, X_train, y_train, cv = 10)
print('Accuracies : ', accuracies)
print('AVG Accuracies : ', accuracies.mean())
print('STD:',accuracies.std())
| Titanic - Machine Learning from Disaster |
11,296,321 | features_list = []
for feature in features:
single_item = ''
for item in feature:
item= item.replace(' ','-')
single_item = single_item + ' ' + item
single_item = single_item[1:]
features_list.append(single_item )<feature_engineering> | clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
y_pred = y_pred.astype('int64')
submission = pd.DataFrame()
submission['PassengerId'] = data_test['PassengerId']
submission['Survived'] = y_pred
submission['Survived'].value_counts()
| Titanic - Machine Learning from Disaster |
11,296,321 | <categorify><EOS> | submission.to_csv(r'Submission.csv', index = False, header = True ) | Titanic - Machine Learning from Disaster |
10,843,677 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_disk> | import numpy as np
import pandas as pd
import seaborn as sns
from scipy import stats
import matplotlib.pyplot as plt
import torch
from torch import nn
import torch.optim
from torch.nn import functional as F
from torch.utils.data import TensorDataset, DataLoader
from torch.utils.data.sampler import SubsetRandomSampler
f... | Titanic - Machine Learning from Disaster |
10,843,677 | with open('.. /input/test.json')as test_data:
test_data = json.load(test_data )<define_variables> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
train_data.head() | Titanic - Machine Learning from Disaster |
10,843,677 | features_test = [x['ingredients'] for x in test_data]<define_variables> | test_data = pd.read_csv('/kaggle/input/titanic/test.csv')
test_data.head() | Titanic - Machine Learning from Disaster |
10,843,677 | features_list_test = []
for feature in features_test:
single_item = ''
for item in feature:
single_item = single_item + ' ' + item
single_item = single_item[1:]
features_list_test.append(single_item )<feature_engineering> | women = train_data.loc[train_data.Sex=='female']["Survived"]
rate_women = sum(women)/ len(women)
F"% of women who survived: {rate_women}" | Titanic - Machine Learning from Disaster |
10,843,677 | test_features = vectorizor.transform(features_list_test )<train_model> | men = train_data.loc[train_data.Sex=='male']['Survived']
men_rate = sum(men)/ len(men)
F"% of men who survived: {men_rate}" | Titanic - Machine Learning from Disaster |
10,843,677 | model= LogisticRegression()
model.fit(X_features,y )<compute_test_metric> | fare_mean_1st = train_data[train_data["Pclass"]==1].Fare.mean()
fare_mean_2nd = train_data[train_data["Pclass"]==2].Fare.mean()
fare_mean_3rd = train_data[train_data["Pclass"]==3].Fare.mean()
F"Average cost of tickets for 1st, snd, 3rd classes: \
{fare_mean_1st} || {fare_mean_2nd} || {fare_mean_3rd}"
| Titanic - Machine Learning from Disaster |
10,843,677 | model.score(X_features, y )<load_from_disk> | woman_survived_1st = len(train_data[(train_data["Sex"]=="female")&(train_data["Survived"]==1)&(train_data["Pclass"]==1)].index)/ len(train_data[(train_data["Sex"]=="female")&(train_data["Pclass"]==1)].index)
woman_survived_2nd = len(train_data[(train_data["Sex"]=="female")&(train_data["Survived"]==1)&(train_data["Pcla... | Titanic - Machine Learning from Disaster |
10,843,677 | df = pd.read_json('.. /input/test.json' )<predict_on_test> | woman_survived_1st = len(train_data[(train_data["Sex"]=="male")&(train_data["Survived"]==1)&(train_data["Pclass"]==1)].index)/ len(train_data[(train_data["Sex"]=="male")&(train_data["Pclass"]==1)].index)
woman_survived_2nd = len(train_data[(train_data["Sex"]=="male")&(train_data["Survived"]==1)&(train_data["Pclass"]==... | Titanic - Machine Learning from Disaster |
10,843,677 | df['cuisine'] = le.inverse_transform(model.predict(test_features))<save_to_csv> | train_data.isnull().sum() | Titanic - Machine Learning from Disaster |
10,843,677 | df= df[['id', 'cuisine']]
df.to_csv('submit.csv', index=False )<load_from_csv> | test_data.isnull().sum() | Titanic - Machine Learning from Disaster |
10,843,677 | train = pd.read_json('.. /input/train.json', orient='columns')
test = pd.read_json('.. /input/test.json', orient='columns')
sample_submission = pd.read_csv(".. /input/sample_submission.csv" )<feature_engineering> | X = train_data.drop(['PassengerId', 'Name', 'Ticket', 'Cabin', 'Embarked'], axis=1)
X_test = test_data.drop(['PassengerId','Name', 'Ticket', 'Cabin', 'Embarked'], axis=1 ) | Titanic - Machine Learning from Disaster |
10,843,677 | def sub_space(x):
temp_value = list()
for i in x:
temp_value.append(re.sub(r'[^0-9a-zA-Z]+','_',i.lower()))
return temp_value
train['ingredients_new'] = train['ingredients'].apply(sub_space)
test['ingredients_new'] = test['ingredients'].apply(sub_space)
def convert_list_to_sent(x):
return ' '.join(x)
train['ingredie... | X = pd.get_dummies(X)
X_test = pd.get_dummies(X_test)
X.fillna(X.mean() ,inplace=True)
X_test.fillna(X_test.mean() ,inplace=True ) | Titanic - Machine Learning from Disaster |
10,843,677 | X_train, X_val, y_train, y_val = train_test_split(train['ingredient_sent'], train['cuisine'], test_size=0.33, random_state=42 )<categorify> | X.isnull().sum() | Titanic - Machine Learning from Disaster |
10,843,677 | tfidf_vect = TfidfVectorizer(lowercase=True,binary=True)
X_train_tfidf = tfidf_vect.fit_transform(X_train)
X_val_tfidf = tfidf_vect.transform(X_val)
X_test_tfidf = tfidf_vect.transform(test['ingredient_sent'])
<categorify> | X_test.isnull().sum() | Titanic - Machine Learning from Disaster |
10,843,677 | lb = LabelEncoder()
y_train_encode = lb.fit_transform(y_train)
y_val_encode = lb.transform(y_val)
y_train_dummy = np_utils.to_categorical(y_train_encode)
y_val_dummy = np_utils.to_categorical(y_val_encode )<choose_model_class> | features = ["Pclass", "Sex_female", "Age", "Fare", "SibSp", "Parch"]
y= X['Survived']
X = pd.DataFrame(X, columns = features)
X_test = pd.DataFrame(X_test, columns = features)
for col in features:
X[col] =(X[col] - X[col].mean())/ X[col].std()
X_test[col] =(X_test[col] - X_test[col].mean())/ X_test[col].std()
for col... | Titanic - Machine Learning from Disaster |
10,843,677 | input_shape = X_train_tfidf.shape[1]
def model_structure1() :
mdl = Sequential()
mdl.add(Dense(512, init='glorot_uniform', activation='relu',input_shape=(input_shape,)))
mdl.add(Dropout(0.5))
mdl.add(Dense(128, init='glorot_uniform', activation='relu'))
mdl.add(Dropout(0.5))
mdl.add(Dense(20, activation='softmax'))
md... | model = RandomForestClassifier(n_estimators = 100, max_features='auto', criterion='entropy',max_depth=10)
model.fit(X, y)
predictions = model.predict(X_test)
output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('random_forest_submission.csv', index=False)
print("Your... | Titanic - Machine Learning from Disaster |
10,843,677 | print("Compile model...")
estimator = KerasClassifier(build_fn=model_structure1, epochs=10, batch_size=128 )<train_model> | df = pd.read_csv("random_forest_submission.csv")
df | Titanic - Machine Learning from Disaster |
10,843,677 | history = estimator.fit(X_train_tfidf.toarray() , y_train_dummy,\
validation_data=(X_val_tfidf.toarray() ,y_val_dummy))
<predict_on_test> | X = X.to_numpy()
y = y.to_numpy().reshape(-1, 1)
X_test = X_test.to_numpy() | Titanic - Machine Learning from Disaster |
10,843,677 | mnb_train_prediction = estimator.predict_proba(X_train_tfidf.toarray())
mnb_val_prediction = estimator.predict_proba(X_val_tfidf.toarray())
mnb_tr_pred_value = estimator.predict(X_train_tfidf.toarray())
mnb_val_pred_value = estimator.predict(X_val_tfidf.toarray())
mnb_test_pred_value = estimator.predict(X_test_tfid... | def batch_data(batch_size, input_data, target, test_data, train_type = "regression", val_size=0.1):
if train_type == "regression":
target_tensor = torch.FloatTensor(target)
elif train_type == "classification":
target_tensor = torch.LongTensor(target)
target_tensor = target_tensor.squeeze()
input_tensor = torch.Floa... | Titanic - Machine Learning from Disaster |
10,843,677 | test_pred = list(lb.inverse_transform(mnb_test_pred_value))
print(test_pred )<prepare_output> | batch_size = 32
train_loader, val_loader, test_loader = batch_data(batch_size, X, y, X_test ) | Titanic - Machine Learning from Disaster |
10,843,677 | result = pd.DataFrame({'id':test['id'],'cuisine':test_pred})
result.head()
<save_to_csv> | class LinearRegression(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(6, 20)
self.fc2 = nn.Linear(20, 1)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
x = self.fc1(x)
x = self.sigmoid(x)
x = self.fc2(x)
return x
| Titanic - Machine Learning from Disaster |
10,843,677 | result.to_csv('submission.csv',index=False )<load_from_csv> | def init_weights(m):
if type(m)== nn.Linear:
torch.nn.init.xavier_uniform(m.weight)
m.bias.data.fill_(0.01 ) | Titanic - Machine Learning from Disaster |
10,843,677 | sns.set_style("whitegrid")
with open('.. /input/train.json', 'r')as f:
txt = f.read()
df = pd.DataFrame(json.loads(txt))
df.head()<feature_engineering> | linear_regression_model = LinearRegression()
linear_regression_model.apply(init_weights)
print(linear_regression_model ) | Titanic - Machine Learning from Disaster |
10,843,677 | df['joined'] = df.ingredients.map(lambda x: ' '.join(x))
df_nb = df[['cuisine','joined']]
df_nb.head()<feature_engineering> | lr = 0.01
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(linear_regression_model.parameters() , lr=lr, momentum=0.9)
batch_size = 32 | Titanic - Machine Learning from Disaster |
10,843,677 | count_vect = CountVectorizer()
tfidf_transformer = TfidfTransformer()
X = count_vect.fit_transform(df_nb.joined)
X = tfidf_transformer.fit_transform(X)
X.shape<compute_train_metric> | def train_model(model, batch_size, epochs, cost_function, print_every = 100):
val_loss_min = np.Inf
for e in range(epochs):
val_loss = 0.0
train_loss = 0.0
model.train()
for inputs, labels in train_loader:
optimizer.zero_grad()
output = model(inputs)
loss = cost_function(output, labels)
loss.backward()
optimizer.step... | Titanic - Machine Learning from Disaster |
10,843,677 | clf = MultinomialNB()
scores = cross_val_score(clf, X, df_nb.cuisine, cv=5)
print('accuracy CV:',scores )<choose_model_class> | train_model(linear_regression_model, batch_size, epochs=3000, cost_function=criterion ) | Titanic - Machine Learning from Disaster |
10,843,677 | def simple_NN(input_shape, nodes_per=[60], hidden=0, out=2, act_out='softmax', act_hid='relu', drop=True, d_rate=0.1):
model = Sequential()
model.add(Dense(nodes_per[0],activation=act_hid,input_shape=input_shape))
if drop:
model.add(Dropout(d_rate))
try:
if hidden != 0:
for i,j in zip(range(hidden), nodes_per[1:]):
m... | linear_regression_model.load_state_dict(torch.load('model_linear.pt')) | Titanic - Machine Learning from Disaster |
10,843,677 | with open('.. /input/test.json', 'r')as f:
txt = f.read()
df_test = pd.DataFrame(json.loads(txt))
df_test['joined'] = df_test.ingredients.map(lambda x: ' '.join(x))
df_test = df_test.drop(['ingredients'], axis=1)
df_test.head()<predict_on_test> | with torch.no_grad() :
for data in test_loader:
output = linear_regression_model(data)
preds = torch.round(output)
preds = preds.squeeze()
survived = preds.numpy()
| Titanic - Machine Learning from Disaster |
10,843,677 | dec_dict = dict([(x,y)for y,x in ch_dict.items() ])
X_test = np.array(df_test.joined)
X_test = count_vect.transform(X_test)
X_test = tfidf_transformer.transform(X_test)
preds = model.predict(X_test)
y_test = [dec_dict[np.argmax(x)] for x in preds]
df_test['cuisine'] = y_test
df_test.head()<save_to_csv> | survived = survived.astype('int' ) | Titanic - Machine Learning from Disaster |
10,843,677 | df_test = df_test.drop('joined', axis=1)
df_test.to_csv('result.csv', index=False)
print('written to csv.' )<set_options> | submission = pd.DataFrame({'PassengerId': test_data['PassengerId'], 'Survived': survived})
submission.to_csv('submission_regression.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
10,843,677 | % matplotlib inline<load_from_disk> | df = pd.read_csv("submission_regression.csv")
df | Titanic - Machine Learning from Disaster |
10,843,677 | train = pd.read_json(".. /input/train.json")
test = pd.read_json(".. /input/test.json" )<categorify> | train_loader, val_loader, test_loader = batch_data(batch_size, X, y, X_test, train_type="classification", val_size=0.2 ) | Titanic - Machine Learning from Disaster |
10,843,677 | train["ingredients"] = [", ".join(ingredients)for ingredients in train.ingredients]
test["ingredients"] = [", ".join(ingredients)for ingredients in test.ingredients]
target_enc = LabelEncoder()
y = target_enc.fit_transform(train.cuisine )<string_transform> | class Clasification(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(6, 20)
self.fc2 = nn.Linear(20, 2)
def forward(self, x):
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
| Titanic - Machine Learning from Disaster |
10,843,677 | def tokenize(text):
tokens = nltk.word_tokenize(text)
stems = [PorterStemmer().stem(word)for word in tokens]
return(stems)
tfidf = TfidfVectorizer(tokenizer=tokenize )<feature_engineering> | classification_model = Clasification()
classification_model.apply(init_weights)
classification_model | Titanic - Machine Learning from Disaster |
10,843,677 | X = tfidf.fit_transform(train.ingredients )<train_model> | lr = 0.01
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(classification_model.parameters() , lr=lr, momentum=0.9)
batch_size = 64 | Titanic - Machine Learning from Disaster |
10,843,677 | model = make_pipeline(TfidfVectorizer() , LinearSVC(C = 0.5))
model.fit(train.ingredients, y )<choose_model_class> | train_model(classification_model, batch_size, 3000, criterion ) | Titanic - Machine Learning from Disaster |
10,843,677 | svd = TruncatedSVD(n_components=300 )<feature_engineering> | with torch.no_grad() :
for data in test_loader:
output = classification_model(data.float())
_, preds = torch.max(output.data, 1)
survived = preds.numpy() | Titanic - Machine Learning from Disaster |
10,843,677 | X_proj = svd.fit_transform(X )<choose_model_class> | submission = pd.DataFrame({'PassengerId': test_data['PassengerId'], 'Survived': survived})
submission.to_csv('submission_classification.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
10,843,677 | model = LinearSVC(C = 0.5)
<compute_test_metric> | df = pd.read_csv("submission_classification.csv")
df.head() | Titanic - Machine Learning from Disaster |
10,843,677 | cross_val_score(model, X_proj, y )<compute_test_metric> | X_valid = [next(iter(val_loader)) [0].numpy() ]
y_valid = next(iter(val_loader)) [1].numpy() | Titanic - Machine Learning from Disaster |
10,843,677 | cross_val_score(model, train.ingredients, y )<predict_on_test> | from xgboost import XGBClassifier
from sklearn.metrics import mean_absolute_error | Titanic - Machine Learning from Disaster |
10,843,677 | preds = model.predict(test.ingredients)
preds = target_enc.inverse_transform(preds )<create_dataframe> | xg_model = XGBClassifier(learning_rate=0.05, n_estimators=800)
xg_model.fit(X, y ) | Titanic - Machine Learning from Disaster |
10,843,677 | solution = pd.DataFrame({"id":test.id, "cuisine":preds} )<save_to_csv> | predictions = xg_model.predict(X_test)
predictions | Titanic - Machine Learning from Disaster |
10,843,677 | <set_options><EOS> | output = pd.DataFrame({'PassengerId': test_data.PassengerId, 'Survived': predictions})
output.to_csv('xg_boost_submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
7,006,399 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<import_modules> | warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
7,006,399 | from keras.models import Sequential
from keras.layers import Dense, Activation<load_from_csv> | gender_submission = pd.read_csv(".. /input/titanic/gender_submission.csv")
test = pd.read_csv(".. /input/titanic/test.csv")
train = pd.read_csv(".. /input/titanic/train.csv")
display(test.head(15))
display(train.describe() ) | Titanic - Machine Learning from Disaster |
7,006,399 | print("reading train files")
train = pd.read_csv('.. /input/jigsaw-toxic-comment-classification-challenge/train.csv',encoding='utf-8')
train = train.replace(r'
',' ', regex=True)
train = train.replace(r'\',' ', regex=True)
print(train.head())
print("Now reading test files")
test=pd.read_csv('.. /input/jigsaw-toxi... | all_data['Docker_num'] = [cab[:1] if pd.notnull(cab)else "Unknown" for cab in all_data['Cabin']]
all_data['Has_cabin_informed'] = [1 if pd.notnull(cab)else 0 for cab in all_data['Cabin']]
all_data['Title'] = [re.search('\, (.*)\.', name ).group(1)for name in all_data['Name']]
all_data.set_value(all_data['PassengerId']=... | Titanic - Machine Learning from Disaster |
7,006,399 | def add_features(df):
df['comment_text'] = df['comment_text'].apply(lambda x:str(x))
df['total_length'] = df['comment_text'].apply(len)
df['capitals'] = df['comment_text'].apply(lambda comment: sum(1 for c in comment if c.isupper()))
df['caps_vs_length'] = df.apply(lambda row: float(row['capitals'])/float(row['total_l... | sns.distplot(all_data['Fare'].dropna())
plt.ylabel('Frequency')
plt.title('Fare distribution')
all_data['Fare']=all_data['Fare'].apply(lambda x: np.log(x)) | Titanic - Machine Learning from Disaster |
7,006,399 | train_comb = train.groupby(COLUMNS)\
.size() \
.sort_values(ascending=False)\
.reset_index() \
.rename(columns={0: 'count'})
train_comb.head(n=10 )<sort_values> | sns.distplot(all_data['Age'].dropna())
plt.ylabel('Frequency')
plt.title('Age distribution')
all_data['Age']=all_data['Age'].apply(lambda x: np.log(x))
print("Feature engineering: Completed" ) | Titanic - Machine Learning from Disaster |
7,006,399 | train[COLUMNS].corr().abs().unstack().sort_values(ascending=False )<feature_engineering> | X = all_data[:len(train)]
X_test_full = all_data[len(train):]
y = X.Survived
X.drop('Survived', axis=1, inplace=True)
print(len(all_data), len(X), len(X_test_full))
X_train_full, X_valid_full, y_train, y_valid = train_test_split(X, y, train_size=0.95, test_size=0.05, random_state=0)
low_cardinality_cols = [cname for ... | Titanic - Machine Learning from Disaster |
7,006,399 | word_counter = {}
def clean_text(text):
text = re.sub('[{}]'.format(string.punctuation), ' ', text.lower())
return ' '.join([word for word in text.split() if word not in(eng_stopwords)])
for categ in CATEGORIES:
d = Counter()
train[train[categ] == 1]['comment_text'].apply(lambda t: d.update(clean_text(t ).split()))
w... | def xgb_optimize(X_train, y_train):
xgb1 = xgb()
parameters = {'nthread':[1],
'learning_rate': [.005,.004,.003,.002,.0009, 0.008],
'max_depth': [4, 5, 6, 7],
'min_child_weight': [4, 5, 6],
'silent': [1],
'subsample': [0.5],
'colsample_bytree': [0.7],
'n_estimators': [1000, 2500, 5000, 7500]}
xgb_grid = GridSearchCV(xgb... | Titanic - Machine Learning from Disaster |
7,006,399 | max_features=20000
maxlen = 50
tokenizer = text.Tokenizer(num_words=max_features)
tokenizer.fit_on_texts(list(X_train)+ list(X_test))
X_train_sequence = tokenizer.texts_to_sequences(X_train)
X_test_sequence = tokenizer.texts_to_sequences(X_test)
x_train = sequence.pad_sequences(X_train_sequence, maxlen=maxlen)
x_te... | model = xgb(colsample_bytree=0.7, learning_rate=0.0009, max_depth=6, min_child_weight=5, n_estimators=2500,
nthread=1, silent=1, subsample=0.7, random_state=0,
early_stopping_rounds = 10, eval_set=[(X_valid, y_valid)], verbose=False)
print("Let's the training begin.Plase wait.")
my_pipeline = Pipeline(steps=[('model'... | Titanic - Machine Learning from Disaster |
7,006,399 | max_features=20000
maxlen = 50<feature_engineering> | scores = cross_val_score(my_pipeline, X_train, y_train,
cv=5,
scoring='accuracy')
print(scores ) | Titanic - Machine Learning from Disaster |
7,006,399 | <count_values><EOS> | output = pd.DataFrame({'PassengerId': X_test.index+892,
'Survived': preds_test.astype(int)})
output.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
6,244,686 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<train_model> | %matplotlib inline
warnings.filterwarnings("ignore" ) | Titanic - Machine Learning from Disaster |
6,244,686 | print("Base Accuracy - Predicting all labels as non toxic ")
(1-train_comb[['toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate']].mean())*100.0<compute_train_metric> | train_df=pd.read_csv("/kaggle/input/titanic/train.csv")
test_df=pd.read_csv("/kaggle/input/titanic/test.csv")
train_df.head() | Titanic - Machine Learning from Disaster |
6,244,686 | class RocAucEvaluation(Callback):
def __init__(self, validation_data=() , interval=1):
super(Callback, self ).__init__()
self.interval = interval
self.X_val, self.y_val = validation_data
self.max_score = 0
self.not_better_count = 0
def on_epoch_end(self, epoch, logs={}):
if epoch % self.interval == 0:
y_pred = self.mod... | y=train_df["Survived"].values
train_df.drop(["Survived","PassengerId"],inplace=True,axis=1)
test_df.drop(["PassengerId"],inplace=True,axis=1)
train_df.head() | Titanic - Machine Learning from Disaster |
6,244,686 | def get_model(features,clipvalue=1.,num_filters=40,dropout=0.5,embed_size=200):
features_input = Input(shape=(features.shape[1],))
inp = Input(shape=(maxlen,))
x = Embedding(max_features, embed_size, weights=[embedding_vectors], trainable=False,name='EmbeddingLayer' )(inp)
x, x_h, x_c = Bidirectional(GRU(num_filters, ... | train_df["train"]=1
test_df["train"]=0
combined_df=pd.concat([train_df,test_df] ) | Titanic - Machine Learning from Disaster |
6,244,686 | model = get_model(features)
batch_size = 32
epochs = 5
gc.collect()
K.clear_session()
num_folds = 5
predict = np.zeros(( test.shape[0],6))
scores = []
oof_predict = np.zeros(( train.shape[0],6))
kf = KFold(n_splits=num_folds, shuffle=True, random_state=239)
for train_index, test_index in kf.split(x_train):
kfold_y_tr... | Image("/kaggle/input/missing-values-mechanism/Missingtheory.png" ) | Titanic - Machine Learning from Disaster |
6,244,686 | print("Code Run Completed" )<load_from_csv> | null_df,del_rows=null_info(combined_df,"Null values on train Data" ) | Titanic - Machine Learning from Disaster |
6,244,686 | train = pd.read_csv(".. /input/jigsaw-toxic-comment-classification-challenge/train.csv")
test = pd.read_csv(".. /input/jigsaw-toxic-comment-classification-challenge/test.csv")
train.columns
<feature_engineering> | model_df= combined_df[null_df] | Titanic - Machine Learning from Disaster |
6,244,686 | train['length'] = train['comment_text'].apply(len )<categorify> | model_df.isna().sum() | Titanic - Machine Learning from Disaster |
6,244,686 | tokenizer = Tokenizer()
tokenizer.fit_on_texts(train['comment_text'])
train_x = tokenizer.texts_to_sequences(train['comment_text'])
train_x = pad_sequences(train_x, maxlen=300)
<count_values> | Image("/kaggle/input/missing-values-mechanism/Missingtheory.png" ) | Titanic - Machine Learning from Disaster |
6,244,686 | print("Word count:",len(tokenizer.word_counts))
<count_values> | def imputation(data):
data_numeric=data.select_dtypes(include=np.number)
data_categorical=data.select_dtypes(exclude=np.number)
display(Markdown("
display(data[data_numeric.isna().values].head(2))
display(data[data_categorical.isna().values].head(2))
data.fillna(data_numeric.median() ,inplace=True)
for i in data_cat... | Titanic - Machine Learning from Disaster |
6,244,686 | print("Document count:", tokenizer.document_count)
<categorify> | def remove_exists(data1,data2,del_rows):
data1.drop(data2.columns,axis=1,inplace=True)
data1.drop(del_rows,axis=1,inplace=True)
display(data1.head())
remove_exists(combined_df,model_df,del_rows ) | Titanic - Machine Learning from Disaster |
6,244,686 | embeddings_index = {}
file = '.. /input/glove840b300dtxt/glove.840B.300d.txt'
with open(file, encoding='utf8')as f:
for line in f:
values = line.rstrip().rsplit(' ')
word = values[0]
coefs = np.asarray(values[1:], dtype='float32')
embeddings_index[word] = coefs
print('Loaded %s word vectors.' % len(embeddings_index))... | df_cate.drop("Ticket",axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
6,244,686 | num_words = min(len(embeddings_index), len(tokenizer.word_index))
print(num_words )<feature_engineering> | model_df[df_cate.columns]=df_cate.copy()
model_df[df_num.columns]=df_num.copy() | Titanic - Machine Learning from Disaster |
6,244,686 | embedding_matrix = np.zeros(( num_words, 300))
total_invalid_record_count = 0
for item in tokenizer.word_index.items() :
try:
word, index = item[0], item[1]
embedding_matrix[index] = embeddings_index[word]
except Exception as e:
print("Exception occured for record:", word)
total_invalid_record_count += 1
print("total_... | model_df["Sex"]=model_df.Sex.map({"male":0,"female":1} ) | Titanic - Machine Learning from Disaster |
6,244,686 | print("total_invalid_record_count:",total_invalid_record_count)
print("Word Index:",len(tokenizer.word_index))
correct_records = len(tokenizer.word_index)- total_invalid_record_count
print("Total correct records:",correct_records )<feature_engineering> | model_df["Embarked"]=model_df.Embarked.map({"S":0,"C":1,"Q":2} ) | Titanic - Machine Learning from Disaster |
6,244,686 | embedding_matrix = np.zeros(( correct_records, 300))
total_invalid_record_count = 0
index_val = 0
for item in tokenizer.word_index.items() :
try:
word, index = item[0], item[1]
embedding_matrix[index_val] = embeddings_index[word]
index_val += 1
except Exception as e:
total_invalid_record_count += 1
print("total_invalid... | model_df["family"]=model_df["SibSp"] + model_df["Parch"] + 1 | Titanic - Machine Learning from Disaster |
6,244,686 | from keras.layers import Dense, Input, LSTM, Bidirectional, Conv1D
from keras.layers import Dropout, Embedding
from keras.preprocessing import text, sequence
from keras.layers import GlobalMaxPooling1D, GlobalAveragePooling1D, concatenate, SpatialDropout1D
from keras.models import Model
from keras.models import Sequent... | titles = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
model_df['Title'] = model_df.Name.str.extract('([A-Za-z]+)\.', expand= False)
model_df['Title'] = model_df['Title'].replace(['Lady', 'Countess','Capt', 'Col','Don', 'Dr','Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
model_df['Title'] = model_df['Ti... | Titanic - Machine Learning from Disaster |
6,244,686 | model = Sequential()
model.add(Embedding(correct_records, 300, weights=[embedding_matrix], input_length=300))
model.add(LSTM(128))
model.add(Dense(6, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary() )<split> | model_df['Age'] = model_df['Age'].astype(int)
model_df.loc[ model_df['Age'] <= 11, 'Age'] = 0
model_df.loc[(model_df['Age'] > 11)&(model_df['Age'] <= 18), 'Age'] = 1
model_df.loc[(model_df['Age'] > 18)&(model_df['Age'] <= 22), 'Age'] = 2
model_df.loc[(model_df['Age'] > 22)&(model_df['Age'] <= 27), 'Age'] = 3
model_df.... | Titanic - Machine Learning from Disaster |
6,244,686 | train_y = train[['toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate']]
X_train, X_test, y_train, y_test = train_test_split(train_x, train_y, test_size=0.33, random_state=42 )<train_model> | model_df['Fare'] = model_df['Fare'].astype(int)
model_df.loc[ model_df['Fare'] <= 7.91, 'Fare'] = 0
model_df.loc[(model_df['Fare'] > 7.91)&(model_df['Fare'] <= 14.454), 'Fare'] = 1
model_df.loc[(model_df['Fare'] > 14.454)&(model_df['Fare'] <= 31), 'Fare'] = 2
model_df.loc[(model_df['Fare'] > 31)&(model_df['Fare'] <= 9... | Titanic - Machine Learning from Disaster |
6,244,686 | model.fit(X_train, y_train, epochs=1, batch_size=64 )<save_to_csv> | model_df.drop(["SibSp","Parch","Name"],axis=1,inplace=True)
model_df.head() | Titanic - Machine Learning from Disaster |
6,244,686 | tokenizer.fit_on_texts(test['comment_text'])
test_x = tokenizer.texts_to_sequences(test['comment_text'])
test_x = pad_sequences(test_x, maxlen=300)
predictions = model.predict(test_x, batch_size=64, verbose=1)
submission = pd.read_csv('.. /input/jigsaw-toxic-comment-classification-challenge/sample_submission.csv')
... | X_train=model_df[model_df.train==1]
X_test=model_df[model_df.train==0]
Y_train=y
X_train.drop("train",axis=1,inplace=True)
X_test.drop("train",axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
6,244,686 |
<import_modules> | sgd = linear_model.SGDClassifier(max_iter=5, tol=None)
sgd.fit(X_train, Y_train)
acc_sgd = round(sgd.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
6,244,686 | import pandas as pd<import_modules> | random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
6,244,686 | import pandas as pd<load_from_csv> | GBC = GradientBoostingClassifier()
GBC.fit(X_train, Y_train)
acc_GBC = round(GBC.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
6,244,686 | glove = pd.read_csv(".. /input/nb-svm-strong-linear-baseline/submission.csv")
subb = pd.read_csv('.. /input/fasttext-like-baseline-with-keras-lb-0-053/submission_bn_fasttext.csv')
ave = pd.read_csv('.. /input/toxic-avenger/submission.csv')
lstm = pd.read_csv('.. /input/toxicfiles/baselinelstm0069.csv')
svm = pd.rea... | logreg = LogisticRegression()
logreg.fit(X_train, Y_train)
acc_log = round(logreg.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
6,244,686 | col = col.tolist()
col.remove('id' )<feature_engineering> | knn = KNeighborsClassifier(n_neighbors = 3)
knn.fit(X_train, Y_train)
acc_knn = round(knn.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
6,244,686 | for i in col:
ble[i] =(2*subb[i] + 3*lstm[i] + 4*glove[i] + 5*svm[i] + ave[i])/ 15<save_to_csv> | gaussian = GaussianNB()
gaussian.fit(X_train, Y_train)
acc_gaussian = round(gaussian.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
6,244,686 | ble.to_csv('submission20.csv', index = False )<set_options> | perceptron = Perceptron(max_iter=5)
perceptron.fit(X_train, Y_train)
acc_perceptron = round(perceptron.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
6,244,686 | np.random.seed(42)
warnings.filterwarnings('ignore')
os.environ['OMP_NUM_THREADS'] = '4'<load_from_csv> | linear_svc = LinearSVC()
linear_svc.fit(X_train, Y_train)
acc_linear_svc = round(linear_svc.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
6,244,686 | EMBEDDING_FILE = '.. /input/fasttext-crawl-300d-2m/crawl-300d-2M.vec'
train = pd.read_csv('.. /input/jigsaw-toxic-comment-classification-challenge/train.csv')
test = pd.read_csv('.. /input/jigsaw-toxic-comment-classification-challenge/test.csv')
submission = pd.read_csv('.. /input/jigsaw-toxic-comment-classification-... | decision_tree = DecisionTreeClassifier()
decision_tree.fit(X_train, Y_train)
acc_decision_tree = round(decision_tree.score(X_train, Y_train)* 100, 2 ) | Titanic - Machine Learning from Disaster |
6,244,686 | max_features = 30000
maxlen = 100
embed_size = 300
tokenizer = text.Tokenizer(num_words=max_features)
tokenizer.fit_on_texts(list(X_train)+ list(X_test))
X_train = tokenizer.texts_to_sequences(X_train)
X_test = tokenizer.texts_to_sequences(X_test)
x_train = sequence.pad_sequences(X_train, maxlen=maxlen)
x_test = se... | results = pd.DataFrame({
'Model': ['Support Vector Machines','GBC', 'KNN', 'Logistic Regression',
'Random Forest', 'Naive Bayes', 'Perceptron',
'Stochastic Gradient Decent',
'Decision Tree'],
'Score': [acc_linear_svc,acc_GBC, acc_knn, acc_log,
acc_random_forest, acc_gaussian, acc_perceptron,
acc_sgd, acc_decision_tree]... | 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.