Проблемы с самостоятельно реализованной логистической регрессией

Я пытаюсь самостоятельно реализовать алгоритм логистической регрессии для самообучения, но у меня возникают некоторые проблемы с достижением аналогичной точности, как у логистической регрессии из sklearn.

Вот код, который я использую (набор данных, который я использую, это набор данных ‘training.csv’ по Титаник из Kaggle, который вы можете скачать здесь, если хотите протестировать это самостоятельно).

import numpy as np
import random
import matplotlib.pyplot as plt
#%matplotlib inline

def cost(X, Y, W):
    """
    x = матрица признаков
    y = вектор истинных меток
    w = вектор весов
    """
    m = len(Y)
    if isinstance(Y, list):
        Y = np.array(Y)
    return -(1/m) * np.sum([Y*np.log(sigmoid(W, X)), (1-Y)*np.log(1-sigmoid(W, X))])

def sigmoid(w, x):
    """Гипотетическая функция логистической регрессии.

    w = вектор весов
    x = вектор признаков
    """

    z = np.dot(w.T, x)
    return 1 / (1 + np.exp(-z))

def grad_descent(A, w, y, 
                 lr = 0.01, 
                 stochastic = False, 
                 max_iter = 1000, 
                 mute = True, 
                 plot = True):
    """
    A = дизайн матрица
    w = вектор весов
    y = истинная метка
    lr = скорость обучения
    stochastic = использовать ли стохастический градиентный спуск
    max_iter = максимальное количество эпох для обучения
    mute = выводить ли текущую эпоху на экран
    plot = строить ли график функции потерь после завершения обучения
    """
    if not isinstance(A, np.ndarray):
        m = "A должно быть numpy массивом, получено %s"
        raise TypeError(m % type(A).__name__)

    if isinstance(y, list):
        y = np.array(y)
        y = y.T
        y = np.expand_dims(y, axis = 1)
    if isinstance(w, list):
        w = np.array(w)
        # Сделать w столбцовым вектором
        w.shape = (A.shape[1], 1)

    losses = []
    i = 0

    while i < max_iter:
        old_weights = w
        # создать/обновить вектор alpha
        alpha = [sigmoid(w, A[i, :]) for i in range(A.shape[0])]
        if not mute:
            print("Эпоха %d" % (i+1))

        if stochastic:
            # стохастический градиентный спуск выбирает точку обучения случайным образом
            # здесь мы выбираем случайную строку из матрицы A
            rand = random.randint(0, A.shape[0]-1)
            # выбираем случайные значения
            temp_A = A[rand].T
            temp_A = temp_A.reshape(A.shape[1], 1)
            temp_b = alpha[rand] - y[rand]

            # Расчет градиента
            grad = np.dot(temp_A, (temp_b))
            # Обновление весов
            w = (w.T - (lr * grad)).T

        # выполнить пакетный градиентный спуск
        else:
            # количество образцов
            m = len(y)
            # Расчет градиента
            grad = (1/m) * np.dot(A.T, (alpha - y))
            # Обновление весов
            w = w - (lr * grad)

        if i != 0:
            # если потеря начинает увеличиваться, тогда остановись
            if cost(A.T, y, w) > losses[-1]:
                print("Остановка на эпохе %d" % i)
                if plot:
                    print('Потери')
                    plt.plot(losses)
                return old_weights

                break

        # Отслеживание значения функции потерь
        losses.append(cost(A.T, y, w))

        # увеличиваем счетчик эпох
        i += 1

    print("Остановка на эпохе %d" % i)
    if plot:
        print('Потери')
        plt.plot(losses)

    return w

#############################################################################
#############################################################################
#############################################################################
if __name__ == "__main__":

    import pandas as pd

    train = pd.read_csv(r'C:\Users\LENOVO\Documents\Self_Study\titanic\train.csv')

    # преобразуем столбец Sex в нули и единицы
    train['Sex'] = train['Sex'].map({'female': 1, 'male': 0})

    # В столбце fare есть нулевые значения, заменим их на более вероятное значение
    rows = np.where(train.Fare == np.min(train.Fare))
    # присваиваем среднее значение стоимости для данного класса
    class_ = train.iloc[rows[0], 2].values

    for clas, row in zip(class_, rows[0]):

        # находим среднее
        Pclass = train.loc[(train['Pclass'] == clas)]
        c_mean = np.mean(Pclass['Fare'])
        # присваиваем значение правильной строке
        train.iloc[row, 9] = c_mean

    train.head()

    # задаем скорость обучения
    lr = 0.01

    sexes = train.Sex
    fares = train.Fare

    # масштабируем значение fare, деля на максимальное значение, чтобы получить диапазон от 0 до 1
    fares = fares/np.max(fares)

    # помещаем в матричный формат
    A = np.array([[1, s, f] for s, f in zip(sexes, fares)])
    # создаем начальные веса
    w = [0, 0, 0]
    # получаем истинные метки
    y = list(train.Survived)

    # обучаем модель
    weights = grad_descent(A, w, y, lr = 0.01,
                           stochastic = False)

    # Давайте используем эти веса, чтобы сделать предсказания на обучающих данных и увидеть, как это выглядит
    def classification(weights, features):
        prob = sigmoid(weights, features)
        if prob > .5:
            return 1
        else:
            return 0

    correct = 0

    for i, row in train.iterrows():
        fare = row['Fare']
        sex = row['Sex']
        A = np.array([[1, sex, fare]])
        A.shape = (1, 3)
        pred = classification(weights, A[0,:])

        if row['Survived'] == pred:
            correct += 1

    print(correct/len(train.index))

В итоге я получаю около 65% точности, в то время как используя sklearn, я могу добиться 78% точности. Я понимаю, что алгоритм sklearn, вероятно, гораздо более сложен, чем мой, но я надеялся, что смогу хотя бы приблизиться к нему (может быть, в районе 70%). Есть какие-то советы?

Вы используете (стохастический) градиентный спуск. Чтобы он работал правильно, скорость обучения (размер шага) должна быть установлена правильно. Я предполагаю, что ошибка заключается именно в этом.

Вместо этого вы можете попробовать логистическую регрессию через IRLS (см. ее определение), сравните также IRLS и GD

Или для введенных вами данных вы только что нашли плохой локальный оптимум.