kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,612,785 | sex_mapping = {"male": 0, "female": 1}
train['Sex'] = train['Sex'].map(sex_mapping)
test['Sex'] = test['Sex'].map(sex_mapping)
train.head()<categorify> | for i in index_nan_age:
age_predict=train_df["Age"][(( train_df["SibSp"]==train_df.iloc[i]["SibSp"])&(train_df["Parch"]==train_df.iloc[i]["Parch"])&(train_df["Pclass"]==train_df.iloc[i]["Pclass"])) ].median()
age_med=train_df["Age"].median()
if not np.isnan(age_predict):
train_df["Age"].iloc[i]=age_predict
else:
train_... | Titanic - Machine Learning from Disaster |
10,612,785 | embarked_mapping = {"S": 1, "C": 2, "Q": 3}
train['Embarked'] = train['Embarked'].map(embarked_mapping)
test['Embarked'] = test['Embarked'].map(embarked_mapping)
train.head()<split> | train_df[train_df["Age"].isnull() ] | Titanic - Machine Learning from Disaster |
10,612,785 | predictors = train.drop(['Survived', 'PassengerId'], axis=1)
target = train["Survived"]
x_train, x_val, y_train, y_val = train_test_split(predictors, target, test_size = 0.22, random_state = 0 )<predict_on_test> | s="Braund, Mr.Owen Harris"
s.split("." ) | Titanic - Machine Learning from Disaster |
10,612,785 | gaussian = GaussianNB()
gaussian.fit(x_train, y_train)
y_pred = gaussian.predict(x_val)
acc_gaussian = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_gaussian )<compute_train_metric> | s.split(".")[0].split("," ) | Titanic - Machine Learning from Disaster |
10,612,785 | logreg = LogisticRegression()
logreg.fit(x_train, y_train)
y_pred = logreg.predict(x_val)
acc_logreg = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_logreg )<compute_train_metric> | s.split(".")[0].split(",")[1] | Titanic - Machine Learning from Disaster |
10,612,785 | svc = SVC()
svc.fit(x_train, y_train)
y_pred = svc.predict(x_val)
acc_svc = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_svc )<compute_train_metric> | s.split(".")[0].split(",")[-1] | Titanic - Machine Learning from Disaster |
10,612,785 | linear_svc = LinearSVC()
linear_svc.fit(x_train, y_train)
y_pred = linear_svc.predict(x_val)
acc_linear_svc = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_linear_svc )<compute_train_metric> | name=train_df["Name"]
train_df["Title"]=[ i.split(".")[0].split(",")[-1].strip() for i in name] | Titanic - Machine Learning from Disaster |
10,612,785 | perceptron = Perceptron()
perceptron.fit(x_train, y_train)
y_pred = perceptron.predict(x_val)
acc_perceptron = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_perceptron )<train_model> | train_df["Title"].value_counts() | Titanic - Machine Learning from Disaster |
10,612,785 | decisiontree = DecisionTreeClassifier()
decisiontree.fit(x_train, y_train)
y_pred = decisiontree.predict(x_val)
acc_decisiontree = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_decisiontree )<train_model> | train_df["Title"]=train_df["Title"].replace(["Lady","the Countess","Capt","Col","Don","Dr","Major","Rev","Sir","Jonkheer","Dona"],"other" ) | Titanic - Machine Learning from Disaster |
10,612,785 | randomforest = RandomForestClassifier()
randomforest.fit(x_train, y_train)
y_pred = randomforest.predict(x_val)
acc_randomforest = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_randomforest )<compute_train_metric> | train_df["Title"].value_counts() | Titanic - Machine Learning from Disaster |
10,612,785 | knn = KNeighborsClassifier()
knn.fit(x_train, y_train)
y_pred = knn.predict(x_val)
acc_knn = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_knn )<predict_on_test> | train_df["Title"]=[0 if i == "Master" else 1 if i== "Miss" or i=="Ms" or i=="Mlle" or i=="Mrs" else 2 if i=="Mr" else 3 for i in train_df["Title"]] | Titanic - Machine Learning from Disaster |
10,612,785 | sgd = SGDClassifier()
sgd.fit(x_train, y_train)
y_pred = sgd.predict(x_val)
acc_sgd = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_sgd )<predict_on_test> | train_df.drop(labels=["Name"],axis=1,inplace=True ) | Titanic - Machine Learning from Disaster |
10,612,785 | gbk = GradientBoostingClassifier()
gbk.fit(x_train, y_train)
y_pred = gbk.predict(x_val)
acc_gbk = round(accuracy_score(y_pred, y_val)* 100, 2)
print(acc_gbk )<create_dataframe> | train_df=pd.get_dummies(train_df,columns=["Title"] ) | Titanic - Machine Learning from Disaster |
10,612,785 | models = pd.DataFrame({
'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression',
'Random Forest', 'Naive Bayes', 'Perceptron', 'Linear SVC',
'Decision Tree', 'Stochastic Gradient Descent', 'Gradient Boosting Classifier','XGBClassifier'],
'Score': [acc_svc, acc_knn, acc_logreg,
acc_randomforest, acc_gaussian, ... | train_df["Fsize"]=train_df["SibSp"] + train_df["Parch"] + 1 | Titanic - Machine Learning from Disaster |
10,612,785 | ids = test['PassengerId']
predictions = gbk.predict(test.drop('PassengerId', axis=1))
output = pd.DataFrame({ 'PassengerId' : ids, 'Survived': predictions })
output.to_csv('./submission.csv', index=False )<set_options> | train_df["family-size"]=[1 if i<5 else 0 for i in train_df["Fsize"]] | Titanic - Machine Learning from Disaster |
10,612,785 | %matplotlib inline
warnings.filterwarnings('ignore')
<load_from_csv> | train_df=pd.get_dummies(train_df,columns=["family-size"] ) | Titanic - Machine Learning from Disaster |
10,612,785 | df = pd.read_csv('/kaggle/input/eval-lab-2-f464/train.csv')
test = pd.read_csv('/kaggle/input/eval-lab-2-f464/test.csv' )<prepare_x_and_y> | train_df=pd.get_dummies(train_df,columns=["Embarked"] ) | Titanic - Machine Learning from Disaster |
10,612,785 | num_features = ['id','chem_1', 'chem_2', 'chem_4','chem_5','chem_6','attribute']
num_features1 = ['chem_1', 'chem_2', 'chem_4','chem_5','chem_6','attribute']
X_train = df[num_features]
y_train = df["class"]
X = X_train
y = y_train<import_modules> | a=" A./5.2152" | Titanic - Machine Learning from Disaster |
10,612,785 |
<predict_on_test> | tickets=[]
for i in list(train_df.Ticket):
if not i.isdigit() :
tickets.append(i.replace(".","" ).replace("/","" ).strip().split() [0])
else:
tickets.append("x")
train_df["Ticket"]=tickets | Titanic - Machine Learning from Disaster |
10,612,785 | clf1 = XGBClassifier().fit(X[num_features],y)
y_pred1 = clf1.predict(test[num_features])
clf2 = XGBClassifier().fit(X[num_features1],y)
y_pred2 = clf2.predict(test[num_features1] )<save_to_csv> | train_df=pd.get_dummies(train_df,columns=["Ticket"],prefix="T" ) | Titanic - Machine Learning from Disaster |
10,612,785 | answer = pd.DataFrame(data={'id':test['id'],'class':y_pred1})
answer.to_csv('final1.csv',index=False)
answer = pd.DataFrame(data={'id':test['id'],'class':y_pred2})
answer.to_csv('final2.csv',index=False )<import_modules> | train_df["Pclass"]=train_df["Pclass"].astype("category" ) | Titanic - Machine Learning from Disaster |
10,612,785 | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
<load_from_csv> | train_df=pd.get_dummies(train_df,columns=["Pclass"] ) | Titanic - Machine Learning from Disaster |
10,612,785 | dataset = pd.read_csv('.. /input/eval-lab-2-f464/train.csv' )<load_from_csv> | train_df.Sex=train_df.Sex.astype("category" ) | Titanic - Machine Learning from Disaster |
10,612,785 | test = pd.read_csv('.. /input/eval-lab-2-f464/test.csv' )<count_missing_values> | train_df.Sex.value_counts() | Titanic - Machine Learning from Disaster |
10,612,785 | dataset.isnull().sum()<drop_column> | train_df=pd.get_dummies(train_df,columns=["Sex"] ) | Titanic - Machine Learning from Disaster |
10,612,785 | dataset.drop(['id'], axis = 1, inplace = True )<prepare_x_and_y> | train_df.drop(labels=["PassengerId", "Cabin"],axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
10,612,785 | X = dataset[dataset.drop(['class'], axis = 1 ).columns].values
y = dataset['class'].values<split> | train_df.drop(labels=["SibSp", "Parch"],axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
10,612,785 | train_x, test_x, train_y, test_y = train_test_split(X, y, test_size = 20/120 )<train_model> | train_df.Sex_0.value_counts() | Titanic - Machine Learning from Disaster |
10,612,785 | clf = DecisionTreeClassifier(random_state = 42)
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)) )<train_model> | from sklearn.model_selection import train_test_split, StratifiedKFold, GridSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTr... | Titanic - Machine Learning from Disaster |
10,612,785 | clf = RandomForestClassifier(random_state = 42)
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)) )<train_model> | test=train_df[train_df_len:] | Titanic - Machine Learning from Disaster |
10,612,785 | clf = GradientBoostingClassifier(random_state = 42)
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)) )<train_model> | test.drop(labels=["Survived"], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
10,612,785 | clf = AdaBoostClassifier(random_state = 42)
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)) )<compute_train_metric> | train=train_df[:train_df_len]
X_train= train.drop(labels=["Survived"],axis=1)
y_train=train.Survived
print("X_train",len(X_train))
print("y_train",len(y_train))
X_train, X_test, y_train, y_test=train_test_split(X_train, y_train, test_size=0.10, random_state=42)
print("X_train",len(X_train))
print("X_test",len(X_test)... | Titanic - Machine Learning from Disaster |
10,612,785 | clf = ExtraTreesClassifier(random_state = 42, max_depth = 10, n_estimators = 1000, min_samples_split = 2)
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)))
scoring = ['accuracy']
scores = cross_validate(clf, X, y, cv=6, scoring = scoring)
print(np.mean(scores['test_accuracy']))<compute_tr... | logreg=LogisticRegression(solver ='lbfgs',multi_class ='multinomial',max_iter = 500)
logreg.fit(X_train,y_train ) | Titanic - Machine Learning from Disaster |
10,612,785 | clf = BernoulliNB()
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)) )<train_model> | acc_log_train=round(logreg.score(X_train,y_train)*100,2 ) | Titanic - Machine Learning from Disaster |
10,612,785 | clf = LogisticRegression(random_state = 42, penalty='l1')
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)) )<train_on_grid> | acc_log_test=round(logreg.score(X_test,y_test)*100,2 ) | Titanic - Machine Learning from Disaster |
10,612,785 |
<compute_train_metric> | print("Training accuracy {}".format(acc_log_train))
print("Test accuracy {}".format(acc_log_test)) | Titanic - Machine Learning from Disaster |
10,612,785 | clf = SGDClassifier()
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)))
print(accuracy_score(train_y, clf.predict(train_x)) )<train_model> | nb=GaussianNB()
nb.fit(X_train,y_train)
acc_nb_train=round(nb.score(X_train,y_train)*100,2)
acc_nb_test=round(nb.score(X_test,y_test)*100,2)
print(acc_nb_train)
print(acc_nb_test)
| Titanic - Machine Learning from Disaster |
10,612,785 | clf = KNeighborsClassifier(n_neighbors = 5, leaf_size = 10, weights = 'distance', algorithm = 'auto')
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)))
print(accuracy_score(train_y, clf.predict(train_x)) )<train_on_grid> | random_state=42
classifier=[DecisionTreeClassifier(random_state=random_state),
SVC(random_state=random_state),
RandomForestClassifier(random_state=random_state),
LogisticRegression(random_state=random_state),
KNeighborsClassifier() ]
dt_param_grid={"min_samples_split": range(10,500,20),
"max_depth": range(1,20,2)}
svc_... | Titanic - Machine Learning from Disaster |
10,612,785 | clf = XGBClassifier()
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)) )<train_on_grid> | range(len(classifier)) | Titanic - Machine Learning from Disaster |
10,612,785 |
<compute_train_metric> | cv_result=[]
best_estimators=[]
for i in range(len(classifier)) :
clf=GridSearchCV(classifier[i],param_grid=classifier_param[i],
cv=StratifiedKFold(n_splits=10),scoring="accuracy",
n_jobs=-1,
verbose=1
)
clf.fit(X_train,y_train)
cv_result.append(clf.best_score_)
best_estimators.append(clf.best_estimator_)
print(cv... | Titanic - Machine Learning from Disaster |
10,612,785 | clf = ExtraTreesClassifier(random_state = 42)
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)))
print(accuracy_score(train_y, clf.predict(train_x)) )<compute_train_metric> | votingC=VotingClassifier(estimators=[("dt",best_estimators[0]),
("rfc",best_estimators[2]),
("lr",best_estimators[3])],
voting="soft",n_jobs=-1)
votingC=votingC.fit(X_train,y_train)
print(accuracy_score(votingC.predict(X_test),y_test)) | Titanic - Machine Learning from Disaster |
10,612,785 | clf = ExtraTreesClassifier(random_state = 0)
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)))
print(accuracy_score(train_y, clf.predict(train_x)) )<compute_train_metric> | test_survived=pd.Series(votingC.predict(test),name="Survived")
results=pd.concat([test_PassengerId,test_survived],axis=1)
results.to_csv("titanic.csv",index=False ) | Titanic - Machine Learning from Disaster |
10,612,785 | clf = GaussianNB()
clf.fit(train_x, train_y)
print(accuracy_score(test_y, clf.predict(test_x)) )<prepare_x_and_y> | test_survived=pd.Series(votingC.predict(test),name="Survived" ).astype(int)
results=pd.concat([test_PassengerId,test_survived],axis=1)
results.to_csv("titanic.csv",index=False ) | Titanic - Machine Learning from Disaster |
14,169,066 | test_X = test[test.drop('id', axis = 1 ).columns].values<predict_on_test> | train_df = pd.read_csv("/kaggle/input/titanic/train.csv")
train_df.head() | Titanic - Machine Learning from Disaster |
14,169,066 | gsc = RandomForestClassifier(n_estimators=1000)
gsc.fit(X, y)
print(accuracy_score(train_y, gsc.predict(train_x)))
print(accuracy_score(test_y, gsc.predict(test_x)))
test_Y = gsc.predict(test_X )<create_dataframe> | test_df = pd.read_csv("/kaggle/input/titanic/test.csv")
test_df.head() | Titanic - Machine Learning from Disaster |
14,169,066 | data = {'id':test['id'],'class':test_Y}
df = pd.DataFrame(data )<save_to_csv> | train_df[['Sex', 'Survived']].groupby(['Sex'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,169,066 | df.to_csv(path_or_buf ='output.csv', index = False )<load_from_csv> | train_df[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,169,066 | df_train = pd.read_csv('/kaggle/input/1056lab-diabetes-diagnosis/train.csv', index_col=0)
df_test = pd.read_csv('/kaggle/input/1056lab-diabetes-diagnosis/test.csv', index_col=0 )<set_options> | train_df[['SibSp', 'Survived']].groupby(['SibSp'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,169,066 | %matplotlib inline
sns.countplot(x='Diabetes', data=df_train)
plt.show()<categorify> | train_df[['Parch', 'Survived']].groupby(['Parch'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,169,066 | df_train_dummies = pd.get_dummies(df_train_over, columns=['Gender'], drop_first=True)
df_test_dummies = pd.get_dummies(df_test, columns=['Gender'], drop_first=True )<train_model> | train_df[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False ).mean().sort_values(by='Survived', ascending=False)
| Titanic - Machine Learning from Disaster |
14,169,066 | X_train_dummies = df_train_dummies.drop(columns='Diabetes' ).values
y_train_dummies = df_train_dummies['Diabetes'].values
rfc = RandomForestClassifier(max_depth=4, n_estimators=50, criterion='gini')
rfc.fit(X_train_dummies, y_train_dummies )<predict_on_test> | all_df = [train_df, test_df] | Titanic - Machine Learning from Disaster |
14,169,066 | X_test = df_test_dummies.values
y_pred = rfc.predict_proba(X_test)[:, 1]<save_to_csv> | for df in all_df:
df['Sex'] = df['Sex'].map({'male': 0, 'female': 1} ).astype(int)
train_df.head() | Titanic - Machine Learning from Disaster |
14,169,066 | submit = pd.read_csv('/kaggle/input/1056lab-diabetes-diagnosis/sampleSubmission.csv')
submit['Diabetes'] = y_pred
submit.to_csv('submission.csv', index=False )<import_modules> | common_Pclass = 'S'
train_df['Embarked'].fillna(common_Pclass, inplace=True)
train_df['Embarked'] = train_df['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int)
test_df['Embarked'] = test_df['Embarked'].map({'S': 0, 'C': 1, 'Q': 2} ).astype(int)
train_df.head() | Titanic - Machine Learning from Disaster |
14,169,066 | sys.path.insert(0, '/kaggle/input/efficientnetmodel/efficientnetModel.py')
sys.path.append('/kaggle/input/efficientnetmodel')
sys.path.append('/kaggle/input/efficientnetmodel/utils.py')
<init_hyperparams> | train_df['Cabin'].isna().sum() | Titanic - Machine Learning from Disaster |
14,169,066 |
IMAGE_SIZE = 320
def int_parameter(level, maxval):
return int(level * maxval / 10)
def float_parameter(level, maxval):
return float(level)* maxval / 10.
def sample_level(n):
return np.random.uniform(low=0.1, high=n)
def autocontrast(pil_img, _):
return ImageOps.autocontrast(pil_img)
def equalize(pil_img, _):
... | train_df['Cabin'].fillna('X', inplace=True)
test_df['Cabin'].fillna('X', inplace=True ) | Titanic - Machine Learning from Disaster |
14,169,066 | use_gpu = torch.cuda.is_available()
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
dir_test = ".. /input/issm2020-ai-challenge/semTest/semTest/"
data_dir = '.. /input/issm2020-ai-challenge/semTrain/semTrain'
batch_size = 16
lr = 0.01
momentum = 0.9
num_epochs = 100
input_size = 224
class_num = 10
net_name = 'efficientnet-ori... | train_df['Cabin'].value_counts() | Titanic - Machine Learning from Disaster |
14,169,066 | model_ft=torch.load('/kaggle/input/efficientnetmodel/efficientnet-oriDuAug-b799.pth')
model_ft = model_ft.eval().cuda()
test_csv(model_ft )<prepare_x_and_y> | for df in all_df:
df['Cabin'] = df['Cabin'].astype(str ).str[0]
test_df['Cabin'] | Titanic - Machine Learning from Disaster |
14,169,066 | %matplotlib inline
train = pd.read_csv('.. /input/cars-train.csv')
val = pd.read_csv('.. /input/cars-test.csv')
x_train = pd.get_dummies(train.drop(['class', 'car.id'], axis=1))
x_val = pd.get_dummies(val.drop(['class', 'car.id'], axis=1))
y_train = pd.get_dummies(train['class'])
y_val = pd.get_dummies(val['class'] ... | train_df.groupby(['Survived', 'Cabin'])['PassengerId'].sum() | Titanic - Machine Learning from Disaster |
14,169,066 | model = Sequential()
model.add(Dense(128, input_dim=(21), activation = 'selu'))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Dense(128, activation = 'selu'))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Dense(128, activation = 'selu'))
model.add(Dropout(0.2))
model.add(BatchN... | for df in all_df:
df.loc[(df['Cabin'] == 'A'), 'Cabin'] = 0
df.loc[(df['Cabin'] == 'B'), 'Cabin'] = 1
df.loc[(df['Cabin'] == 'C'), 'Cabin'] = 1
df.loc[(df['Cabin'] == 'D'), 'Cabin'] = 1
df.loc[(df['Cabin'] == 'E'), 'Cabin'] = 1
df.loc[(df['Cabin'] == 'F'), 'Cabin'] = 0
df.loc[(df['Cabin'] == 'G'), 'Cabin'] = 0
df.loc[(... | Titanic - Machine Learning from Disaster |
14,169,066 | model.fit(x_train, y_train, epochs = 600, batch_size = 32 )<compute_test_metric> | guess_df = np.zeros(( 3,2))
guess_df | Titanic - Machine Learning from Disaster |
14,169,066 | score = model.evaluate(x_train, y_train)
print('
train loss is: ' + str(score[0].round(4)))
print('train accuracy is: ' + str(score[1]))
score = model.evaluate(x_val, y_val)
print('
test loss is: ' + str(score[0].round(4)))
print('test accuracy is: ' + str(score[1]))<load_from_csv> | for df in all_df:
for i in range(0,3):
for j in range(0,2):
guess = df[(df['Pclass']==i+1)&(df['Sex']==j)]['Age'].dropna()
guess_df[i,j] = guess.median()
for i in range(0,3):
for j in range(0,2):
df.loc[(df['Age'].isna())&(df['Pclass']==i+1)&(df['Sex']==j), 'Age'] = guess_df[i,j]
df['Age'] = df['Age'].dropna().astype(i... | Titanic - Machine Learning from Disaster |
14,169,066 | test = pd.read_csv('.. /input/cars-final-prediction.csv')
test_new = pd.get_dummies(test.drop(['car.id'], axis=1))
preds = model.predict_classes(test_new)
keras_dict = {0: 'acc', 1: 'good', 2: 'unacc', 3: 'vgood'}
converted_preds = []
for prediction in preds:
converted_preds.append(keras_dict[prediction])
test['clas... | for df in all_df:
df.loc[(df['Age'] <= 16), 'Age'] = 0
df.loc[(df['Age'] > 16)&(df['Age'] <= 32), 'Age'] = 1
df.loc[(df['Age'] > 32)&(df['Age'] <= 48), 'Age'] = 2
df.loc[(df['Age'] > 48)&(df['Age'] <= 64), 'Age'] = 3
df.loc[(df['Age'] > 64), 'Age'] = 4
train_df.head() | Titanic - Machine Learning from Disaster |
14,169,066 | output_csv.to_csv('car-submission.csv', index=False )<install_modules> | train_df.groupby('Age', as_index=False)['Survived'].mean().sort_values(by='Age', ascending=True ) | Titanic - Machine Learning from Disaster |
14,169,066 | !pip install.. /input/kaggle-efficientnet-repo/efficientnet-1.0.0-py3-none-any.whl<set_options> | train_df.isna().sum() | Titanic - Machine Learning from Disaster |
14,169,066 | %matplotlib inline
pd.set_option('max_rows', 1000)
pd.set_option('max_columns', 1000 )<set_options> | train_df.drop(['AgeBand'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,169,066 | def seed_everything(seed=42):
os.environ['PYTHONHASHSEED'] = str(seed)
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
def get_strategy() :
try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
print('Running on TPU {}'.format(tpu.cluster_spec().as_dict() ['worker']))
except ValueError:
tpu... | train_df.isna().sum() | Titanic - Machine Learning from Disaster |
14,169,066 | INPUT_DIR = '.. /input/ailab-ml-training-1/'
ARTIFACT_DIR = '.. /input/v2-5-ailab1-training/'
PATH = {
'train': os.path.join(INPUT_DIR, 'train.csv'),
'submission': os.path.join(INPUT_DIR, 'sample_submission.csv'),
'train_image_dir': os.path.join(INPUT_DIR, 'train_images/train_images'),
'test_image_dir': os.path.join(IN... | test_df.isna().sum() | Titanic - Machine Learning from Disaster |
14,169,066 | seed_everything(args.seed )<load_from_csv> | test_df['Fare'].fillna(test_df['Fare'].median() , inplace=True ) | Titanic - Machine Learning from Disaster |
14,169,066 | train_df = pd.read_csv(PATH['train'])
submission_df = pd.read_csv(PATH['submission'] )<prepare_x_and_y> | for df in all_df:
df.loc[df['Fare'] <= 7.91, 'Fare'] = 0
df.loc[(df['Fare'] > 7.91)&(df['Fare'] <= 14.454), 'Fare'] = 1
df.loc[(df['Fare'] > 14.454)&(df['Fare'] <= 31.0), 'Fare'] = 2
df.loc[(df['Fare'] > 31.0), 'Fare'] = 3
df['Fare'] = df['Fare'].astype(int)
train_df.head() | Titanic - Machine Learning from Disaster |
14,169,066 | def normalize(image):
image -= tf.constant([0.485 * 255, 0.456 * 255, 0.406 * 255])
image /= tf.constant([0.229 * 255, 0.224 * 255, 0.225 * 255])
return image
def get_model(
input_size=(224, 224, 3),
backbone='efficientnet-b0',
weights='imagenet',
n_classes=10,
):
print(f'Using backbone {backbone} and weights {weig... | train_df.drop('FareBand', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,169,066 | oof = np.zeros(( len(train_df), args.n_classes))
predictions = np.zeros(( len(submission_df), args.n_classes))
train_fnames = train_df[ID].tolist()
submission_fnames = submission_df[ID].tolist()
gcs_path = KaggleDatasets().get_gcs_path(PATH['gcs'])
for fold in range(args.n_splits):
if fold not in args.use_folds:
print... | for df in all_df:
df['FamilySize'] = df['SibSp'] + df['Parch'] + 1
train_df.groupby('FamilySize', as_index=False)['Survived'].mean().sort_values('Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,169,066 | score = accuracy_score(train_df[TARGET].values, np.argmax(oof, axis=1))
print(f'CV score: {score:.5f}' )<save_to_csv> | for df in all_df:
df['Family'] = 0
df.loc[(df['FamilySize'] >= 5), 'Family'] = 1
df.loc[(df['FamilySize'] > 1)&(df['FamilySize'] < 5), 'Family'] = 2
train_df.groupby('Family', as_index=False)['Survived'].mean().sort_values('Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
14,169,066 | np.save('oof', oof)
np.save('predictions', predictions)
submission_df[TARGET] = np.argmax(predictions, axis=1 ).tolist()
submission_df.to_csv('submission.csv', index=False)
FileLink('submission.csv' )<import_modules> | train_df.drop('FamilySize', axis=1, inplace=True)
test_df.drop('FamilySize', axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,169,066 | print(os.listdir(".. /input"))
<load_from_csv> | for df in all_df:
title = df['Name'].apply(lambda x:x.split(',')[1].split('.')[0] ).copy()
df['Title'] = title.str.strip()
train_df.groupby(['Title', 'Survived'])['PassengerId'].count().sort_values(ascending=False ) | Titanic - Machine Learning from Disaster |
14,169,066 | train_df = pd.read_csv('.. /input/train.csv' )<create_dataframe> | title_map = {"Mr": 0, "Miss": 1, "Mrs": 2, "Master": 3, "Rare": 4}
for df in all_df:
df['Title'] = df['Title'].map(title_map)
df['Title'] = df['Title'].fillna(0)
df['Title'] = df['Title'].astype(int)
all_df = [train_df, test_df]
train_df.head() | Titanic - Machine Learning from Disaster |
14,169,066 | train_data = []
for i, row in train_df.iterrows() :
for text in row['text'].split('.'):
train_data.append([row['president'], text])
train_data = pd.DataFrame(train_data, columns=['president', 'text'] )<string_transform> | train_df.drop(['Name', 'Ticket'], axis=1, inplace=True)
test_df.drop(['Name', 'Ticket'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
14,169,066 | def remove_punctuation_numbers(text):
punc_numbers = string.punctuation + '0123456789'
return ''.join([l for l in text if l not in punc_numbers] )<string_transform> | y_train = train_df['Survived']
features = ['Pclass', 'Sex', 'Age', 'Fare', 'Embarked', \
'Family', 'SibSp', 'Parch', 'Title', 'Cabin']
X_train = train_df[features]
X_test = test_df[features] | Titanic - Machine Learning from Disaster |
14,169,066 | def tokeniser(text):
return TreebankWordTokenizer().tokenize(text )<not_enough_vertices> | forest = RandomForestClassifier(n_estimators=153, max_depth=5, random_state=1)
forest.fit(X_train, y_train)
y_pred = forest.predict(X_train)
print('Accuracy Score: ', forest.score(X_train, y_train))
print('
Confusion Matric: ', confusion_matrix(y_train, y_pred))
print('
Classification Report: ', classification_repor... | Titanic - Machine Learning from Disaster |
14,169,066 | <not_enough_vertices><EOS> | predict = forest.predict(X_test)
report = pd.DataFrame({'PassengerId': test_df.PassengerId, 'Survived': predict})
report.to_csv('submission.csv', index=False)
print("Your submission was successfully saved!" ) | Titanic - Machine Learning from Disaster |
13,816,070 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<string_transform> | pd.options.mode.chained_assignment = None
%matplotlib inline
warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
13,816,070 | def data_cleaner(text):
text = text.lower()
text = remove_punctuation_numbers(text)
lst = tokeniser(text)
lst = remove_stop_words(lst)
return ' '.join(lemmetizer(lst))<feature_engineering> | train_data = pd.read_csv(".. /input/titanic/train.csv", index_col="PassengerId")
test_data = pd.read_csv(".. /input/titanic/test.csv", index_col="PassengerId" ) | Titanic - Machine Learning from Disaster |
13,816,070 | train_data['clean_text'] = train_data['text'].apply(data_cleaner )<categorify> | print(train_data["Pclass"].unique())
train_data[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
13,816,070 | train_data.president = train_data.president.map({'deKlerk':0,'Mandela':1,
'Mbeki':2, 'Motlanthe':3,
'Zuma': 4, 'Ramaphosa':5} )<split> | train_data.Name[1].split() | Titanic - Machine Learning from Disaster |
13,816,070 | X = train_data.clean_text
y = train_data.president
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.33,
random_state=0,
stratify=y )<not_enough_vertices> | train_data = train_data.assign(fname = train_data.Name.str.split("," ).str[0])
train_data["title"] = pd.Series([i.split(",")[1].split(".")[0].strip() for i in train_data.Name], index=train_data.index ) | Titanic - Machine Learning from Disaster |
13,816,070 | vect = CountVectorizer(ngram_range=(1,2))<feature_engineering> | test_data = test_data.assign(fname = test_data.Name.str.split("," ).str[0])
test_data["title"] = pd.Series([i.split(",")[1].split(".")[0].strip() for i in test_data.Name], index=test_data.index)
train_data.drop("Name", axis=1, inplace=True)
test_data.drop("Name", axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
13,816,070 | X_train_ = vect.fit_transform(X_train )<choose_model_class> | print(test_data.fname.nunique())
print(test_data.title.nunique() ) | Titanic - Machine Learning from Disaster |
13,816,070 | log = LogisticRegressionCV(dual=False, penalty='l2', multi_class='multinomial' )<train_model> | train_data["title"] = train_data['title'].replace(other_titles, 'Other')
train_data["title"] = train_data["title"].map({"Mr":0, "Miss":1, "Ms" : 1 , "Mme":1, "Mlle":1, "Mrs":1, "Master":2, "Other":3})
test_data["title"] = test_data['title'].replace(other_titles, 'Other')
test_data["title"] = test_data["title"].map({... | Titanic - Machine Learning from Disaster |
13,816,070 | log.fit(X_train_, y_train )<compute_train_metric> | print(train_data.title)
print(test_data.title.isna().sum() ) | Titanic - Machine Learning from Disaster |
13,816,070 | print(accuracy_score(y_train, log.predict(X_train_)) )<compute_test_metric> | oh = OneHotEncoder(handle_unknown="ignore", sparse = False)
train_data = train_data.join(pd.DataFrame(oh.fit_transform(train_data[["fname", "title"]]), index = train_data.index))
test_data = test_data.join(pd.DataFrame(oh.transform(test_data[["fname", "title"]]), index = test_data.index))
train_data.drop("fname", axis... | Titanic - Machine Learning from Disaster |
13,816,070 | print(accuracy_score(y_test, log.predict(vect.transform(X_test))))<load_from_csv> | print(train_data["Sex"].unique())
train_data[['Sex', 'Survived']].groupby(['Sex'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
13,816,070 | test_data = pd.read_csv('.. /input/test.csv' )<feature_engineering> | interactions = train_data.assign(sex_class = train_data['Sex'] + "_" + train_data['Pclass'].astype("str"))
interactions[['sex_class', 'Survived']].groupby(['sex_class'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
13,816,070 | test_data.text = test_data.text.apply(data_cleaner )<predict_on_test> | train_data = train_data.assign(sex_class = train_data['Sex'] + "_" + train_data['Pclass'].astype("str"))
test_data = test_data.assign(sex_class = test_data['Sex'] + "_" + test_data['Pclass'].astype("str")) | Titanic - Machine Learning from Disaster |
13,816,070 | test_data['president'] = log.predict(vect.transform(test_data.text))<drop_column> | train_data = train_data.join(pd.get_dummies(train_data['Pclass'], prefix="Pclass"))
test_data = test_data.join(pd.get_dummies(test_data['Pclass'], prefix="Pclass")) | Titanic - Machine Learning from Disaster |
13,816,070 | test_data.drop('text', axis=1, inplace=True, )<save_to_csv> | train_data["Sex"] = train_data["Sex"].map({"female":0, "male":1})
test_data["Sex"] = test_data["Sex"].map({"female":0, "male":1} ) | Titanic - Machine Learning from Disaster |
13,816,070 | test_data.to_csv('Thapelo_log.csv',index=False )<import_modules> | train_data["sex_class"] = train_data["sex_class"].map({"female_1":0, "female_2":1, "female_3":2, "male_1":4, "male_2":5, "male_3":6})
test_data["sex_class"] = test_data["sex_class"].map({"female_1":0, "female_2":1, "female_3":2, "male_1":4, "male_2":5, "male_3":6} ) | Titanic - Machine Learning from Disaster |
13,816,070 | from sklearn.preprocessing import LabelEncoder
from sklearn.linear_model import LogisticRegression<load_from_csv> | def find_similar_passengers(id, dataset):
subset = dataset[(dataset.title == dataset.title[id])&
(dataset.Pclass == dataset.Pclass[id])]
if subset["Age"].mean() == "NaN":
subset = dataset[(dataset["sex_class"] == dataset.iloc[id]["sex_class"])]
if subset["Age"].mean() == "NaN":
subset = dataset[(dataset["sex"] == data... | Titanic - Machine Learning from Disaster |
13,816,070 | train_users_game1_df = pd.read_csv(".. /input/ds2019uec-task2/train_users_game1.csv")
train_users_game2_df = pd.read_csv(".. /input/ds2019uec-task2/train_users_game2.csv")
test_users_game1_df = pd.read_csv(".. /input/ds2019uec-task2/test_users_game1.csv" )<categorify> | no_ages = train_data[train_data["Age"].isna() ].index
for pid in no_ages:
train_data.Age[pid] = find_similar_passengers(pid, train_data)
no_ages_test = test_data[test_data["Age"].isna() ].index
for pid2 in no_ages_test:
test_data.Age[pid2] = find_similar_passengers(pid2, test_data ) | Titanic - Machine Learning from Disaster |
13,816,070 | train_user_encoder = LabelEncoder()
train_user_encoder.fit(np.concatenate([train_users_game1_df["user_id"], train_users_game2_df["user_id"]]))
print(train_user_encoder.classes_.shape)
game1_encoder = LabelEncoder()
game1_encoder.fit(np.concatenate([train_users_game1_df["game_title"], test_users_game1_df["game_title"]]... | train_data["age_group"] = pd.cut(train_data["Age"], bins=[0,5,65,100], labels=[0,1,2] ).astype("int64")
test_data["age_group"] = pd.cut(test_data["Age"], bins=[0,5,65,100], labels=[0,1,2] ).astype("int64" ) | Titanic - Machine Learning from Disaster |
13,816,070 | X = np.zeros(( 9393, 4155))
user_vec = train_user_encoder.transform(train_users_game1_df["user_id"])
game_vec = game1_encoder.transform(train_users_game1_df["game_title"])
for i, j in zip(user_vec, game_vec):
X[i, j] = 1<prepare_x_and_y> | train_data[['SibSp', 'Survived']].groupby(['SibSp'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
13,816,070 | Y_mat = np.zeros(( 9393, 1000))
user_vec = train_user_encoder.transform(train_users_game2_df["user_id"])
game_vec = train_users_game2_df["predict_game_id"]
for i, j in zip(user_vec, game_vec):
Y_mat[i, j] = 1<load_from_csv> | train_data[['Parch', 'Survived']].groupby(['Parch'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | 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.