gd_with_df() is the function that I originally ran to show my experimentations. However, the time required to run the code is too long whenever the number of iteration increases.

In this post, I will be presenting three means of storing data into dataframes.

Dataframe#

def gd_with_df(x, y, epochs, df, alpha = 0.01):
    intercept, coefficient = 2.0, -7.5
    predictions = predict(intercept, coefficient, x)
    sum_error = np.sum((predictions - y) ** 2) / (2 * len(x))
    df.loc[0] = [intercept, coefficient, sum_error]
    for epoch in range(1, epochs + 1):
        predictions = predict(intercept, coefficient, x)
        b0_error = (1/len(x)) * np.sum(predictions - y)
        b1_error = (1/len(x)) * np.sum((predictions - y) * x)
        intercept = intercept - alpha * b0_error
        coefficient = coefficient - alpha * b1_error 
        sum_error = np.sum((predictions - y) ** 2) / (2 * len(x))
        df.loc[epoch] = [intercept, coefficient, sum_error]
        sum_error = 0
    return df

List#

def gd_with_list(x, y, epochs, df, alpha = 0.01):
    intercepts = list()
    coefficients = list()
    sum_errors = list()
    
    intercept, coefficient = 2.0, -7.5
    predictions = predict(intercept, coefficient, x)
    sum_error = np.sum((predictions - y) ** 2) / (2 * len(x))
    
    intercepts.append(intercept)
    coefficients.append(coefficient)
    sum_errors.append(sum_error)

    for epoch in range(1, epochs+1):
        predictions = predict(intercept, coefficient, x)
        b0_error = (1/len(x)) * np.sum(predictions - y)
        b1_error = (1/len(x)) * np.sum((predictions - y) * x)
        intercept = intercept - alpha * b0_error
        coefficient = coefficient - alpha * b1_error 
        sum_error = np.sum((predictions - y) ** 2) / (2 * len(x))

        intercepts.append(intercept)
        coefficients.append(coefficient)
        sum_errors.append(sum_error)

        sum_error = 0

    df['intercept'] = intercepts
    df['coefficient'] = coefficients
    df['sum_error'] = sum_errors

    return df

Dictionary#

def gd_with_dict(x, y, epochs, df, alpha = 0.01):
    intercept, coefficient = 2.0, -7.5
    predictions = predict(intercept, coefficient, x)
    sum_error = np.sum((predictions - y) ** 2) / (2 * len(x))
    
    result = {
        'intercept': [intercept],
        'coefficient': [coefficient],
        'sum_error': [sum_error]
    }

    for epoch in range(1, epochs+1):
        predictions = predict(intercept, coefficient, x)
        b0_error = (1/len(x)) * np.sum(predictions - y)
        b1_error = (1/len(x)) * np.sum((predictions - y) * x)
        intercept = intercept - alpha * b0_error
        coefficient = coefficient - alpha * b1_error 
        sum_error = np.sum((predictions - y) ** 2) / (2 * len(x))

        result['intercept'].append(intercept)
        result['coefficient'].append(coefficient)
        result['sum_error'].append(sum_error)

        sum_error = 0

    # convert dict to dataframe
    df = pd.DataFrame(result)

    return df

Observation#

Summing the numbers up into a single picture, we can see that working with both lists and dictionaries is much faster than working with dataframes.