kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
8,698,078 |
<predict_on_test> | cols=["Age", "Fare", "TravelAlone", "Pclass_1", "Pclass_2","Embarked_C","Embarked_S","Sex_male","IsMinor"]
X_DT=df_final[cols]
Y_DT=df_final['Survived']
tree1.fit(X_DT, Y_DT ) | Titanic - Machine Learning from Disaster |
8,698,078 |
<categorify> | tree1_view = tree.export_graphviz(tree1, out_file=None, feature_names = X_DT.columns.values, rotate=True)
tree1viz = graphviz.Source(tree1_view)
tree1viz | Titanic - Machine Learning from Disaster |
8,698,078 | test.loc[(test.matchType!='solo')&(test.matchType!='duo')&(test.matchType!='squad')&(test.matchType!='solo-fpp')&(test.matchType!='duo-fpp')&(test.matchType!='squad-fpp'),'matchType']='other'
test['matchType']=test['matchType'].map({'solo':0 , 'duo':1, 'squad':2, 'solo-fpp':3, 'duo-fpp':4, 'squad-fpp':5,'other':6} )<co... | final_test_DT=final_test[cols]
Y_pred_DT = tree1.predict(final_test_DT)
submission = pd.DataFrame({
"PassengerId": test_df["PassengerId"],
"Survived": Y_pred_DT
})
submission.to_csv('titanic_DT.csv', index=False ) | Titanic - Machine Learning from Disaster |
8,698,078 | test.isnull().sum()<count_missing_values> | submission = pd.DataFrame({
"PassengerId": test_df["PassengerId"],
"Survived": Y_pred_RF* 0.8 + Y_pred_DT*0.2
})
submission.to_csv('titanic_ensemble.csv', index=False ) | Titanic - Machine Learning from Disaster |
8,698,078 | test.isnull().sum()<categorify> | from sympy import simplify, cos, sin, Symbol, Function, tanh, pprint, init_printing, exp
from sympy.functions import Min,Max | Titanic - Machine Learning from Disaster |
8,698,078 | data_test=enc.fit(test[['matchType']])
temp_test=enc.transform(test[['matchType']])
temp2=pd.DataFrame(temp_test.toarray() ,columns=["solo", "duo", "squad", "solo-fpp", "duo-fpp", "squad-fpp","other"])
temp2=temp2.set_index(test.index.values)
temp2
test=pd.concat([test,temp2],axis=1)
del test['matchType']
<drop_c... | A = 0.058823499828577
B = 0.841127
C = 0.138462007045746
D = 0.31830988618379069
E = 2.810815
F = 0.63661977236758138
G = 5.428569793701172
H = 3.1415926535897931
I = 0.592158
J = 4.869778
K = 0.063467
L = -0.091481
M = 0.0821533
N = 0.720430016517639
O = 0.230145
P = 9.89287
Q = 785
R = 1.07241
S = 281
T = 734
U = 5.3... | Titanic - Machine Learning from Disaster |
8,698,078 | test['killsasist']=test['kills']+test['assists']+test['roadKills']
test['total_distance']=test['swimDistance']+test['rideDistance']+test['walkDistance']
test['external_booster']=test['boosts']+test['weaponsAcquired']+test['heals']
test=test.drop(['assists','kills','swimDistance','rideDistance','walkDistance','boosts','... | def GeneticFunction(data,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM):
return(( np.minimum(((((A + data["Sex"])- np.cos(( data["Pclass"] / AH)))* AH)) ,(( B)))* AH)+
np.maximum(((data["SibSp"] - AC)) ,(-(np.minimum(( data["Sex"]),(np.sin(data["Parch"])))* data["Pclass"])))... | Titanic - Machine Learning from Disaster |
8,698,078 | test=test.drop(['killPoints','maxPlace','winPoints'],axis=1 )<categorify> | def CleanData(data):
data.drop(['Ticket', 'Name'], inplace=True, axis=1)
data.Sex.fillna('0', inplace=True)
data.loc[data.Sex != 'male', 'Sex'] = 0
data.loc[data.Sex == 'male', 'Sex'] = 1
data.Cabin.fillna('0', inplace=True)
data.loc[data.Cabin.str[0] == 'A', 'Cabin'] = 1
data.loc[data.Cabin.str[0] == 'B', 'Cabin'] ... | Titanic - Machine Learning from Disaster |
8,698,078 | test['Players_all']=test.groupby('matchId')['Id'].transform('count')
test['players_group']=test.groupby('groupId')['Id'].transform('count' )<drop_column> | raw_train = pd.read_csv('.. /input/titanic/train.csv')
raw_test = pd.read_csv('.. /input/titanic/test.csv')
cleanedTrain = CleanData(raw_train)
cleanedTest = CleanData(raw_test)
thisArray = BIG.copy()
testPredictions = Outputs(GeneticFunction(cleanedTrain,thisArray[0],thisArray[1],thisArray[2],thisArray[3],thisArra... | Titanic - Machine Learning from Disaster |
8,698,078 | <save_to_csv><EOS> | testPredictions = Outputs(GeneticFunction(cleanedTest,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM))
pdtest = pd.DataFrame({'PassengerId': cleanedTest.PassengerId.astype(int),
'Survived': testPredictions.astype(int)})
pdtest.to_csv('submission_GA.csv', index=False)
pdtest... | Titanic - Machine Learning from Disaster |
3,610,082 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<load_from_csv> | if not sys.warnoptions:
warnings.simplefilter("ignore")
| Titanic - Machine Learning from Disaster |
3,610,082 | train = pd.read_csv(".. /input/train_V2.csv")
test = pd.read_csv(".. /input/test_V2.csv" )<correct_missing_values> | data_train = pd.read_csv(".. /input/train.csv")
data_test= pd.read_csv(".. /input/test.csv" ) | Titanic - Machine Learning from Disaster |
3,610,082 | train = train.dropna()<feature_engineering> | print("Training Data shape:", data_train.shape)
print("Test Data shape:", data_test.shape ) | Titanic - Machine Learning from Disaster |
3,610,082 | train['rideDistance'] =(train['rideDistance']/10 ).round(0)
train['swimDistance'] =(train['swimDistance']/10 ).round(0)
train['walkDistance'] =(train['walkDistance']/10 ).round(0 )<feature_engineering> | label = data_train['Survived'] | Titanic - Machine Learning from Disaster |
3,610,082 | test['rideDistance'] =(test['rideDistance']/10 ).round(0)
test['swimDistance'] =(test['swimDistance']/10 ).round(0)
test['walkDistance'] =(test['walkDistance']/10 ).round(0 )<feature_engineering> | if label.isnull().sum() ==0:
print("No missing values")
else:
print(label.isnull().sum() , 'missing values found in dataset' ) | Titanic - Machine Learning from Disaster |
3,610,082 | test["winPlacePerc"] = -1<concatenate> | for column in data_train.columns:
print(column, len(data_train[column].unique())) | Titanic - Machine Learning from Disaster |
3,610,082 | df = pd.concat([train, test] )<drop_column> | print('Amount of missing data in Fare for train:', data_train.Fare.isnull().sum())
print('Amount of missing data in Fare for test:',data_test.Fare.isnull().sum())
print("--------------------------------------------------")
print('Amount of missing data in Embarked for train:',data_train.Embarked.isnull().sum())
pri... | Titanic - Machine Learning from Disaster |
3,610,082 | del train
del test<feature_engineering> | data_train['Embarked'] = data_train['Embarked'].fillna("S")
data_test['Fare'] = data_test['Fare'].fillna(data_train['Fare'].median() ) | Titanic - Machine Learning from Disaster |
3,610,082 | df["Id"] = df.index<filter> | print(data_train.Age.isnull().sum())
print(data_test.Age.isnull().sum() ) | Titanic - Machine Learning from Disaster |
3,610,082 |
<filter> | data_train['Age_NA'] =np.where(data_train.Age.isnull() , 1, 0)
data_test['Age_NA'] =np.where(data_test.Age.isnull() , 1, 0 ) | Titanic - Machine Learning from Disaster |
3,610,082 | duo = df[(df['matchType']=='duo')|(df['matchType']=='normal-duo')|(df['matchType']=='duo-fpp')|(df['matchType']=='normal-duo-fpp')]
squad = df[(df['matchType']=='squad')|(df['matchType']=='normal-squad')|(df['matchType']=='squad-fpp')|(df['matchType']=='normal-squad-fpp')]
solo = df[(df['matchType']=='solo')|(df['match... | data_train['Age_mean'] =np.where(data_train.Age.isnull() , data_train['Age'].mean() , data_train['Age'])
data_test['Age_mean'] =np.where(data_test.Age.isnull() , data_test['Age'].mean() , data_test['Age'])
| Titanic - Machine Learning from Disaster |
3,610,082 | dp_by_type = {'flare':[flare,62],
'crash':[crash,149],
'squad':[squad,53635],
'solo':[solo,16165],
'duo':[duo,29691]
}<save_to_csv> | for column in data_train.columns:
print(column, len(data_train[column].unique())) | Titanic - Machine Learning from Disaster |
3,610,082 | for name,ele in dp_by_type.items() :
print(name + " : " + str(len(ele[0])))
ele[0].to_csv(name+'.csv', index=False)
ele[0] = 0<drop_column> | data_train = data_train.drop(['PassengerId'], axis=1)
data_test = data_test.drop(['PassengerId'], axis=1 ) | Titanic - Machine Learning from Disaster |
3,610,082 | del duo,squad,solo,flare,crash<set_options> | def ticket_sep(data_ticket):
ticket_type = []
for i in range(len(data_ticket)) :
ticket =data_ticket.iloc[i]
for c in string.punctuation:
ticket = ticket.replace(c,"")
splited_ticket = ticket.split(" ")
if len(splited_ticket)== 1:
ticket_type.append('NO')
else:
ticket_type.append(splited_ticket[0])
return ticket_ty... | Titanic - Machine Learning from Disaster |
3,610,082 | del df
gc.collect()<concatenate> | data_train["ticket_type"] = ticket_sep(data_train.Ticket)
data_train.head() | Titanic - Machine Learning from Disaster |
3,610,082 | def featureEngineering(df):
return featureEngineeringSecond(reduce_mem_usage(featureEngineeringFirst(df)) )<feature_engineering> | data_test["ticket_type"]= ticket_sep(data_test.Ticket)
data_test.head() | Titanic - Machine Learning from Disaster |
3,610,082 | def items(df):
df['items'] = df['heals'] + df['boosts']
return df
def survival(df):
df["survival"] = df["revives"] + df["boosts"] + df["heals"]
return df
def players_in_team(df):
agg = df.groupby(['groupId'] ).size().to_frame('players_in_team')
return df.merge(agg, how='left', on=['groupId'])
def total_distance(df):
... | data_train["ticket_type"] = np.where(data_train["ticket_type"]=='SOTONOQ', 'A5', data_train["ticket_type"])
data_test["ticket_type"] = np.where(data_test["ticket_type"]=='SOTONOQ', 'A5', data_test["ticket_type"])
| Titanic - Machine Learning from Disaster |
3,610,082 | def featureEngineeringFirst(df):
print(" Feature Engineering First started...")
df = items(df)
gc.collect()
df = survival(df)
gc.collect()
df = players_in_team(df)
gc.collect()
df = total_distance(df)
gc.collect()
df = total_time_by_distance(df)
gc.collect()
gc.collect()
df = teamwork(df)
gc.collect()
df = total... | data_train = data_train.drop(['Ticket'], axis=1)
data_test = data_test.drop(['Ticket'], axis=1 ) | Titanic - Machine Learning from Disaster |
3,610,082 | def min_by_team(df):
features = list(df.columns)
features.remove('Id')
features.remove('groupId')
features.remove('matchId')
agg = df.groupby(['matchId','groupId'])[features].min()
agg_rank = agg.groupby('matchId')[features].rank(pct=True ).reset_index()
return agg, agg_rank
def max_by_team(df):
features = list(df.... | print('Missing values in Train set:', data_train.Cabin.isnull().sum())
print('Missing values in Test set:', data_test.Cabin.isnull().sum() ) | Titanic - Machine Learning from Disaster |
3,610,082 | def mergeWithAgg(df,agg,agg_rank,name):
print(" Merge "+name)
df = df.merge(agg, suffixes=["", "_"+name], how='left', on=['matchId', 'groupId'])
df = df.merge(agg_rank, suffixes=["", "_"+name+"_rank"], how='left', on=['matchId', 'groupId'])
return reduce_mem_usage(df )<statistical_test> | def cabin_sep(data_cabin):
cabin_type = []
for i in range(len(data_cabin)) :
if data_cabin.isnull() [i] == True:
cabin_type.append('NaN')
else:
cabin = data_cabin[i]
cabin_type.append(cabin[:1])
return cabin_type | Titanic - Machine Learning from Disaster |
3,610,082 | def featureEngineeringSecond(df):
print(" Feature Engineering Second started...")
print(" Min")
min_, min_rank = min_by_team(df)
gc.collect()
print(" Max")
max_, max_rank = max_by_team(df)
gc.collect()
print(" Sum")
sum_, sum_rank = sum_by_team(df)
gc.collect()
print(" Median")
median_, median_rank = median_by_... | data_train['cabin_type'] = cabin_sep(data_train.Cabin)
data_test['cabin_type'] = cabin_sep(data_test.Cabin)
data_train.head() | Titanic - Machine Learning from Disaster |
3,610,082 | def baseline_model(input_dim):
model = Sequential()
model.add(Dense(32, kernel_initializer='he_normal',input_dim=input_dim , activation='selu'))
model.add(Dense(64, kernel_initializer='he_normal', activation='selu'))
model.add(Dense(128, kernel_initializer='he_normal', activation='selu'))
model.add(Dropout(0.1))
model.... | data_train = data_train.drop(['Cabin'], axis=1)
data_test = data_test.drop(['Cabin'], axis=1 ) | Titanic - Machine Learning from Disaster |
3,610,082 | def normalize(df):
result = df.copy()
for feature_name in df.columns:
if df[feature_name].dtype != object:
max_value = df[feature_name].max()
min_value = df[feature_name].min()
result[feature_name] =(df[feature_name] - min_value)/(max_value - min_value)
return result<normalization> | def name_sep(data):
families=[]
titles = []
new_name = []
for i in range(len(data)) :
name = data.iloc[i]
if '(' in name:
name_no_bracket = name.split('(')[0]
else:
name_no_bracket = name
family = name_no_bracket.split(",")[0]
title = name_no_bracket.split(",")[1].strip().split(" ")[0]
for c in string.punctuation:
name... | Titanic - Machine Learning from Disaster |
3,610,082 | def learningPart(df,batch_size):
print(" Data processing started...")
df_winPlacePerc = df.winPlacePerc
df = df.drop('winPlacePerc', axis=1)
df = df.drop('matchType', axis=1)
df = featureEngineering(df)
df = df.drop('matchId', axis=1)
df = df.drop('groupId', axis=1)
gc.collect()
df['winPlacePerc'] = df_winPlacePe... | data_train['family'], data_train['title'], data_train['Name'] = name_sep(data_train.Name)
data_test['family'], data_test['title'], data_test['Name'] = name_sep(data_test.Name)
data_train.head() | Titanic - Machine Learning from Disaster |
3,610,082 | def minmax(df):
df_minmax = pd.DataFrame()
for feature_name in df.columns:
v_min = df[feature_name].min()
v_max = df[feature_name].max()
df_minmax[feature_name] = pd.Series([v_min,v_max])
return df_minmax<prepare_x_and_y> | len([x for x in data_train.family.unique() if x in data_test.family.unique() ] ) | Titanic - Machine Learning from Disaster |
3,610,082 | def learningPart(df,batch_size):
print(" Data processing started...")
df = df.drop('matchType', axis=1)
train_df = df[df["winPlacePerc"] != -1]
gc.collect()
test_df = df[df["winPlacePerc"] == -1]
test_df = test_df.drop('winPlacePerc', axis=1)
del df
gc.collect()
train_df_Y = train_df.winPlacePerc
train_df_X = train_... | len([x for x in data_train.family.unique() if x not in data_test.family.unique() ] ) | Titanic - Machine Learning from Disaster |
3,610,082 | result = {}
for name,typeGame in dp_by_type.items() :
print("Start "+ name)
predict, history = learningPart(pd.read_csv(name+".csv"),typeGame[1])
result[name] = [predict,history]
print("End "+ name)
dp_by_type[name] = 0<define_variables> | len([x for x in data_test.family.unique() if x not in data_train.family.unique() ] ) | Titanic - Machine Learning from Disaster |
3,610,082 | data = []
for key,ele in result.items() :
data.append(ele[0])
<concatenate> | data_train['family_size'] = data_train.SibSp + data_train.Parch +1
data_test['family_size'] = data_test.SibSp + data_test.Parch +1
rate_family = data_train.groupby('family')['Survived', 'family','family_size'].median()
rate_family.head() | Titanic - Machine Learning from Disaster |
3,610,082 | df = pd.concat(data, ignore_index=True)
df = df.sort_values(by='Id', ascending=[True])
df = df.reset_index(drop=True )<load_from_csv> | overlap_family ={}
for i in range(len(rate_family)) :
if rate_family.index[i] in overlap and rate_family.iloc[i,1] > 1:
overlap_family[rate_family.index[i]] = rate_family.iloc[i,0] | Titanic - Machine Learning from Disaster |
3,610,082 | submission = pd.read_csv(".. /input/sample_submission_V2.csv" )<feature_engineering> | mean_survival_rate = np.mean(data_train.Survived)
family_survival_rate = []
family_survival_rate_NA = []
for i in range(len(data_train)) :
if data_train.family[i] in overlap_family:
family_survival_rate.append(overlap_family[data_train.family[i]])
family_survival_rate_NA.append(1)
else:
family_survival_rate.append(m... | Titanic - Machine Learning from Disaster |
3,610,082 | submission["winPlacePerc"] = df.winPlacePerc<save_to_csv> | mean_survival_rate = np.mean(data_train.Survived)
family_survival_rate = []
family_survival_rate_NA = []
for i in range(len(data_test)) :
if data_test.family[i] in overlap_family:
family_survival_rate.append(overlap_family[data_test.family[i]])
family_survival_rate_NA.append(1)
else:
family_survival_rate.append(mean... | Titanic - Machine Learning from Disaster |
3,610,082 | submission.to_csv('submission.csv', index=False )<save_to_csv> | data_train = data_train.drop(['Name', 'family'], axis=1)
data_test = data_test.drop(['Name', 'family'], axis=1)
data_train.head() | Titanic - Machine Learning from Disaster |
3,610,082 | submission.to_csv('submission.csv', index=False )<load_from_csv> | IQR = data_train.Fare.quantile(0.75)- data_train.Fare.quantile(0.25)
upper_bound = data_train.Fare.quantile(0.75)+ 3*IQR
data_train.loc[data_train.Fare >upper_bound, 'Fare'] = upper_bound
data_test.loc[data_test.Fare >upper_bound, 'Fare'] = upper_bound
max(data_train.Fare ) | Titanic - Machine Learning from Disaster |
3,610,082 | df_train= pd.read_csv('.. /input/pubg-finish-placement-prediction/train_V2.csv')
df_test= pd.read_csv('.. /input/pubg-finish-placement-prediction/test_V2.csv' )<feature_engineering> | IQR = data_train.Age_mean.quantile(0.75)- data_train.Age_mean.quantile(0.25)
upper_bound = data_train.Age_mean.quantile(0.75)+ 3*IQR
data_train.loc[data_train.Age_mean >upper_bound, 'Age_mean'] = upper_bound
data_test.loc[data_test.Age_mean >upper_bound, 'Age_mean'] = upper_bound
max(data_train.Age_mean ) | Titanic - Machine Learning from Disaster |
3,610,082 | df_train['belongs']= 'train'
df_test['belongs']= 'test'<concatenate> | upper_bound = data_train.Age.mean() + 3* data_train.Age.std()
data_train.loc[data_train.Age >upper_bound, 'Age'] = upper_bound
data_test.loc[data_test.Age >upper_bound, 'Age'] = upper_bound
max(data_train.Age ) | Titanic - Machine Learning from Disaster |
3,610,082 | df= pd.concat([df_train.drop('winPlacePerc', axis= 1), df_test], axis= 0, ignore_index= True )<feature_engineering> | print(data_train["family_size"].value_counts() /len(data_train)) | Titanic - Machine Learning from Disaster |
3,610,082 | df['killRate']= df['kills']/ df['matchDuration']<feature_engineering> | print('Pclass')
print(data_train["Pclass"].value_counts() /len(data_train))
print(data_test["Pclass"].value_counts() /len(data_train))
print("------------------------------")
print('Sex')
print(data_train["Sex"].value_counts() /len(data_train))
print(data_test["Sex"].value_counts() /len(data_train))
print("---------... | Titanic - Machine Learning from Disaster |
3,610,082 | df['DBNORate']= df['DBNOs']/ df['matchDuration']<feature_engineering> | data = pd.concat([data_train.drop(['Survived'], axis=1), data_test], axis =0, sort = False)
data.head() | Titanic - Machine Learning from Disaster |
3,610,082 | df['entryCount']= 1<groupby> | le = LabelEncoder()
columns = ['Sex', 'Embarked', 'ticket_type', 'cabin_type', 'title']
for col in columns:
le.fit(data[col])
data[col] = le.transform(data[col])
data.head() | Titanic - Machine Learning from Disaster |
3,610,082 | df['total_players_match']= df.groupby(['matchId'])['entryCount'].transform(np.sum )<groupby> | data = data.drop(['Age_mean', 'Age_NA'], axis =1 ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['total_players_group']= df.groupby(['groupId'])['entryCount'].transform(np.sum )<feature_engineering> | sum(data.Age.isnull() ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['killPlacePerc']=(df['killPlace']/ df['total_players_match'] )<feature_engineering> | x_train_age = data.dropna().drop(['Age'], axis =1)
y_train_age = data.dropna() ['Age'] | Titanic - Machine Learning from Disaster |
3,610,082 | df.loc[df['killPoints']== 0, 'killPoints']= 1<groupby> | x_test_age = data[pd.isnull(data.Age)].drop(['Age'], axis =1 ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['maxKillPointsMatch']= df.groupby(['matchId'])['killPoints'].transform(np.max )<groupby> | model_lin = make_pipeline(StandardScaler() ,KernelRidge())
kfold = model_selection.KFold(n_splits=10, random_state=4, shuffle = True)
parameters = {'kernelridge__gamma' : [0.001, 0.01, 0.1, 1, 10, 100, 1000],
'kernelridge__kernel': ['rbf', 'linear'],
'kernelridge__alpha' :[0.001, 0.01, 0.1, 1, 10, 100, 1000],
}
searc... | Titanic - Machine Learning from Disaster |
3,610,082 | df['maxKillPointsGroup']= df.groupby(['groupId'])['killPoints'].transform(np.max )<feature_engineering> | print("Best parameters are:", search_lin.best_params_)
print("Best accuracy achieved:",search_lin.cv_results_['mean_test_score'].mean() ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['ratioMatchKillPoints']= df['killPoints']/ df['maxKillPointsMatch']<feature_engineering> | y_test_age = search_lin.predict(x_test_age ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['ratioGroupKillPoints']= df['killPoints']/ df['maxKillPointsGroup']<data_type_conversions> | data.loc[data['Age'].isnull() , 'Age'] = y_test_age | Titanic - Machine Learning from Disaster |
3,610,082 | df['killPointsBuckets']= df['killPointsBuckets'].astype(np.int8 )<feature_engineering> | idx = int(data_train.shape[0])
data_train['Age'] = data.iloc[:idx].Age
data_test['Age'] = data.iloc[idx:].Age | Titanic - Machine Learning from Disaster |
3,610,082 | df.loc[df['winPoints']== 0, 'winPoints']= 1<groupby> | le = LabelEncoder()
data_train_LE = data_train.copy()
data_test_LE = data_test.copy()
columns = ['Sex', 'Embarked', 'ticket_type', 'cabin_type', 'title']
for col in columns:
le.fit(data_train_LE[col])
data_train_LE[col] = le.fit_transform(data_train_LE[col])
data_test_LE[col] = le.transform(data_test_LE[col])
data_t... | Titanic - Machine Learning from Disaster |
3,610,082 | df['maxWinPointsMatch']= df.groupby(['matchId'])['winPoints'].transform(np.max )<groupby> | drop_col = ['Age_mean', 'SibSp', 'Parch']
data_train_LE = data_train_LE.drop(drop_col, axis=1)
data_test_LE = data_test_LE.drop(drop_col, axis=1 ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['maxWinPointsGroup']= df.groupby(['groupId'])['winPoints'].transform(np.max )<feature_engineering> | X_train_onehot = data_train.drop(drop_col, axis=1)
X_test_onehot = data_test.drop(drop_col, axis=1 ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['ratioMatchWinPoints']= df['winPoints']/ df['maxKillPointsMatch']<feature_engineering> | columns = ['cabin_type', 'title', 'Sex', 'Embarked', 'ticket_type', 'Pclass']
for col in columns:
X_train_onehot = pd.concat([X_train_onehot, pd.get_dummies(X_train_onehot[col], drop_first = True)], axis =1)
X_test_onehot = pd.concat([X_test_onehot, pd.get_dummies(X_test_onehot[col], drop_first = True)], axis =1)
| Titanic - Machine Learning from Disaster |
3,610,082 | df['ratioGroupWinPoints']= df['winPoints']/ df['maxKillPointsGroup']<data_type_conversions> | X_train_onehot = X_train_onehot.drop(columns, axis=1)
X_test_onehot = X_test_onehot.drop(columns, axis=1 ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['winPointsBuckets']= df['winPointsBuckets'].astype(np.int8 )<groupby> | X_train_lab = data_train.drop(drop_col, axis=1)
X_test_lab = data_test.drop(drop_col, axis=1 ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['killPointsSumMatch']= df.groupby(['matchId'])['killPoints'].transform(np.sum )<groupby> | le = LabelEncoder()
columns = ['Sex', 'Embarked', 'ticket_type', 'cabin_type', 'title']
for col in columns:
le.fit(data_train[col])
X_train_lab[col] = le.transform(X_train_lab[col])
X_test_lab[col] = le.transform(X_test_lab[col])
X_test_lab.head() | Titanic - Machine Learning from Disaster |
3,610,082 | df['killPointsSumGroup']= df.groupby(['groupId'])['killPoints'].transform(np.sum )<feature_engineering> | X_train_mean = data_train.drop(drop_col, axis=1)
X_test_mean = data_test.drop(drop_col, axis=1 ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['ratioKillPointsGroupAndMatch']= df['killPointsSumGroup']/ df['killPointsSumMatch']<groupby> | columns = ['cabin_type', 'title', 'Sex', 'Embarked', 'ticket_type']
for col in columns:
ordered_labels = X_train_mean.groupby([col])['Survived'].mean().to_dict()
X_train_mean[col] = X_train_mean[col].map(ordered_labels)
X_test_mean[col] = X_test_mean[col].map(ordered_labels ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['avgKillPointsGroup']= df.groupby(['matchId'])['killPoints'].transform(np.mean )<groupby> | X_train_freq = data_train.drop(drop_col, axis=1)
X_test_freq = data_test.drop(drop_col, axis=1 ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['avgKillPointsMatch']= df.groupby(['groupId'])['killPoints'].transform(np.mean )<feature_engineering> | columns = ['cabin_type', 'title', 'Sex', 'Embarked', 'ticket_type']
for col in columns:
ordered_labels = X_train_freq[col].value_counts().to_dict()
X_train_freq[col] = X_train_freq[col].map(ordered_labels)
X_test_freq[col] = X_test_freq[col].map(ordered_labels ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['ratioAvgKillPointsGroupAndMatch']= df['avgKillPointsGroup']/ df['avgKillPointsMatch']<groupby> | random_state = 4 | Titanic - Machine Learning from Disaster |
3,610,082 | df['groupRevived']= df.groupby(['groupId'])['revives'].transform(np.sum )<groupby> | kfold = StratifiedKFold(n_splits=5 ) | Titanic - Machine Learning from Disaster |
3,610,082 | df['groupTeamKills']= df.groupby(['groupId'])['teamKills'].transform(np.sum )<feature_engineering> | def separate(X_train):
X = X_train.drop(columns= ['Survived'])
Y = X_train['Survived']
return X, Y | Titanic - Machine Learning from Disaster |
3,610,082 | df['avgSpeed']=(df['walkDistance']+ df['swimDistance']+ df['rideDistance'])/ df['matchDuration']<categorify> | X_onehot, Y_onehot = separate(X_train_onehot)
X_lab, Y_lab = separate(X_train_lab)
X_mean, Y_mean = separate(X_train_mean)
X_freq, Y_freq = separate(X_train_freq ) | Titanic - Machine Learning from Disaster |
3,610,082 | le= LabelEncoder()
le.fit(df['matchType'] )<categorify> | random_state = 4
classifiers = []
classifiers.append(( 'SVC', make_pipeline(StandardScaler() ,SVC(random_state=random_state))))
classifiers.append(( 'DecisionTree', DecisionTreeClassifier(random_state=random_state)))
classifiers.append(( 'AdaBoost', AdaBoostClassifier(DecisionTreeClassifier(random_state=random_state),... | Titanic - Machine Learning from Disaster |
3,610,082 | df['matchTypeLabels']= le.fit_transform(df['matchType'] )<drop_column> | def random_forest(X, Y, X_test):
parameters = {'max_depth' : [2, 4, 5, 10],
'n_estimators' : [200, 500, 1000, 2000],
'min_samples_split' : [3, 4, 5],
}
kfold = model_selection.KFold(n_splits=3, random_state=random_state, shuffle = True)
model_RFC = RandomForestClassifier(random_state = 4, n_jobs = -1)
search_RFC = Gr... | Titanic - Machine Learning from Disaster |
3,610,082 | df.drop(['entryCount', 'groupId', 'matchId', 'matchType', 'DBNOs', 'winPoints', 'killPoints', 'killStreaks', 'maxKillPointsGroup', 'revives', 'headshotKills', 'teamKills', 'roadKills', 'vehicleDestroys'], axis= 1, inplace= True )<rename_columns> | param_RFC_onehot, model_RFC_onehot, search_RFC_onehot, predicted_cv_RFC_onehot = random_forest(X_onehot, Y_onehot, X_test_onehot)
param_RFC_lab, model_RFC_lab, search_RFC_lab, predicted_cv_RFC_lab = random_forest(X_lab, Y_lab, X_test_lab)
param_RFC_mean, model_RFC_mean, search_RFC_mean, predicted_cv_RFC_mean = random... | Titanic - Machine Learning from Disaster |
3,610,082 | df.set_index('Id', inplace= True )<filter> | def fit_pred_RF(X, Y, X_test):
model_RFC = RandomForestClassifier(max_depth =2, min_samples_split =3, n_estimators = 5000,
random_state = 4, n_jobs = -1)
model_RFC.fit(X, Y)
predicted= model_RFC.predict(X_test)
return predicted, model_RFC
| Titanic - Machine Learning from Disaster |
3,610,082 | df_train= df[df['belongs']== 'train']<filter> | predicted_RFC_onehot, model_RFC_onehot = fit_pred_RF(X_onehot, Y_onehot, X_test_onehot)
predicted_RFC_lab, model_RFC_lab = fit_pred_RF(X_lab, Y_lab, X_test_lab)
predicted_RFC_mean, model_RFC_mean = fit_pred_RF(X_mean, Y_mean, X_test_mean)
predicted_RFC_freq, model_RFC_freq = fit_pred_RF(X_freq, Y_freq, X_test_freq ) | Titanic - Machine Learning from Disaster |
3,610,082 | df_test= df[df['belongs']== 'test']<drop_column> | def grad_boost(X, Y, X_test):
parameters = {'max_depth' : [2, 4, 10, 15],
'n_estimators' : [10, 50, 100],
'min_samples_split' : [5, 10, 15],
}
kfold = model_selection.KFold(n_splits=3, random_state=random_state, shuffle = True)
model_GBC = GradientBoostingClassifier(random_state = 4)
search_GBC = GridSearchCV(model_G... | Titanic - Machine Learning from Disaster |
3,610,082 | df_train.drop('belongs', axis= 1, inplace= True )<drop_column> | param_GBC_onehot, model_GBC_onehot, search_GBC_onehot, predicted_cv_GBC_onehot = grad_boost(X_onehot, Y_onehot, X_test_onehot)
param_GBC_lab, model_GBC_lab, search_GBC_lab, predicted_cv_GBC_lab = grad_boost(X_lab, Y_lab, X_test_lab)
param_GBC_mean, model_GBC_mean, search_GBC_mean, predicted_cv_GBC_mean = grad_boost(X... | Titanic - Machine Learning from Disaster |
3,610,082 | df_test.drop('belongs', axis= 1, inplace= True )<load_from_csv> | def fit_pred_GBC(X, Y, X_test):
model_GBC = GradientBoostingClassifier(max_depth = 2, min_samples_split = 15, n_estimators = 10,\
random_state = 4, max_features= 'auto')
model_GBC.fit(X, Y)
predicted= model_GBC.predict(X_test)
return predicted, model_GBC | Titanic - Machine Learning from Disaster |
3,610,082 | df_train['winPlacePerc']= pd.read_csv('.. /input/pubg-finish-placement-prediction/train_V2.csv', usecols= ['winPlacePerc'] )<rename_columns> | predicted_GBC_onehot, model_GBC_onehot = fit_pred_GBC(X_onehot, Y_onehot, X_test_onehot)
predicted_GBC_lab, model_GBC_lab = fit_pred_GBC(X_lab, Y_lab, X_test_lab)
predicted_GBC_mean, model_GBC_mean = fit_pred_GBC(X_mean, Y_mean, X_test_mean)
predicted_GBC_freq, model_GBC_freq = fit_pred_GBC(X_freq, Y_freq, X_test_fr... | Titanic - Machine Learning from Disaster |
3,610,082 | df_train.set_index('Id', inplace= True )<correct_missing_values> | def mod_KNN(X, Y, X_test):
model_KNN=make_pipeline(MinMaxScaler() ,KNeighborsClassifier())
kfold = model_selection.KFold(n_splits=3, random_state=random_state, shuffle = True)
parameters=[{'kneighborsclassifier__n_neighbors': [2,3,4,5,6,7,8,9,10]}]
search_KNN = GridSearchCV(estimator=model_KNN, param_grid=parameters,... | Titanic - Machine Learning from Disaster |
3,610,082 | df_train.dropna(inplace= True )<split> | param_KNN_onehot, model_KNN_onehot, search_KNN_onehot, predicted_cv_KNN_onehot = mod_KNN(X_onehot, Y_onehot, X_test_onehot)
param_KNN_lab, model_KNN_lab, search_KNN_lab, predicted_cv_KNN_lab = mod_KNN(X_lab, Y_lab, X_test_lab)
param_KNN_mean, model_KNN_mean, search_KNN_mean, predicted_cv_KNN_mean = mod_KNN(X_mean, Y_... | Titanic - Machine Learning from Disaster |
3,610,082 | X_train, X_test, y_train, y_test= train_test_split(df_train.drop(['winPlacePerc'], axis= 1), df_train['winPlacePerc'], test_size= 0.3 )<choose_model_class> | def fit_pred_KNN(X, Y, X_test):
model_KNN = make_pipeline(MinMaxScaler() ,KNeighborsClassifier(n_neighbors=11))
model_KNN.fit(X, Y)
predicted= model_KNN.predict(X_test)
return predicted, model_KNN | Titanic - Machine Learning from Disaster |
3,610,082 | model= XGBRegressor(n_estimators= 500, max_depth= 7, n_jobs= -1, min_child_weight= 7, subsample=0.84, colsample_bytree= 0.97, eta=0.3, seed=42 )<train_model> | predicted_KNN_onehot, model_KNN_onehot = fit_pred_KNN(X_onehot, Y_onehot, X_test_onehot)
predicted_KNN_lab, model_KNN_lab = fit_pred_KNN(X_lab, Y_lab, X_test_lab)
predicted_KNN_mean, model_KNN_mean = fit_pred_KNN(X_mean, Y_mean, X_test_mean)
predicted_KNN_freq, model_KNN_freq = fit_pred_KNN(X_freq, Y_freq, X_test_fr... | Titanic - Machine Learning from Disaster |
3,610,082 | model.fit(
X_train,
y_train,
eval_metric="rmse",
eval_set=[(X_train, y_train),(X_test, y_test)],
verbose=True,
early_stopping_rounds = 10 )<save_to_csv> | def mod_SVC(X, Y, X_test):
model_SVC=make_pipeline(StandardScaler() ,SVC(random_state=1))
parameters=[{'svc__C': [0.0001,0.001,0.1,1, 10, 100],
'svc__gamma':[0.0001,0.001,0.1,1,10,50,100],
'svc__kernel':['rbf'],
'svc__degree' : [1,2,3,4]
}]
kfold = model_selection.KFold(n_splits=3, random_state=random_state, shuffle = ... | Titanic - Machine Learning from Disaster |
3,610,082 | predictions= pd.DataFrame({'winPlacePerc': model.predict(df_test ).clip(0,1)}, index= df_test.index)
predictions.to_csv('submission_1.csv' )<categorify> | param_SVC_onehot, model_SVC_onehot, search_SVC_onehot, predicted_cv_SVC_onehot = mod_SVC(X_onehot, Y_onehot, X_test_onehot)
param_SVC_lab, model_SVC_lab, search_SVC_lab, predicted_cv_SVC_lab = mod_SVC(X_lab, Y_lab, X_test_lab)
param_SVC_mean, model_SVC_mean, search_SVC_mean, predicted_cv_SVC_mean = mod_SVC(X_mean, Y_... | Titanic - Machine Learning from Disaster |
3,610,082 | def memory_reduce(df):
start_memory = df.memory_usage().sum() /1024**2
for col in df.columns:
col_type = df[col].dtype
if(col_type != object):
min_val = min(df[col])
max_val = max(df[col])
if(str(col_type)[:3] == 'int'):
if(min_val > np.iinfo(np.int8 ).min and max_val < np.iinfo(np.int8 ).max):
df[col] = df[col].asty... | def fit_pred_SVC(X, Y, X_test):
model_SVC = make_pipeline(StandardScaler() ,SVC(random_state=random_state, C= 1, gamma = 0.001, kernel = 'rbf', degree =1))
model_SVC.fit(X, Y)
predicted= model_SVC.predict(X_test)
return predicted, model_SVC | Titanic - Machine Learning from Disaster |
3,610,082 |
<load_from_csv> | predicted_SVC_onehot, model_SVC_onehot = fit_pred_SVC(X_onehot, Y_onehot, X_test_onehot)
predicted_SVC_lab, model_SVC_lab = fit_pred_SVC(X_lab, Y_lab, X_test_lab)
predicted_SVC_mean, model_SVC_mean = fit_pred_SVC(X_mean, Y_mean, X_test_mean)
predicted_SVC_freq, model_SVC_freq = fit_pred_SVC(X_freq, Y_freq, X_test_fr... | Titanic - Machine Learning from Disaster |
3,610,082 | startTime = time.time()
def feature_engineering(is_train = True , debug = True):
test_Idx = None
if(is_train):
print('processing train data')
if(debug):
df = memory_reduce(pd.read_csv('.. /input/train_V2.csv' , nrows=10000))
else:
df = memory_reduce(pd.read_csv('.. /input/train_V2.csv'))
df = df[pd.notnull(df['winPlac... | predicted = np.where(((predicted_SVC_mean + predicted_KNN_onehot+predicted_RFC_onehot+predicted_RFC_freq+ predicted_RFC_mean)/5)> 0.5, 1, 0)
| Titanic - Machine Learning from Disaster |
3,610,082 | <categorify><EOS> | test =pd.read_csv(".. /input/test.csv")
submission = pd.DataFrame({'PassengerId': test['PassengerId'],'Survived':predicted})
submission.head()
filename = 'Titanic Predictions Public.csv'
submission.to_csv(filename,index=False)
print('Saved file: ' + filename ) | Titanic - Machine Learning from Disaster |
9,263,527 | <SOS> metric: categorizationaccuracy Kaggle data source: titanic-machine-learning-from-disaster<define_variables> | pd.plotting.register_matplotlib_converters()
%matplotlib inline
sns.set_style('dark')
print('Setup complete' ) | Titanic - Machine Learning from Disaster |
9,263,527 |
<train_model> | train_data = pd.read_csv('/kaggle/input/titanic/train.csv')
train_data.head() | Titanic - Machine Learning from Disaster |
9,263,527 | warnings.filterwarnings('ignore')
startTime = time.time()
print(startTime)
train_index = round(int(x_train.shape[0]*0.8))
dev_X = x_train[:train_index]
val_X = x_train[train_index:]
dev_y = y_train[:train_index]
val_y = y_train[train_index:]
gc.collect() ;
def run_lgb(train_X, train_y, val_X, val_y, x_test):
params =... | test_data = pd.read_csv('/kaggle/input/titanic/test.csv')
test_data.head() | Titanic - Machine Learning from Disaster |
9,263,527 | startTime = time.time()
df_sub = pd.read_csv(".. /input/sample_submission_V2.csv")
df_test = pd.read_csv(".. /input/test_V2.csv")
df_sub['winPlacePerc'] = pred_test
df_sub = df_sub.merge(df_test[["Id", "matchId", "groupId", "maxPlace", "numGroups"]], on="Id", how="left")
df_sub_group = df_sub.groupby(["matchId", "gr... | train_data['Survived'].value_counts(normalize=True ) | Titanic - Machine Learning from Disaster |
9,263,527 |
<feature_engineering> | train_data.groupby('Pclass' ).Survived.mean() | Titanic - Machine Learning from Disaster |
9,263,527 |
<categorify> | train_data.groupby(['Pclass', 'Sex'] ).Survived.mean() | Titanic - Machine Learning from Disaster |
9,263,527 |
<train_model> | train_data.loc[train_data.Fare==0] | Titanic - Machine Learning from Disaster |
9,263,527 |
<train_model> | def remove_zero_fares(row):
if row.Fare == 0:
row.Fare = np.NaN
return row
train_data = train_data.apply(remove_zero_fares, axis=1)
test_data = test_data.apply(remove_zero_fares, axis=1)
print('Number of zero-Fares: {:d}'.format(train_data.loc[train_data.Fare==0].shape[0])) | 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.