No module named 'common_utils'

[tomron]

Hello,

I work on mac os and try to run the LFR demo. I created a conda environment as in the README and install using pip the entire package( pip install 'aif360[all]' ).

When I run the first cell in the notebook I get the error No module named 'common_utils'. This script exists in the examples directory (here) but is not imported correctly.

[kalikhademi]

I have the same problem after installing aif360 using [all] command. Do you find any solution for this?

[hoffmansc]

Did you clone the full repo from GitHub or just download the single demo notebook file? In the readme we recommend cloning and installing with pip install -e '.[all]' so the examples are included with all the necessary files. The examples aren't included in the package on PyPI.

[kalikhademi]

I installed it using same command (pip install 'aif360[all]'). I also downloaded the repo folder for aif360 and put it in the same directory but the error "No module named "common_utils" is still there.

Thanks,

[gizemsogancioglu]

I also have the same problem although I did the setup as you suggested in the README.

[bdubbs09]

Has anyone found a solution to this? I'm still getting the same error.

[bertainsikt]

I have the same issue, I've done %pip install common_utils in the notebook, but I still get the error :
ModuleNotFoundError: No module named 'common_utils'
Is there any solution?

[che2198]

I have the same issue, I've done %pip install common_utils in the notebook, but I still get the error :
ModuleNotFoundError: No module named 'common_utils'
Is there any solution?

[lgoetz]

there's a compute_metrics here: https://github.com/Trusted-AI/AIF360/blob/746e763191ef46ba3ab5c601b96ce3f6dcb772fd/examples/common_utils.py which seems not to have been merged. A quick fix would be to copy that to e.g. aif360.metrics.classification_metric

[rahuloliver]

I have the same issue as well.
ModuleNotFoundError: No module named 'common_utils'
Is there any solution to this?

[UsamaShahzad7]

Make a lab_utils_common.py file with the following code and place it where you have your project or jupyter notebook file:

"""
lab_utils_common
contains common routines and variable definitions
used by all the labs in this week.
by contrast, specific, large plotting routines will be in separate files
and are generally imported into the week where they are used.
those files will import this file
"""
import copy
import math
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrowPatch
from ipywidgets import Output
from matplotlib.widgets import Button, CheckButtons

np.set_printoptions(precision=2)

dlc = dict(dlblue = '#0096ff', dlorange = '#FF9300', dldarkred='#C00000', dlmagenta='#FF40FF', dlpurple='#7030A0', dldarkblue = '#0D5BDC')
dlblue = '#0096ff'; dlorange = '#FF9300'; dldarkred='#C00000'; dlmagenta='#FF40FF'; dlpurple='#7030A0'; dldarkblue = '#0D5BDC'
dlcolors = [dlblue, dlorange, dldarkred, dlmagenta, dlpurple]
plt.style.use('./deeplearning.mplstyle')

def sigmoid(z):
"""
Compute the sigmoid of z

Parameters
----------
z : array_like
    A scalar or numpy array of any size.

Returns
-------
 g : array_like
     sigmoid(z)
"""
z = np.clip( z, -500, 500 )           # protect against overflow
g = 1.0/(1.0+np.exp(-z))

return g

##########################################################

Regression Routines

##########################################################

def predict_logistic(X, w, b):
""" performs prediction """
return sigmoid(X @ w + b)

def predict_linear(X, w, b):
""" performs prediction """
return X @ w + b

def compute_cost_logistic(X, y, w, b, lambda_=0, safe=False):
"""
Computes cost using logistic loss, non-matrix version

Args:
  X (ndarray): Shape (m,n)  matrix of examples with n features
  y (ndarray): Shape (m,)   target values
  w (ndarray): Shape (n,)   parameters for prediction
  b (scalar):               parameter  for prediction
  lambda_ : (scalar, float) Controls amount of regularization, 0 = no regularization
  safe : (boolean)          True-selects under/overflow safe algorithm
Returns:
  cost (scalar): cost
"""

m,n = X.shape
cost = 0.0
for i in range(m):
    z_i    = np.dot(X[i],w) + b                                             #(n,)(n,) or (n,) ()
    if safe:  #avoids overflows
        cost += -(y[i] * z_i ) + log_1pexp(z_i)
    else:
        f_wb_i = sigmoid(z_i)                                                   #(n,)
        cost  += -y[i] * np.log(f_wb_i) - (1 - y[i]) * np.log(1 - f_wb_i)       # scalar
cost = cost/m

reg_cost = 0
if lambda_ != 0:
    for j in range(n):
        reg_cost += (w[j]**2)                                               # scalar
    reg_cost = (lambda_/(2*m))*reg_cost

return cost + reg_cost

def log_1pexp(x, maximum=20):
''' approximate log(1+exp^x)
https://stats.stackexchange.com/questions/475589/numerical-computation-of-cross-entropy-in-practice
Args:
x : (ndarray Shape (n,1) or (n,) input
out : (ndarray Shape matches x output ~= np.log(1+exp(x))
'''

out  = np.zeros_like(x,dtype=float)
i    = x <= maximum
ni   = np.logical_not(i)

