





'''simple docstring'''






import numpy

# List of input, output pairs
snake_case_     =	(
    ((5, 2, 3), 15),
    ((6, 5, 9), 25),
    ((11, 12, 13), 41),
    ((1, 1, 1), 8),
    ((11, 12, 13), 41),
)
snake_case_     =	(((5_15, 22, 13), 5_55), ((61, 35, 49), 1_50))
snake_case_     =	[2, 4, 1, 5]
snake_case_     =	len(train_data)
snake_case_     =	0.0_09
def 							_lowerCamelCase(  UpperCamelCase__    : Any    ,       UpperCamelCase__    : Any="train"		)		->  Union[str, Any]:
    return calculate_hypothesis_value(__UpperCAmelCase    ,       __UpperCAmelCase		) - output(
        __UpperCAmelCase    ,       __UpperCAmelCase		)
def 							_lowerCamelCase(  UpperCamelCase__    : str		)		->  List[Any]:
    A       :       int							=						0
    for i in range(len(__UpperCAmelCase		) - 1		):
        hyp_val += data_input_tuple[i] * parameter_vector[i + 1]
    hyp_val += parameter_vector[0]
    return hyp_val
def 							_lowerCamelCase(  UpperCamelCase__    : List[str]    ,       UpperCamelCase__    : List[str]		)		->  Optional[int]:







    if data_set == "train":
        return train_data[example_no][1]
    elif data_set == "test":
        return test_data[example_no][1]
    return None
def 							_lowerCamelCase(  UpperCamelCase__    : Tuple    ,       UpperCamelCase__    : Union[str, Any]		)		->  str:







    if data_set == "train":
        return _hypothesis_value(train_data[example_no][0]		)
    elif data_set == "test":
        return _hypothesis_value(test_data[example_no][0]		)
    return None
def 							_lowerCamelCase(  UpperCamelCase__    : List[str]    ,       UpperCamelCase__    : List[str]=m		)		->  Optional[int]:
    A       :       Tuple							=						0
    for i in range(__UpperCAmelCase		):
        if index == -1:
            summation_value += _error(__UpperCAmelCase		)
        else:
            summation_value += _error(__UpperCAmelCase		) * train_data[i][0][index]
    return summation_value
def 							_lowerCamelCase(  UpperCamelCase__    : List[str]		)		->  Union[str, Any]:
    A       :       Tuple							=						summation_of_cost_derivative(__UpperCAmelCase    ,       __UpperCAmelCase		) / m
    return cost_derivative_value
def 							_lowerCamelCase(  )		->  Any:
    global parameter_vector
    # Tune these values to set a tolerance value for predicted output
    A       :       int							=						0.0_0_0_0_0_2
    A       :       List[Any]							=						0
    A       :       Union[str, Any]							=						0
    while True:
        j += 1
        A       :       Union[str, Any]							=						[0, 0, 0, 0]
        for i in range(0    ,       len(__UpperCAmelCase		)		):
            A       :       str							=						get_cost_derivative(i - 1		)
            A       :       Any							=						(
                parameter_vector[i] - LEARNING_RATE * cost_derivative
            )
        if numpy.allclose(
            __UpperCAmelCase    ,       __UpperCAmelCase    ,       atol=__UpperCAmelCase    ,       rtol=__UpperCAmelCase    ,       ):
            break
        A       :       List[Any]							=						temp_parameter_vector
    print(('''Number of iterations:''', j)		)
def 							_lowerCamelCase(  )		->  str:







    for i in range(len(__UpperCAmelCase		)		):
        print(('''Actual output value:''', output(__UpperCAmelCase    ,       '''test'''		))		)
        print(('''Hypothesis output:''', calculate_hypothesis_value(__UpperCAmelCase    ,       '''test'''		))		)


if __name__ == "__main__":
     run_gradient_descent()
     print("""\nTesting gradient descent for a linear hypothesis function.\n""")
     test_gradient_descent()








'''simple docstring'''






