
import numpy

# List of input, output pairs
lowercase						:      Tuple									= (
    ((5, 2, 3), 15),
    ((6, 5, 9), 25),
    ((11, 12, 13), 41),
    ((1, 1, 1), 8),
    ((11, 12, 13), 41),
)
lowercase						:      Tuple									= (((515, 22, 13), 555), ((61, 35, 49), 150))
lowercase						:      List[str]									= [2, 4, 1, 5]
lowercase						:      Tuple									= len(train_data)
lowercase						:      Optional[Any]									= 0.0_0_9




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    Any		,						_lowerCamelCase				:    Any="train")      ->					Tuple:






							'''simple docstring'''





							return calculate_hypothesis_value(_lowerCamelCase		,						_lowerCamelCase) - output(
							    _lowerCamelCase		,						_lowerCamelCase)




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    Optional[Any])      ->					Optional[int]:






							'''simple docstring'''





							__UpperCamelCase			:     Dict         =      0
							for i in range(len(_lowerCamelCase) - 1):
														hyp_val += data_input_tuple[i] * parameter_vector[i + 1]
							hyp_val += parameter_vector[0]
							return hyp_val




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    Any		,						_lowerCamelCase				:    List[Any])      ->					List[str]:






							'''simple docstring'''





							if data_set == "train":
														return train_data[example_no][1]
							elif data_set == "test":
														return test_data[example_no][1]
							return None




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    Dict		,						_lowerCamelCase				:    Tuple)      ->					List[str]:






							'''simple docstring'''





							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 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    Dict		,						_lowerCamelCase				:    Optional[Any]=m)      ->					List[str]:






							'''simple docstring'''





							__UpperCamelCase			:     int         =      0
							for i in range(_lowerCamelCase):
														if index == -1:
																					summation_value += _error(_lowerCamelCase)
														else:
																					summation_value += _error(_lowerCamelCase) * train_data[i][0][index]
							return summation_value




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    Any)      ->					str:






							'''simple docstring'''





							__UpperCamelCase			:     Tuple         =      summation_of_cost_derivative(_lowerCamelCase		,						_lowerCamelCase) / m
							return cost_derivative_value




def 			_SCREAMING_SNAKE_CASE      (	)      ->					Optional[int]:






							'''simple docstring'''





							global parameter_vector
							# Tune these values to set a tolerance value for predicted output
							__UpperCamelCase			:     List[str]         =      0.0_0_0_0_0_2
							__UpperCamelCase			:     List[str]         =      0
							__UpperCamelCase			:     Any         =      0
							while True:
														j += 1
														__UpperCamelCase			:     int         =      [0, 0, 0, 0]
														for i in range(0		,						len(_lowerCamelCase)):
																					__UpperCamelCase			:     Union[str, Any]         =      get_cost_derivative(i - 1)
																					__UpperCamelCase			:     Any         =      (
																					    parameter_vector[i] - LEARNING_RATE * cost_derivative
																					)
														if numpy.allclose(
														    _lowerCamelCase		,						_lowerCamelCase		,						atol=_lowerCamelCase		,						rtol=_lowerCamelCase		,						):
																					break
														__UpperCamelCase			:     Any         =      temp_parameter_vector
							print(("Number of iterations:", j))




def 			_SCREAMING_SNAKE_CASE      (	)      ->					List[str]:






							'''simple docstring'''





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


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

from __future__ import annotations

import math
from collections import Counter
from string import ascii_lowercase




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    str)      ->					None:






							'''simple docstring'''





							__UpperCamelCase     ,		__UpperCamelCase			:     Optional[Any]         =      analyze_text(_lowerCamelCase)
							__UpperCamelCase			:     List[str]         =      list(" " + ascii_lowercase)
							# what is our total sum of probabilities.
							__UpperCamelCase			:     Any         =      sum(single_char_strings.values())

							# one length string
							__UpperCamelCase			:     Optional[Any]         =      0
							# for each alpha we go in our dict and if it is in it we calculate entropy
							for ch in my_alphas:
														if ch in single_char_strings:
																					__UpperCamelCase			:     List[Any]         =      single_char_strings[ch]
																					__UpperCamelCase			:     List[str]         =      my_str / all_sum
																					my_fir_sum += prob * math.loga(_lowerCamelCase)  # entropy formula.

    # print entropy
							print(F'{round(-1 * my_fir_sum):.1f}')

							# two len string
							__UpperCamelCase			:     Optional[Any]         =      sum(two_char_strings.values())
							__UpperCamelCase			:     Tuple         =      0
							# for each alpha (two in size) calculate entropy.
							for cha in my_alphas:
														for cha in my_alphas:
																					__UpperCamelCase			:     List[str]         =      cha + cha
																					if sequence in two_char_strings:
																												__UpperCamelCase			:     Optional[Any]         =      two_char_strings[sequence]
																												__UpperCamelCase			:     Any         =      int(_lowerCamelCase) / all_sum
																												my_sec_sum += prob * math.loga(_lowerCamelCase)

    # print second entropy
							print(F'{round(-1 * my_sec_sum):.1f}')

							# print the difference between them
							print(F'{round((-1 * my_sec_sum) - (-1 * my_fir_sum)):.1f}')




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    str)      ->					tuple[dict, dict]:






							'''simple docstring'''





							__UpperCamelCase			:     Tuple         =      Counter()  # type: ignore
							__UpperCamelCase			:     Any         =      Counter()  # type: ignore
							single_char_strings[text[-1]] += 1

							# first case when we have space at start.
							two_char_strings[" " + text[0]] += 1
							for i in range(0		,						len(_lowerCamelCase) - 1):
														single_char_strings[text[i]] += 1
														two_char_strings[text[i : i + 2]] += 1
							return single_char_strings, two_char_strings




def 			_SCREAMING_SNAKE_CASE      (	)      ->					List[str]:






							'''simple docstring'''





							import doctest

							doctest.testmod()
							# text = (
							#     "Had repulsive dashwoods suspicion sincerity but advantage now him. Remark "
							#     "easily garret nor nay. Civil those mrs enjoy shy fat merry. You greatest "
							#     "jointure saw horrible. He private he on be imagine suppose. Fertile "
							#     "beloved evident through no service elderly is. Blind there if every no so "
							#     "at. Own neglected you preferred way sincerity delivered his attempted. To "
							#     "of message cottage windows do besides against uncivil.  Delightful "
							#     "unreserved impossible few estimating men favourable see entreaties. She "
							#     "propriety immediate was improving. He or entrance humoured likewise "
							#     "moderate. Much nor game son say feel. Fat make met can must form into "
							#     "gate. Me we offending prevailed discovery. "
							# )

							# calculate_prob(text)


if __name__ == "__main__":
		main()