out[i]  = np.log(1 + np.exp(x[i]))
out[ni] = x[ni]
return out

def compute_cost_matrix(X, y, w, b, logistic=False, lambda_=0, safe=True):
"""
Computes the cost using using matrices
Args:
X : (ndarray, Shape (m,n)) matrix of examples
y : (ndarray Shape (m,) or (m,1)) target value of each example
w : (ndarray Shape (n,) or (n,1)) Values of parameter(s) of the model
b : (scalar ) Values of parameter of the model
verbose : (Boolean) If true, print out intermediate value f_wb
Returns:
total_cost: (scalar) cost
"""
m = X.shape[0]
y = y.reshape(-1,1) # ensure 2D
w = w.reshape(-1,1) # ensure 2D
if logistic:
if safe: #safe from overflow
z = X @ w + b #(m,n)(n,1)=(m,1)
cost = -(y * z) + log_1pexp(z)
cost = np.sum(cost)/m # (scalar)
else:
f = sigmoid(X @ w + b) # (m,n)(n,1) = (m,1)
cost = (1/m)(np.dot(-y.T, np.log(f)) - np.dot((1-y).T, np.log(1-f))) # (1,m)(m,1) = (1,1)
cost = cost[0,0] # scalar
else:
f = X @ w + b # (m,n)(n,1) = (m,1)
cost = (1/(2m)) * np.sum((f - y)**2) # scalar

reg_cost = (lambda_/(2*m)) * np.sum(w**2)                                   # scalar

total_cost = cost + reg_cost                                                # scalar

return total_cost                                                           # scalar

def compute_gradient_matrix(X, y, w, b, logistic=False, lambda_=0):
"""
Computes the gradient using matrices

Args:
  X : (ndarray, Shape (m,n))          matrix of examples
  y : (ndarray  Shape (m,) or (m,1))  target value of each example
  w : (ndarray  Shape (n,) or (n,1))  Values of parameters of the model
  b : (scalar )                       Values of parameter of the model
  logistic: (boolean)                 linear if false, logistic if true
  lambda_:  (float)                   applies regularization if non-zero
Returns
  dj_dw: (array_like Shape (n,1))     The gradient of the cost w.r.t. the parameters w
  dj_db: (scalar)                     The gradient of the cost w.r.t. the parameter b
"""
m = X.shape[0]
y = y.reshape(-1,1)             # ensure 2D
w = w.reshape(-1,1)             # ensure 2D

f_wb  = sigmoid( X @ w + b ) if logistic else  X @ w + b      # (m,n)(n,1) = (m,1)
err   = f_wb - y                                              # (m,1)
dj_dw = (1/m) * (X.T @ err)                                   # (n,m)(m,1) = (n,1)
dj_db = (1/m) * np.sum(err)                                   # scalar

dj_dw += (lambda_/m) * w        # regularize                  # (n,1)

return dj_db, dj_dw                                           # scalar, (n,1)

def gradient_descent(X, y, w_in, b_in, alpha, num_iters, logistic=False, lambda_=0, verbose=True, Trace=True):
"""
Performs batch gradient descent to learn theta. Updates theta by taking
num_iters gradient steps with learning rate alpha

Args:
  X (ndarray):    Shape (m,n)         matrix of examples
  y (ndarray):    Shape (m,) or (m,1) target value of each example
  w_in (ndarray): Shape (n,) or (n,1) Initial values of parameters of the model
  b_in (scalar):                      Initial value of parameter of the model
  logistic: (boolean)                 linear if false, logistic if true
  lambda_:  (float)                   applies regularization if non-zero
  alpha (float):                      Learning rate
  num_iters (int):                    number of iterations to run gradient descent

Returns:
  w (ndarray): Shape (n,) or (n,1)    Updated values of parameters; matches incoming shape
  b (scalar):                         Updated value of parameter
"""
# An array to store cost J and w's at each iteration primarily for graphing later
J_history = []
w = copy.deepcopy(w_in)  #avoid modifying global w within function
b = b_in
w = w.reshape(-1,1)      #prep for matrix operations
y = y.reshape(-1,1)
last_cost = np.Inf

for i in range(num_iters):

    # Calculate the gradient and update the parameters
    dj_db,dj_dw = compute_gradient_matrix(X, y, w, b, logistic, lambda_)

    # Update Parameters using w, b, alpha and gradient
    w = w - alpha * dj_dw
    b = b - alpha * dj_db

    # Save cost J at each iteration
    ccost = compute_cost_matrix(X, y, w, b, logistic, lambda_)
    if Trace and i<100000:      # prevent resource exhaustion
        J_history.append( ccost )

    # Print cost every at intervals 10 times or as many iterations if < 10
    if i% math.ceil(num_iters / 10) == 0:
        if verbose: print(f"Iteration {i:4d}: Cost {ccost}   ")
        if verbose ==2: print(f"dj_db, dj_dw = {dj_db: 0.3f}, {dj_dw.reshape(-1)}")

        if ccost == last_cost:
            alpha = alpha/10
            print(f" alpha now {alpha}")
        last_cost = ccost

return w.reshape(w_in.shape), b, J_history  #return final w,b and J history for graphing

