path
stringlengths 13
17
| screenshot_names
sequencelengths 1
873
| code
stringlengths 0
40.4k
| cell_type
stringclasses 1
value |
|---|---|---|---|
33115163/cell_43 | [
"text_plain_output_1.png",
"image_output_1.png"
] | from sklearn.preprocessing import MinMaxScaler
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
test = pd.read_csv('../input/mobile-price-classification/test.csv')
train = pd.read_csv('../input/mobile-price-classification/train.csv')
numerical = ['battery_power', 'clock_speed', 'fc', 'int_memory', 'm_dep', 'mobile_wt', 'n_cores', 'pc', 'px_height', 'px_width', 'ram', 'sc_h', 'sc_w', 'talk_time']
categorical = ['blue', 'dual_sim', 'four_g', 'three_g', 'touch_screen', 'wifi']
df = pd.melt(train[categorical])
#numerical attributes
fig = plt.figure(figsize=(15,20))
for i,col in enumerate(numerical):
ax=plt.subplot(5,3,i+1)
train[col].plot.hist(ax = ax).tick_params(axis = 'x',labelrotation = 360)
ax.legend(loc = 'upper center', bbox_to_anchor=(0.5, 1.1))
plt.show()
skewed = ['clock_speed', 'fc', 'm_dep', 'px_height', 'sc_w']
no_skewed = ['battery_power', 'int_memory', 'mobile_wt', 'n_cores', 'pc', 'px_width', 'ram', 'sc_h', 'talk_time']
#correlation between attributes
corr = train.corr()
fig, (ax) = plt.subplots(1,1,sharey = True, figsize = (20,10))
sns.heatmap(corr, cmap = 'Blues')
#variables with symmetrical distributions
group_no_skewed = train.groupby('price_range')[no_skewed].mean().reset_index()
fig = plt.figure(figsize=(15,20))
for i,col in enumerate(group_no_skewed.iloc[:,1:].columns):
ax=plt.subplot(5,3,i+1)
group_no_skewed.iloc[:,1:][col].plot.bar(ax = ax).tick_params(axis = 'x',labelrotation = 360)
ax.legend(loc = 'upper center', bbox_to_anchor=(0.5, 1.1))
plt.show()
#variables with skewed distributions
group_skewed = train.groupby('price_range')[skewed].median().reset_index()
fig = plt.figure(figsize=(15,20))
for i,col in enumerate(group_skewed.iloc[:,1:].columns):
ax=plt.subplot(5,3,i+1)
group_skewed.iloc[:,1:][col].plot.bar(ax = ax).tick_params(axis = 'x',labelrotation = 360)
ax.legend(loc = 'upper center', bbox_to_anchor=(0.5, 1.1))
plt.show()
from sklearn.preprocessing import MinMaxScaler
scaler_train = MinMaxScaler()
train_num_scaled = scaler_train.fit_transform(train[numerical])
scaler_train.data_max_
scaler_train.data_min_ | code |
33115163/cell_24 | [
"text_plain_output_1.png",
"image_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
test = pd.read_csv('../input/mobile-price-classification/test.csv')
train = pd.read_csv('../input/mobile-price-classification/train.csv')
numerical = ['battery_power', 'clock_speed', 'fc', 'int_memory', 'm_dep', 'mobile_wt', 'n_cores', 'pc', 'px_height', 'px_width', 'ram', 'sc_h', 'sc_w', 'talk_time']
categorical = ['blue', 'dual_sim', 'four_g', 'three_g', 'touch_screen', 'wifi']
df = pd.melt(train[categorical])
#numerical attributes
fig = plt.figure(figsize=(15,20))
for i,col in enumerate(numerical):
ax=plt.subplot(5,3,i+1)
train[col].plot.hist(ax = ax).tick_params(axis = 'x',labelrotation = 360)
ax.legend(loc = 'upper center', bbox_to_anchor=(0.5, 1.1))
plt.show()
#correlation between attributes
corr = train.corr()
fig, (ax) = plt.subplots(1,1,sharey = True, figsize = (20,10))
sns.heatmap(corr, cmap = 'Blues')
corr.sort_values(by=['price_range'], ascending=False).iloc[0].sort_values(ascending=False) | code |
33115163/cell_22 | [
"text_plain_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
test = pd.read_csv('../input/mobile-price-classification/test.csv')
train = pd.read_csv('../input/mobile-price-classification/train.csv')
numerical = ['battery_power', 'clock_speed', 'fc', 'int_memory', 'm_dep', 'mobile_wt', 'n_cores', 'pc', 'px_height', 'px_width', 'ram', 'sc_h', 'sc_w', 'talk_time']
categorical = ['blue', 'dual_sim', 'four_g', 'three_g', 'touch_screen', 'wifi']
df = pd.melt(train[categorical])
#numerical attributes
fig = plt.figure(figsize=(15,20))
for i,col in enumerate(numerical):
ax=plt.subplot(5,3,i+1)
train[col].plot.hist(ax = ax).tick_params(axis = 'x',labelrotation = 360)
ax.legend(loc = 'upper center', bbox_to_anchor=(0.5, 1.1))
plt.show()
corr = train.corr()
fig, ax = plt.subplots(1, 1, sharey=True, figsize=(20, 10))
sns.heatmap(corr, cmap='Blues') | code |
33115163/cell_53 | [
"text_html_output_1.png"
] | print(X_train.shape)
print(y_train.shape)
print(X_val.shape)
print(y_val.shape) | code |
33115163/cell_10 | [
"text_html_output_1.png"
] | import pandas as pd
test = pd.read_csv('../input/mobile-price-classification/test.csv')
train = pd.read_csv('../input/mobile-price-classification/train.csv')
test.info() | code |
33115163/cell_37 | [
"image_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
test = pd.read_csv('../input/mobile-price-classification/test.csv')
train = pd.read_csv('../input/mobile-price-classification/train.csv')
numerical = ['battery_power', 'clock_speed', 'fc', 'int_memory', 'm_dep', 'mobile_wt', 'n_cores', 'pc', 'px_height', 'px_width', 'ram', 'sc_h', 'sc_w', 'talk_time']
categorical = ['blue', 'dual_sim', 'four_g', 'three_g', 'touch_screen', 'wifi']
df = pd.melt(train[categorical])
#numerical attributes
fig = plt.figure(figsize=(15,20))
for i,col in enumerate(numerical):
ax=plt.subplot(5,3,i+1)
train[col].plot.hist(ax = ax).tick_params(axis = 'x',labelrotation = 360)
ax.legend(loc = 'upper center', bbox_to_anchor=(0.5, 1.1))
plt.show()
skewed = ['clock_speed', 'fc', 'm_dep', 'px_height', 'sc_w']
no_skewed = ['battery_power', 'int_memory', 'mobile_wt', 'n_cores', 'pc', 'px_width', 'ram', 'sc_h', 'talk_time']
#correlation between attributes
corr = train.corr()
fig, (ax) = plt.subplots(1,1,sharey = True, figsize = (20,10))
sns.heatmap(corr, cmap = 'Blues')
#variables with symmetrical distributions
group_no_skewed = train.groupby('price_range')[no_skewed].mean().reset_index()
fig = plt.figure(figsize=(15,20))
for i,col in enumerate(group_no_skewed.iloc[:,1:].columns):
ax=plt.subplot(5,3,i+1)
group_no_skewed.iloc[:,1:][col].plot.bar(ax = ax).tick_params(axis = 'x',labelrotation = 360)
ax.legend(loc = 'upper center', bbox_to_anchor=(0.5, 1.1))
plt.show()
#variables with skewed distributions
group_skewed = train.groupby('price_range')[skewed].median().reset_index()
fig = plt.figure(figsize=(15,20))
for i,col in enumerate(group_skewed.iloc[:,1:].columns):
ax=plt.subplot(5,3,i+1)
group_skewed.iloc[:,1:][col].plot.bar(ax = ax).tick_params(axis = 'x',labelrotation = 360)
ax.legend(loc = 'upper center', bbox_to_anchor=(0.5, 1.1))
plt.show()
sns.catplot('price_range', col='dual_sim', data=train, kind='count') | code |
2013301/cell_9 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
point_diff = make_point_diff_mat(df2)
np.corrcoef(point_diff.T)
bool_point_diff = make_bool_point_diff_mat(df2)
np.corrcoef(bool_point_diff.T)
prob_of_winning_given(bool_point_diff, DOWN_AT_HALF) | code |
2013301/cell_25 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
point_diff = make_point_diff_mat(df2)
np.corrcoef(point_diff.T)
bool_point_diff = make_bool_point_diff_mat(df2)
np.corrcoef(bool_point_diff.T)
max_prob_winning_DOWN_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, DOWN_AT_HALF)
if prob > max_prob_winning_DOWN_at_half:
max_prob_winning_DOWN_at_half = prob
max_team = abbr
max_prob_winning_UP_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, UP_AT_HALF)
if prob > max_prob_winning_UP_at_half:
max_prob_winning_UP_at_half = prob
max_team = abbr
df_cavs = df2[df2['teamAbbr'] == 'CLE']
point_diff_cavs = make_point_diff_mat(df_cavs)
np.corrcoef(point_diff_cavs.T)
bool_point_diff_cavs = make_bool_point_diff_mat(df_cavs)
np.corrcoef(bool_point_diff_cavs.T)
df_warr = df2[df2.teamAbbr == 'GS']
point_diff_warr = make_point_diff_mat(df_warr)
np.corrcoef(point_diff_warr.T)
bool_point_diff_warr = make_bool_point_diff_mat(df_warr)
np.corrcoef(bool_point_diff_warr.T)
prob_of_winning_given(bool_point_diff_warr, DOWN_AT_HALF) | code |
2013301/cell_4 | [
"text_plain_output_1.png"
] | import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2 | code |
2013301/cell_23 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
point_diff = make_point_diff_mat(df2)
np.corrcoef(point_diff.T)
bool_point_diff = make_bool_point_diff_mat(df2)
np.corrcoef(bool_point_diff.T)
max_prob_winning_DOWN_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, DOWN_AT_HALF)
if prob > max_prob_winning_DOWN_at_half:
max_prob_winning_DOWN_at_half = prob
max_team = abbr
max_prob_winning_UP_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, UP_AT_HALF)
if prob > max_prob_winning_UP_at_half:
max_prob_winning_UP_at_half = prob
max_team = abbr
df_cavs = df2[df2['teamAbbr'] == 'CLE']
point_diff_cavs = make_point_diff_mat(df_cavs)
np.corrcoef(point_diff_cavs.T)
bool_point_diff_cavs = make_bool_point_diff_mat(df_cavs)
np.corrcoef(bool_point_diff_cavs.T)
df_warr = df2[df2.teamAbbr == 'GS']
point_diff_warr = make_point_diff_mat(df_warr)
np.corrcoef(point_diff_warr.T) | code |
2013301/cell_20 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
point_diff = make_point_diff_mat(df2)
np.corrcoef(point_diff.T)
bool_point_diff = make_bool_point_diff_mat(df2)
np.corrcoef(bool_point_diff.T)
max_prob_winning_DOWN_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, DOWN_AT_HALF)
if prob > max_prob_winning_DOWN_at_half:
max_prob_winning_DOWN_at_half = prob
max_team = abbr
max_prob_winning_UP_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, UP_AT_HALF)
if prob > max_prob_winning_UP_at_half:
max_prob_winning_UP_at_half = prob
max_team = abbr
df_cavs = df2[df2['teamAbbr'] == 'CLE']
point_diff_cavs = make_point_diff_mat(df_cavs)
np.corrcoef(point_diff_cavs.T)
bool_point_diff_cavs = make_bool_point_diff_mat(df_cavs)
np.corrcoef(bool_point_diff_cavs.T)
prob_of_winning_given(bool_point_diff_cavs, UP_AT_HALF) | code |
2013301/cell_26 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
point_diff = make_point_diff_mat(df2)
np.corrcoef(point_diff.T)
bool_point_diff = make_bool_point_diff_mat(df2)
np.corrcoef(bool_point_diff.T)
max_prob_winning_DOWN_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, DOWN_AT_HALF)
if prob > max_prob_winning_DOWN_at_half:
max_prob_winning_DOWN_at_half = prob
max_team = abbr
max_prob_winning_UP_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, UP_AT_HALF)
if prob > max_prob_winning_UP_at_half:
max_prob_winning_UP_at_half = prob
max_team = abbr
df_cavs = df2[df2['teamAbbr'] == 'CLE']
point_diff_cavs = make_point_diff_mat(df_cavs)
np.corrcoef(point_diff_cavs.T)
bool_point_diff_cavs = make_bool_point_diff_mat(df_cavs)
np.corrcoef(bool_point_diff_cavs.T)
df_warr = df2[df2.teamAbbr == 'GS']
point_diff_warr = make_point_diff_mat(df_warr)
np.corrcoef(point_diff_warr.T)
bool_point_diff_warr = make_bool_point_diff_mat(df_warr)
np.corrcoef(bool_point_diff_warr.T)
prob_of_winning_given(bool_point_diff_warr, UP_AT_HALF) | code |
2013301/cell_19 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
point_diff = make_point_diff_mat(df2)
np.corrcoef(point_diff.T)
bool_point_diff = make_bool_point_diff_mat(df2)
np.corrcoef(bool_point_diff.T)
max_prob_winning_DOWN_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, DOWN_AT_HALF)
if prob > max_prob_winning_DOWN_at_half:
max_prob_winning_DOWN_at_half = prob
max_team = abbr
max_prob_winning_UP_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, UP_AT_HALF)
if prob > max_prob_winning_UP_at_half:
max_prob_winning_UP_at_half = prob
max_team = abbr
df_cavs = df2[df2['teamAbbr'] == 'CLE']
point_diff_cavs = make_point_diff_mat(df_cavs)
np.corrcoef(point_diff_cavs.T)
bool_point_diff_cavs = make_bool_point_diff_mat(df_cavs)
np.corrcoef(bool_point_diff_cavs.T)
prob_of_winning_given(bool_point_diff_cavs, DOWN_AT_HALF) | code |
2013301/cell_7 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
point_diff = make_point_diff_mat(df2)
np.corrcoef(point_diff.T) | code |
2013301/cell_18 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
point_diff = make_point_diff_mat(df2)
np.corrcoef(point_diff.T)
bool_point_diff = make_bool_point_diff_mat(df2)
np.corrcoef(bool_point_diff.T)
max_prob_winning_DOWN_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, DOWN_AT_HALF)
if prob > max_prob_winning_DOWN_at_half:
max_prob_winning_DOWN_at_half = prob
max_team = abbr
max_prob_winning_UP_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, UP_AT_HALF)
if prob > max_prob_winning_UP_at_half:
max_prob_winning_UP_at_half = prob
max_team = abbr
df_cavs = df2[df2['teamAbbr'] == 'CLE']
point_diff_cavs = make_point_diff_mat(df_cavs)
np.corrcoef(point_diff_cavs.T)
bool_point_diff_cavs = make_bool_point_diff_mat(df_cavs)
np.corrcoef(bool_point_diff_cavs.T) | code |
2013301/cell_8 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
point_diff = make_point_diff_mat(df2)
np.corrcoef(point_diff.T)
bool_point_diff = make_bool_point_diff_mat(df2)
np.corrcoef(bool_point_diff.T) | code |
2013301/cell_17 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
point_diff = make_point_diff_mat(df2)
np.corrcoef(point_diff.T)
bool_point_diff = make_bool_point_diff_mat(df2)
np.corrcoef(bool_point_diff.T)
max_prob_winning_DOWN_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, DOWN_AT_HALF)
if prob > max_prob_winning_DOWN_at_half:
max_prob_winning_DOWN_at_half = prob
max_team = abbr
max_prob_winning_UP_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, UP_AT_HALF)
if prob > max_prob_winning_UP_at_half:
max_prob_winning_UP_at_half = prob
max_team = abbr
df_cavs = df2[df2['teamAbbr'] == 'CLE']
point_diff_cavs = make_point_diff_mat(df_cavs)
np.corrcoef(point_diff_cavs.T) | code |
2013301/cell_24 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
point_diff = make_point_diff_mat(df2)
np.corrcoef(point_diff.T)
bool_point_diff = make_bool_point_diff_mat(df2)
np.corrcoef(bool_point_diff.T)
max_prob_winning_DOWN_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, DOWN_AT_HALF)
if prob > max_prob_winning_DOWN_at_half:
max_prob_winning_DOWN_at_half = prob
max_team = abbr
max_prob_winning_UP_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, UP_AT_HALF)
if prob > max_prob_winning_UP_at_half:
max_prob_winning_UP_at_half = prob
max_team = abbr
df_cavs = df2[df2['teamAbbr'] == 'CLE']
point_diff_cavs = make_point_diff_mat(df_cavs)
np.corrcoef(point_diff_cavs.T)
bool_point_diff_cavs = make_bool_point_diff_mat(df_cavs)
np.corrcoef(bool_point_diff_cavs.T)
df_warr = df2[df2.teamAbbr == 'GS']
point_diff_warr = make_point_diff_mat(df_warr)
np.corrcoef(point_diff_warr.T)
bool_point_diff_warr = make_bool_point_diff_mat(df_warr)
np.corrcoef(bool_point_diff_warr.T) | code |
2013301/cell_14 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
max_prob_winning_DOWN_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, DOWN_AT_HALF)
if prob > max_prob_winning_DOWN_at_half:
max_prob_winning_DOWN_at_half = prob
max_team = abbr
max_prob_winning_UP_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, UP_AT_HALF)
if prob > max_prob_winning_UP_at_half:
max_prob_winning_UP_at_half = prob
max_team = abbr
print(max_team)
print(max_prob_winning_UP_at_half) | code |
2013301/cell_10 | [
"text_html_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
point_diff = make_point_diff_mat(df2)
np.corrcoef(point_diff.T)
bool_point_diff = make_bool_point_diff_mat(df2)
np.corrcoef(bool_point_diff.T)
prob_of_winning_given(bool_point_diff, UP_AT_HALF) | code |
2013301/cell_12 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
import numpy as np
import pandas as pd
pd.options.mode.chained_assignment = None
DOWN_AT_HALF = -1
TIE_AT_HALF = 0
UP_AT_HALF = 1
df16 = pd.read_csv('../input/2016-17_teamBoxScore.csv')
df17 = pd.read_csv('../input/2017-18_teamBoxScore.csv')
df = pd.concat((df16, df17))
df2 = df[['teamAbbr', 'teamPTS', 'teamPTS1', 'teamPTS2', 'opptPTS', 'opptPTS1', 'opptPTS2']]
df2.loc[:, 'teamPTSH1'] = df2['teamPTS1'] + df['teamPTS2']
df2.loc[:, 'opptPTSH1'] = df2['opptPTS1'] + df['opptPTS2']
df2.loc[:, 'ptdiffH1'] = df2['teamPTSH1'] - df2['opptPTSH1']
df2.loc[:, 'ptdiff'] = df2['teamPTS'] - df2['opptPTS']
df2
def make_point_diff_mat(df):
point_diff_df = df[['ptdiffH1', 'ptdiff']]
point_diff = point_diff_df.as_matrix()
return point_diff
def make_bool_point_diff_mat(df):
point_diff = make_point_diff_mat(df)
bool_point_diff = np.copy(point_diff)
bool_point_diff[bool_point_diff > 0] = 1
bool_point_diff[bool_point_diff < 0] = -1
return bool_point_diff
def prob_of_winning_given(bool_point_diff, event):
return np.mean((bool_point_diff[bool_point_diff[:, 0] == event][:, 1] + 1) / 2)
max_prob_winning_DOWN_at_half = 0
max_team = None
for abbr in df2.teamAbbr.unique():
df_team = df2[df.teamAbbr == abbr]
bool_point_diff_team = make_bool_point_diff_mat(df_team)
prob = prob_of_winning_given(bool_point_diff_team, DOWN_AT_HALF)
if prob > max_prob_winning_DOWN_at_half:
max_prob_winning_DOWN_at_half = prob
max_team = abbr
print(max_team)
print(max_prob_winning_DOWN_at_half) | code |
104127726/cell_4 | [
"text_plain_output_1.png"
] | !nvidia-smi | code |
104127726/cell_3 | [
"text_plain_output_1.png"
] | # Installing requierd libraires
!pip install --upgrade -q fastai
!pip install timm -q
!pip install albumentations==0.4.6 -q
!pip install transformers -q | code |
104127726/cell_5 | [
"application_vnd.jupyter.stderr_output_1.png"
] | if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
print(f'Using device: {device}') | code |
1005555/cell_13 | [
"text_plain_output_1.png",
"image_output_1.png"
] | import pandas as pd
dataset = pd.read_csv('../input/911.csv')
dataset[dataset['Category'] == 'Traffic']['Sub-Category'].value_counts().head(6) | code |
1005555/cell_9 | [
"text_plain_output_1.png"
] | import pandas as pd
dataset = pd.read_csv('../input/911.csv')
dataset['Category'].value_counts() | code |
1005555/cell_4 | [
"text_plain_output_1.png"
] | import pandas as pd
dataset = pd.read_csv('../input/911.csv')
dataset.info() | code |
1005555/cell_6 | [
"text_plain_output_1.png",
"image_output_1.png"
] | import pandas as pd
dataset = pd.read_csv('../input/911.csv')
dataset['title'].value_counts().head(5) | code |
1005555/cell_11 | [
"text_html_output_1.png"
] | import pandas as pd
dataset = pd.read_csv('../input/911.csv')
dataset[dataset['Category'] == 'EMS']['Sub-Category'].value_counts().head(6) | code |
1005555/cell_19 | [
"text_plain_output_1.png"
] | import pandas as pd
dataset = pd.read_csv('../input/911.csv')
dataset['dayofweek'].value_counts() | code |
1005555/cell_18 | [
"text_plain_output_1.png"
] | import pandas as pd
import seaborn as sns
dataset = pd.read_csv('../input/911.csv')
sns.countplot('dayofweek', data=dataset) | code |
1005555/cell_8 | [
"text_plain_output_1.png",
"image_output_1.png"
] | import pandas as pd
import seaborn as sns
dataset = pd.read_csv('../input/911.csv')
sns.countplot('Category', data=dataset) | code |
1005555/cell_16 | [
"text_plain_output_1.png"
] | import pandas as pd
import seaborn as sns
dataset = pd.read_csv('../input/911.csv')
sns.countplot('timezone', data=dataset) | code |
1005555/cell_10 | [
"text_plain_output_1.png"
] | import pandas as pd
dataset = pd.read_csv('../input/911.csv')
dataset['title'].nunique() | code |
1005555/cell_12 | [
"text_plain_output_1.png"
] | import pandas as pd
dataset = pd.read_csv('../input/911.csv')
dataset[dataset['Category'] == 'Fire']['Sub-Category'].value_counts().head(6) | code |
1005555/cell_5 | [
"text_plain_output_1.png"
] | import pandas as pd
dataset = pd.read_csv('../input/911.csv')
dataset.head(5) | code |
74060454/cell_13 | [
"text_html_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.drop(15870, inplace=True)
plt.figure(figsize=(12, 10))
plt.scatter(house_df['sqft_living'], house_df['price'], color='green')
plt.show() | code |
74060454/cell_25 | [
"text_plain_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
my_submission = pd.DataFrame({'Id': test.Id, 'SalePrice': predicted_prices})
my_submission.to_csv('submission.csv', index=False) | code |
74060454/cell_4 | [
"text_plain_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.info() | code |
74060454/cell_23 | [
"text_plain_output_1.png"
] | from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score
from sklearn.model_selection import train_test_split
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.drop(15870, inplace=True)
from sklearn.model_selection import train_test_split
y = house_df['price']
X = house_df[['bedrooms', 'bathrooms', 'sqft_living', 'sqft_lot', 'floors', 'waterfront', 'view', 'condition', 'grade', 'sqft_above', 'sqft_basement', 'yr_built', 'yr_renovated', 'zipcode', 'lat', 'long', 'sqft_living15', 'sqft_lot15']]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
from sklearn.linear_model import LinearRegression
lr = LinearRegression(fit_intercept=True)
lr.fit(X_train, y_train)
pred = lr.predict(X_test)
from sklearn.metrics import r2_score
print('R^2:', r2_score(y_test, pred)) | code |
74060454/cell_2 | [
"image_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.head() | code |
74060454/cell_11 | [
"text_plain_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.drop(15870, inplace=True)
plt.figure(figsize=(12, 10))
plt.hist(x=house_df['floors'])
plt.show() | code |
74060454/cell_19 | [
"image_output_1.png"
] | from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.drop(15870, inplace=True)
from sklearn.model_selection import train_test_split
y = house_df['price']
X = house_df[['bedrooms', 'bathrooms', 'sqft_living', 'sqft_lot', 'floors', 'waterfront', 'view', 'condition', 'grade', 'sqft_above', 'sqft_basement', 'yr_built', 'yr_renovated', 'zipcode', 'lat', 'long', 'sqft_living15', 'sqft_lot15']]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
from sklearn.linear_model import LinearRegression
lr = LinearRegression(fit_intercept=True)
lr.fit(X_train, y_train)
pred = lr.predict(X_test)
plt.figure(figsize=(21, 15), dpi=96)
sns.set_theme(style='white')
sns.jointplot(x=y_test, y=pred, kind='reg', line_kws={'color': 'red'})
plt.show() | code |
74060454/cell_1 | [
"text_plain_output_1.png"
] | import os
import numpy as np
import pandas as pd
import os
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename)) | code |
74060454/cell_7 | [
"text_plain_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
plt.figure(figsize=(12, 10))
sns.scatterplot(x=house_df['bedrooms'], y=house_df['price'], color='teal')
plt.show() | code |
74060454/cell_18 | [
"image_output_1.png"
] | from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.drop(15870, inplace=True)
from sklearn.model_selection import train_test_split
y = house_df['price']
X = house_df[['bedrooms', 'bathrooms', 'sqft_living', 'sqft_lot', 'floors', 'waterfront', 'view', 'condition', 'grade', 'sqft_above', 'sqft_basement', 'yr_built', 'yr_renovated', 'zipcode', 'lat', 'long', 'sqft_living15', 'sqft_lot15']]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
from sklearn.linear_model import LinearRegression
lr = LinearRegression(fit_intercept=True)
lr.fit(X_train, y_train)
pred = lr.predict(X_test)
train_score = lr.score(X_train, y_train)
print(f'Train score of trained model: {train_score * 100}')
test_score = lr.score(X_test, y_test)
print(f'Test score of trained model: {test_score * 100}') | code |
74060454/cell_8 | [
"application_vnd.jupyter.stderr_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df[house_df['bedrooms'] > 30] | code |
74060454/cell_16 | [
"text_html_output_1.png"
] | from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.drop(15870, inplace=True)
from sklearn.model_selection import train_test_split
y = house_df['price']
X = house_df[['bedrooms', 'bathrooms', 'sqft_living', 'sqft_lot', 'floors', 'waterfront', 'view', 'condition', 'grade', 'sqft_above', 'sqft_basement', 'yr_built', 'yr_renovated', 'zipcode', 'lat', 'long', 'sqft_living15', 'sqft_lot15']]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
from sklearn.linear_model import LinearRegression
lr = LinearRegression(fit_intercept=True)
lr.fit(X_train, y_train) | code |
74060454/cell_3 | [
"text_plain_output_1.png",
"image_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum() | code |
74060454/cell_24 | [
"text_plain_output_1.png"
] | from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import sklearn.metrics as m
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.drop(15870, inplace=True)
from sklearn.model_selection import train_test_split
y = house_df['price']
X = house_df[['bedrooms', 'bathrooms', 'sqft_living', 'sqft_lot', 'floors', 'waterfront', 'view', 'condition', 'grade', 'sqft_above', 'sqft_basement', 'yr_built', 'yr_renovated', 'zipcode', 'lat', 'long', 'sqft_living15', 'sqft_lot15']]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
from sklearn.linear_model import LinearRegression
lr = LinearRegression(fit_intercept=True)
lr.fit(X_train, y_train)
pred = lr.predict(X_test)
import sklearn.metrics as m
n = X_test.shape[0]
p = X_test.shape[1] - 1
R2 = m.r2_score(y_test, pred)
adj_rsquared = 1 - (1 - R2) * ((n - 1) / (n - p - 1))
print('Adjusted R Squared: {}'.format(adj_rsquared)) | code |
74060454/cell_14 | [
"image_output_1.png"
] | from sklearn.model_selection import train_test_split
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.drop(15870, inplace=True)
from sklearn.model_selection import train_test_split
y = house_df['price']
X = house_df[['bedrooms', 'bathrooms', 'sqft_living', 'sqft_lot', 'floors', 'waterfront', 'view', 'condition', 'grade', 'sqft_above', 'sqft_basement', 'yr_built', 'yr_renovated', 'zipcode', 'lat', 'long', 'sqft_living15', 'sqft_lot15']]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
print(f'Total # of sample in whole dataset: {len(X)}')
print('*****' * 10)
print(f'Total # of sample in train dataset: {len(X_train)}')
print(f'Shape of X_train: {X_train.shape}')
print('*****' * 10)
print(f'Total # of sample in test dataset: {len(X_test)}')
print(f'Shape of X_test: {X_test.shape}') | code |
74060454/cell_22 | [
"image_output_1.png"
] | from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error,mean_absolute_error
from sklearn.model_selection import train_test_split
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.drop(15870, inplace=True)
from sklearn.model_selection import train_test_split
y = house_df['price']
X = house_df[['bedrooms', 'bathrooms', 'sqft_living', 'sqft_lot', 'floors', 'waterfront', 'view', 'condition', 'grade', 'sqft_above', 'sqft_basement', 'yr_built', 'yr_renovated', 'zipcode', 'lat', 'long', 'sqft_living15', 'sqft_lot15']]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
from sklearn.linear_model import LinearRegression
lr = LinearRegression(fit_intercept=True)
lr.fit(X_train, y_train)
pred = lr.predict(X_test)
import sklearn.metrics
from sklearn.metrics import mean_squared_error, mean_absolute_error
print('Mean Squared Error:', mean_squared_error(y_test, pred))
print()
print('Root Mean Squared Error:', np.sqrt(mean_squared_error(y_test, pred)))
print()
print('Mean Absolute Error:', mean_absolute_error(y_test, pred))
print()
print('Mean Absolute Percentage Error:', np.mean(np.abs((y_test - pred) / y_test)) * 100) | code |
74060454/cell_10 | [
"text_html_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.drop(15870, inplace=True)
plt.figure(figsize=(12, 10))
sns.barplot(x=house_df['bedrooms'], y=house_df['price'], color='teal')
plt.show() | code |
74060454/cell_12 | [
"text_plain_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.drop(15870, inplace=True)
plt.figure(figsize=(12, 10))
sns.barplot(x=house_df['bathrooms'], y=house_df['price'], color='olive')
plt.show() | code |
74060454/cell_5 | [
"text_plain_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
house_df = pd.read_csv('../input/housesalesprediction/kc_house_data.csv')
house_df.isnull().sum()
house_df.describe() | code |
128049389/cell_9 | [
"text_plain_output_1.png"
] | from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
from sklearn.model_selection import train_test_split
from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import StandardScaler
import numpy as np
import numpy as np
import pandas as pd
import pandas as pd
import pandas as pd
import tensorflow as tf
df_train = pd.read_csv('/kaggle/input/playground-series-s3e13/train.csv')
df_test = pd.read_csv('/kaggle/input/playground-series-s3e13/test.csv')
df_train = df_train.drop('id', axis=1)
df_test = df_test.drop('id', axis=1)
df_train['prognosis'] = pd.Categorical(df_train['prognosis'])
X_train = df_train.drop('prognosis', axis=1)
y_train = df_train['prognosis']
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(df_test)
X_train, X_val, y_train, y_val = train_test_split(X_train_scaled, y_train, test_size=0.2, random_state=42)
params = {'n_estimators': [100, 200, 300], 'max_depth': [5, 10, 15, None], 'min_samples_split': [2, 5, 10], 'min_samples_leaf': [1, 2, 4]}
rf = RandomForestClassifier(random_state=42)
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
grid_search = GridSearchCV(rf, params, cv=skf, n_jobs=-1, verbose=2)
grid_search.fit(X_train, y_train)
best_params = grid_search.best_params_
best_score = grid_search.best_score_
y_pred_val = grid_search.predict(X_val)
acc_score_val = accuracy_score(y_val, y_pred_val)
class_report = classification_report(y_val, y_pred_val)
import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report
from sklearn.model_selection import GridSearchCV
df_train = pd.read_csv('/kaggle/input/playground-series-s3e13/train.csv')
df_test = pd.read_csv('/kaggle/input/playground-series-s3e13/test.csv')
le = LabelEncoder()
df_train['prognosis'] = le.fit_transform(df_train['prognosis'])
X_train, X_val, y_train, y_val = train_test_split(df_train.drop(['id', 'prognosis'], axis=1), df_train['prognosis'], test_size=0.2, random_state=42)
rfc = RandomForestClassifier(random_state=42)
rfc.fit(X_train, y_train)
y_pred_val = rfc.predict(X_val)
acc_score_val = accuracy_score(y_val, y_pred_val)
prec_score_val = precision_score(y_val, y_pred_val, average='weighted')
rec_score_val = recall_score(y_val, y_pred_val, average='weighted')
f1_score_val = f1_score(y_val, y_pred_val, average='weighted')
class_report_val = classification_report(y_val, y_pred_val)
param_grid = {'n_estimators': [10, 50, 100, 200], 'max_depth': [None, 10, 20, 30], 'min_samples_split': [2, 5, 10], 'min_samples_leaf': [1, 2, 4]}
grid_search = GridSearchCV(estimator=rfc, param_grid=param_grid, cv=5)
grid_search.fit(X_train, y_train)
rfc_final = grid_search.best_estimator_
rfc_final.fit(df_train.drop(['id', 'prognosis'], axis=1), df_train['prognosis'])
y_pred_test = rfc_final.predict(df_test.drop(['id'], axis=1))
submission_df = pd.DataFrame({'id': df_test['id'], 'prognosis': le.inverse_transform(y_pred_test)})
submission_df
import pandas as pd
import numpy as np
import tensorflow as tf
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report
df_train = pd.read_csv('/kaggle/input/playground-series-s3e13/train.csv')
df_test = pd.read_csv('/kaggle/input/playground-series-s3e13/test.csv')
le = LabelEncoder()
df_train['prognosis'] = le.fit_transform(df_train['prognosis'])
X_train, X_val, y_train, y_val = train_test_split(df_train.drop(['id', 'prognosis'], axis=1), df_train['prognosis'], test_size=0.2, random_state=42)
model = tf.keras.Sequential([tf.keras.layers.Dense(128, input_shape=(X_train.shape[1],), activation='relu'), tf.keras.layers.Dense(64, activation='relu'), tf.keras.layers.Dense(11, activation='softmax')])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_val, y_val))
y_pred_val = model.predict(X_val)
y_pred_val = np.argmax(y_pred_val, axis=1)
acc_score_val = accuracy_score(y_val, y_pred_val)
prec_score_val = precision_score(y_val, y_pred_val, average='weighted')
rec_score_val = recall_score(y_val, y_pred_val, average='weighted')
f1_score_val = f1_score(y_val, y_pred_val, average='weighted')
class_report_val = classification_report(y_val, y_pred_val)
print('Validation Accuracy Score:', acc_score_val)
print('Validation Precision Score:', prec_score_val)
print('Validation Recall Score:', rec_score_val)
print('Validation F1 Score:', f1_score_val)
print('Validation Classification Report:\n', class_report_val)
X_test = df_test.drop(['id'], axis=1)
y_pred_test = model.predict(X_test)
y_pred_test = le.inverse_transform(np.argmax(y_pred_test, axis=1))
df_submission = pd.DataFrame({'id': df_test['id'], 'prognosis': y_pred_test})
df_submission.to_csv('submission.csv', index=False) | code |
128049389/cell_4 | [
"text_html_output_1.png"
] | import pandas as pd
df_train = pd.read_csv('/kaggle/input/playground-series-s3e13/train.csv')
df_test = pd.read_csv('/kaggle/input/playground-series-s3e13/test.csv')
df_test | code |
128049389/cell_6 | [
"application_vnd.jupyter.stderr_output_2.png",
"text_plain_output_3.png",
"text_plain_output_1.png"
] | from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
from sklearn.preprocessing import StandardScaler
import pandas as pd
df_train = pd.read_csv('/kaggle/input/playground-series-s3e13/train.csv')
df_test = pd.read_csv('/kaggle/input/playground-series-s3e13/test.csv')
df_train = df_train.drop('id', axis=1)
df_test = df_test.drop('id', axis=1)
df_train['prognosis'] = pd.Categorical(df_train['prognosis'])
X_train = df_train.drop('prognosis', axis=1)
y_train = df_train['prognosis']
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(df_test)
X_train, X_val, y_train, y_val = train_test_split(X_train_scaled, y_train, test_size=0.2, random_state=42)
params = {'n_estimators': [100, 200, 300], 'max_depth': [5, 10, 15, None], 'min_samples_split': [2, 5, 10], 'min_samples_leaf': [1, 2, 4]}
rf = RandomForestClassifier(random_state=42)
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
grid_search = GridSearchCV(rf, params, cv=skf, n_jobs=-1, verbose=2)
grid_search.fit(X_train, y_train)
best_params = grid_search.best_params_
best_score = grid_search.best_score_
print('Best Hyperparameters: ', best_params)
print('Best Accuracy Score: ', best_score) | code |
128049389/cell_1 | [
"text_plain_output_2.png",
"application_vnd.jupyter.stderr_output_1.png"
] | import os
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
import matplotlib.pyplot as plt
import os
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename)) | code |
128049389/cell_7 | [
"text_plain_output_1.png"
] | from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
from sklearn.preprocessing import StandardScaler
import pandas as pd
df_train = pd.read_csv('/kaggle/input/playground-series-s3e13/train.csv')
df_test = pd.read_csv('/kaggle/input/playground-series-s3e13/test.csv')
df_train = df_train.drop('id', axis=1)
df_test = df_test.drop('id', axis=1)
df_train['prognosis'] = pd.Categorical(df_train['prognosis'])
X_train = df_train.drop('prognosis', axis=1)
y_train = df_train['prognosis']
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(df_test)
X_train, X_val, y_train, y_val = train_test_split(X_train_scaled, y_train, test_size=0.2, random_state=42)
params = {'n_estimators': [100, 200, 300], 'max_depth': [5, 10, 15, None], 'min_samples_split': [2, 5, 10], 'min_samples_leaf': [1, 2, 4]}
rf = RandomForestClassifier(random_state=42)
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
grid_search = GridSearchCV(rf, params, cv=skf, n_jobs=-1, verbose=2)
grid_search.fit(X_train, y_train)
best_params = grid_search.best_params_
best_score = grid_search.best_score_
y_pred_val = grid_search.predict(X_val)
acc_score_val = accuracy_score(y_val, y_pred_val)
print('Validation Accuracy Score:', acc_score_val)
class_report = classification_report(y_val, y_pred_val)
print(class_report) | code |
128049389/cell_8 | [
"text_html_output_1.png",
"text_plain_output_1.png"
] | from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import StandardScaler
import pandas as pd
import pandas as pd
df_train = pd.read_csv('/kaggle/input/playground-series-s3e13/train.csv')
df_test = pd.read_csv('/kaggle/input/playground-series-s3e13/test.csv')
df_train = df_train.drop('id', axis=1)
df_test = df_test.drop('id', axis=1)
df_train['prognosis'] = pd.Categorical(df_train['prognosis'])
X_train = df_train.drop('prognosis', axis=1)
y_train = df_train['prognosis']
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(df_test)
X_train, X_val, y_train, y_val = train_test_split(X_train_scaled, y_train, test_size=0.2, random_state=42)
params = {'n_estimators': [100, 200, 300], 'max_depth': [5, 10, 15, None], 'min_samples_split': [2, 5, 10], 'min_samples_leaf': [1, 2, 4]}
rf = RandomForestClassifier(random_state=42)
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
grid_search = GridSearchCV(rf, params, cv=skf, n_jobs=-1, verbose=2)
grid_search.fit(X_train, y_train)
best_params = grid_search.best_params_
best_score = grid_search.best_score_
y_pred_val = grid_search.predict(X_val)
acc_score_val = accuracy_score(y_val, y_pred_val)
class_report = classification_report(y_val, y_pred_val)
import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report
from sklearn.model_selection import GridSearchCV
df_train = pd.read_csv('/kaggle/input/playground-series-s3e13/train.csv')
df_test = pd.read_csv('/kaggle/input/playground-series-s3e13/test.csv')
le = LabelEncoder()
df_train['prognosis'] = le.fit_transform(df_train['prognosis'])
X_train, X_val, y_train, y_val = train_test_split(df_train.drop(['id', 'prognosis'], axis=1), df_train['prognosis'], test_size=0.2, random_state=42)
rfc = RandomForestClassifier(random_state=42)
rfc.fit(X_train, y_train)
y_pred_val = rfc.predict(X_val)
acc_score_val = accuracy_score(y_val, y_pred_val)
prec_score_val = precision_score(y_val, y_pred_val, average='weighted')
rec_score_val = recall_score(y_val, y_pred_val, average='weighted')
f1_score_val = f1_score(y_val, y_pred_val, average='weighted')
class_report_val = classification_report(y_val, y_pred_val)
print('Validation Accuracy Score:', acc_score_val)
print('Validation Precision Score:', prec_score_val)
print('Validation Recall Score:', rec_score_val)
print('Validation F1 Score:', f1_score_val)
print('Validation Classification Report:\n', class_report_val)
param_grid = {'n_estimators': [10, 50, 100, 200], 'max_depth': [None, 10, 20, 30], 'min_samples_split': [2, 5, 10], 'min_samples_leaf': [1, 2, 4]}
grid_search = GridSearchCV(estimator=rfc, param_grid=param_grid, cv=5)
grid_search.fit(X_train, y_train)
rfc_final = grid_search.best_estimator_
rfc_final.fit(df_train.drop(['id', 'prognosis'], axis=1), df_train['prognosis'])
y_pred_test = rfc_final.predict(df_test.drop(['id'], axis=1))
submission_df = pd.DataFrame({'id': df_test['id'], 'prognosis': le.inverse_transform(y_pred_test)})
submission_df | code |
128049389/cell_3 | [
"text_plain_output_1.png"
] | import pandas as pd
df_train = pd.read_csv('/kaggle/input/playground-series-s3e13/train.csv')
df_test = pd.read_csv('/kaggle/input/playground-series-s3e13/test.csv')
df_train.info() | code |
128049389/cell_5 | [
"text_plain_output_1.png"
] | from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
from sklearn.preprocessing import StandardScaler
import pandas as pd
df_train = pd.read_csv('/kaggle/input/playground-series-s3e13/train.csv')
df_test = pd.read_csv('/kaggle/input/playground-series-s3e13/test.csv')
print(df_train.isnull().sum())
df_train = df_train.drop('id', axis=1)
df_test = df_test.drop('id', axis=1)
df_train['prognosis'] = pd.Categorical(df_train['prognosis'])
X_train = df_train.drop('prognosis', axis=1)
y_train = df_train['prognosis']
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(df_test)
X_train, X_val, y_train, y_val = train_test_split(X_train_scaled, y_train, test_size=0.2, random_state=42) | code |
2008965/cell_4 | [
"text_plain_output_1.png"
] | child_happiness = np.full((n_gift_type, n_children), -1 * multiplier, dtype=np.int16)
gift_happiness = np.full((n_gift_type, n_children), -1, dtype=np.int16)
to_add = (np.arange(n_gift_pref, 0, -1) * ratio_child_happiness + 1) * int(multiplier)
for child, wishlist in tqdm(enumerate(child_wishlists)):
child_happiness[wishlist, child] += to_add
to_add = np.arange(n_child_pref, 0, -1) * ratio_gift_happiness + 1
for gift, goodkids in tqdm(enumerate(gift_goodkids)):
gift_happiness[gift, goodkids] += to_add | code |
2008965/cell_8 | [
"text_plain_output_1.png"
] | children, gifts = zip(*random_sub)
for _ in range(100):
score = avg_normalized_happiness(children, gifts)
print('ANH', score) | code |
2008965/cell_12 | [
"application_vnd.jupyter.stderr_output_3.png",
"text_plain_output_2.png",
"application_vnd.jupyter.stderr_output_1.png"
] | for _ in range(100):
score = avg_normalized_happiness(random_sub)
print('ANH', score) | code |
73092218/cell_13 | [
"text_plain_output_1.png"
] | from sklearn.metrics import mean_squared_error
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
import numpy as np
import pandas as pd
import xgboost as xgb
train = pd.read_csv('../input/30-days-of-ml/train.csv', index_col=0)
test = pd.read_csv('../input/30-days-of-ml/test.csv', index_col=0)
sub = pd.read_csv('/kaggle/input/30-days-of-ml/sample_submission.csv')
y = train.target
X_all = pd.get_dummies(train.drop(['target'], axis=1).append(test)).copy()
X, X_test = (X_all[:300000], X_all[300000:])
from sklearn.model_selection import train_test_split
X_train, X_valid, y_train, y_valid = train_test_split(X[:5000], y[:5000], test_size=0.2, random_state=42)
import xgboost as xgb
from sklearn.model_selection import GridSearchCV
params = {'max_depth': [2], 'gamma': [0], 'eta': [0], 'subsample': [0.8], 'colsample_bytree': [0.8], 'colsample_bylevel': [1.0], 'n_estimators': [1200]}
model = xgb.XGBRFRegressor(eval_metric='rmse', random_state=42, verbosity=1)
cv = GridSearchCV(model, params, cv=5)
cv.fit(X_train, y_train)
cv.best_estimator_
y_train_pred = cv.predict(X_train)
y_valid_pred = cv.predict(X_valid)
from sklearn.metrics import mean_squared_error
print('RMSE train : %.4f, valid : %.4f' % (np.sqrt(mean_squared_error(y_train, y_train_pred)), np.sqrt(mean_squared_error(y_valid, y_valid_pred)))) | code |
73092218/cell_4 | [
"text_plain_output_1.png"
] | import pandas as pd
train = pd.read_csv('../input/30-days-of-ml/train.csv', index_col=0)
test = pd.read_csv('../input/30-days-of-ml/test.csv', index_col=0)
sub = pd.read_csv('/kaggle/input/30-days-of-ml/sample_submission.csv')
test.info() | code |
73092218/cell_6 | [
"text_plain_output_1.png"
] | import pandas as pd
train = pd.read_csv('../input/30-days-of-ml/train.csv', index_col=0)
test = pd.read_csv('../input/30-days-of-ml/test.csv', index_col=0)
sub = pd.read_csv('/kaggle/input/30-days-of-ml/sample_submission.csv')
y = train.target
X_all = pd.get_dummies(train.drop(['target'], axis=1).append(test)).copy()
X, X_test = (X_all[:300000], X_all[300000:])
print(X.shape, y.shape, X_test.shape) | code |
73092218/cell_11 | [
"text_plain_output_1.png"
] | from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
import pandas as pd
import xgboost as xgb
train = pd.read_csv('../input/30-days-of-ml/train.csv', index_col=0)
test = pd.read_csv('../input/30-days-of-ml/test.csv', index_col=0)
sub = pd.read_csv('/kaggle/input/30-days-of-ml/sample_submission.csv')
y = train.target
X_all = pd.get_dummies(train.drop(['target'], axis=1).append(test)).copy()
X, X_test = (X_all[:300000], X_all[300000:])
from sklearn.model_selection import train_test_split
X_train, X_valid, y_train, y_valid = train_test_split(X[:5000], y[:5000], test_size=0.2, random_state=42)
import xgboost as xgb
from sklearn.model_selection import GridSearchCV
params = {'max_depth': [2], 'gamma': [0], 'eta': [0], 'subsample': [0.8], 'colsample_bytree': [0.8], 'colsample_bylevel': [1.0], 'n_estimators': [1200]}
model = xgb.XGBRFRegressor(eval_metric='rmse', random_state=42, verbosity=1)
cv = GridSearchCV(model, params, cv=5)
cv.fit(X_train, y_train)
cv.best_estimator_ | code |
73092218/cell_8 | [
"text_plain_output_1.png"
] | from sklearn.model_selection import train_test_split
import pandas as pd
train = pd.read_csv('../input/30-days-of-ml/train.csv', index_col=0)
test = pd.read_csv('../input/30-days-of-ml/test.csv', index_col=0)
sub = pd.read_csv('/kaggle/input/30-days-of-ml/sample_submission.csv')
y = train.target
X_all = pd.get_dummies(train.drop(['target'], axis=1).append(test)).copy()
X, X_test = (X_all[:300000], X_all[300000:])
from sklearn.model_selection import train_test_split
X_train, X_valid, y_train, y_valid = train_test_split(X[:5000], y[:5000], test_size=0.2, random_state=42)
print(X_train.shape, y_train.shape, X_valid.shape, y_valid.shape) | code |
73092218/cell_16 | [
"text_plain_output_1.png"
] | from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
import pandas as pd
import xgboost as xgb
train = pd.read_csv('../input/30-days-of-ml/train.csv', index_col=0)
test = pd.read_csv('../input/30-days-of-ml/test.csv', index_col=0)
sub = pd.read_csv('/kaggle/input/30-days-of-ml/sample_submission.csv')
y = train.target
X_all = pd.get_dummies(train.drop(['target'], axis=1).append(test)).copy()
X, X_test = (X_all[:300000], X_all[300000:])
from sklearn.model_selection import train_test_split
X_train, X_valid, y_train, y_valid = train_test_split(X[:5000], y[:5000], test_size=0.2, random_state=42)
import xgboost as xgb
from sklearn.model_selection import GridSearchCV
params = {'max_depth': [2], 'gamma': [0], 'eta': [0], 'subsample': [0.8], 'colsample_bytree': [0.8], 'colsample_bylevel': [1.0], 'n_estimators': [1200]}
model = xgb.XGBRFRegressor(eval_metric='rmse', random_state=42, verbosity=1)
cv = GridSearchCV(model, params, cv=5)
cv.fit(X_train, y_train)
cv.best_estimator_
y_train_pred = cv.predict(X_train)
y_valid_pred = cv.predict(X_valid)
cv.fit(X, y)
pred = cv.predict(X_test)
sub['target'] = pred
sub.to_csv('submission.csv', index=False)
print(sub) | code |
73092218/cell_3 | [
"text_plain_output_1.png"
] | import pandas as pd
train = pd.read_csv('../input/30-days-of-ml/train.csv', index_col=0)
test = pd.read_csv('../input/30-days-of-ml/test.csv', index_col=0)
sub = pd.read_csv('/kaggle/input/30-days-of-ml/sample_submission.csv')
train.info() | code |
73092218/cell_14 | [
"text_plain_output_1.png"
] | from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
import pandas as pd
import xgboost as xgb
train = pd.read_csv('../input/30-days-of-ml/train.csv', index_col=0)
test = pd.read_csv('../input/30-days-of-ml/test.csv', index_col=0)
sub = pd.read_csv('/kaggle/input/30-days-of-ml/sample_submission.csv')
y = train.target
X_all = pd.get_dummies(train.drop(['target'], axis=1).append(test)).copy()
X, X_test = (X_all[:300000], X_all[300000:])
from sklearn.model_selection import train_test_split
X_train, X_valid, y_train, y_valid = train_test_split(X[:5000], y[:5000], test_size=0.2, random_state=42)
import xgboost as xgb
from sklearn.model_selection import GridSearchCV
params = {'max_depth': [2], 'gamma': [0], 'eta': [0], 'subsample': [0.8], 'colsample_bytree': [0.8], 'colsample_bylevel': [1.0], 'n_estimators': [1200]}
model = xgb.XGBRFRegressor(eval_metric='rmse', random_state=42, verbosity=1)
cv = GridSearchCV(model, params, cv=5)
cv.fit(X_train, y_train)
cv.best_estimator_
y_train_pred = cv.predict(X_train)
y_valid_pred = cv.predict(X_valid)
cv.fit(X, y) | code |
73092218/cell_10 | [
"text_plain_output_1.png"
] | from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
import pandas as pd
import xgboost as xgb
train = pd.read_csv('../input/30-days-of-ml/train.csv', index_col=0)
test = pd.read_csv('../input/30-days-of-ml/test.csv', index_col=0)
sub = pd.read_csv('/kaggle/input/30-days-of-ml/sample_submission.csv')
y = train.target
X_all = pd.get_dummies(train.drop(['target'], axis=1).append(test)).copy()
X, X_test = (X_all[:300000], X_all[300000:])
from sklearn.model_selection import train_test_split
X_train, X_valid, y_train, y_valid = train_test_split(X[:5000], y[:5000], test_size=0.2, random_state=42)
import xgboost as xgb
from sklearn.model_selection import GridSearchCV
params = {'max_depth': [2], 'gamma': [0], 'eta': [0], 'subsample': [0.8], 'colsample_bytree': [0.8], 'colsample_bylevel': [1.0], 'n_estimators': [1200]}
model = xgb.XGBRFRegressor(eval_metric='rmse', random_state=42, verbosity=1)
cv = GridSearchCV(model, params, cv=5)
cv.fit(X_train, y_train) | code |
73092218/cell_12 | [
"text_plain_output_1.png"
] | from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
import pandas as pd
import xgboost as xgb
train = pd.read_csv('../input/30-days-of-ml/train.csv', index_col=0)
test = pd.read_csv('../input/30-days-of-ml/test.csv', index_col=0)
sub = pd.read_csv('/kaggle/input/30-days-of-ml/sample_submission.csv')
y = train.target
X_all = pd.get_dummies(train.drop(['target'], axis=1).append(test)).copy()
X, X_test = (X_all[:300000], X_all[300000:])
from sklearn.model_selection import train_test_split
X_train, X_valid, y_train, y_valid = train_test_split(X[:5000], y[:5000], test_size=0.2, random_state=42)
import xgboost as xgb
from sklearn.model_selection import GridSearchCV
params = {'max_depth': [2], 'gamma': [0], 'eta': [0], 'subsample': [0.8], 'colsample_bytree': [0.8], 'colsample_bylevel': [1.0], 'n_estimators': [1200]}
model = xgb.XGBRFRegressor(eval_metric='rmse', random_state=42, verbosity=1)
cv = GridSearchCV(model, params, cv=5)
cv.fit(X_train, y_train)
cv.best_estimator_
y_train_pred = cv.predict(X_train)
y_valid_pred = cv.predict(X_valid)
print(len(y_train_pred), len(y_valid_pred)) | code |
72078585/cell_4 | [
"text_html_output_1.png"
] | import pandas as pd
df_train = pd.read_csv('../input/tabulardata-kfolds-created/train_folds.csv')
df_test = pd.read_csv('../input/tabular-playground-series-aug-2021/test.csv')
sample_submission = pd.read_csv('../input/tabular-playground-series-aug-2021/sample_submission.csv')
useful_features = [c for c in df_train.columns if c not in ('id', 'loss', 'kfold')]
df_train[useful_features] | code |
72078585/cell_6 | [
"text_plain_output_1.png"
] | from sklearn.metrics import mean_squared_error
from xgboost import XGBRegressor
import pandas as pd
df_train = pd.read_csv('../input/tabulardata-kfolds-created/train_folds.csv')
df_test = pd.read_csv('../input/tabular-playground-series-aug-2021/test.csv')
sample_submission = pd.read_csv('../input/tabular-playground-series-aug-2021/sample_submission.csv')
useful_features = [c for c in df_train.columns if c not in ('id', 'loss', 'kfold')]
df_train[useful_features]
from xgboost import XGBRegressor
xtrain = df_train[df_train.kfold != 0]
xvalid = df_train[df_train.kfold == 0]
ytrain = xtrain['loss']
xtrain = xtrain[useful_features]
yvalid = xvalid['loss']
xvalid = xvalid[useful_features]
model = XGBRegressor(n_estimators=500, random_state=0)
model.fit(xtrain, ytrain, early_stopping_rounds=5, eval_set=[(xvalid, yvalid)], verbose=False)
preds_valid = model.predict(xvalid)
print(mean_squared_error(yvalid, preds_valid, squared=False)) | code |
72078585/cell_3 | [
"text_html_output_1.png"
] | import pandas as pd
df_train = pd.read_csv('../input/tabulardata-kfolds-created/train_folds.csv')
df_test = pd.read_csv('../input/tabular-playground-series-aug-2021/test.csv')
sample_submission = pd.read_csv('../input/tabular-playground-series-aug-2021/sample_submission.csv')
sample_submission.head() | code |
1006593/cell_13 | [
"application_vnd.jupyter.stderr_output_1.png"
] | from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt
import pandas as pd
dataset = pd.read_csv('../input/train.csv')
X = dataset.iloc[:, [4, 2, 6, 5]].values
y = dataset.iloc[:, 1].values
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
fig.set_size_inches(98.5, 90.5)
ax = fig.add_subplot(999, projection='3d')
i=0
for g , xs ,ys , zs in X:
c = y[i]
i +=1
if c == 1:
cc='blue' #servive
else:
cc='yellow' #died
if g == 1:
m = "^" # male
else:
m = "v" #famle
ax.scatter(xs, ys, zs , c=cc , marker=m)
ax.set_xlabel('class')
ax.set_ylabel('sibsp')
ax.set_zlabel('age')
plt.show()
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors=4, metric='minkowski', p=2)
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
fig = plt.figure()
fig.set_size_inches(98.5, 90.5)
ax = fig.add_subplot(999, projection='3d')
i = 0
for g, xs, ys, zs in X_test:
c = y_test[i]
if c == 1:
cc = 'blue'
else:
cc = 'red'
if g == 1:
m = '^'
else:
m = 'v'
if y_pred[i] == y_test[i]:
if y_pred[i] == 1:
cc = 'green'
else:
cc = 'yellow'
m = '+'
i += 1
ax.scatter(xs, ys, zs, c=cc, marker=m)
ax.set_xlabel('class')
ax.set_ylabel('sibsp')
ax.set_zlabel('age')
plt.show() | code |
1006593/cell_20 | [
"text_plain_output_1.png"
] | from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt
import pandas as pd
dataset = pd.read_csv('../input/train.csv')
X = dataset.iloc[:, [4, 2, 6, 5]].values
y = dataset.iloc[:, 1].values
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
fig.set_size_inches(98.5, 90.5)
ax = fig.add_subplot(999, projection='3d')
i=0
for g , xs ,ys , zs in X:
c = y[i]
i +=1
if c == 1:
cc='blue' #servive
else:
cc='yellow' #died
if g == 1:
m = "^" # male
else:
m = "v" #famle
ax.scatter(xs, ys, zs , c=cc , marker=m)
ax.set_xlabel('class')
ax.set_ylabel('sibsp')
ax.set_zlabel('age')
plt.show()
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors=4, metric='minkowski', p=2)
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
fig = plt.figure()
fig.set_size_inches(98.5, 90.5)
ax = fig.add_subplot(999, projection='3d')
i=0
for g , xs ,ys , zs in X_test:
c = y_test[i]
if c == 1:
cc='blue' #servive
else:
cc='red' #died
if g == 1:
m = "^" # male
else:
m = "v" #famle
if y_pred[i] == y_test[i]:
if y_pred[i] == 1:
cc = 'green'
else:
cc = 'yellow'
m = "+"
i +=1
ax.scatter(xs, ys, zs , c=cc , marker=m )
ax.set_xlabel('class')
ax.set_ylabel('sibsp')
ax.set_zlabel('age')
plt.show()
realdata = pd.read_csv('../input/test.csv')
X_real = realdata.iloc[:, [3, 1, 5, 4]].values
X_real
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_real = sc.fit_transform(X_real)
y_real_pred = classifier.predict(X_real)
fig = plt.figure()
fig.set_size_inches(98.5, 90.5)
ax = fig.add_subplot(999, projection='3d')
i = 0
for g, xs, ys, zs in X_real:
c = y_real_pred[i]
if c == 1:
cc = 'blue'
else:
cc = 'red'
if g == 1:
m = '^'
else:
m = 'v'
i += 1
ax.scatter(xs, ys, zs, c=cc, marker=m)
ax.set_xlabel('class')
ax.set_ylabel('sibsp')
ax.set_zlabel('age')
plt.show() | code |
1006593/cell_19 | [
"text_html_output_1.png"
] | from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import StandardScaler
import pandas as pd
dataset = pd.read_csv('../input/train.csv')
X = dataset.iloc[:, [4, 2, 6, 5]].values
y = dataset.iloc[:, 1].values
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
realdata = pd.read_csv('../input/test.csv')
X_real = realdata.iloc[:, [3, 1, 5, 4]].values
X_real
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_real = sc.fit_transform(X_real) | code |
1006593/cell_7 | [
"application_vnd.jupyter.stderr_output_1.png"
] | import matplotlib.pyplot as plt
import matplotlib.pyplot as plt
import pandas as pd
dataset = pd.read_csv('../input/train.csv')
X = dataset.iloc[:, [4, 2, 6, 5]].values
y = dataset.iloc[:, 1].values
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
fig.set_size_inches(98.5, 90.5)
ax = fig.add_subplot(999, projection='3d')
i = 0
for g, xs, ys, zs in X:
c = y[i]
i += 1
if c == 1:
cc = 'blue'
else:
cc = 'yellow'
if g == 1:
m = '^'
else:
m = 'v'
ax.scatter(xs, ys, zs, c=cc, marker=m)
ax.set_xlabel('class')
ax.set_ylabel('sibsp')
ax.set_zlabel('age')
plt.show() | code |
1006593/cell_8 | [
"image_output_1.png"
] | from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import pandas as pd
dataset = pd.read_csv('../input/train.csv')
X = dataset.iloc[:, [4, 2, 6, 5]].values
y = dataset.iloc[:, 1].values
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test) | code |
1006593/cell_16 | [
"text_plain_output_2.png",
"text_plain_output_1.png"
] | import pandas as pd
dataset = pd.read_csv('../input/train.csv')
realdata = pd.read_csv('../input/test.csv')
X_real = realdata.iloc[:, [3, 1, 5, 4]].values
X_real | code |
1006593/cell_3 | [
"text_plain_output_1.png"
] | import pandas as pd
dataset = pd.read_csv('../input/train.csv')
dataset.head() | code |
1006593/cell_17 | [
"image_output_1.png"
] | from sklearn.preprocessing import Imputer
from sklearn.preprocessing import Imputer
import pandas as pd
dataset = pd.read_csv('../input/train.csv')
X = dataset.iloc[:, [4, 2, 6, 5]].values
y = dataset.iloc[:, 1].values
from sklearn.preprocessing import Imputer
imputer = Imputer(missing_values='NaN', strategy='mean', axis=0)
imputer = imputer.fit(X[:, 1:])
X[:, 1:] = imputer.transform(X[:, 1:])
realdata = pd.read_csv('../input/test.csv')
X_real = realdata.iloc[:, [3, 1, 5, 4]].values
X_real
from sklearn.preprocessing import Imputer
imputer = Imputer(missing_values='NaN', strategy='mean', axis=0)
imputer = imputer.fit(X_real[:, 1:])
X_real[:, 1:] = imputer.transform(X_real[:, 1:])
X_real | code |
1006593/cell_14 | [
"text_plain_output_1.png"
] | import pandas as pd
dataset = pd.read_csv('../input/train.csv')
realdata = pd.read_csv('../input/test.csv')
realdata.head() | code |
1006593/cell_10 | [
"text_html_output_1.png"
] | from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
import pandas as pd
dataset = pd.read_csv('../input/train.csv')
X = dataset.iloc[:, [4, 2, 6, 5]].values
y = dataset.iloc[:, 1].values
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors=4, metric='minkowski', p=2)
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
cm | code |
1006593/cell_12 | [
"image_output_1.png"
] | from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt
import pandas as pd
dataset = pd.read_csv('../input/train.csv')
X = dataset.iloc[:, [4, 2, 6, 5]].values
y = dataset.iloc[:, 1].values
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
fig.set_size_inches(98.5, 90.5)
ax = fig.add_subplot(999, projection='3d')
i=0
for g , xs ,ys , zs in X:
c = y[i]
i +=1
if c == 1:
cc='blue' #servive
else:
cc='yellow' #died
if g == 1:
m = "^" # male
else:
m = "v" #famle
ax.scatter(xs, ys, zs , c=cc , marker=m)
ax.set_xlabel('class')
ax.set_ylabel('sibsp')
ax.set_zlabel('age')
plt.show()
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors=4, metric='minkowski', p=2)
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
def getscore(orgin, predicted):
score = len(orgin)
j = 0
for i in predicted:
if i == orgin[j]:
j += 1
else:
score -= 1
j += 1
result = score / float(len(orgin)) * 100
result = str(result)
return result + '%'
getscore(y_test, y_pred) | code |
49124799/cell_13 | [
"text_html_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
df = pd.read_csv('../input/hackerearth-love-in-the-time-of-screens/data.csv')
df.drop(columns=['user_id', 'username'], inplace=True)
df.shape
lan = []
for i in df['language']:
l = i.split(',')
for j in l:
if j not in lan:
lan.append(j)
XX = {}
for i in lan:
l = []
for j in df['language']:
if i in j.split(','):
l.append(1)
else:
l.append(0)
XX[i] = l
len(XX['english']) | code |
49124799/cell_9 | [
"text_html_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
df = pd.read_csv('../input/hackerearth-love-in-the-time-of-screens/data.csv')
df.drop(columns=['user_id', 'username'], inplace=True)
df.shape | code |
49124799/cell_34 | [
"text_plain_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
df = pd.read_csv('../input/hackerearth-love-in-the-time-of-screens/data.csv')
data = pd.DataFrame()
data.head() | code |
49124799/cell_23 | [
"text_plain_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
df = pd.read_csv('../input/hackerearth-love-in-the-time-of-screens/data.csv')
df.drop(columns=['user_id', 'username'], inplace=True)
df.shape
df.drop(columns=['language', 'bio'], inplace=True)
df.shape
a = df.dtypes
df.shape | code |
49124799/cell_20 | [
"text_plain_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
df = pd.read_csv('../input/hackerearth-love-in-the-time-of-screens/data.csv')
df.drop(columns=['user_id', 'username'], inplace=True)
df.shape
df.drop(columns=['language', 'bio'], inplace=True)
df.shape
a = df.dtypes
df.head() | code |
49124799/cell_6 | [
"text_plain_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
df = pd.read_csv('../input/hackerearth-love-in-the-time-of-screens/data.csv')
df.drop(columns=['user_id', 'username'], inplace=True)
df.head() | code |
49124799/cell_29 | [
"text_plain_output_1.png"
] | from sklearn.metrics.pairwise import cosine_similarity
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
df = pd.read_csv('../input/hackerearth-love-in-the-time-of-screens/data.csv')
df.drop(columns=['user_id', 'username'], inplace=True)
df.shape
lan = []
for i in df['language']:
l = i.split(',')
for j in l:
if j not in lan:
lan.append(j)
XX = {}
for i in lan:
l = []
for j in df['language']:
if i in j.split(','):
l.append(1)
else:
l.append(0)
XX[i] = l
df.drop(columns=['language', 'bio'], inplace=True)
df.shape
a = df.dtypes
df.shape
X = df.values
X.shape
ans = []
for i in X:
l = []
for j in X:
l.append(cosine_similarity([i], [j]) * 100)
ans.append(l)
ans[1][0][0][0] | code |
49124799/cell_26 | [
"text_plain_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
df = pd.read_csv('../input/hackerearth-love-in-the-time-of-screens/data.csv')
df.drop(columns=['user_id', 'username'], inplace=True)
df.shape
df.drop(columns=['language', 'bio'], inplace=True)
df.shape
a = df.dtypes
df.shape
X = df.values
X.shape | code |
49124799/cell_11 | [
"text_html_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
df = pd.read_csv('../input/hackerearth-love-in-the-time-of-screens/data.csv')
df.drop(columns=['user_id', 'username'], inplace=True)
df.shape
lan = []
for i in df['language']:
l = i.split(',')
for j in l:
if j not in lan:
lan.append(j)
print(len(lan)) | code |
49124799/cell_1 | [
"text_plain_output_1.png"
] | import os
import numpy as np
import pandas as pd
import os
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename)) | code |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.