# Error while doing Gaussian Naive Bayes in Jupyter Notebook

I am currently doing “Intro to Machine Learning” free course in udacity, where there’s a quiz regarding Gaussian Naive Bayes. The code is giving desired output when running in the udacity environment(as shown in image below) Code output in udacity environment

But it is showing error when I run it in jupyter notebook, for module class_vis.py it’s showing error ‘NoneType’ object has no attribute ‘predict'(as shown in image below) Error in jupyter notebook

Here are the codes for all modules :-

1. studentMain.py
```    Naive Bayes classifier to classify the terrain data.

The objective of this exercise is to recreate the decision
boundary found in the lesson video, and make a plot that
visually shows the decision boundary """

from prep_terrain_data import makeTerrainData
from class_vis import prettyPicture, output_image
from ClassifyNB import classify

import numpy as np
import pylab as pl

features_train, labels_train, features_test, labels_test = makeTerrainData()

### the training data (features_train, labels_train) have both "fast" and "slow" points mixed
### in together--separate them so we can give them different colors in the scatterplot,
### and visually identify them
grade_fast = [features_train[ii] for ii in range(0, len(features_train)) if labels_train[ii]==0]
bumpy_fast = [features_train[ii] for ii in range(0, len(features_train)) if labels_train[ii]==0]
grade_slow = [features_train[ii] for ii in range(0, len(features_train)) if labels_train[ii]==1]
bumpy_slow = [features_train[ii] for ii in range(0, len(features_train)) if labels_train[ii]==1]

# You will need to complete this function imported from the ClassifyNB script.
# Be sure to change to that code tab to complete this quiz.
clf = classify(features_train, labels_train)
### draw the decision boundary with the text points overlaid
prettyPicture(clf, features_test, labels_test)
```
1. class_vis.py
```#from udacityplots import *
import warnings
warnings.filterwarnings("ignore")

import matplotlib
matplotlib.use('agg')

import matplotlib.pyplot as plt
import pylab as pl
import numpy as np

#import numpy as np
#import matplotlib.pyplot as plt
#plt.ioff()

def prettyPicture(clf, X_test, y_test):
x_min = 0.0; x_max = 1.0
y_min = 0.0; y_max = 1.0

# Plot the decision boundary. For that, we will assign a color to each
# point in the mesh [x_min, m_max]x[y_min, y_max].
h = .01  # step size in the mesh
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])

# Put the result into a color plot
Z = Z.reshape(xx.shape)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())

plt.pcolormesh(xx, yy, Z, cmap=pl.cm.seismic)

# Plot also the test points
grade_sig = [X_test[ii] for ii in range(0, len(X_test)) if y_test[ii]==0]
bumpy_sig = [X_test[ii] for ii in range(0, len(X_test)) if y_test[ii]==0]
grade_bkg = [X_test[ii] for ii in range(0, len(X_test)) if y_test[ii]==1]
bumpy_bkg = [X_test[ii] for ii in range(0, len(X_test)) if y_test[ii]==1]

plt.scatter(grade_sig, bumpy_sig, color = "b", label="fast")
plt.scatter(grade_bkg, bumpy_bkg, color = "r", label="slow")
plt.legend()
plt.xlabel("bumpiness")

plt.savefig("test.png")

import base64
import json
import subprocess

def output_image(name, format, bytes):
image_start = "BEGIN_IMAGE_f9825uweof8jw9fj4r8"
image_end = "END_IMAGE_0238jfw08fjsiufhw8frs"
data = {}
data['name'] = name
data['format'] = format
data['bytes'] = base64.encodestring(bytes)
print (image_start+json.dumps(data)+image_end)
```
1. prep_terrain_data.py
```#!/usr/bin/python
import random

def makeTerrainData(n_points=1000):
###############################################################################
### make the toy dataset
random.seed(42)
grade = [random.random() for ii in range(0,n_points)]
bumpy = [random.random() for ii in range(0,n_points)]
error = [random.random() for ii in range(0,n_points)]
y = [round(grade[ii]*bumpy[ii]+0.3+0.1*error[ii]) for ii in range(0,n_points)]
for ii in range(0, len(y)):
y[ii] = 1.0

### split into train/test sets
X = [[gg, ss] for gg, ss in zip(grade, bumpy)]
split = int(0.75*n_points)
X_train = X[0:split]
X_test  = X[split:]
y_train = y[0:split]
y_test  = y[split:]

grade_sig = [X_train[ii] for ii in range(0, len(X_train)) if y_train[ii]==0]
bumpy_sig = [X_train[ii] for ii in range(0, len(X_train)) if y_train[ii]==0]
grade_bkg = [X_train[ii] for ii in range(0, len(X_train)) if y_train[ii]==1]
bumpy_bkg = [X_train[ii] for ii in range(0, len(X_train)) if y_train[ii]==1]

grade_sig = [X_test[ii] for ii in range(0, len(X_test)) if y_test[ii]==0]
bumpy_sig = [X_test[ii] for ii in range(0, len(X_test)) if y_test[ii]==0]
grade_bkg = [X_test[ii] for ii in range(0, len(X_test)) if y_test[ii]==1]
bumpy_bkg = [X_test[ii] for ii in range(0, len(X_test)) if y_test[ii]==1]

return X_train, y_train, X_test, y_test
#    return training_data, test_data
```
1. ClassifyNB.py
```#ClassifyNB.py
def classify(features_train, labels_train):
### import the sklearn module for GaussianNB
### create classifier
### fit the classifier on the training features and labels
### return the fit classifier

from sklearn.naive_bayes import GaussianNB
clf = GaussianNB()
clf.fit(features_train,labels_train)
```

As far as I see your classify function doesn’t return anything, yet you assign it’s return value to a variable which will set it to `None` according to python standards. To fix this insert a return statement at the classify function:

```def classify(features_train, labels_train):
### import the sklearn module for GaussianNB
### create classifier
### fit the classifier on the training features and labels
### return the fit classifier