def zscore_normalize_features(X):
"""
computes X, zcore normalized by column

Args:
  X (ndarray): Shape (m,n) input data, m examples, n features

Returns:
  X_norm (ndarray): Shape (m,n)  input normalized by column
  mu (ndarray):     Shape (n,)   mean of each feature
  sigma (ndarray):  Shape (n,)   standard deviation of each feature
"""
# find the mean of each column/feature
mu     = np.mean(X, axis=0)                 # mu will have shape (n,)
# find the standard deviation of each column/feature
sigma  = np.std(X, axis=0)                  # sigma will have shape (n,)
# element-wise, subtract mu for that column from each example, divide by std for that column
X_norm = (X - mu) / sigma

return X_norm, mu, sigma

#check our work
#from sklearn.preprocessing import scale
#scale(X_orig, axis=0, with_mean=True, with_std=True, copy=True)

######################################################

Common Plotting Routines

######################################################

def plot_data(X, y, ax, pos_label="y=1", neg_label="y=0", s=80, loc='best' ):
""" plots logistic data with two axis """
# Find Indices of Positive and Negative Examples
pos = y == 1
neg = y == 0
pos = pos.reshape(-1,) #work with 1D or 1D y vectors
neg = neg.reshape(-1,)

# Plot examples
ax.scatter(X[pos, 0], X[pos, 1], marker='x', s=s, c = 'red', label=pos_label)
ax.scatter(X[neg, 0], X[neg, 1], marker='o', s=s, label=neg_label, facecolors='none', edgecolors=dlblue, lw=3)
ax.legend(loc=loc)

ax.figure.canvas.toolbar_visible = False
ax.figure.canvas.header_visible = False
ax.figure.canvas.footer_visible = False

def plt_tumor_data(x, y, ax):
""" plots tumor data on one axis """
pos = y == 1
neg = y == 0

ax.scatter(x[pos], y[pos], marker='x', s=80, c = 'red', label="malignant")
ax.scatter(x[neg], y[neg], marker='o', s=100, label="benign", facecolors='none', edgecolors=dlblue,lw=3)
ax.set_ylim(-0.175,1.1)
ax.set_ylabel('y')
ax.set_xlabel('Tumor Size')
ax.set_title("Logistic Regression on Categorical Data")

ax.figure.canvas.toolbar_visible = False
ax.figure.canvas.header_visible = False
ax.figure.canvas.footer_visible = False

Draws a threshold at 0.5

def draw_vthresh(ax,x):
""" draws a threshold """
ylim = ax.get_ylim()
xlim = ax.get_xlim()
ax.fill_between([xlim[0], x], [ylim[1], ylim[1]], alpha=0.2, color=dlblue)
ax.fill_between([x, xlim[1]], [ylim[1], ylim[1]], alpha=0.2, color=dldarkred)
ax.annotate("z >= 0", xy= [x,0.5], xycoords='data',
xytext=[30,5],textcoords='offset points')
d = FancyArrowPatch(
posA=(x, 0.5), posB=(x+3, 0.5), color=dldarkred,
arrowstyle='simple, head_width=5, head_length=10, tail_width=0.0',
)
ax.add_artist(d)
ax.annotate("z < 0", xy= [x,0.5], xycoords='data',
xytext=[-50,5],textcoords='offset points', ha='left')
f = FancyArrowPatch(
posA=(x, 0.5), posB=(x-3, 0.5), color=dlblue,
arrowstyle='simple, head_width=5, head_length=10, tail_width=0.0',
)
ax.add_artist(f)

#-----------------------------------------------------

common interactive plotting routines

#-----------------------------------------------------

class button_manager:
''' Handles some missing features of matplotlib check buttons
on init:
creates button, links to button_click routine,
calls call_on_click with active index and firsttime=True
on click:
maintains single button on state, calls call_on_click
'''

#@output.capture()  # debug
def __init__(self,fig, dim, labels, init, call_on_click):
    '''
    dim: (list)     [leftbottom_x,bottom_y,width,height]
    labels: (list)  for example ['1','2','3','4','5','6']
    init: (list)    for example [True, False, False, False, False, False]
    '''
    self.fig = fig
    self.ax = plt.axes(dim)  #lx,by,w,h
    self.init_state = init
    self.call_on_click = call_on_click
    self.button  = CheckButtons(self.ax,labels,init)
    self.button.on_clicked(self.button_click)
    self.status = self.button.get_status()
    self.call_on_click(self.status.index(True),firsttime=True)

#@output.capture()  # debug
def reinit(self):
    self.status = self.init_state
    self.button.set_active(self.status.index(True))      #turn off old, will trigger update and set to status

#@output.capture()  # debug
def button_click(self, event):
    ''' maintains one-on state. If on-button is clicked, will process correctly '''
    #new_status = self.button.get_status()
    #new = [self.status[i] ^ new_status[i] for i in range(len(self.status))]
    #newidx = new.index(True)
    self.button.eventson = False
    self.button.set_active(self.status.index(True))  #turn off old or reenable if same
    self.button.eventson = True
    self.status = self.button.get_status()
    self.call_on_click(self.status.index(True))