path
stringlengths 13
17
| screenshot_names
sequencelengths 1
873
| code
stringlengths 0
40.4k
| cell_type
stringclasses 1
value |
|---|---|---|---|
128010282/cell_4 | [
"text_plain_output_1.png",
"image_output_1.png"
] | import pandas as pd
Data = pd.read_csv('/kaggle/input/boston-housing-dataset/HousingData.csv')
Data.head() | code |
128010282/cell_6 | [
"text_plain_output_1.png"
] | import pandas as pd
Data = pd.read_csv('/kaggle/input/boston-housing-dataset/HousingData.csv')
Data.shape
Data.columns | code |
128010282/cell_2 | [
"text_html_output_1.png"
] | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split, GridSearchCV, cross_validate, cross_val_score, cross_val_predict
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.svm import SVR
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, accuracy_score | code |
128010282/cell_11 | [
"text_html_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd
Data = pd.read_csv('/kaggle/input/boston-housing-dataset/HousingData.csv')
Data.shape
Data.columns
Data.isnull().sum().sum()
Data.corr() | code |
128010282/cell_7 | [
"text_plain_output_1.png"
] | import pandas as pd
Data = pd.read_csv('/kaggle/input/boston-housing-dataset/HousingData.csv')
Data.shape
Data.columns
Data.describe() | code |
128010282/cell_15 | [
"text_plain_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
Data = pd.read_csv('/kaggle/input/boston-housing-dataset/HousingData.csv')
Data.shape
Data.columns
Data.isnull().sum().sum()
Data.corr()
sns.barplot(Data) | code |
128010282/cell_16 | [
"text_plain_output_1.png",
"image_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
Data = pd.read_csv('/kaggle/input/boston-housing-dataset/HousingData.csv')
Data.shape
Data.columns
Data.isnull().sum().sum()
Data.corr()
feature_name = list(Data.columns[:-1])
plt.figure(figsize=(30, 30))
for i in range(len(feature_name)):
plt.subplot(7, 2, i + 1)
sns.barplot(x=Data[feature_name[i]], y=Data['MEDV']) | code |
128010282/cell_14 | [
"text_html_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
Data = pd.read_csv('/kaggle/input/boston-housing-dataset/HousingData.csv')
Data.shape
Data.columns
Data.isnull().sum().sum()
Data.corr()
Data.hist(figsize=(30, 30)) | code |
128010282/cell_22 | [
"text_plain_output_1.png",
"image_output_1.png"
] | from sklearn.impute import SimpleImputer
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
Data = pd.read_csv('/kaggle/input/boston-housing-dataset/HousingData.csv')
Data.shape
Data.columns
Data.isnull().sum().sum()
Data.corr()
feature_name = list(Data.columns[:-1])
Data.drop('NOX', axis=1, inplace=True)
Data_copy = SimpleImputer().fit_transform(Data)
Data = pd.DataFrame(Data_copy, columns=Data.columns)
Data.isnull().sum().sum()
Data.shape | code |
128010282/cell_10 | [
"application_vnd.jupyter.stderr_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd
Data = pd.read_csv('/kaggle/input/boston-housing-dataset/HousingData.csv')
Data.shape
Data.columns
Data.isnull().sum().sum()
plt.figure(figsize=(5, 5))
plt.pie([Data.shape[0], Data.isnull().sum().sum()], labels=['Not_Null', 'Null'], autopct='%1.2f%%') | code |
128010282/cell_12 | [
"text_plain_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
Data = pd.read_csv('/kaggle/input/boston-housing-dataset/HousingData.csv')
Data.shape
Data.columns
Data.isnull().sum().sum()
Data.corr()
sns.heatmap(Data.corr(), cmap='hot', annot=True) | code |
128010282/cell_5 | [
"image_output_1.png"
] | import pandas as pd
Data = pd.read_csv('/kaggle/input/boston-housing-dataset/HousingData.csv')
Data.shape | code |
34151195/cell_9 | [
"image_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
df = pd.read_csv('/kaggle/input/pima-indians-diabetes-database/diabetes.csv')
data = df.iloc[:, 0:8]
plt.tight_layout()
colnames = data.columns.values
plt.tight_layout()
data.plot(kind='box', subplots=True, layout=(3, 3), sharex=False, figsize=(12, 10))
plt.tight_layout()
plt.show() | code |
34151195/cell_6 | [
"image_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
df = pd.read_csv('/kaggle/input/pima-indians-diabetes-database/diabetes.csv')
data = df.iloc[:, 0:8]
data.hist(figsize=(12, 10))
plt.tight_layout()
plt.show() | code |
34151195/cell_11 | [
"text_html_output_1.png"
] | from pandas.plotting import scatter_matrix
import matplotlib.pyplot as plt
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
df = pd.read_csv('/kaggle/input/pima-indians-diabetes-database/diabetes.csv')
data = df.iloc[:, 0:8]
plt.tight_layout()
colnames = data.columns.values
plt.tight_layout()
plt.tight_layout()
#Correlation Matrix Plot
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
correlations = data.corr()
# plot correlation matrix
fig = plt.figure(figsize=(16,12))
ax = fig.add_subplot(111)
cax = ax.matshow(correlations, vmin=-1, vmax=1)
fig.colorbar(cax)
ticks = np.arange(0,9,1)
ax.set_xticks(ticks)
ax.set_yticks(ticks)
ax.set_xticklabels(names)
ax.set_yticklabels(names)
plt.show()
from pandas.plotting import scatter_matrix
scatter_matrix(data, figsize=(16, 16))
plt.show() | code |
34151195/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 |
34151195/cell_8 | [
"image_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
df = pd.read_csv('/kaggle/input/pima-indians-diabetes-database/diabetes.csv')
data = df.iloc[:, 0:8]
plt.tight_layout()
colnames = data.columns.values
data.plot(kind='density', figsize=(12, 10), subplots=True, layout=(3, 3), sharex=False)
plt.tight_layout()
plt.show() | code |
34151195/cell_3 | [
"image_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
df = pd.read_csv('/kaggle/input/pima-indians-diabetes-database/diabetes.csv')
df.head() | code |
34151195/cell_10 | [
"text_html_output_1.png"
] | import matplotlib.pyplot as plt
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
df = pd.read_csv('/kaggle/input/pima-indians-diabetes-database/diabetes.csv')
data = df.iloc[:, 0:8]
plt.tight_layout()
colnames = data.columns.values
plt.tight_layout()
plt.tight_layout()
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
correlations = data.corr()
fig = plt.figure(figsize=(16, 12))
ax = fig.add_subplot(111)
cax = ax.matshow(correlations, vmin=-1, vmax=1)
fig.colorbar(cax)
ticks = np.arange(0, 9, 1)
ax.set_xticks(ticks)
ax.set_yticks(ticks)
ax.set_xticklabels(names)
ax.set_yticklabels(names)
plt.show() | code |
34151195/cell_5 | [
"image_output_1.png"
] | import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
df = pd.read_csv('/kaggle/input/pima-indians-diabetes-database/diabetes.csv')
data = df.iloc[:, 0:8]
data.head() | code |
128043001/cell_4 | [
"text_plain_output_1.png"
] | import pandas as pd
train = pd.read_csv('/kaggle/input/classification-problem-uni/data_inlf_train.csv', encoding='gbk')
train.head() | code |
128043001/cell_7 | [
"text_plain_output_1.png"
] | from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
import pandas as pd
train = pd.read_csv('/kaggle/input/classification-problem-uni/data_inlf_train.csv', encoding='gbk')
y = train['inlf'].values
train.drop(['inlf'], axis=1, inplace=True)
x = train.values
scaler = StandardScaler()
x = scaler.fit_transform(x)
model = LogisticRegression(max_iter=10000)
model.fit(x, y) | code |
128043001/cell_8 | [
"text_plain_output_1.png"
] | from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import StandardScaler
import pandas as pd
train = pd.read_csv('/kaggle/input/classification-problem-uni/data_inlf_train.csv', encoding='gbk')
y = train['inlf'].values
train.drop(['inlf'], axis=1, inplace=True)
x = train.values
scaler = StandardScaler()
x = scaler.fit_transform(x)
model = LogisticRegression(max_iter=10000)
model.fit(x, y)
y_pred_class = model.predict(x)
accuracy_score(y, y_pred_class) | code |
128043001/cell_12 | [
"text_html_output_1.png"
] | from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import StandardScaler
import pandas as pd
train = pd.read_csv('/kaggle/input/classification-problem-uni/data_inlf_train.csv', encoding='gbk')
y = train['inlf'].values
train.drop(['inlf'], axis=1, inplace=True)
x = train.values
scaler = StandardScaler()
x = scaler.fit_transform(x)
model = LogisticRegression(max_iter=10000)
model.fit(x, y)
y_pred_class = model.predict(x)
accuracy_score(y, y_pred_class)
test = pd.read_csv('/kaggle/input/classification-problem-uni/data_inlf_test.csv', encoding='gbk')
x = test.values
x = scaler.transform(x)
y_pred_class = model.predict(x)
y_pred_class | code |
18153363/cell_25 | [
"text_plain_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
from sklearn import metrics
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt # Matlab-style plotting
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
corrmat = train.corr()
missing = train.isnull().sum()
train_dummy = pd.get_dummies(pd.read_csv('../input/train.csv'))
ghost_num = {'type': {'Ghoul': 1, 'Goblin': 2, 'Ghost': 3}}
train.replace(ghost_num, inplace=True)
ntrain = train.shape[0]
ntest = test.shape[0]
y = train.type.values
all_data = pd.concat((train, test)).reset_index(drop=True)
all_data.drop(['type'], axis=1, inplace=True)
all_data.drop(['color'], axis=1, inplace=True)
all_data_simple = pd.DataFrame()
all_data_simple['bone_hair'] = all_data['bone_hair']
all_data_simple['rotting_flesh'] = all_data['rotting_flesh']
all_data_simple['bone_soul'] = all_data['bone_soul']
all_data_simple['hair_soul'] = all_data['hair_soul']
from sklearn.metrics import accuracy_score, log_loss
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
classifiers = [KNeighborsClassifier(3), SVC(kernel='rbf', C=0.025, probability=True), NuSVC(probability=True), DecisionTreeClassifier(), RandomForestClassifier(), AdaBoostClassifier(), GradientBoostingClassifier(), GaussianNB(), LinearDiscriminantAnalysis(), QuadraticDiscriminantAnalysis()]
log_cols = ['Classifier', 'Accuracy', 'Log Loss']
log = pd.DataFrame(columns=log_cols)
for clf in classifiers:
clf.fit(train_X, train_y)
name = clf.__class__.__name__
score = clf.score(val_X, val_y)
from sklearn.model_selection import GridSearchCV
from sklearn import metrics
accuracy_scorer = metrics.make_scorer(metrics.accuracy_score)
params = {'n_estimators': [10, 20, 50, 100], 'criterion': ['gini', 'entropy'], 'max_depth': [None, 5, 10, 25, 50]}
rf = RandomForestClassifier(random_state=0)
clf = GridSearchCV(rf, param_grid=params, scoring=accuracy_scorer, cv=5, n_jobs=-1)
clf.fit(train_X, train_y)
params = {'n_estimators': [10, 25, 50, 100], 'max_samples': [1, 3, 5, 10]}
bag = BaggingClassifier(random_state=0)
clf = GridSearchCV(bag, param_grid=params, scoring=accuracy_scorer, cv=5, n_jobs=-1)
clf.fit(train_X, train_y)
print('Best score: {}'.format(clf.best_score_))
print('Best parameters: {}'.format(clf.best_params_)) | code |
18153363/cell_4 | [
"application_vnd.jupyter.stderr_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
print('The train data size before dropping Id feature is : {} '.format(train.shape))
print('The test data size before dropping Id feature is : {} '.format(test.shape))
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
print('\nThe train data size after dropping Id feature is : {} '.format(train.shape))
print('The test data size after dropping Id feature is : {} '.format(test.shape)) | code |
18153363/cell_23 | [
"text_html_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
from sklearn import metrics
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt # Matlab-style plotting
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
corrmat = train.corr()
missing = train.isnull().sum()
train_dummy = pd.get_dummies(pd.read_csv('../input/train.csv'))
ghost_num = {'type': {'Ghoul': 1, 'Goblin': 2, 'Ghost': 3}}
train.replace(ghost_num, inplace=True)
ntrain = train.shape[0]
ntest = test.shape[0]
y = train.type.values
all_data = pd.concat((train, test)).reset_index(drop=True)
all_data.drop(['type'], axis=1, inplace=True)
all_data.drop(['color'], axis=1, inplace=True)
all_data_simple = pd.DataFrame()
all_data_simple['bone_hair'] = all_data['bone_hair']
all_data_simple['rotting_flesh'] = all_data['rotting_flesh']
all_data_simple['bone_soul'] = all_data['bone_soul']
all_data_simple['hair_soul'] = all_data['hair_soul']
from sklearn.metrics import accuracy_score, log_loss
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
classifiers = [KNeighborsClassifier(3), SVC(kernel='rbf', C=0.025, probability=True), NuSVC(probability=True), DecisionTreeClassifier(), RandomForestClassifier(), AdaBoostClassifier(), GradientBoostingClassifier(), GaussianNB(), LinearDiscriminantAnalysis(), QuadraticDiscriminantAnalysis()]
log_cols = ['Classifier', 'Accuracy', 'Log Loss']
log = pd.DataFrame(columns=log_cols)
for clf in classifiers:
clf.fit(train_X, train_y)
name = clf.__class__.__name__
score = clf.score(val_X, val_y)
from sklearn.model_selection import GridSearchCV
from sklearn import metrics
accuracy_scorer = metrics.make_scorer(metrics.accuracy_score)
params = {'n_estimators': [10, 20, 50, 100], 'criterion': ['gini', 'entropy'], 'max_depth': [None, 5, 10, 25, 50]}
rf = RandomForestClassifier(random_state=0)
clf = GridSearchCV(rf, param_grid=params, scoring=accuracy_scorer, cv=5, n_jobs=-1)
clf.fit(train_X, train_y)
print('Best score: {}'.format(clf.best_score_))
print('Best parameters: {}'.format(clf.best_params_)) | code |
18153363/cell_33 | [
"text_plain_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.ensemble import VotingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt # Matlab-style plotting
import numpy as np # linear algebra
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import shap
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
corrmat = train.corr()
missing = train.isnull().sum()
train_dummy = pd.get_dummies(pd.read_csv('../input/train.csv'))
ghost_num = {'type': {'Ghoul': 1, 'Goblin': 2, 'Ghost': 3}}
train.replace(ghost_num, inplace=True)
ntrain = train.shape[0]
ntest = test.shape[0]
y = train.type.values
all_data = pd.concat((train, test)).reset_index(drop=True)
all_data.drop(['type'], axis=1, inplace=True)
all_data.drop(['color'], axis=1, inplace=True)
all_data_simple = pd.DataFrame()
all_data_simple['bone_hair'] = all_data['bone_hair']
all_data_simple['rotting_flesh'] = all_data['rotting_flesh']
all_data_simple['bone_soul'] = all_data['bone_soul']
all_data_simple['hair_soul'] = all_data['hair_soul']
from sklearn.metrics import accuracy_score, log_loss
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
classifiers = [KNeighborsClassifier(3), SVC(kernel='rbf', C=0.025, probability=True), NuSVC(probability=True), DecisionTreeClassifier(), RandomForestClassifier(), AdaBoostClassifier(), GradientBoostingClassifier(), GaussianNB(), LinearDiscriminantAnalysis(), QuadraticDiscriminantAnalysis()]
log_cols = ['Classifier', 'Accuracy', 'Log Loss']
log = pd.DataFrame(columns=log_cols)
for clf in classifiers:
clf.fit(train_X, train_y)
name = clf.__class__.__name__
score = clf.score(val_X, val_y)
rf_best = RandomForestClassifier(criterion='entropy', max_depth=5, n_estimators=50)
bag_best = BaggingClassifier(max_samples=5, n_estimators=100, random_state=0)
import shap
explainer = shap.TreeExplainer(classifiers[1], train_X)
shap_values = explainer.shap_values(train_X)
shap.initjs()
top_cols = train_X.columns[np.argsort(shap_values.std(0))[::-1]][:10]
voting_clf = VotingClassifier(estimators=[('rf', rf_best), ('bag', bag_best)], voting='hard')
voting_clf.fit(train_X, train_y)
ghost_cat = {'type': {1: 'Ghoul', 2: 'Goblin', 3: 'Ghost'}}
test = all_data_simple[ntrain:]
sub = pd.DataFrame()
sub['id'] = test_ID
sub['type'] = voting_clf.predict(test)
sub.replace(ghost_cat, inplace=True)
sub.to_csv('subvoting_clf.csv', index=False)
sub.head() | code |
18153363/cell_29 | [
"text_plain_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.ensemble import VotingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt # Matlab-style plotting
import numpy as np # linear algebra
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import shap
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
corrmat = train.corr()
missing = train.isnull().sum()
train_dummy = pd.get_dummies(pd.read_csv('../input/train.csv'))
ghost_num = {'type': {'Ghoul': 1, 'Goblin': 2, 'Ghost': 3}}
train.replace(ghost_num, inplace=True)
ntrain = train.shape[0]
ntest = test.shape[0]
y = train.type.values
all_data = pd.concat((train, test)).reset_index(drop=True)
all_data.drop(['type'], axis=1, inplace=True)
all_data.drop(['color'], axis=1, inplace=True)
all_data_simple = pd.DataFrame()
all_data_simple['bone_hair'] = all_data['bone_hair']
all_data_simple['rotting_flesh'] = all_data['rotting_flesh']
all_data_simple['bone_soul'] = all_data['bone_soul']
all_data_simple['hair_soul'] = all_data['hair_soul']
from sklearn.metrics import accuracy_score, log_loss
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
classifiers = [KNeighborsClassifier(3), SVC(kernel='rbf', C=0.025, probability=True), NuSVC(probability=True), DecisionTreeClassifier(), RandomForestClassifier(), AdaBoostClassifier(), GradientBoostingClassifier(), GaussianNB(), LinearDiscriminantAnalysis(), QuadraticDiscriminantAnalysis()]
log_cols = ['Classifier', 'Accuracy', 'Log Loss']
log = pd.DataFrame(columns=log_cols)
for clf in classifiers:
clf.fit(train_X, train_y)
name = clf.__class__.__name__
score = clf.score(val_X, val_y)
rf_best = RandomForestClassifier(criterion='entropy', max_depth=5, n_estimators=50)
bag_best = BaggingClassifier(max_samples=5, n_estimators=100, random_state=0)
import shap
explainer = shap.TreeExplainer(classifiers[1], train_X)
shap_values = explainer.shap_values(train_X)
shap.initjs()
top_cols = train_X.columns[np.argsort(shap_values.std(0))[::-1]][:10]
voting_clf = VotingClassifier(estimators=[('rf', rf_best), ('bag', bag_best)], voting='hard')
voting_clf.fit(train_X, train_y)
print('The accuracy for DecisionTree and Random Forest is:', voting_clf.score(val_X, val_y)) | code |
18153363/cell_11 | [
"text_html_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
import matplotlib.pyplot as plt # Matlab-style plotting
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
corrmat = train.corr()
missing = train.isnull().sum()
ghost_num = {'type': {'Ghoul': 1, 'Goblin': 2, 'Ghost': 3}}
train.replace(ghost_num, inplace=True)
train.head() | code |
18153363/cell_19 | [
"text_html_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
import matplotlib.pyplot as plt # Matlab-style plotting
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
corrmat = train.corr()
missing = train.isnull().sum()
train_dummy = pd.get_dummies(pd.read_csv('../input/train.csv'))
ghost_num = {'type': {'Ghoul': 1, 'Goblin': 2, 'Ghost': 3}}
train.replace(ghost_num, inplace=True)
ntrain = train.shape[0]
ntest = test.shape[0]
y = train.type.values
all_data = pd.concat((train, test)).reset_index(drop=True)
all_data.drop(['type'], axis=1, inplace=True)
train[train['bone_length'] > 0.8] | code |
18153363/cell_1 | [
"text_plain_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
print(os.listdir('../input')) | code |
18153363/cell_7 | [
"text_plain_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_dummy = pd.get_dummies(pd.read_csv('../input/train.csv'))
train_dummy.head() | code |
18153363/cell_18 | [
"text_plain_output_1.png",
"image_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
import matplotlib.pyplot as plt # Matlab-style plotting
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
corrmat = train.corr()
missing = train.isnull().sum()
train_dummy = pd.get_dummies(pd.read_csv('../input/train.csv'))
ghost_num = {'type': {'Ghoul': 1, 'Goblin': 2, 'Ghost': 3}}
train.replace(ghost_num, inplace=True)
ntrain = train.shape[0]
ntest = test.shape[0]
y = train.type.values
all_data = pd.concat((train, test)).reset_index(drop=True)
all_data.drop(['type'], axis=1, inplace=True)
all_data.drop(['color'], axis=1, inplace=True)
all_data_simple = pd.DataFrame()
all_data_simple['bone_hair'] = all_data['bone_hair']
all_data_simple['rotting_flesh'] = all_data['rotting_flesh']
all_data_simple['bone_soul'] = all_data['bone_soul']
all_data_simple['hair_soul'] = all_data['hair_soul']
all_data_simple.head() | code |
18153363/cell_28 | [
"text_html_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.ensemble import VotingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt # Matlab-style plotting
import numpy as np # linear algebra
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import shap
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
corrmat = train.corr()
missing = train.isnull().sum()
train_dummy = pd.get_dummies(pd.read_csv('../input/train.csv'))
ghost_num = {'type': {'Ghoul': 1, 'Goblin': 2, 'Ghost': 3}}
train.replace(ghost_num, inplace=True)
ntrain = train.shape[0]
ntest = test.shape[0]
y = train.type.values
all_data = pd.concat((train, test)).reset_index(drop=True)
all_data.drop(['type'], axis=1, inplace=True)
all_data.drop(['color'], axis=1, inplace=True)
all_data_simple = pd.DataFrame()
all_data_simple['bone_hair'] = all_data['bone_hair']
all_data_simple['rotting_flesh'] = all_data['rotting_flesh']
all_data_simple['bone_soul'] = all_data['bone_soul']
all_data_simple['hair_soul'] = all_data['hair_soul']
from sklearn.metrics import accuracy_score, log_loss
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
classifiers = [KNeighborsClassifier(3), SVC(kernel='rbf', C=0.025, probability=True), NuSVC(probability=True), DecisionTreeClassifier(), RandomForestClassifier(), AdaBoostClassifier(), GradientBoostingClassifier(), GaussianNB(), LinearDiscriminantAnalysis(), QuadraticDiscriminantAnalysis()]
log_cols = ['Classifier', 'Accuracy', 'Log Loss']
log = pd.DataFrame(columns=log_cols)
for clf in classifiers:
clf.fit(train_X, train_y)
name = clf.__class__.__name__
score = clf.score(val_X, val_y)
import shap
explainer = shap.TreeExplainer(classifiers[1], train_X)
shap_values = explainer.shap_values(train_X)
shap.initjs()
top_cols = train_X.columns[np.argsort(shap_values.std(0))[::-1]][:10]
from sklearn.ensemble import VotingClassifier
ensemble = VotingClassifier(estimators=[('4', classifiers[4]), ('3', classifiers[3]), ('5', classifiers[5])], voting='soft', weights=[1, 1, 1]).fit(train_X, train_y)
print('The accuracy for DecisionTree and Random Forest is:', ensemble.score(val_X, val_y)) | code |
18153363/cell_8 | [
"text_html_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_dummy = pd.get_dummies(pd.read_csv('../input/train.csv'))
corrs = train_dummy.corr().abs().unstack().sort_values(kind='quicksort').reset_index()
corrs = corrs[corrs['level_0'] != corrs['level_1']]
corrs.tail(20) | code |
18153363/cell_3 | [
"text_plain_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train.head(10) | code |
18153363/cell_22 | [
"text_html_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt # Matlab-style plotting
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
corrmat = train.corr()
missing = train.isnull().sum()
train_dummy = pd.get_dummies(pd.read_csv('../input/train.csv'))
ghost_num = {'type': {'Ghoul': 1, 'Goblin': 2, 'Ghost': 3}}
train.replace(ghost_num, inplace=True)
ntrain = train.shape[0]
ntest = test.shape[0]
y = train.type.values
all_data = pd.concat((train, test)).reset_index(drop=True)
all_data.drop(['type'], axis=1, inplace=True)
all_data.drop(['color'], axis=1, inplace=True)
all_data_simple = pd.DataFrame()
all_data_simple['bone_hair'] = all_data['bone_hair']
all_data_simple['rotting_flesh'] = all_data['rotting_flesh']
all_data_simple['bone_soul'] = all_data['bone_soul']
all_data_simple['hair_soul'] = all_data['hair_soul']
from sklearn.metrics import accuracy_score, log_loss
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
classifiers = [KNeighborsClassifier(3), SVC(kernel='rbf', C=0.025, probability=True), NuSVC(probability=True), DecisionTreeClassifier(), RandomForestClassifier(), AdaBoostClassifier(), GradientBoostingClassifier(), GaussianNB(), LinearDiscriminantAnalysis(), QuadraticDiscriminantAnalysis()]
log_cols = ['Classifier', 'Accuracy', 'Log Loss']
log = pd.DataFrame(columns=log_cols)
for clf in classifiers:
clf.fit(train_X, train_y)
name = clf.__class__.__name__
print('=' * 30)
print(name)
print('****Results****')
score = clf.score(val_X, val_y)
print('Score: {:.4%}'.format(score))
print('=' * 30) | code |
18153363/cell_27 | [
"text_html_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt # Matlab-style plotting
import numpy as np # linear algebra
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import shap
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
corrmat = train.corr()
missing = train.isnull().sum()
train_dummy = pd.get_dummies(pd.read_csv('../input/train.csv'))
ghost_num = {'type': {'Ghoul': 1, 'Goblin': 2, 'Ghost': 3}}
train.replace(ghost_num, inplace=True)
ntrain = train.shape[0]
ntest = test.shape[0]
y = train.type.values
all_data = pd.concat((train, test)).reset_index(drop=True)
all_data.drop(['type'], axis=1, inplace=True)
all_data.drop(['color'], axis=1, inplace=True)
all_data_simple = pd.DataFrame()
all_data_simple['bone_hair'] = all_data['bone_hair']
all_data_simple['rotting_flesh'] = all_data['rotting_flesh']
all_data_simple['bone_soul'] = all_data['bone_soul']
all_data_simple['hair_soul'] = all_data['hair_soul']
from sklearn.metrics import accuracy_score, log_loss
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
classifiers = [KNeighborsClassifier(3), SVC(kernel='rbf', C=0.025, probability=True), NuSVC(probability=True), DecisionTreeClassifier(), RandomForestClassifier(), AdaBoostClassifier(), GradientBoostingClassifier(), GaussianNB(), LinearDiscriminantAnalysis(), QuadraticDiscriminantAnalysis()]
log_cols = ['Classifier', 'Accuracy', 'Log Loss']
log = pd.DataFrame(columns=log_cols)
for clf in classifiers:
clf.fit(train_X, train_y)
name = clf.__class__.__name__
score = clf.score(val_X, val_y)
import shap
explainer = shap.TreeExplainer(classifiers[1], train_X)
shap_values = explainer.shap_values(train_X)
shap.summary_plot(shap_values, train_X)
shap.initjs()
shap.force_plot(explainer.expected_value[1], shap_values[1], train_X.iloc[:, 1:10])
top_cols = train_X.columns[np.argsort(shap_values.std(0))[::-1]][:10]
for col in top_cols:
shap.dependence_plot(col, shap_values, train_X) | code |
18153363/cell_12 | [
"text_plain_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
import matplotlib.pyplot as plt # Matlab-style plotting
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
corrmat = train.corr()
missing = train.isnull().sum()
train_dummy = pd.get_dummies(pd.read_csv('../input/train.csv'))
ghost_num = {'type': {'Ghoul': 1, 'Goblin': 2, 'Ghost': 3}}
train.replace(ghost_num, inplace=True)
ntrain = train.shape[0]
ntest = test.shape[0]
y = train.type.values
all_data = pd.concat((train, test)).reset_index(drop=True)
all_data.drop(['type'], axis=1, inplace=True)
print('all_data size is : {}'.format(all_data.shape)) | code |
18153363/cell_5 | [
"text_plain_output_1.png"
] | from plotly.offline import init_notebook_mode, iplot
import matplotlib.pyplot as plt # Matlab-style plotting
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode, iplot
init_notebook_mode(connected=True)
import seaborn as sns
color = sns.color_palette()
sns.set_style('darkgrid')
import warnings
def ignore_warn(*args, **kwargs):
pass
warnings.warn = ignore_warn
from scipy import stats
from scipy.stats import norm, skew
pd.set_option('display.float_format', lambda x: '{:.3f}'.format(x))
import os
train = pd.read_csv('../input/train.csv')
test = pd.read_csv('../input/test.csv')
train_ID = train['id']
test_ID = test['id']
train.drop('id', axis=1, inplace=True)
test.drop('id', axis=1, inplace=True)
corrmat = train.corr()
plt.subplots(figsize=(12, 9))
sns.heatmap(corrmat, vmax=0.9, square=True, cbar=True, annot=True) | code |
122245079/cell_21 | [
"text_plain_output_1.png"
] | import matplotlib.pyplot as plt
import numpy as np # linear algebra
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import numpy as np
import pandas as pd
import os
df = pd.read_csv(os.path.join(dirname, filename))
df.isnull().sum()
df.columns
def Price_Converter(string):
lis = string.split()
res = [eval(i) for i in lis]
return np.prod(res)
df.Price = df.Price.str.strip()
df.Price = df.Price.str.replace(',', '')
df.Price = df.Price.str.replace('Lakh', '100000')
df.Price = df.Price.map(Price_Converter)
df.Year = pd.to_datetime(df.Year, format='%Y')
import seaborn as sns
import matplotlib.pyplot as plt
plt.figure(figsize=(5,5))
ax1 = sns.boxplot(y = df.Price, x= df['Fuel Type'],hue=df.Suspension)
plt.figure(figsize=(5,5))
ax1 = sns.boxplot(y = df['kms Driven'], x= df['Fuel Type'],hue=df.Suspension)
df.drop(df.loc[df['kms Driven'] >= 2000000.0].index, axis=0, inplace=True)
df.drop(df.loc[df['kms Driven'] >= 600000.0].index, axis=0, inplace=True)
sns.pairplot(df, hue='Fuel Type') | code |
122245079/cell_13 | [
"text_plain_output_1.png"
] | import numpy as np # linear algebra
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import numpy as np
import pandas as pd
import os
df = pd.read_csv(os.path.join(dirname, filename))
df.isnull().sum()
df.columns
def Price_Converter(string):
lis = string.split()
res = [eval(i) for i in lis]
return np.prod(res)
df.Price = df.Price.str.strip()
df.Price = df.Price.str.replace(',', '')
df.Price = df.Price.str.replace('Lakh', '100000')
df.Price = df.Price.map(Price_Converter)
df.Year = pd.to_datetime(df.Year, format='%Y')
df['Car Model'].value_counts() | code |
122245079/cell_4 | [
"text_plain_output_1.png",
"image_output_1.png"
] | import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import numpy as np
import pandas as pd
import os
df = pd.read_csv(os.path.join(dirname, filename))
df.isnull().sum() | code |
122245079/cell_6 | [
"image_output_1.png"
] | import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import numpy as np
import pandas as pd
import os
df = pd.read_csv(os.path.join(dirname, filename))
df.isnull().sum()
df.columns | code |
122245079/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 |
122245079/cell_18 | [
"text_plain_output_1.png"
] | import matplotlib.pyplot as plt
import numpy as np # linear algebra
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import numpy as np
import pandas as pd
import os
df = pd.read_csv(os.path.join(dirname, filename))
df.isnull().sum()
df.columns
def Price_Converter(string):
lis = string.split()
res = [eval(i) for i in lis]
return np.prod(res)
df.Price = df.Price.str.strip()
df.Price = df.Price.str.replace(',', '')
df.Price = df.Price.str.replace('Lakh', '100000')
df.Price = df.Price.map(Price_Converter)
df.Year = pd.to_datetime(df.Year, format='%Y')
import seaborn as sns
import matplotlib.pyplot as plt
plt.figure(figsize=(5,5))
ax1 = sns.boxplot(y = df.Price, x= df['Fuel Type'],hue=df.Suspension)
plt.figure(figsize=(5, 5))
ax1 = sns.boxplot(y=df['kms Driven'], x=df['Fuel Type'], hue=df.Suspension) | code |
122245079/cell_15 | [
"text_plain_output_1.png"
] | import numpy as np # linear algebra
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import numpy as np
import pandas as pd
import os
df = pd.read_csv(os.path.join(dirname, filename))
df.isnull().sum()
df.columns
def Price_Converter(string):
lis = string.split()
res = [eval(i) for i in lis]
return np.prod(res)
df.Price = df.Price.str.strip()
df.Price = df.Price.str.replace(',', '')
df.Price = df.Price.str.replace('Lakh', '100000')
df.Price = df.Price.map(Price_Converter)
df.Year = pd.to_datetime(df.Year, format='%Y')
df.head() | code |
122245079/cell_16 | [
"text_plain_output_1.png"
] | import matplotlib.pyplot as plt
import numpy as np # linear algebra
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import numpy as np
import pandas as pd
import os
df = pd.read_csv(os.path.join(dirname, filename))
df.isnull().sum()
df.columns
def Price_Converter(string):
lis = string.split()
res = [eval(i) for i in lis]
return np.prod(res)
df.Price = df.Price.str.strip()
df.Price = df.Price.str.replace(',', '')
df.Price = df.Price.str.replace('Lakh', '100000')
df.Price = df.Price.map(Price_Converter)
df.Year = pd.to_datetime(df.Year, format='%Y')
import seaborn as sns
import matplotlib.pyplot as plt
plt.figure(figsize=(5, 5))
ax1 = sns.boxplot(y=df.Price, x=df['Fuel Type'], hue=df.Suspension) | code |
122245079/cell_3 | [
"image_output_1.png"
] | import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import numpy as np
import pandas as pd
import os
df = pd.read_csv(os.path.join(dirname, filename))
df.head(10) | code |
122245079/cell_24 | [
"text_html_output_1.png"
] | import matplotlib.pyplot as plt
import numpy as np # linear algebra
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import seaborn as sns
import numpy as np
import pandas as pd
import os
df = pd.read_csv(os.path.join(dirname, filename))
df.isnull().sum()
df.columns
def Price_Converter(string):
lis = string.split()
res = [eval(i) for i in lis]
return np.prod(res)
df.Price = df.Price.str.strip()
df.Price = df.Price.str.replace(',', '')
df.Price = df.Price.str.replace('Lakh', '100000')
df.Price = df.Price.map(Price_Converter)
df.Year = pd.to_datetime(df.Year, format='%Y')
import seaborn as sns
import matplotlib.pyplot as plt
plt.figure(figsize=(5,5))
ax1 = sns.boxplot(y = df.Price, x= df['Fuel Type'],hue=df.Suspension)
plt.figure(figsize=(5,5))
ax1 = sns.boxplot(y = df['kms Driven'], x= df['Fuel Type'],hue=df.Suspension)
df.drop(df.loc[df['kms Driven'] >= 2000000.0].index, axis=0, inplace=True)
df.drop(df.loc[df['kms Driven'] >= 600000.0].index, axis=0, inplace=True)
df['Fuel Type'].unique() | code |
122245079/cell_12 | [
"text_html_output_1.png"
] | import numpy as np # linear algebra
import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import numpy as np
import pandas as pd
import os
df = pd.read_csv(os.path.join(dirname, filename))
df.isnull().sum()
df.columns
def Price_Converter(string):
lis = string.split()
res = [eval(i) for i in lis]
return np.prod(res)
df.Price = df.Price.str.strip()
df.Price = df.Price.str.replace(',', '')
df.Price = df.Price.str.replace('Lakh', '100000')
df.Price = df.Price.map(Price_Converter)
df.Year = pd.to_datetime(df.Year, format='%Y')
df.info() | code |
122245079/cell_5 | [
"text_plain_output_1.png"
] | import os
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import numpy as np
import pandas as pd
import os
df = pd.read_csv(os.path.join(dirname, filename))
df.isnull().sum()
df.info() | code |
106194409/cell_21 | [
"image_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df2.describe(include='object').round().T
df2.head() | code |
106194409/cell_13 | [
"text_plain_output_1.png"
] | import matplotlib.pyplot as plt
import missingno as msno
import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.describe(include='object').round().T
df2.describe(include='object').round().T
round(df1.isna().sum() / df1.shape[0], 2)
msno.matrix(df1)
msno.heatmap(df1)
plt.show() | code |
106194409/cell_9 | [
"text_plain_output_2.png",
"text_plain_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df2.describe(include='object').round().T | code |
106194409/cell_4 | [
"application_vnd.jupyter.stderr_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.info() | code |
106194409/cell_23 | [
"text_html_output_1.png",
"text_plain_output_1.png"
] | from catboost import CatBoostClassifier
from lightgbm import LGBMClassifier
from sklearn.impute import KNNImputer
from xgboost import XGBClassifier
import matplotlib.pyplot as plt
import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.describe(include='object').round().T
df2.describe(include='object').round().T
round(df1.isna().sum() / df1.shape[0], 2)
df1['Transported'] = df1['Transported'].astype(bool)
quant_imputer = KNNImputer(n_neighbors=3)
quant_features = ['RoomService', 'FoodCourt', 'ShoppingMall', 'Spa', 'VRDeck']
for df in [df1, df2]:
df['HomePlanet'].fillna('Earth', inplace=True)
df['CryoSleep'].fillna(False, inplace=True)
df['Cabin'].fillna('Z/99999/Z', inplace=True)
df['Destination'].fillna('TRAPPIST-1e', inplace=True)
df['VIP'].fillna(False, inplace=True)
df[quant_features + ['Age']] = pd.DataFrame(quant_imputer.fit_transform(df[quant_features + ['Age']]))
df['TotalSpending'] = df[quant_features].sum(axis=1)
df['Deck'] = df['Cabin'].apply(lambda x: x.split('/')[0]).astype(str)
df['Num'] = df['Cabin'].apply(lambda x: x.split('/')[1]).astype(str)
df['Side'] = df['Cabin'].apply(lambda x: x.split('/')[2]).astype(str)
df['Passenger_Group'] = df['PassengerId'].apply(lambda x: x.split('_')[0]).astype(str)
df['Passenger_Num'] = df['PassengerId'].apply(lambda x: x.split('_')[1]).astype(str)
df['Passenger_Group'] = df['Passenger_Group'].astype('category')
df['HomePlanet'] = df['HomePlanet'].astype('category')
df['CryoSleep'] = df['CryoSleep'].astype(bool)
df['Deck'] = df['Deck'].astype('category')
df['Side'] = df['Side'].astype('category')
df['Destination'] = df['Destination'].astype('category')
for df in [df1, df2]:
df['Group_Size'] = df['Passenger_Group'].map(lambda x: pd.concat([df1['Passenger_Group'], df2['Passenger_Group']]).value_counts()[x])
y_true_df1 = df1['Transported']
features = ['Group_Size', 'HomePlanet', 'CryoSleep', 'Destination', 'VIP', 'Deck', 'Side', 'Age', 'TotalSpending'] + quant_features
x_df1 = pd.get_dummies(df1[features], drop_first=True)
x_df2 = pd.get_dummies(df2[features], drop_first=True)
lgbm_clf = LGBMClassifier(n_estimators=3000, random_state=0, learning_rate=0.0015, objective='binary')
xgb_clf = XGBClassifier()
catboost_clf = CatBoostClassifier()
clf = VotingClassifier([('lgbm', lgbm_clf), ('xgm', xgb_clf), ('catboost', catboost_clf)], voting='hard')
clf = clf.fit(x_df1, y_true_df1)
y_predicted = clf.predict(x_df1)
accuracy_score(y_true_df1, y_predicted) | code |
106194409/cell_20 | [
"image_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df2.describe(include='object').round().T
df2.info() | code |
106194409/cell_6 | [
"text_html_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.describe() | code |
106194409/cell_2 | [
"text_plain_output_2.png",
"text_plain_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.head() | code |
106194409/cell_11 | [
"text_html_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.describe(include='object').round().T
print('Percentage of missing data per feature:\n')
round(df1.isna().sum() / df1.shape[0], 2) | code |
106194409/cell_19 | [
"image_output_2.png",
"image_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.describe(include='object').round().T
round(df1.isna().sum() / df1.shape[0], 2)
df1.head() | code |
106194409/cell_7 | [
"text_plain_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df2.describe() | code |
106194409/cell_18 | [
"text_html_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.describe(include='object').round().T
round(df1.isna().sum() / df1.shape[0], 2)
df1.info() | code |
106194409/cell_8 | [
"text_html_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.describe(include='object').round().T | code |
106194409/cell_15 | [
"text_html_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.describe(include='object').round().T
round(df1.isna().sum() / df1.shape[0], 2)
print('Statistical Distribution of Passengers NOT in CryoSleep\n')
round(df1[df1['CryoSleep'] == False].describe(), 3) | code |
106194409/cell_16 | [
"text_html_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.describe(include='object').round().T
round(df1.isna().sum() / df1.shape[0], 2)
df1[df1['CryoSleep'] == True][['Room Service', 'FoodCourt', 'ShoppingMall', 'Spa', 'VRDeck']] = 0.1 | code |
106194409/cell_3 | [
"text_html_output_1.png",
"text_plain_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df2.head() | code |
106194409/cell_14 | [
"text_html_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.describe(include='object').round().T
round(df1.isna().sum() / df1.shape[0], 2)
print('Statistical Distribution of Passengers in CryoSleep\n')
round(df1[df1['CryoSleep'] == True].describe(), 3) | code |
106194409/cell_10 | [
"text_html_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.describe(include='object').round().T
df2.describe(include='object').round().T
for df in [df1, df2]:
df.isna().mean().plot(kind='barh', figsize=(10, 5))
plt.show()
print('') | code |
106194409/cell_12 | [
"text_plain_output_1.png"
] | import matplotlib.pyplot as plt
import missingno as msno
import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df1.describe(include='object').round().T
df2.describe(include='object').round().T
round(df1.isna().sum() / df1.shape[0], 2)
msno.matrix(df1)
plt.show() | code |
106194409/cell_5 | [
"text_plain_output_1.png"
] | import pandas as pd
df1 = pd.read_csv('../input/spaceship-titanic/train.csv')
df2 = pd.read_csv('../input/spaceship-titanic/test.csv')
df2.info() | code |
128047896/cell_21 | [
"text_plain_output_1.png"
] | import pandas as pd
wp = pd.read_csv('https://raw.githubusercontent.com/kunal-mallick/Kaggle-Project/Working/Water%20Quality(Drinking%20Water%20Potability)/src/main/resources/water_potability.csv')
wp
wp_nrow = wp.shape[0]
def lost_record():
wp_nrow_now = wp.shape[0]
lost = wp_nrow - wp_nrow_now
lost = lost / wp_nrow * 100
lost = round(lost, 2)
return
def missing_percentage(wp):
m = wp.isna().sum()
total = int(wp.shape[0])
for i in range(len(wp.columns)):
percentage = round(m[i] / total * 100)
wp.fillna(value={'ph': wp['ph'].median(), 'Sulfate': wp['Sulfate'].median(), 'Trihalomethanes': wp['Trihalomethanes'].median()}, inplace=True)
missing_percentage(wp) | code |
128047896/cell_13 | [
"text_html_output_1.png"
] | import pandas as pd
wp = pd.read_csv('https://raw.githubusercontent.com/kunal-mallick/Kaggle-Project/Working/Water%20Quality(Drinking%20Water%20Potability)/src/main/resources/water_potability.csv')
wp
wp_nrow = wp.shape[0]
def lost_record():
wp_nrow_now = wp.shape[0]
lost = wp_nrow - wp_nrow_now
lost = lost / wp_nrow * 100
lost = round(lost, 2)
return
wp.info() | code |
128047896/cell_30 | [
"text_html_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
wp = pd.read_csv('https://raw.githubusercontent.com/kunal-mallick/Kaggle-Project/Working/Water%20Quality(Drinking%20Water%20Potability)/src/main/resources/water_potability.csv')
wp
wp_nrow = wp.shape[0]
def lost_record():
wp_nrow_now = wp.shape[0]
lost = wp_nrow - wp_nrow_now
lost = lost / wp_nrow * 100
lost = round(lost, 2)
return
def missing_percentage(wp):
m = wp.isna().sum()
total = int(wp.shape[0])
for i in range(len(wp.columns)):
percentage = round(m[i] / total * 100)
wp.fillna(value={'ph': wp['ph'].median(), 'Sulfate': wp['Sulfate'].median(), 'Trihalomethanes': wp['Trihalomethanes'].median()}, inplace=True)
wp[wp.duplicated()]
fig, ax = plt.subplots(3, 3, figsize=(15, 8))
plt.setp(ax[0, 0], title='PH')
sns.boxplot(wp['ph'], orient='h', ax=ax[0, 0], color='#ffadad')
plt.setp(ax[0, 1], title='Hardness')
sns.boxplot(wp['Hardness'], orient='h', ax=ax[0, 1], color='#ffadad')
plt.setp(ax[0, 2], title='Solids')
sns.boxplot(wp['Solids'], orient='h', ax=ax[0, 2], color='#ffadad')
plt.setp(ax[1, 0], title='Chloramines')
sns.boxplot(wp['Chloramines'], orient='h', ax=ax[1, 0], color='#ffadad')
plt.setp(ax[1, 1], title='Sulfate')
sns.boxplot(wp['Sulfate'], orient='h', ax=ax[1, 1], color='#ffd6a5')
plt.setp(ax[1, 2], title='Conductivity')
sns.boxplot(wp['Conductivity'], orient='h', ax=ax[1, 2], color='#ffd6a5')
plt.setp(ax[2, 0], title='Organic_carbon')
sns.boxplot(wp['Organic_carbon'], orient='h', ax=ax[2, 0], color='#ffadad')
plt.setp(ax[2, 1], title='Trihalomethanes')
sns.boxplot(wp['Trihalomethanes'], orient='h', ax=ax[2, 1], color='#ffd6a5')
plt.setp(ax[2, 2], title='Turbidity')
sns.boxplot(wp['Turbidity'], orient='h', ax=ax[2, 2], color='#fdffb6')
plt.tight_layout() | code |
128047896/cell_26 | [
"text_plain_output_1.png"
] | import pandas as pd
wp = pd.read_csv('https://raw.githubusercontent.com/kunal-mallick/Kaggle-Project/Working/Water%20Quality(Drinking%20Water%20Potability)/src/main/resources/water_potability.csv')
wp
wp_nrow = wp.shape[0]
def lost_record():
wp_nrow_now = wp.shape[0]
lost = wp_nrow - wp_nrow_now
lost = lost / wp_nrow * 100
lost = round(lost, 2)
return
def missing_percentage(wp):
m = wp.isna().sum()
total = int(wp.shape[0])
for i in range(len(wp.columns)):
percentage = round(m[i] / total * 100)
wp.fillna(value={'ph': wp['ph'].median(), 'Sulfate': wp['Sulfate'].median(), 'Trihalomethanes': wp['Trihalomethanes'].median()}, inplace=True)
wp[wp.duplicated()] | code |
128047896/cell_11 | [
"text_html_output_1.png"
] | import pandas as pd
wp = pd.read_csv('https://raw.githubusercontent.com/kunal-mallick/Kaggle-Project/Working/Water%20Quality(Drinking%20Water%20Potability)/src/main/resources/water_potability.csv')
wp
wp_nrow = wp.shape[0]
def lost_record():
wp_nrow_now = wp.shape[0]
lost = wp_nrow - wp_nrow_now
lost = lost / wp_nrow * 100
lost = round(lost, 2)
return
wp.describe() | code |
128047896/cell_32 | [
"image_output_1.png"
] | import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
wp = pd.read_csv('https://raw.githubusercontent.com/kunal-mallick/Kaggle-Project/Working/Water%20Quality(Drinking%20Water%20Potability)/src/main/resources/water_potability.csv')
wp
wp_nrow = wp.shape[0]
def lost_record():
wp_nrow_now = wp.shape[0]
lost = wp_nrow - wp_nrow_now
lost = lost / wp_nrow * 100
lost = round(lost, 2)
return
def missing_percentage(wp):
m = wp.isna().sum()
total = int(wp.shape[0])
for i in range(len(wp.columns)):
percentage = round(m[i] / total * 100)
wp.fillna(value={'ph': wp['ph'].median(), 'Sulfate': wp['Sulfate'].median(), 'Trihalomethanes': wp['Trihalomethanes'].median()}, inplace=True)
wp[wp.duplicated()]
fig, ax = plt.subplots(3, 3, figsize = (15,8))
plt.setp(ax[0,0], title = 'PH')
sns.boxplot(wp['ph'], orient = 'h', ax = ax[0,0], color = '#ffadad')
plt.setp(ax[0,1], title = 'Hardness')
sns.boxplot(wp['Hardness'], orient = 'h', ax = ax[0,1], color = '#ffadad')
plt.setp(ax[0,2], title = 'Solids')
sns.boxplot(wp['Solids'], orient = 'h', ax = ax[0,2], color = '#ffadad')
plt.setp(ax[1,0], title = 'Chloramines')
sns.boxplot(wp['Chloramines'], orient = 'h', ax = ax[1,0], color = '#ffadad')
plt.setp(ax[1,1], title = 'Sulfate')
sns.boxplot(wp['Sulfate'], orient = 'h', ax = ax[1,1], color = '#ffd6a5')
plt.setp(ax[1,2], title = 'Conductivity')
sns.boxplot(wp['Conductivity'], orient = 'h', ax = ax[1,2], color = '#ffd6a5')
plt.setp(ax[2,0], title = 'Organic_carbon')
sns.boxplot(wp['Organic_carbon'], orient = 'h', ax = ax[2,0], color = '#ffadad')
plt.setp(ax[2,1], title = 'Trihalomethanes')
sns.boxplot(wp['Trihalomethanes'], orient = 'h', ax = ax[2,1], color = '#ffd6a5')
plt.setp(ax[2,2], title = 'Turbidity')
sns.boxplot(wp['Turbidity'], orient = 'h', ax = ax[2,2], color = '#fdffb6')
plt.tight_layout()
fig, ax = plt.subplots(3, 3, figsize=(15, 8))
plt.setp(ax[0, 0], title='PH')
sns.distplot(wp['ph'], ax=ax[0, 0], color='#e9ff70')
plt.setp(ax[0, 1], title='Hardness')
sns.distplot(wp['Hardness'], ax=ax[0, 1], color='#ffd670')
plt.setp(ax[0, 2], title='Solids')
sns.distplot(wp['Solids'], ax=ax[0, 2], color='#ff9770')
plt.setp(ax[1, 0], title='Chloramines')
sns.distplot(wp['Chloramines'], ax=ax[1, 0], color='#ffd670')
plt.setp(ax[1, 1], title='Sulfate')
sns.distplot(wp['Sulfate'], ax=ax[1, 1], color='#ffd670')
plt.setp(ax[1, 2], title='Conductivity')
sns.distplot(wp['Conductivity'], ax=ax[1, 2], color='#ff9770')
plt.setp(ax[2, 0], title='Organic_carbon')
sns.distplot(wp['Organic_carbon'], ax=ax[2, 0], color='#ff9770')
plt.setp(ax[2, 1], title='Trihalomethanes')
sns.distplot(wp['Trihalomethanes'], ax=ax[2, 1], color='#ff9770')
plt.setp(ax[2, 2], title='Turbidity')
sns.distplot(wp['Turbidity'], ax=ax[2, 2], color='#ff9770')
plt.tight_layout() | code |
128047896/cell_17 | [
"text_plain_output_1.png"
] | import pandas as pd
wp = pd.read_csv('https://raw.githubusercontent.com/kunal-mallick/Kaggle-Project/Working/Water%20Quality(Drinking%20Water%20Potability)/src/main/resources/water_potability.csv')
wp
wp_nrow = wp.shape[0]
def lost_record():
wp_nrow_now = wp.shape[0]
lost = wp_nrow - wp_nrow_now
lost = lost / wp_nrow * 100
lost = round(lost, 2)
return
def missing_percentage(wp):
m = wp.isna().sum()
total = int(wp.shape[0])
for i in range(len(wp.columns)):
percentage = round(m[i] / total * 100)
missing_percentage(wp) | code |
128047896/cell_24 | [
"text_plain_output_1.png"
] | import numpy as np
import pandas as pd
wp = pd.read_csv('https://raw.githubusercontent.com/kunal-mallick/Kaggle-Project/Working/Water%20Quality(Drinking%20Water%20Potability)/src/main/resources/water_potability.csv')
wp
wp_nrow = wp.shape[0]
def lost_record():
wp_nrow_now = wp.shape[0]
lost = wp_nrow - wp_nrow_now
lost = lost / wp_nrow * 100
lost = round(lost, 2)
return
def missing_percentage(wp):
m = wp.isna().sum()
total = int(wp.shape[0])
for i in range(len(wp.columns)):
percentage = round(m[i] / total * 100)
wp.fillna(value={'ph': wp['ph'].median(), 'Sulfate': wp['Sulfate'].median(), 'Trihalomethanes': wp['Trihalomethanes'].median()}, inplace=True)
def uni(df):
pass
uni(wp) | code |
128047896/cell_5 | [
"text_plain_output_1.png",
"image_output_1.png"
] | import pandas as pd
wp = pd.read_csv('https://raw.githubusercontent.com/kunal-mallick/Kaggle-Project/Working/Water%20Quality(Drinking%20Water%20Potability)/src/main/resources/water_potability.csv')
wp | code |
328147/cell_20 | [
"text_plain_output_1.png",
"image_output_1.png"
] | from sklearn.cross_validation import KFold
from sklearn.metrics import log_loss
from sklearn.preprocessing import LabelEncoder
import numpy as np
import pandas as pd
gatrain = pd.read_csv('../input/gender_age_train.csv')
gatest = pd.read_csv('../input/gender_age_test.csv')
letarget = LabelEncoder().fit(gatrain.group.values)
y = letarget.transform(gatrain.group.values)
n_classes = len(letarget.classes_)
phone = pd.read_csv('../input/phone_brand_device_model.csv', encoding='utf-8')
phone = phone.drop_duplicates('device_id', keep='first')
lebrand = LabelEncoder().fit(phone.phone_brand)
phone['brand'] = lebrand.transform(phone.phone_brand)
m = phone.phone_brand.str.cat(phone.device_model)
lemodel = LabelEncoder().fit(m)
phone['model'] = lemodel.transform(m)
train = gatrain.merge(phone[['device_id', 'brand', 'model']], how='left', on='device_id')
class GenderAgeGroupProb(object):
def __init__(self):
pass
def fit(self, df, by, n_smoothing, weights):
self.by = by
self.n_smoothing = n_smoothing
self.weights = np.divide(weights, sum(weights))
self.classes_ = sorted(df['group'].unique())
self.n_classes_ = len(self.classes_)
self.group_freq = df['group'].value_counts().sort_index() / df.shape[0]
self.prob_by = []
for i, b in enumerate(self.by):
c = df.groupby([b, 'group']).size().unstack().fillna(0)
total = c.sum(axis=1)
prob = c.add(self.n_smoothing[i] * self.group_freq).div(total + self.n_smoothing[i], axis=0)
self.prob_by.append(prob)
return self
def predict_proba(self, df):
pred = pd.DataFrame(np.zeros((len(df.index), self.n_classes_)), columns=self.classes_, index=df.index)
pred_by = []
for i, b in enumerate(self.by):
pred_by.append(df[[b]].merge(self.prob_by[i], how='left', left_on=b, right_index=True).fillna(self.group_freq)[self.classes_])
pred = pred.radd(pred_by[i].values * self.weights[i])
pred.loc[pred.iloc[:, 0].isnull(), :] = self.group_freq
return pred[self.classes_].values
def score(ptrain, by, n_smoothing, weights=[0.5, 0.5]):
kf = KFold(ptrain.shape[0], n_folds=10, shuffle=True, random_state=0)
pred = np.zeros((ptrain.shape[0], n_classes))
for itrain, itest in kf:
train = ptrain.iloc[itrain, :]
test = ptrain.iloc[itest, :]
ytrain, ytest = (y[itrain], y[itest])
clf = GenderAgeGroupProb().fit(train, by, n_smoothing, weights)
pred[itest, :] = clf.predict_proba(test)
return log_loss(y, pred)
test = gatest.merge(phone[['device_id', 'brand', 'model']], how='left', on='device_id')
test.head(3) | code |
328147/cell_6 | [
"text_html_output_1.png"
] | import pandas as pd
gatrain = pd.read_csv('../input/gender_age_train.csv')
gatest = pd.read_csv('../input/gender_age_test.csv')
phone = pd.read_csv('../input/phone_brand_device_model.csv', encoding='utf-8')
phone.head(3) | code |
328147/cell_1 | [
"application_vnd.jupyter.stderr_output_1.png"
] | import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import os
from sklearn.preprocessing import LabelEncoder
from sklearn.cross_validation import KFold
from sklearn.metrics import log_loss | code |
328147/cell_18 | [
"text_html_output_1.png"
] | from sklearn.cross_validation import KFold
from sklearn.metrics import log_loss
from sklearn.preprocessing import LabelEncoder
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
gatrain = pd.read_csv('../input/gender_age_train.csv')
gatest = pd.read_csv('../input/gender_age_test.csv')
letarget = LabelEncoder().fit(gatrain.group.values)
y = letarget.transform(gatrain.group.values)
n_classes = len(letarget.classes_)
phone = pd.read_csv('../input/phone_brand_device_model.csv', encoding='utf-8')
phone = phone.drop_duplicates('device_id', keep='first')
lebrand = LabelEncoder().fit(phone.phone_brand)
phone['brand'] = lebrand.transform(phone.phone_brand)
m = phone.phone_brand.str.cat(phone.device_model)
lemodel = LabelEncoder().fit(m)
phone['model'] = lemodel.transform(m)
train = gatrain.merge(phone[['device_id', 'brand', 'model']], how='left', on='device_id')
class GenderAgeGroupProb(object):
def __init__(self):
pass
def fit(self, df, by, n_smoothing, weights):
self.by = by
self.n_smoothing = n_smoothing
self.weights = np.divide(weights, sum(weights))
self.classes_ = sorted(df['group'].unique())
self.n_classes_ = len(self.classes_)
self.group_freq = df['group'].value_counts().sort_index() / df.shape[0]
self.prob_by = []
for i, b in enumerate(self.by):
c = df.groupby([b, 'group']).size().unstack().fillna(0)
total = c.sum(axis=1)
prob = c.add(self.n_smoothing[i] * self.group_freq).div(total + self.n_smoothing[i], axis=0)
self.prob_by.append(prob)
return self
def predict_proba(self, df):
pred = pd.DataFrame(np.zeros((len(df.index), self.n_classes_)), columns=self.classes_, index=df.index)
pred_by = []
for i, b in enumerate(self.by):
pred_by.append(df[[b]].merge(self.prob_by[i], how='left', left_on=b, right_index=True).fillna(self.group_freq)[self.classes_])
pred = pred.radd(pred_by[i].values * self.weights[i])
pred.loc[pred.iloc[:, 0].isnull(), :] = self.group_freq
return pred[self.classes_].values
def score(ptrain, by, n_smoothing, weights=[0.5, 0.5]):
kf = KFold(ptrain.shape[0], n_folds=10, shuffle=True, random_state=0)
pred = np.zeros((ptrain.shape[0], n_classes))
for itrain, itest in kf:
train = ptrain.iloc[itrain, :]
test = ptrain.iloc[itest, :]
ytrain, ytest = (y[itrain], y[itest])
clf = GenderAgeGroupProb().fit(train, by, n_smoothing, weights)
pred[itest, :] = clf.predict_proba(test)
return log_loss(y, pred)
n_smoothing = [1, 5, 10, 15, 20, 50, 100]
res = [score(train, ['brand', 'model'], [s, s], [0.5, 0.5]) for s in n_smoothing]
brand_weight = [0, 0.2, 0.4, 0.6, 0.8, 1.0]
res = [score(train, ['brand', 'model'], [15, 15], [b, 1 - b]) for b in brand_weight]
plt.plot(brand_weight, res)
plt.title('Best score {:.5f} at brand_weight = {}'.format(np.min(res), brand_weight[np.argmin(res)]))
plt.xlabel('brand_weight') | code |
328147/cell_3 | [
"text_plain_output_1.png",
"image_output_1.png"
] | import pandas as pd
gatrain = pd.read_csv('../input/gender_age_train.csv')
gatest = pd.read_csv('../input/gender_age_test.csv')
gatrain.head(3) | code |
328147/cell_17 | [
"text_html_output_1.png"
] | from sklearn.cross_validation import KFold
from sklearn.metrics import log_loss
from sklearn.preprocessing import LabelEncoder
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
gatrain = pd.read_csv('../input/gender_age_train.csv')
gatest = pd.read_csv('../input/gender_age_test.csv')
letarget = LabelEncoder().fit(gatrain.group.values)
y = letarget.transform(gatrain.group.values)
n_classes = len(letarget.classes_)
phone = pd.read_csv('../input/phone_brand_device_model.csv', encoding='utf-8')
phone = phone.drop_duplicates('device_id', keep='first')
lebrand = LabelEncoder().fit(phone.phone_brand)
phone['brand'] = lebrand.transform(phone.phone_brand)
m = phone.phone_brand.str.cat(phone.device_model)
lemodel = LabelEncoder().fit(m)
phone['model'] = lemodel.transform(m)
train = gatrain.merge(phone[['device_id', 'brand', 'model']], how='left', on='device_id')
class GenderAgeGroupProb(object):
def __init__(self):
pass
def fit(self, df, by, n_smoothing, weights):
self.by = by
self.n_smoothing = n_smoothing
self.weights = np.divide(weights, sum(weights))
self.classes_ = sorted(df['group'].unique())
self.n_classes_ = len(self.classes_)
self.group_freq = df['group'].value_counts().sort_index() / df.shape[0]
self.prob_by = []
for i, b in enumerate(self.by):
c = df.groupby([b, 'group']).size().unstack().fillna(0)
total = c.sum(axis=1)
prob = c.add(self.n_smoothing[i] * self.group_freq).div(total + self.n_smoothing[i], axis=0)
self.prob_by.append(prob)
return self
def predict_proba(self, df):
pred = pd.DataFrame(np.zeros((len(df.index), self.n_classes_)), columns=self.classes_, index=df.index)
pred_by = []
for i, b in enumerate(self.by):
pred_by.append(df[[b]].merge(self.prob_by[i], how='left', left_on=b, right_index=True).fillna(self.group_freq)[self.classes_])
pred = pred.radd(pred_by[i].values * self.weights[i])
pred.loc[pred.iloc[:, 0].isnull(), :] = self.group_freq
return pred[self.classes_].values
def score(ptrain, by, n_smoothing, weights=[0.5, 0.5]):
kf = KFold(ptrain.shape[0], n_folds=10, shuffle=True, random_state=0)
pred = np.zeros((ptrain.shape[0], n_classes))
for itrain, itest in kf:
train = ptrain.iloc[itrain, :]
test = ptrain.iloc[itest, :]
ytrain, ytest = (y[itrain], y[itest])
clf = GenderAgeGroupProb().fit(train, by, n_smoothing, weights)
pred[itest, :] = clf.predict_proba(test)
return log_loss(y, pred)
n_smoothing = [1, 5, 10, 15, 20, 50, 100]
res = [score(train, ['brand', 'model'], [s, s], [0.5, 0.5]) for s in n_smoothing]
plt.plot(n_smoothing, res)
plt.title('Best score {:.5f} at n_smoothing = {}'.format(np.min(res), n_smoothing[np.argmin(res)]))
plt.xlabel('n_smoothing') | code |
128017162/cell_21 | [
"text_plain_output_1.png"
] | from tensorflow.keras.callbacks import ModelCheckpoint,EarlyStopping, Callback
from tensorflow.keras.layers import Dropout, Dense, Activation, Flatten, Conv2D, MaxPool2D, BatchNormalization
from tensorflow.keras.models import Sequential
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
import pandas as pd
train_dir = '/kaggle/input/hackerearth/dataset/Train Images'
test_dir = '/kaggle/input/hackerearth/dataset/Test Images'
train = pd.read_csv('/kaggle/input/hackerearth/dataset/train.csv')
num = len(train['Class'].unique())
datagen = ImageDataGenerator(rescale=1.0 / 255.0, validation_split=0.2)
train_it = datagen.flow_from_dataframe(train, directory=train_dir, x_col='Image', y_col='Class', target_size=(150, 150), class_mode='categorical', batch_size=32, subset='training', shuffle=True)
valid_it = datagen.flow_from_dataframe(train, directory=train_dir, x_col='Image', y_col='Class', target_size=(150, 150), class_mode='categorical', subset='validation', batch_size=32, shuffle=True)
model = Sequential()
model.add(Conv2D(16, kernel_size=(5, 5), activation='relu', input_shape=(150, 150, 3)))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(32, kernel_size=(5, 5), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(64, kernel_size=(5, 5), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(num, activation='softmax'))
model.summary()
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
class myCallback(Callback):
def on_epoch_end(self, epoch, logs={}):
if logs.get('accuracy') >= 0.98:
self.model.stop_training = True
callback = myCallback()
hist = model.fit(train_it, epochs=1500, validation_data=valid_it, callbacks=callback)
plt.figure()
plt.plot(hist.history['accuracy'], label='Train Accuracy', color='black')
plt.plot(hist.history['val_accuracy'], label='Validation Accuracy', color='mediumvioletred', linestyle='dashed', markeredgecolor='purple', markeredgewidth=2)
plt.title('Model Accuracy', color='darkred', size=13)
plt.legend()
plt.show() | code |
128017162/cell_9 | [
"text_plain_output_1.png"
] | import pandas as pd
train = pd.read_csv('/kaggle/input/hackerearth/dataset/train.csv')
train['Class'].value_counts() | code |
128017162/cell_25 | [
"text_plain_output_1.png"
] | from tensorflow.keras.callbacks import ModelCheckpoint,EarlyStopping, Callback
from tensorflow.keras.layers import Dropout, Dense, Activation, Flatten, Conv2D, MaxPool2D, BatchNormalization
from tensorflow.keras.models import Sequential
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import pandas as pd
train_dir = '/kaggle/input/hackerearth/dataset/Train Images'
test_dir = '/kaggle/input/hackerearth/dataset/Test Images'
train = pd.read_csv('/kaggle/input/hackerearth/dataset/train.csv')
test = pd.read_csv('/kaggle/input/hackerearth/dataset/test.csv')
num = len(train['Class'].unique())
datagen = ImageDataGenerator(rescale=1.0 / 255.0, validation_split=0.2)
train_it = datagen.flow_from_dataframe(train, directory=train_dir, x_col='Image', y_col='Class', target_size=(150, 150), class_mode='categorical', batch_size=32, subset='training', shuffle=True)
valid_it = datagen.flow_from_dataframe(train, directory=train_dir, x_col='Image', y_col='Class', target_size=(150, 150), class_mode='categorical', subset='validation', batch_size=32, shuffle=True)
model = Sequential()
model.add(Conv2D(16, kernel_size=(5, 5), activation='relu', input_shape=(150, 150, 3)))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(32, kernel_size=(5, 5), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(64, kernel_size=(5, 5), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(num, activation='softmax'))
model.summary()
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
class myCallback(Callback):
def on_epoch_end(self, epoch, logs={}):
if logs.get('accuracy') >= 0.98:
self.model.stop_training = True
callback = myCallback()
hist = model.fit(train_it, epochs=1500, validation_data=valid_it, callbacks=callback)
test_datagen = ImageDataGenerator(rescale=1.0 / 255.0)
SIZE = (150, 150, 3)
test_generator = test_datagen.flow_from_dataframe(test, directory=test_dir, x_col='Image', y_col=None, class_mode=None, target_size=(150, 150))
preds = model.predict(test_generator)
print(preds) | code |
128017162/cell_23 | [
"image_output_1.png"
] | from tensorflow.keras.preprocessing.image import ImageDataGenerator
import pandas as pd
train_dir = '/kaggle/input/hackerearth/dataset/Train Images'
test_dir = '/kaggle/input/hackerearth/dataset/Test Images'
train = pd.read_csv('/kaggle/input/hackerearth/dataset/train.csv')
test = pd.read_csv('/kaggle/input/hackerearth/dataset/test.csv')
test_datagen = ImageDataGenerator(rescale=1.0 / 255.0)
SIZE = (150, 150, 3)
test_generator = test_datagen.flow_from_dataframe(test, directory=test_dir, x_col='Image', y_col=None, class_mode=None, target_size=(150, 150)) | code |
128017162/cell_30 | [
"text_plain_output_1.png"
] | from tensorflow.keras.callbacks import ModelCheckpoint,EarlyStopping, Callback
from tensorflow.keras.layers import Dropout, Dense, Activation, Flatten, Conv2D, MaxPool2D, BatchNormalization
from tensorflow.keras.models import Sequential
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import numpy as np
import pandas as pd
train_dir = '/kaggle/input/hackerearth/dataset/Train Images'
test_dir = '/kaggle/input/hackerearth/dataset/Test Images'
train = pd.read_csv('/kaggle/input/hackerearth/dataset/train.csv')
test = pd.read_csv('/kaggle/input/hackerearth/dataset/test.csv')
num = len(train['Class'].unique())
datagen = ImageDataGenerator(rescale=1.0 / 255.0, validation_split=0.2)
train_it = datagen.flow_from_dataframe(train, directory=train_dir, x_col='Image', y_col='Class', target_size=(150, 150), class_mode='categorical', batch_size=32, subset='training', shuffle=True)
valid_it = datagen.flow_from_dataframe(train, directory=train_dir, x_col='Image', y_col='Class', target_size=(150, 150), class_mode='categorical', subset='validation', batch_size=32, shuffle=True)
model = Sequential()
model.add(Conv2D(16, kernel_size=(5, 5), activation='relu', input_shape=(150, 150, 3)))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(32, kernel_size=(5, 5), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(64, kernel_size=(5, 5), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(num, activation='softmax'))
model.summary()
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
class myCallback(Callback):
def on_epoch_end(self, epoch, logs={}):
if logs.get('accuracy') >= 0.98:
self.model.stop_training = True
callback = myCallback()
hist = model.fit(train_it, epochs=1500, validation_data=valid_it, callbacks=callback)
test_datagen = ImageDataGenerator(rescale=1.0 / 255.0)
SIZE = (150, 150, 3)
test_generator = test_datagen.flow_from_dataframe(test, directory=test_dir, x_col='Image', y_col=None, class_mode=None, target_size=(150, 150))
preds = model.predict(test_generator)
y_pred = [np.argmax(probas) for probas in preds]
y_p = set(y_pred)
y_p | code |
128017162/cell_33 | [
"text_plain_output_1.png"
] | import pandas as pd
train = pd.read_csv('/kaggle/input/hackerearth/dataset/train.csv')
test = pd.read_csv('/kaggle/input/hackerearth/dataset/test.csv')
preds_list = test['Image']
preds_list
preds_list | code |
128017162/cell_6 | [
"text_plain_output_1.png"
] | import pandas as pd
train = pd.read_csv('/kaggle/input/hackerearth/dataset/train.csv')
train.head(5) | code |
128017162/cell_11 | [
"text_html_output_1.png"
] | from tensorflow.keras.preprocessing.image import ImageDataGenerator
import pandas as pd
train_dir = '/kaggle/input/hackerearth/dataset/Train Images'
test_dir = '/kaggle/input/hackerearth/dataset/Test Images'
train = pd.read_csv('/kaggle/input/hackerearth/dataset/train.csv')
datagen = ImageDataGenerator(rescale=1.0 / 255.0, validation_split=0.2)
train_it = datagen.flow_from_dataframe(train, directory=train_dir, x_col='Image', y_col='Class', target_size=(150, 150), class_mode='categorical', batch_size=32, subset='training', shuffle=True)
valid_it = datagen.flow_from_dataframe(train, directory=train_dir, x_col='Image', y_col='Class', target_size=(150, 150), class_mode='categorical', subset='validation', batch_size=32, shuffle=True) | code |
128017162/cell_19 | [
"text_plain_output_1.png"
] | from tensorflow.keras.callbacks import ModelCheckpoint,EarlyStopping, Callback
from tensorflow.keras.layers import Dropout, Dense, Activation, Flatten, Conv2D, MaxPool2D, BatchNormalization
from tensorflow.keras.models import Sequential
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import pandas as pd
train_dir = '/kaggle/input/hackerearth/dataset/Train Images'
test_dir = '/kaggle/input/hackerearth/dataset/Test Images'
train = pd.read_csv('/kaggle/input/hackerearth/dataset/train.csv')
num = len(train['Class'].unique())
datagen = ImageDataGenerator(rescale=1.0 / 255.0, validation_split=0.2)
train_it = datagen.flow_from_dataframe(train, directory=train_dir, x_col='Image', y_col='Class', target_size=(150, 150), class_mode='categorical', batch_size=32, subset='training', shuffle=True)
valid_it = datagen.flow_from_dataframe(train, directory=train_dir, x_col='Image', y_col='Class', target_size=(150, 150), class_mode='categorical', subset='validation', batch_size=32, shuffle=True)
model = Sequential()
model.add(Conv2D(16, kernel_size=(5, 5), activation='relu', input_shape=(150, 150, 3)))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(32, kernel_size=(5, 5), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(64, kernel_size=(5, 5), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(num, activation='softmax'))
model.summary()
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
class myCallback(Callback):
def on_epoch_end(self, epoch, logs={}):
if logs.get('accuracy') >= 0.98:
self.model.stop_training = True
callback = myCallback()
hist = model.fit(train_it, epochs=1500, validation_data=valid_it, callbacks=callback) | code |
128017162/cell_1 | [
"text_plain_output_1.png"
] | # !pip install seaborn
# !pip install tensorflow
# !pip install keras
# # !pip install sklearn
!pip install visualkeras
# !pip install pydot
# !pip install opencv-python
# !pip install numpy
# !pip install pandas
# !pip install matplotlib
# !pip install tensorflow
# !pip install keras | code |
128017162/cell_7 | [
"text_html_output_1.png"
] | import pandas as pd
train = pd.read_csv('/kaggle/input/hackerearth/dataset/train.csv')
test = pd.read_csv('/kaggle/input/hackerearth/dataset/test.csv')
test.head(5) | code |
128017162/cell_32 | [
"text_plain_output_1.png"
] | import pandas as pd
train = pd.read_csv('/kaggle/input/hackerearth/dataset/train.csv')
test = pd.read_csv('/kaggle/input/hackerearth/dataset/test.csv')
test | code |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.