kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
3,782,114 | def predict(xtest,input_name=None):
baggedpred=np.array([ 0.0 for d in range(0, xtest.shape[0])])
model= joblib.load(input_name)
preds=model.predict(xtest)
baggedpred+=preds
return baggedpred
<define_variables> | train_df[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
3,782,114 | names=["lag_confirmed_rate" + str(k+1)for k in range(size)]
for day in days_back_confimed:
names+=["days_ago_confirmed_count_" + str(day)]
for window in windows:
names+=["ma" + str(window)+ "_rate_confirmed" + str(k+1)for k in range(size)]
names+=["std" + str(window)+ "_rate_confirmed" + str(k+1)for k in range(size)]
n... | train_df[["SibSp", "Survived"]].groupby(['SibSp'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
3,782,114 | def decay_4_first_10_then_1_f(array):
arr=[1.0 for k in range(len(array)) ]
for j in range(len(array)) :
if j<10:
arr[j]=1.+(max(1,array[j])-1.) /4.
else :
arr[j]=1.
return arr
def decay_16_first_10_then_1_f(array):
arr=[1.0 for k in range(len(array)) ]
for j in range(len(array)) :
if j<10:
arr[j]=1.+(max(1,array[j... | train_df[["Parch", "Survived"]].groupby(['Parch'], as_index=False ).mean().sort_values(by='Survived', ascending=False ) | Titanic - Machine Learning from Disaster |
3,782,114 | key_to_confirmed_rate={}
key_to_fatality_rate={}
key_to_confirmed={}
key_to_fatality={}
print(len(features_cv), len(name_cv),len(standard_confirmed_cv),len(standard_fatalities_cv))
print(preds_confirmed_cv.shape,preds_confirmed_standard_cv.shape,preds_fatalities_cv.shape,preds_fatalities_standard_cv.shape)
for j in ra... | train_test_data = [train_df, test_df]
for dataset in train_test_data:
dataset['Title'] = dataset['Name'].str.extract('([A-Za-z]+)\.', expand=False)
train_df['Title'].value_counts() | Titanic - Machine Learning from Disaster |
3,782,114 | train_new=train[["Date","ConfirmedCases","Fatalities","key","rate_ConfirmedCases","rate_Fatalities"]]
test_new=pd.merge(test,train_new, how="left", left_on=["key","Date"], right_on=["key","Date"] ).reset_index(drop=True)
test_new<categorify> | test_df['Title'].value_counts() | Titanic - Machine Learning from Disaster |
3,782,114 | def fillin_columns(frame,key_column, original_name, training_horizon, test_horizon, unique_values, key_to_values):
keys=frame[key_column].values
original_values=frame[original_name].values.tolist()
print(len(keys), len(original_values), training_horizon ,test_horizon,len(key_to_values))
for j in range(unique_values):
c... | title_mapping = {"Mr": 0, "Miss": 1, "Mrs": 2,
"Master": 3, "Dr": 3, "Rev": 3, "Col": 3, "Major": 3, "Mlle": 3,"Countess": 3,
"Ms": 3, "Lady": 3, "Jonkheer": 3, "Don": 3, "Dona" : 3, "Mme": 3,"Capt": 3,"Sir": 3 }
for dataset in train_test_data:
dataset['Title'] = dataset['Title'].map(title_mapping ) | Titanic - Machine Learning from Disaster |
3,782,114 | if not sys.warnoptions:
warnings.simplefilter("ignore")
warnings.filterwarnings("ignore")
<compute_test_metric> | X_train_df = train_df.drop(columns=['Survived', 'PassengerId', 'Name', 'Ticket', 'Cabin'])
X_test_df = test_df.drop(columns=['PassengerId', 'Name', 'Ticket', 'Cabin'] ) | Titanic - Machine Learning from Disaster |
3,782,114 | def RMSLE(pred,actual):
return np.sqrt(np.mean(np.power(( np.log(pred+1)-np.log(actual+1)) ,2)) )<load_from_csv> | y_train_df = train_df['Survived']
y_test_df = test_df['PassengerId'] | Titanic - Machine Learning from Disaster |
3,782,114 | pd.set_option('mode.chained_assignment', None)
test = pd.read_csv("/kaggle/input/covid19-global-forecasting-week-4/test.csv")
train = pd.read_csv("/kaggle/input/covid19-global-forecasting-week-4/train.csv")
train['Province_State'].fillna('', inplace=True)
test['Province_State'].fillna('', inplace=True)
train['Date... | X_train_df.isnull().sum() | Titanic - Machine Learning from Disaster |
3,782,114 | feature_day = [1,20,50,100,200,500,1000]
def CreateInput(data):
feature = []
for day in feature_day:
data.loc[:,'Number day from ' + str(day)+ ' case'] = 0
if(train[(train['Country_Region'] == country)&(train['Province_State'] == province)&(train['ConfirmedCases'] < day)]['Date'].count() > 0):
fromday = train[(train['C... | X_test_df.isnull().sum() | Titanic - Machine Learning from Disaster |
3,782,114 | feature_day = [1,20,50,100,200,500,1000]
def CreateInput(data):
feature = []
for day in feature_day:
data.loc[:,'Number day from ' + str(day)+ ' case'] = 0
if(train[(train['Country_Region'] == country)&(train['Province_State'] == province)&(train['ConfirmedCases'] < day)]['Date'].count() > 0):
fromday = train[(train['C... | def impute_age(cols):
Age = cols[0]
Pclass = cols[1]
if pd.isnull(Age):
if Pclass == 1:
return 37
elif Pclass == 2:
return 29
else:
return 24
else:
return Age | Titanic - Machine Learning from Disaster |
3,782,114 | method_list = ['Exponential Smoothing','SARIMA']
method_val = [df_val_1,df_val_2]
for i in range(0,2):
df_val = method_val[i]
method_score = [method_list[i]] + [RMSLE(df_val[(df_val['ConfirmedCases'].isnull() == False)]['ConfirmedCases'].values,df_val[(df_val['ConfirmedCases'].isnull() == False)]['ConfirmedCases_hat'].... | X_train_df['Age'] = X_train_df[['Age','Pclass']].apply(impute_age,axis=1)
X_test_df['Age'] = X_test_df[['Age','Pclass']].apply(impute_age,axis=1 ) | Titanic - Machine Learning from Disaster |
3,782,114 | df_val = df_val_2
submission = df_val[['ForecastId','ConfirmedCases_hat','Fatalities_hat']]
submission.columns = ['ForecastId','ConfirmedCases','Fatalities']
submission.to_csv('submission.csv', index=False)
submission<set_options> | def Age_cat(x):
if x <=4 :
return 1
elif x>4 and x<=14:
return 2
elif x>14 and x<=30:
return 3
else:
return 4 | Titanic - Machine Learning from Disaster |
3,782,114 | warnings.filterwarnings("ignore" )<load_from_csv> | X_train_df['Age'] = X_train_df['Age'].apply(Age_cat)
X_test_df['Age'] = X_test_df['Age'].apply(Age_cat ) | Titanic - Machine Learning from Disaster |
3,782,114 | df_train=pd.read_csv(".. /input/covid19-global-forecasting-week-4/train.csv")
df_test=pd.read_csv(".. /input/covid19-global-forecasting-week-4/test.csv")
df_sub=pd.read_csv(".. /input/covid19-global-forecasting-week-4/submission.csv")
print(df_train.shape)
print(df_test.shape)
print(df_sub.shape )<count_unique_val... | X_train_df['With_someone'] = X_train_df['SibSp'] | X_train_df['Parch']
X_test_df['With_someone'] = X_test_df['SibSp'] | X_test_df['Parch']
X_train_df['Family'] = X_train_df['SibSp'] + X_train_df['Parch']+1
X_test_df['Family'] = X_test_df['SibSp'] + X_test_df['Parch']+1 | Titanic - Machine Learning from Disaster |
3,782,114 | print(f"Unique Countries: {len(df_train.Country_Region.unique())}" )<count_unique_values> | X_train_df['With_someone'] =X_train_df['With_someone'].apply(lambda x:1 if x >=1 else 0)
X_test_df['With_someone'] =X_test_df['With_someone'].apply(lambda x:1 if x >=1 else 0 ) | Titanic - Machine Learning from Disaster |
3,782,114 | print(f"Unique Regions: {df_train.shape[0]/len(df_train.Date.unique())}" )<count_values> | mod = X_train_df.Embarked.value_counts().argmax()
X_train_df.Embarked.fillna(mod, inplace=True ) | Titanic - Machine Learning from Disaster |
3,782,114 | df_train.Country_Region.value_counts()<count_missing_values> | fare_med = train_df.Fare.median()
X_test_df.Fare.fillna(fare_med, inplace=True ) | Titanic - Machine Learning from Disaster |
3,782,114 | print(f"Number of rows without Country_Region : {df_train.Country_Region.isna().sum() }" )<feature_engineering> | X_train_df.isnull().sum() | Titanic - Machine Learning from Disaster |
3,782,114 | df_train["UniqueRegion"]=df_train.Country_Region
df_train.UniqueRegion[df_train.Province_State.isna() ==False]=df_train.Province_State+" , "+df_train.Country_Region
df_train[df_train.Province_State.isna() ==False]<drop_column> | X_test_df.isnull().sum() | Titanic - Machine Learning from Disaster |
3,782,114 | df_train.drop(labels=["Id","Province_State","Country_Region"], axis=1, inplace=True )<feature_engineering> | X_train_df.replace({"male": 0, "female": 1}, inplace=True)
X_test_df.replace({"male": 0, "female": 1}, inplace=True)
X_train_df.replace({"S": 0, "C": 1, "Q": 2}, inplace=True)
X_test_df.replace({"S": 0, "C": 1, "Q": 2}, inplace=True ) | Titanic - Machine Learning from Disaster |
3,782,114 | test_dates=list(df_test.Date.unique())
print(f"Period :{len(df_test.Date.unique())} days")
print(f"From : {df_test.Date.min() } To : {df_test.Date.max() }" )<define_variables> | X_train_df = pd.get_dummies(X_train_df, columns=['Pclass', 'Embarked','Age','Title'], drop_first=True)
X_test_df = pd.get_dummies(X_test_df, columns=['Pclass', 'Embarked','Age','Title'], drop_first=True)
X_train_df.head() | Titanic - Machine Learning from Disaster |
3,782,114 | print(f"Total Regions : {df_test.shape[0]/43}" )<feature_engineering> | X_train_df = X_train_df.drop(columns=['SibSp','Parch'])
X_test_df = X_test_df.drop(columns=['SibSp','Parch'] ) | Titanic - Machine Learning from Disaster |
3,782,114 | df_test["UniqueRegion"]=df_test.Country_Region
df_test.UniqueRegion[df_test.Province_State.isna() ==False]=df_test.Province_State+" , "+df_test.Country_Region
df_test.drop(labels=["Province_State","Country_Region"], axis=1, inplace=True )<count_unique_values> | sc_X = MinMaxScaler()
X_train_df[['Fare','Family']] = sc_X.fit_transform(X_train_df[['Fare','Family']])
X_test_df[['Fare','Family']] = sc_X.transform(X_test_df[['Fare','Family']] ) | Titanic - Machine Learning from Disaster |
3,782,114 | len(df_test.UniqueRegion.unique() )<define_variables> | from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import ... | Titanic - Machine Learning from Disaster |
3,782,114 | only_train_dates=set(train_dates)-set(test_dates)
print("Only train dates : ",len(only_train_dates))
intersection_dates=set(test_dates)&set(train_dates)
print("Intersection dates : ",len(intersection_dates))
only_test_dates=set(test_dates)-set(train_dates)
print("Only Test dates : ",len(only_test_dates))<feature_eng... | logi_clf = LogisticRegression(random_state=0)
logi_parm = {"penalty": ['l1', 'l2'], "C": [0.1, 0.5, 1, 5, 10, 50]}
svm_clf = SVC(random_state=0)
svm_parm = {'kernel': ['rbf', 'poly'], 'C': [0.1, 0.5, 1, 5, 10, 50], 'degree': [3, 5, 7],
'gamma': ['auto', 'scale']}
dt_clf = DecisionTreeClassifier(random_state=0)
dt_pa... | Titanic - Machine Learning from Disaster |
3,782,114 | df_test_temp=pd.DataFrame()
df_test_temp["Date"]=df_test.Date
df_test_temp["ConfirmedCases"]=0.0
df_test_temp["Fatalities"]=0.0
df_test_temp["UniqueRegion"]=df_test.UniqueRegion
df_test_temp["Delta"]=1.0<feature_engineering> | clf1 = RandomForestClassifier()
clf1.fit(X_train_df,y_train_df)
rf_rand = GridSearchCV(clf1,{'n_estimators':[50,100,200,300,500],'max_depth':[i for i in range(2,11)]},cv=10)
rf_rand.fit(X_train_df,y_train_df)
print(rf_rand.best_score_)
print(rf_rand.best_params_ ) | Titanic - Machine Learning from Disaster |
3,782,114 | %%time
final_df=pd.DataFrame(columns=["Date","ConfirmedCases","Fatalities","UniqueRegion"])
for region in df_train.UniqueRegion.unique() :
df_temp=df_train[df_train.UniqueRegion==region].reset_index()
df_temp["Delta"]=1.0
size_train=df_temp.shape[0]
for i in range(1,df_temp.shape[0]):
if(df_temp.ConfirmedCases[i-1]>0)... | clf2 = GradientBoostingClassifier()
clf2.fit(X_train_df,y_train_df)
gb_rand = GridSearchCV(clf2,{'n_estimators':[50,100,200,300,500],'learning_rate':[0.01,0.1,1],'max_depth':[i for i in range(2,11)]},cv=10)
gb_rand.fit(X_train_df,y_train_df)
print(gb_rand.best_score_)
print(gb_rand.best_params_ ) | Titanic - Machine Learning from Disaster |
3,782,114 | df_sub.Fatalities=final_df.Fatalities
df_sub.ConfirmedCases=final_df.ConfirmedCases
df_sub.to_csv("submission.csv", index=None )<import_modules> | clf3 = SVC(gamma='auto')
clf3.fit(X_train_df,y_train_df)
svc_rand = GridSearchCV(clf3,{'C':[5,10,15,20],'degree':[i for i in range(1,11)]},cv=10)
svc_rand.fit(X_train_df,y_train_df)
print(svc_rand.best_score_)
print(svc_rand.best_params_ ) | Titanic - Machine Learning from Disaster |
3,782,114 | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import datetime
import catboost<set_options> | clf1 = RandomForestClassifier(max_depth=6,n_estimators=200)
clf1.fit(X_train_df,y_train_df)
clf2 = GradientBoostingClassifier(n_estimators=300,learning_rate=0.01,max_depth=4,random_state=0)
clf2.fit(X_train_df,y_train_df)
clf3 = SVC(C=5,degree=1,gamma='auto',probability=True)
clf3.fit(X_train_df,y_train_df ) | Titanic - Machine Learning from Disaster |
3,782,114 | print(tf.test.is_gpu_available() )<load_from_disk> | eclf = VotingClassifier(estimators=[('rf',clf1),('gb',clf2),('svc',clf3)],voting='soft',weights=[2.5,2.5,2] ) | Titanic - Machine Learning from Disaster |
3,782,114 | df=pd.read_json('.. /input/whats-cooking-kernels-only/train.json', orient='records', dtype={"id":int, "cuisine":str,"ingredients":list} )<define_variables> | eclf.fit(X_train_df,y_train_df ) | Titanic - Machine Learning from Disaster |
3,782,114 | lists = [df['ingredients'].values[i] for i in range(len(df)) ]<concatenate> | pred = eclf.predict(X_test_df ) | Titanic - Machine Learning from Disaster |
3,782,114 | unique_ingredients = list(set(list(np.concatenate(lists))))<count_unique_values> | cols = ['PassengerId', 'Survived']
submit_df = pd.DataFrame(np.hstack(( y_test_df.values.reshape(-1,1),pred.reshape(-1,1))),
columns=cols ) | Titanic - Machine Learning from Disaster |
3,782,114 | <define_variables><EOS> | submit_df.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
3,326,054 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | GradientBoostingClassifier, ExtraTreesClassifier)
INPUT_DIR = '.. /input'
N_FOLDS = 4
N_ITER = 50
SEED = 32 | Titanic - Machine Learning from Disaster |
3,326,054 | inv_d = dict(zip(unique_ingredients, np.arange(len(unique_ingredients))))<feature_engineering> |
df_train_raw = pd.read_csv(os.path.join(INPUT_DIR, 'train.csv'))
df_test_raw = pd.read_csv(os.path.join(INPUT_DIR, 'test.csv')) | Titanic - Machine Learning from Disaster |
3,326,054 | X = np.zeros(shape =(len(df), len(unique_ingredients)))
for i in range(len(df)) :
if i % 10000 == 0:
print(i)
sample = df.loc[i]
l_ingr = sample['ingredients']
for ingr in l_ingr:
X[i,inv_d[ingr]] = 1.0<prepare_x_and_y> |
def get_title(name):
title_search = re.search('([A-Za-z]+)\.', name)
if title_search:
return title_search.group(1)
return ""
df_full = [df_train_raw.copy() , df_test_raw.copy() ]
for dataset in df_full:
dataset['LastName'] = dataset['Name'].apply(lambda x: str.split(x, ",")[0])
dataset['LastName'] = dataset['Las... | Titanic - Machine Learning from Disaster |
3,326,054 | y = df['cuisine'].values<count_unique_values> |
def min_max_scale(train_data, test_data, numeric_cols):
data = pd.concat([train_data, test_data])
scaled_train_data, scaled_test_data = train_data.copy() , test_data.copy()
for feature_name in numeric_cols:
max_v = data[feature_name].max()
min_v = data[feature_name].min()
scaled_train_data[feature_name] =(train_da... | Titanic - Machine Learning from Disaster |
3,326,054 | len(np.unique(y))<load_from_disk> |
MODELS = {
'lr': {
'model': LogisticRegression,
'params': {
'fit_intercept': [True, False],
'multi_class': ['ovr'],
'penalty': ['l2'],
'solver': ['newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga'],
'tol': [0.01, 0.05, 0.1, 0.5, 1, 5],
'random_state': [SEED],
},
'best_params': {'tol': 0.05, 'solver': 'newton-cg', 'rand... | Titanic - Machine Learning from Disaster |
3,326,054 | df_test=pd.read_json('.. /input/whats-cooking-kernels-only/test.json', orient='records', dtype={"id":int,"ingredients":list} )<prepare_x_and_y> |
FIT_FROM_SCRATCH = True
for name, model in MODELS.items() :
if 'best_score' in model and not FIT_FROM_SCRATCH:
print(f'Fitting {name}...')
model['best_estimator'] = model['model'](**model['best_params'] ).fit(x_train, y_train)
scores = cross_val_score(model['best_estimator'], x_train, y_train, cv=N_FOLDS)
score = ... | Titanic - Machine Learning from Disaster |
3,326,054 | X_test = np.zeros(shape =(len(df_test), len(unique_ingredients)))
for i in range(len(df_test)) :
if i % 1000 == 0:
print(i)
sample = df_test.loc[i]
l_ingr = sample['ingredients']
for ingr in l_ingr:
try:
X_test[i,inv_d[ingr]] = 1.0
except:
pass<import_modules> |
df = pd.DataFrame()
X_train, X_test = {}, {}
for name, model in MODELS.items() :
vtrain = MODELS[name]['best_estimator'].predict(x_train)
vtest = MODELS[name]['best_estimator'].predict(x_test)
df[name] = np.reshape(vtrain, [-1])
X_train[name] = vtrain
X_test[name] = vtest | Titanic - Machine Learning from Disaster |
3,326,054 | from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split<train_model> | pred = MODELS['svc']['best_estimator'].predict(x_test ) | Titanic - Machine Learning from Disaster |
3,326,054 | <predict_on_test><EOS> | submission = pd.DataFrame({'PassengerId': df_test_raw['PassengerId'], 'Survived': pred})
submission.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
3,786,214 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<create_dataframe> | import os
import warnings
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from sklearn import metrics, preprocessing
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.ensemble import AdaBoostClassifier
from skl... | Titanic - Machine Learning from Disaster |
3,786,214 | subm = pd.DataFrame({'id':df_test['id'], 'cuisine':Y_test} )<save_to_csv> | warnings.filterwarnings("ignore")
df_train_original = pd.read_csv(".. /input/train.csv")
df_test_original = pd.read_csv(".. /input/test.csv")
| Titanic - Machine Learning from Disaster |
3,786,214 | subm.to_csv('submission.csv', index=False )<set_options> | def trataDados(train, test, drop_list, target):
dados_origin = pd.concat(( train, test))
dados_origin = dados_origin.drop(drop_list, axis=1)
dados_origin[dados_origin.isnull().any(axis=1)]
if dados_origin.isnull().values.any() :
dados_origin = dados_origin.fillna(dados_origin.mean())
dados_origin = pd.get_dummies(dad... | Titanic - Machine Learning from Disaster |
3,786,214 | %matplotlib inline<string_transform> | drop_list = ["Name", "Fare", "Cabin", "Ticket"]
X_train, X_test, y_train, y_test, df_validate = trataDados(
df_train_original, df_test_original, drop_list, "Survived"
) | Titanic - Machine Learning from Disaster |
3,786,214 | tokenize = TweetTokenizer().tokenize<load_from_disk> | temp = []
classifier = [
"Decision Tree",
"Random Forest",
"KNN",
"Extra Trees",
"Ada Boost",
"Gradient Boosting",
]
models = [
DecisionTreeClassifier(
criterion="gini",
max_depth=2,
max_features=None,
min_samples_leaf=1,
min_samples_split=2,
random_state=8,
splitter="random",
),
RandomForestClassifier(
min_samples_... | Titanic - Machine Learning from Disaster |
3,786,214 | print(os.listdir())
train = pd.read_json('/kaggle/input/whats-cooking-kernels-only/train.json')
test = pd.read_json('/kaggle/input/whats-cooking-kernels-only/test.json')
print(train.head())
ytrain = train['cuisine']
print(ytrain.head(5))
Id = test['id']
print(Id.head(5))<feature_engineering> | for index, model in enumerate(models):
model.fit(X_train, y_train)
predict = model.predict(X_test)
temp.append(metrics.accuracy_score(predict, y_test))
predict = model.predict(df_validate)
export(classifier[index], predict, df_validate ) | Titanic - Machine Learning from Disaster |
3,786,214 | tfidf = TfidfVectorizer(binary=True )<data_type_conversions> | models_dataframe = pd.DataFrame(temp, index=classifier)
models_dataframe.columns = ["Accuracy"]
print(models_dataframe)
| Titanic - Machine Learning from Disaster |
10,597,702 | train2 = train
print(( train2['ingredients'][0]))
print(arraytotext(train2['ingredients'][0]))<categorify> | %matplotlib inline | Titanic - Machine Learning from Disaster |
10,597,702 | train_features = tfidf.fit_transform(arraytotext(train['ingredients']))
test_features = tfidf.transform(arraytotext(test['ingredients']))<choose_model_class> | df_train = pd.read_csv(".. /input/titanic/train.csv")
df_test = pd.read_csv(".. /input/titanic/test.csv" ) | Titanic - Machine Learning from Disaster |
10,597,702 | classifier = SVC(C=200, kernel='rbf', degree=3,gamma=1, \
coef0=1, shrinking=True,tol=0.001, probability=False,\
cache_size=200,class_weight=None, verbose=False,\
max_iter=-1,decision_function_shape=None,\
random_state=None )<compute_train_metric> | df_train.isnull().sum() | Titanic - Machine Learning from Disaster |
10,597,702 | model = OneVsRestClassifier(classifier)
scores = cross_val_score(classifier,train_features, ytrain, cv=2)
print("Accuracy: %0.2f(+/- %0.2f)" % \
(scores.mean() , scores.std() * 2))<train_model> | df_test.isnull().sum() | Titanic - Machine Learning from Disaster |
10,597,702 | model.fit(train_features, ytrain )<predict_on_test> | df_train.drop(columns = ["Name" ,"Ticket" , "Cabin"], inplace=True)
df_test.drop(columns = ["Name" ,"Ticket" , "Cabin"], inplace=True ) | Titanic - Machine Learning from Disaster |
10,597,702 | predictions = model.predict(test_features)
print(predictions )<save_to_csv> | df_train.Sex.replace("male" , 0 , inplace =True)
df_train.Sex.replace("female" , 1 , inplace =True)
df_train.Embarked.replace("C" , 0 , inplace =True)
df_train.Embarked.replace("S" , 1 , inplace =True)
df_train.Embarked.replace("Q" , 2 , inplace =True ) | Titanic - Machine Learning from Disaster |
10,597,702 | submission = pd.DataFrame()
submission['id'] = Id
submission['cuisine'] = predictions
submission.to_csv('submission.csv', index=False)
<import_modules> | df_test.Sex.replace("male" , 0 , inplace =True)
df_test.Sex.replace("female" , 1 , inplace =True)
df_test.Embarked.replace("C" , 0 , inplace =True)
df_test.Embarked.replace("S" , 1 , inplace =True)
df_test.Embarked.replace("Q" , 2 , inplace =True ) | Titanic - Machine Learning from Disaster |
10,597,702 | tqdm.pandas()<load_from_disk> | df_train.Age.fillna(df_train.Age.median() , inplace= True)
df_test.Age.fillna(df_train.Age.median() , inplace = True ) | Titanic - Machine Learning from Disaster |
10,597,702 | train = pd.read_json('.. /input/train.json')
test = pd.read_json('.. /input/test.json' )<feature_engineering> | df_test.Fare.fillna(df_train.Fare.median() , inplace = True ) | Titanic - Machine Learning from Disaster |
10,597,702 | train['num_ingredients'] = train['ingredients'].apply(len)
train = train[train['num_ingredients'] > 1]<string_transform> | df_test.isnull().sum() | Titanic - Machine Learning from Disaster |
10,597,702 | lemmatizer = WordNetLemmatizer()
def preprocess(ingredients):
ingredients_text = ' '.join(ingredients)
ingredients_text = ingredients_text.lower()
ingredients_text = ingredients_text.replace('-', ' ')
words = []
for word in ingredients_text.split() :
if re.findall('[0-9]', word): continue
if len(word)<= 2: continue
i... | df_train.isnull().sum() | Titanic - Machine Learning from Disaster |
10,597,702 | train['x'] = train['ingredients'].progress_apply(preprocess)
test['x'] = test['ingredients'].progress_apply(preprocess)
train.head()<feature_engineering> | X = df_train.drop(columns = ["Survived"])
y = df_train["Survived"] | Titanic - Machine Learning from Disaster |
10,597,702 | vectorizer = make_pipeline(
TfidfVectorizer(sublinear_tf=True),
FunctionTransformer(lambda x: x.astype('float16'), validate=False)
)
x_train = vectorizer.fit_transform(train['x'].values)
x_train.sort_indices()
x_test = vectorizer.transform(test['x'].values )<categorify> | train_X, val_X, train_y, val_y = train_test_split(X, y, test_size=0.2, random_state=0 ) | Titanic - Machine Learning from Disaster |
10,597,702 | label_encoder = LabelEncoder()
y_train = label_encoder.fit_transform(train['cuisine'].values)
dict(zip(label_encoder.classes_, label_encoder.transform(label_encoder.classes_)) )<choose_model_class> | classifier = DecisionTreeClassifier(max_leaf_nodes=8 , random_state = 1)
classifier.fit(train_X,train_y)
preds_val = classifier.predict(df_test ) | Titanic - Machine Learning from Disaster |
10,597,702 | estimator = SVC(
C=80,
kernel='rbf',
gamma=1.7,
coef0=1,
cache_size=500,
)
classifier = OneVsRestClassifier(estimator, n_jobs=-1 )<train_model> | test_out = pd.DataFrame({
'PassengerId': df_test.PassengerId,
'Survived': preds_val
})
test_out.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
11,196,065 | %%time
classifier.fit(x_train, y_train )<categorify> | %matplotlib inline
sns.set()
warnings.filterwarnings('ignore' ) | Titanic - Machine Learning from Disaster |
11,196,065 | y_pred = label_encoder.inverse_transform(classifier.predict(x_train))
y_true = label_encoder.inverse_transform(y_train)
print(f'accuracy score on train data: {accuracy_score(y_true, y_pred)}' )<save_to_csv> | train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv' ) | Titanic - Machine Learning from Disaster |
11,196,065 | y_pred = label_encoder.inverse_transform(classifier.predict(x_test))
test['cuisine'] = y_pred
test[['id', 'cuisine']].to_csv('submission.csv', index=False)
test[['id', 'cuisine']].head()<load_from_disk> | train.isnull().sum() | Titanic - Machine Learning from Disaster |
11,196,065 | recipe_data = json.loads(open('.. /input/train.json' ).read() )<create_dataframe> | test.isnull().sum() | Titanic - Machine Learning from Disaster |
11,196,065 | colnames = list(unique_ing)
data = pd.DataFrame(0, index=recipe_id, columns=colnames )<feature_engineering> | train.drop(columns=['PassengerId','Name','Ticket','Cabin'], axis=1, inplace=True)
test.drop(columns=['PassengerId','Name','Ticket','Cabin'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
11,196,065 | data['cuisine'] = cuisine<feature_engineering> | train['Sex'] = [1 if gender=='male' else 0 for gender in train['Sex']]
test['Sex'] = [1 if gender=='male' else 0 for gender in test['Sex']] | Titanic - Machine Learning from Disaster |
11,196,065 | for recipe in recipe_data:
index = recipe['id']
ingredients =recipe['ingredients']
for ingredient in ingredients:
data.at[index, ingredient] = 1<prepare_x_and_y> | train.Age.fillna(train.Age.median() , inplace=True)
test.Age.fillna(test.Age.median() , inplace=True ) | Titanic - Machine Learning from Disaster |
11,196,065 | y, label = pd.factorize(data['cuisine'] )<data_type_conversions> | train.drop(columns=['Age'], inplace=True)
test.drop(columns=['Age'], inplace=True ) | Titanic - Machine Learning from Disaster |
11,196,065 | X_train = data[colnames].values.astype(float)
y_train = keras.utils.to_categorical(y, num_classes=20 )<choose_model_class> | test.Fare.fillna(test.Fare.median() , inplace=True ) | Titanic - Machine Learning from Disaster |
11,196,065 | model = Sequential()
model.add(Dropout(0.3))
model.add(Dense(512, input_dim=6714, activation='linear'))
model.add(LeakyReLU(alpha=.02))
model.add(Dropout(0.5))
model.add(Dense(100, activation='relu'))
model.add(Dense(20, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='Adamax', metrics=[... | train.drop(columns=['Fare'], axis=1, inplace=True)
test.drop(columns=['Fare'], axis=1, inplace=True ) | Titanic - Machine Learning from Disaster |
11,196,065 | model.fit(X_train, y_train,
epochs=25,
batch_size=250)
<load_from_disk> | train.Embarked.fillna(train.Embarked.mode() , inplace=True ) | Titanic - Machine Learning from Disaster |
11,196,065 | test_data = json.loads(open('.. /input/test.json' ).read() )<create_dataframe> | train = pd.get_dummies(train, columns=['Pclass','AgeGroup','Embarked'])
test = pd.get_dummies(test, columns=['Pclass','AgeGroup','Embarked'] ) | Titanic - Machine Learning from Disaster |
11,196,065 | test_recipe_id = []
for recipe in test_data:
test_recipe_id.append(recipe['id'])
test_df = pd.DataFrame(0, index=test_recipe_id, columns=colnames )<define_variables> | predictors = train.drop(columns=['Survived'], axis=1 ) | Titanic - Machine Learning from Disaster |
11,196,065 | ingr_checker = dict.fromkeys(colnames )<feature_engineering> | target = train[['Survived']] | Titanic - Machine Learning from Disaster |
11,196,065 | for recipe in test_data:
index = recipe['id']
ingredients = recipe['ingredients']
for ingredient in ingredients:
if ingredient in ingr_checker:
test_df.at[index, ingredient] = 1<data_type_conversions> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
11,196,065 | X_test = test_df[colnames].values.astype(float )<predict_on_test> | from sklearn.model_selection import train_test_split | Titanic - Machine Learning from Disaster |
11,196,065 | prediction = model.predict(X_test )<prepare_output> | x_train,x_val,y_train,y_val = train_test_split(predictors,target,test_size=0.2,random_state=123 ) | Titanic - Machine Learning from Disaster |
11,196,065 | prediction_classes = prediction.argmax(axis=-1 )<prepare_output> | from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC | Titanic - Machine Learning from Disaster |
11,196,065 | label_names = label[prediction_classes]
df_output = pd.DataFrame({'id' : test_recipe_id, 'cuisine' : label_names})
df_output.head()<save_to_csv> | from sklearn.metrics import accuracy_score | Titanic - Machine Learning from Disaster |
11,196,065 | df_output.to_csv("output.csv", header=True, index=False )<import_modules> | lr = LogisticRegression()
lr.fit(x_train,y_train)
preds = lr.predict(x_val)
lr_accuracy = accuracy_score(y_val,preds)
print(f'Logistic Regression accuracy: {lr_accuracy*100}' ) | Titanic - Machine Learning from Disaster |
11,196,065 | import os
import json
import re
import pandas as pd
from nltk.stem import WordNetLemmatizer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.multiclass import OneVsRestClassifier
from sklearn.svm import SVC
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import FunctionTran... | knn = KNeighborsClassifier()
knn.fit(x_train,y_train)
preds = knn.predict(x_val)
knn_accuracy = accuracy_score(y_val, preds)
print(f'KNN accuracy: {knn_accuracy*100}' ) | Titanic - Machine Learning from Disaster |
11,196,065 | def get_replacements() :
return {'wasabe': 'wasabi', '-': '', 'sauc': 'sauce',
'baby spinach': 'babyspinach', 'coconut cream': 'coconutcream',
'coriander seeds': 'corianderseeds', 'corn tortillas': 'corntortillas',
'cream cheese': 'creamcheese', 'fish sauce': 'fishsauce',
'purple onion': 'purpleonion','refried beans': ... | dt = DecisionTreeClassifier()
dt.fit(x_train,y_train)
preds = dt.predict(x_val)
dt_accuracy = accuracy_score(y_val, preds)
print(f'Decission Tree accuracy: {dt_accuracy*100}' ) | Titanic - Machine Learning from Disaster |
11,196,065 | def tranform_to_single_string(ingredients, lemmatizer, replacements, stop_pattern):
ingredients_text = ' '.join(iter(ingredients))
for key, value in replacements.items() :
ingredients_text = ingredients_text.replace(key, value)
words = []
for word in ingredients_text.split() :
if not stop_pattern.match(word)and len(wo... | rf = RandomForestClassifier()
rf.fit(x_train,y_train)
preds = rf.predict(x_val)
rf_accuracy = accuracy_score(y_val, preds)
print(f'RandomForest accuracy: {rf_accuracy*100}' ) | Titanic - Machine Learning from Disaster |
11,196,065 | def get_estimator() :
return SVC(C=300,
kernel='rbf',
gamma=1.5,
shrinking=True,
tol=0.001,
cache_size=1000,
class_weight=None,
max_iter=-1,
decision_function_shape='ovr',
random_state=42 )<feature_engineering> | gbc = GradientBoostingClassifier()
gbc.fit(x_train,y_train)
preds = gbc.predict(x_val)
gbc_accuracy = accuracy_score(y_val, preds)
print(f'GradientBoostClassifier accuracy: {gbc_accuracy*100}' ) | Titanic - Machine Learning from Disaster |
11,196,065 | def show_unique_ingredients(train):
ingredients = {}
for idx, row in train.iterrows() :
for ingredient in row['ingredients']:
if ingredient not in ingredients:
ingredients[ingredient] = {'sum': 0}
previous = ingredients[ingredient][row['cuisine']] if row['cuisine'] in ingredients[ingredient] else 0
ingredients[ingredie... | svc = SVC()
svc.fit(x_train,y_train)
preds = svc.predict(x_val)
svc_accuracy = accuracy_score(y_val, preds)
print(f'SVC accuracy: {svc_accuracy*100}' ) | Titanic - Machine Learning from Disaster |
11,196,065 | def preprocess(train, test):
lemmatizer = WordNetLemmatizer()
replacements = get_replacements()
train['ingredients'] = train['ingredients'].apply(lambda x: list(map(lambda y: y.lower() , x)))
test['ingredients'] = test['ingredients'].apply(lambda x: list(map(lambda y: y.lower() , x)))
stop_pattern = re.compile('[\d’%... | models = pd.DataFrame({'Model':['LogisticRegression','KNN','DecissionTree','RandomForest','GradientBoostClassifier','SVM'],
'Accuracy':[lr_accuracy*100,knn_accuracy*100,dt_accuracy*100,rf_accuracy*100,gbc_accuracy*100,svc_accuracy*100]})
models | Titanic - Machine Learning from Disaster |
11,196,065 | %%time
def main() :
train = pd.read_json('.. /input/train.json')
test = pd.read_json('.. /input/test.json')
train['num_ingredients'] = train['ingredients'].apply(lambda x: len(x))
test['num_ingredients'] = test['ingredients'].apply(lambda x: len(x))
train = train[train['num_ingredients'] > 2]
x_train, x_test = prepro... | data = pd.read_csv('/kaggle/input/titanic/test.csv')
ids = data['PassengerId'] | Titanic - Machine Learning from Disaster |
11,196,065 | %matplotlib inline
init_notebook_mode(connected=True)
warnings.filterwarnings('ignore')
print(os.listdir(".. /input"))<load_from_disk> | preds = dt.predict(test ) | Titanic - Machine Learning from Disaster |
11,196,065 | train_data = pd.read_json('.. /input/train.json')
test_data = pd.read_json('.. /input/test.json' )<train_model> | output = pd.DataFrame({'PassengerId':ids, 'Survived':preds} ) | Titanic - Machine Learning from Disaster |
11,196,065 | print("The training data consists of {} recipes".format(len(train_data)) )<count_unique_values> | output.to_csv('submission.csv', index=False ) | Titanic - Machine Learning from Disaster |
9,888,019 | print("Number of cuisine categories: {}".format(len(train_data.cuisine.unique())))
train_data.cuisine.unique()<randomize_order> | warnings.filterwarnings("ignore")
| Titanic - Machine Learning from Disaster |
9,888,019 | def random_colours(number_of_colors):
colors = []
for i in range(number_of_colors):
colors.append("
return colors<count_values> | train = pd.read_csv('/kaggle/input/titanic/train.csv')
train.info() | Titanic - Machine Learning from Disaster |
9,888,019 | labelpercents = []
for i in train_data.cuisine.value_counts() :
percent =(i/sum(train_data.cuisine.value_counts())) *100
percent = "%.2f" % percent
percent = str(percent + '%')
labelpercents.append(percent )<set_options> |
def substrings_in_string(big_string, substrings):
for substring in substrings:
if big_string.find(substring)!= -1:
return substring
print(big_string)
return np.nan
def phase1clean(df):
df.Fare = df.Fare.map(lambda x: np.nan if x==0 else x)
df.Cabin = df.Cabin.fillna('Unknown')
cabin_list = ['A', 'B', 'C', 'D', '... | Titanic - Machine Learning from Disaster |
9,888,019 | print("Word Cloud Function.. ")
stopwords = set(STOPWORDS)
size =(20,10)
def cloud(text, title, stopwords=stopwords, size=size):
mpl.rcParams['figure.figsize']=(10.0,10.0)
mpl.rcParams['font.size']=12
mpl.rcParams['savefig.dpi']=100
mpl.rcParams['figure.subplot.bottom']=.1
wordcloud = WordCloud(width=1600, height... | x,y,pred_set,original_train,pred_set_original=get_data()
x.info()
x.head() | 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.