
'''simple docstring'''







import os



def 			_a		(	_SCREAMING_SNAKE_CASE		:   int  ):
						_SCREAMING_SNAKE_CASE				= len(grid[0]  )
						_SCREAMING_SNAKE_CASE				= len(_SCREAMING_SNAKE_CASE  )

						_SCREAMING_SNAKE_CASE				= 0
						_SCREAMING_SNAKE_CASE				= 0
						_SCREAMING_SNAKE_CASE				= 0

						# Check vertically, horizontally, diagonally at the same time (only works
						# for nxn grid)
						for i in range(_SCREAMING_SNAKE_CASE  ):
												for j in range(n_rows - 3  ):
																		_SCREAMING_SNAKE_CASE				= grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
																		_SCREAMING_SNAKE_CASE				= grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3]

																		# Left-to-right diagonal (\) product
																		if i < n_columns - 3:
																								_SCREAMING_SNAKE_CASE				= (
																								    grid[i][j]
																								    * grid[i + 1][j + 1]
																								    * grid[i + 2][j + 2]
																								    * grid[i + 3][j + 3]
																								)

																		# Right-to-left diagonal(/) product
																		if i > 2:
																								_SCREAMING_SNAKE_CASE				= (
																								    grid[i][j]
																								    * grid[i - 1][j + 1]
																								    * grid[i - 2][j + 2]
																								    * grid[i - 3][j + 3]
																								)

																		_SCREAMING_SNAKE_CASE				= max(
																		    _SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )
																		if max_product > largest:
																								_SCREAMING_SNAKE_CASE				= max_product

						return largest



def 			_a		(	):
						_SCREAMING_SNAKE_CASE				= []
						with open(os.path.dirname(_SCREAMING_SNAKE_CASE  ) + "/grid.txt"  ) as file:
												for line in file:
																		grid.append(line.strip("\n"  ).split(" "  )  )

						_SCREAMING_SNAKE_CASE				= [[int(_SCREAMING_SNAKE_CASE  ) for i in grid[j]] for j in range(len(_SCREAMING_SNAKE_CASE  )  )]

						return largest_product(_SCREAMING_SNAKE_CASE  )


if __name__ == "__main__":
						print(solution())

'''simple docstring'''







import numpy

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



def 			_a		(	_SCREAMING_SNAKE_CASE		:   List[Any]	,			_SCREAMING_SNAKE_CASE		:   List[Any]="train"  ):
						return calculate_hypothesis_value(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  ) - output(
						    _SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )



def 			_a		(	_SCREAMING_SNAKE_CASE		:   List[Any]  ):
						_SCREAMING_SNAKE_CASE				= 0
						for i in range(len(_SCREAMING_SNAKE_CASE  ) - 1  ):
												hyp_val += data_input_tuple[i] * parameter_vector[i + 1]
						hyp_val += parameter_vector[0]
						return hyp_val



def 			_a		(	_SCREAMING_SNAKE_CASE		:   str	,			_SCREAMING_SNAKE_CASE		:   Union[str, Any]  ):
						if data_set == "train":
												return train_data[example_no][1]
						elif data_set == "test":
												return test_data[example_no][1]
						return None



def 			_a		(	_SCREAMING_SNAKE_CASE		:   Any	,			_SCREAMING_SNAKE_CASE		:   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 			_a		(	_SCREAMING_SNAKE_CASE		:   Union[str, Any]	,			_SCREAMING_SNAKE_CASE		:   Optional[int]=m  ):
						_SCREAMING_SNAKE_CASE				= 0
						for i in range(_SCREAMING_SNAKE_CASE  ):
												if index == -1:
																		summation_value += _error(_SCREAMING_SNAKE_CASE  )
												else:
																		summation_value += _error(_SCREAMING_SNAKE_CASE  ) * train_data[i][0][index]
						return summation_value



def 			_a		(	_SCREAMING_SNAKE_CASE		:   Optional[Any]  ):
						_SCREAMING_SNAKE_CASE				= summation_of_cost_derivative(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  ) / m
						return cost_derivative_value



def 			_a		(	):
						global parameter_vector
						# Tune these values to set a tolerance value for predicted output
						_SCREAMING_SNAKE_CASE				= 0.000_002
						_SCREAMING_SNAKE_CASE				= 0
						_SCREAMING_SNAKE_CASE				= 0
						while True:
												j += 1
												_SCREAMING_SNAKE_CASE				= [0, 0, 0, 0]
												for i in range(0	,			len(_SCREAMING_SNAKE_CASE  )  ):
																		_SCREAMING_SNAKE_CASE				= get_cost_derivative(i - 1  )
																		_SCREAMING_SNAKE_CASE				= (
																		    parameter_vector[i] - LEARNING_RATE * cost_derivative
																		)
												if numpy.allclose(
												    _SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE	,			atol=_SCREAMING_SNAKE_CASE	,			rtol=_SCREAMING_SNAKE_CASE	,			):
																		break
												_SCREAMING_SNAKE_CASE				= temp_parameter_vector
						print(("Number of iterations:", j)  )



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


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