class LogitReg(Classifier):
    def __init__(self, parameters={}):
        # Default: no regularization
        self.params = {'regwgt': 0.0, 'regularizer': 'None'}
        self.reset(parameters)
        self.transfer=utils.sigmoid
        self.dtransfer = utils.dsigmoid
    def reset(self, parameters):
        self.resetparams(parameters)
        self.weights = None
        if self.params['regularizer'] is 'l1':
            self.regularizer = (utils.l1, utils.dl1)
        elif self.params['regularizer'] is 'l2':
            self.regularizer = (utils.l2, utils.dl2)
        else:
            self.regularizer = (lambda w: 0, lambda w: np.zeros(w.shape,))


    def logit_cost(self, theta, X, y):
        """
        Compute cost for logistic regression using theta as the parameters.
        """
        cost=0.0
        ### YOUR CODE HERE
        h =self.transfer(np.dot(X, theta.T))
        cost =-np.dot(y,np.log(h))-np.dot((1-y),np.log(1-h))+self.params['regwgt']*self.regularizer[0](self.weights)
        ### END YOUR CODE
        return cost

    def logit_cost_grad(self, theta, X, y):
        """
        Compute gradients of the cost with respect to theta.
        """
        grad = np.zeros(len(theta))

        ### YOUR CODE HERE
        theta = np.array(theta, ndmin=2)
        h = self.transfer(np.dot(X, theta.T))
        ll = -1 * (y / h) + (1 - y) / (1 - h)
        result=ll*self.dtransfer(np.dot(X, theta.T))+self.params['regwgt']*self.regularizer[1](self.weights)
        ### END YOUR CODE
        return result

    def learn(self, Xtrain, ytrain):
        """
        Learn the weights using the training data
        """
        ### YOUR CODE HERE
        self.weights = np.zeros(Xtrain.shape[1], )
        stepsize = 0.05
        epoch = 1000
        w = np.zeros(Xtrain.shape[1])
        y=np.array(ytrain,ndmin=2)
        data=np.concatenate((Xtrain, y.T), axis=1)
        for i in range(epoch):
            np.random.shuffle(data)
            for j in range(Xtrain.shape[0]):
                X=np.array(data[j][0:-1],ndmin=2)
                Y=np.array(data[j][-1])
                w = w - (stepsize / (i + 1)) * self.logit_cost_grad(w,X,Y)*X
        self.weights = w


        ### END YOUR CODE

    def predict(self, Xtest):
        """
        Use the parameters computed in self.learn to give predictions on new
        observations.
        """
        ytest = np.zeros(Xtest.shape[0], dtype=int)

        ### YOUR CODE HERE
        for i in range(Xtest.shape[0]):

            p_y1 = self.transfer(np.dot(self.weights, Xtest[i].T))
            if p_y1 >= 0.5:
                ytest[i] = 1

        ### END YOUR CODE

        assert len(ytest) == Xtest.shape[0]
        return ytest