opt_utils.cpython-36.pyc

3

X�]/�@s�dd
lZ
dd
ljZdd
lZdd
lZdd
lZdd
l	Zdd�Z
dd�Zddd�
Zd	d
�Z
dd�Zd
d�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd
S)�Nc
Csd
d
tj
|�
}
|
S)z�
    Compute the sigmoid of x

    Arguments:
    x -- A scalar or numpy array of any size.

    Return:
    s -- sigmoid(x)
    �
)�np�exp)�
x�
s�r�$/home/jovyan/work/week6/opt_utils.py�sigmoids

r	c
Cstj
d
|�}
|
S)z{
    Compute the relu of x

    Arguments:
    x -- A scalar or numpy array of any size.

    Return:
    s -- relu(x)
    r
)r�maximum)rrrrr�relus
rrc
	Cs�tj
j|�

tj
jd
d�}
tj
jd
d�}tj
jdd�}tj
jdd�}tj
jd
d�}tj
jd
d�}tj
jdd�}tj
jdd�}|
|||||||fS)N��r)r�random�seed�randn)	r�W1�b1�W2�b2�dW1�db1�dW2�db2rrr�load_params_and_grads#s







rc
Cs�tj
jd
�

i}
t|�
}x�td|�D]�}tj
j||||d�tjd||d�
|
dt|�
<tj||df�
|
dt|�
<|
dt|�
j	||k||dfs�t
�
|
dt|�
j	||kdfs$t
�
q$W|
S)ab
    Arguments:
    layer_dims -- python array (list) containing the dimensions of each layer in our network
    
    Returns:
    parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                    W1 -- weight matrix of shape (layer_dims[l], layer_dims[l-1])
                    b1 -- bias vector of shape (layer_dims[l], 1)
                    Wl -- weight matrix of shape (layer_dims[l-1], layer_dims[l])
                    bl -- bias vector of shape (1, layer_dims[l])
                    
    Tips:
    - For example: the layer_dims for the "Planar Data classification model" would have been [2,2,1]. 
    This means W1's shape was (2,2), b1 was (1,2), W2 was (2,1) and b2 was (1,1). Now you have to generalize it!
    - In the for loop, use parameters['W' + str(l)] to access Wl, where l is the iterative integer.
    r
rr�
W�
b)rrr�len�ranger�sqrt�str�zeros�shape�AssertionError)Z
layer_dims�
parameters�
L�
lrrr�initialize_parameters2s


<
*
&r&cCsP|
jd
}t
jt
j|�
|
�t
jt
jd
|�
d
|
�}d|t
j|�
}|S)z�
    Implement the cost function
    
    Arguments:
    a3 -- post-activation, output of forward propagation
    Y -- "true" labels vector, same shape as a3
    
    Returns:
    cost - value of the cost function
    rg�?)r!r�multiply�log�sum)�a3�
Y�
mZlogprobs�costrrr�compute_costRs
0
r.cCs�|
d
}|
d}|
d}|
d}|
d}|
d}tj
||�|}t|�
}	tj
||	�|}
t|
�
}tj
||�|}t|�
}
||	|||
|||||
||f}|
|fS)a�
    Implements the forward propagation (and computes the loss) presented in Figure 2.
    
    Arguments:
    X -- input dataset, of shape (input size, number of examples)
    parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3":
                    W1 -- weight matrix of shape ()
                    b1 -- bias vector of shape ()
                    W2 -- weight matrix of shape ()
                    b2 -- bias vector of shape ()
                    W3 -- weight matrix of shape ()
                    b3 -- bias vector of shape ()
    
    Returns:
    loss -- the loss function (vanilla logistic loss)
    rrrr�W3�b3)r�dotrr	)�
Xr#rrrrr/r0�z1�a1�z2�a2�z3r*�cacherrr�forward_propagationes









r9cCs�|jd
}|\}}}}}}	}
}}}
}}d||
|
}t
j||	j�}t
j|d
dd�}t
j|j|�}t
j|t
j|	dk�
�}t
j||j�}t
j|d
dd�}t
j|
j|�}t
j|t
j|dk�
�}t
j||j�}t
j|d
dd�}|||||||||||d�}|S)a�

    Implement the backward propagation presented in figure 2.
    
    Arguments:
    X -- input dataset, of shape (input size, number of examples)
    Y -- true "label" vector (containing 0 if cat, 1 if non-cat)
    cache -- cache output from forward_propagation()
    
    Returns:
    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables
    rg�?T)�axis�keepdimsr
)�dz3�dW3�db3�da2�dz2rr�da1�dz1rr)r!rr1�
Tr)r'�int64)r2r+r8r,r3r4rrr5r6rrr7r*r/r0r<r=r>r?r@rrrArBrrZ	gradientsrrr�backward_propagation�s"











rEc	Cs�|jd
}t
jd
|ft
jd�}t||�\}}xBtd|jd
�D].}|d|fdkr`d
|d|f<q>d|d|f<q>Wtdtt
j|ddd�f|
ddd�fk�
�
�

|S)a

    This function is used to predict the results of a  n-layer neural network.
    
    Arguments:
    X -- data set of examples you would like to label
    parameters -- parameters of the trained model
    
    Returns:
    p -- predictions for the given dataset X
    r)
�dtyper
g�?z
Accuracy: N)	r!rr �intr9r�printr�mean)r2�
yr#r,�
pr*Zcaches�
irrr�predict�s



2rMcCsptj
jd
�
}|dj}
|dj}|dj}|dj}tj|
ddd�f|
ddd�f|dtjjd	�
|
|||fS)
Nzdatasets/data.matr2rJ�Xval�yvalr
r�()�
cr�cmap)�scipy�io�loadmatrC�plt�scatter�cm�Spectral)�data�train_X�train_YZtest_XZtest_Yrrr�load_2D_dataset�s








0r]cCs
|
d
dd�fj�d|
d
dd�fj
�d}}|
ddd�fj�d|
ddd�fj
�d}}d}tjtj|||�tj|||��\}}	|tj|j�|	j�f�
}
|
j|j�
}
t	j
||	|
t	jjd�
t	j
d�

t	jd�

t	j|
d
dd�f|
ddd�f|t	jjd�
t	j�
dS)Nr
rg{�G�z�?)
rR�x2�x1)rQrR)�min�maxr�meshgrid�arange�c_�ravel�reshaper!rV�contourfrXrY�ylabel�xlabelrW�show)�modelr2rJ�x_min�x_max�y_min�y_max�
h�xx�yy�
Zrrr�plot_decision_boundary�s2
2
$





.
rtcCst|
|�\}}|d
k}|S)z�
    Used for plotting decision boundary.
    
    Arguments:
    parameters -- python dictionary containing your parameters 
    X -- input data of size (m, K)
    
    Returns
    predictions -- vector of predictions of our model (red: 0 / blue: 1)
    g�?)
r9)r#r2r*r8�predictionsrrr�predict_dec�s


rvcCsrtj
jd
�

tjjddd�\}}
tj|dd�df|dd�df|
dtjj	d�
|j
}|
jd|
jdf�
}
||
fS)	Nr
i,
g�������?)�	n_samples�noiser
rrP)rQrrR)
rrr�sklearn�datasets�
make_moonsrVrWrXrYrCrfr!)r[r\rrr�load_dataset�s

0

r|)
r)�numpyr�matplotlib.pyplot�pyplotrVZh5py�scipy.iorSry�sklearn.datasetsr	rrr&r.r9rErMr]rtrvr|rrrr�<module>
s"







 &#!