def 							_lowerCamelCase(  UpperCamelCase__    : int		)		->  None:
    A       :       List[Any]							=						generate_pascal_triangle(UpperCamelCase__		)
    for row_idx in range(UpperCamelCase__		):
        # Print left spaces
        for _ in range(num_rows - row_idx - 1		):
            print(end=''' '''		)
        # Print row values
        for col_idx in range(row_idx + 1		):
            if col_idx != row_idx:
                print(triangle[row_idx][col_idx]    ,       end=''' '''		)
            else:
                print(triangle[row_idx][col_idx]    ,       end=''''''		)
        print()
def 							_lowerCamelCase(  UpperCamelCase__    : int		)		->  list[list[int]]:

    if not isinstance(UpperCamelCase__    ,       UpperCamelCase__		):
        raise TypeError('''The input value of \'num_rows\' should be \'int\''''		)

    if num_rows == 0:
        return []
    elif num_rows < 0:
        raise ValueError(
            '''The input value of \'num_rows\' should be greater than or equal to 0'''		)

    A       :       list[list[int]]							=						[]
    for current_row_idx in range(UpperCamelCase__		):
        A       :       Optional[int]							=						populate_current_row(UpperCamelCase__    ,       UpperCamelCase__		)
        triangle.append(UpperCamelCase__		)
    return triangle
def 							_lowerCamelCase(  UpperCamelCase__    : list[list[int]]    ,       UpperCamelCase__    : int		)		->  list[int]:
    A       :       Dict							=						[-1] * (current_row_idx + 1)
    # first and last elements of current row are equal to 1
    A,	A       :       Union[str, Any]							=						1, 1
    for current_col_idx in range(1    ,       UpperCamelCase__		):
        calculate_current_element(
            UpperCamelCase__    ,       UpperCamelCase__    ,       UpperCamelCase__    ,       UpperCamelCase__		)
    return current_row
def 							_lowerCamelCase(  UpperCamelCase__    : list[list[int]]    ,       UpperCamelCase__    : list[int]    ,       UpperCamelCase__    : int    ,       UpperCamelCase__    : int    ,       )		->  None:
    A       :       Dict							=						triangle[current_row_idx - 1][current_col_idx - 1]
    A       :       Any							=						triangle[current_row_idx - 1][current_col_idx]
    A       :       Optional[int]							=						above_to_left_elt + above_to_right_elt
def 							_lowerCamelCase(  UpperCamelCase__    : int		)		->  list[list[int]]:

    if not isinstance(UpperCamelCase__    ,       UpperCamelCase__		):
        raise TypeError('''The input value of \'num_rows\' should be \'int\''''		)

    if num_rows == 0:
        return []
    elif num_rows < 0:
        raise ValueError(
            '''The input value of \'num_rows\' should be greater than or equal to 0'''		)

    A       :       list[list[int]]							=						[[1]]

    for row_index in range(1    ,       UpperCamelCase__		):
        A       :       str							=						[0] + result[-1] + [0]
        A       :       Optional[Any]							=						row_index + 1
        # Calculate the number of distinct elements in a row
        A       :       str							=						sum(divmod(UpperCamelCase__    ,       2		)		)
        A       :       Optional[int]							=						[
            temp_row[i - 1] + temp_row[i] for i in range(1    ,       distinct_elements + 1		)
        ]
        A       :       Any							=						row_first_half[: (row_index + 1) // 2]
        row_second_half.reverse()
        A       :       Any							=						row_first_half + row_second_half
        result.append(UpperCamelCase__		)

    return result
def 							_lowerCamelCase(  )		->  None:
    from collections.abc import Callable
    from timeit import timeit

    def benchmark_a_function(UpperCamelCase__    : Callable    ,       UpperCamelCase__    : int		) -> None:
        A       :       Dict							=						F'''{func.__name__}({value})'''
        A       :       List[Any]							=						timeit(F'''__main__.{call}'''    ,       setup='''import __main__'''		)
        # print(f"{call:38} = {func(value)} -- {timing:.4f} seconds")
        print(F'''{call:38} -- {timing:.4f} seconds'''		)

    for value in range(15		):  # (1, 7, 14):
        for func in (generate_pascal_triangle, generate_pascal_triangle_optimized):
            benchmark_a_function(UpperCamelCase__    ,       UpperCamelCase__		)
        print()


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     benchmark()
