





import numpy as np
from matplotlib import pyplot as plt
from sklearn import datasets







def    _lowerCamelCase  (__lowerCamelCase  :     List[Any]     )   ->    Union[str, Any]:
			return 1 / (1 + np.exp(-z     ))







def    _lowerCamelCase  (__lowerCamelCase  :     Union[str, Any]					,  __lowerCamelCase  :     Union[str, Any]     )   ->    str:
			return (-y * np.log(__lowerCamelCase     ) - (1 - y) * np.log(1 - h     )).mean()







def    _lowerCamelCase  (__lowerCamelCase  :     Any					,  __lowerCamelCase  :     int					,  __lowerCamelCase  :     List[str]     )   ->    Optional[int]:
			a__     = np.dot(__lowerCamelCase					,  __lowerCamelCase     )
			return np.sum(y * scores - np.log(1 + np.exp(__lowerCamelCase     )     )     )







def    _lowerCamelCase  (__lowerCamelCase  :     int					,  __lowerCamelCase  :     List[str]					,  __lowerCamelCase  :     List[Any]					,  __lowerCamelCase  :     Tuple=7_0000     )   ->    List[str]:
			a__     = np.zeros(x.shape[1]     )

			for iterations in range(__lowerCamelCase     ):
						a__     = np.dot(__lowerCamelCase					,  __lowerCamelCase     )
						a__     = sigmoid_function(__lowerCamelCase     )
						a__     = np.dot(x.T					,  h - y     ) / y.size
						a__     = theta - alpha * gradient  # updating the weights
						a__     = np.dot(__lowerCamelCase					,  __lowerCamelCase     )
						a__     = sigmoid_function(__lowerCamelCase     )
						a__     = cost_function(__lowerCamelCase					,  __lowerCamelCase     )
						if iterations % 100 == 0:
									print(f'''loss: {j} \t'''     )  # printing the loss after every 100 iterations
			return theta


# In[68]:

if __name__ == "__main__":
		lowerCAmelCase_   :   int       =					datasets.load_iris()
		lowerCAmelCase_   :   Optional[int]       =					iris.data[:, :2]
		lowerCAmelCase_   :   Union[str, Any]       =					(iris.target != 0) * 1

		lowerCAmelCase_   :   Tuple       =					0.1
		lowerCAmelCase_   :   int       =					logistic_reg(alpha, x, y, max_iterations=70000)
		print("theta: ", theta)  # printing the theta i.e our weights vector







		def    _lowerCamelCase  (__lowerCamelCase  :     List[Any]     )   ->    Tuple:
					return sigmoid_function(
					    np.dot(__lowerCamelCase					,  __lowerCamelCase     )     )  # predicting the value of probability from the logistic regression algorithm

		plt.figure(figsize=(10, 6))
		plt.scatter(x[y == 0][:, 0], x[y == 0][:, 1], color="b", label="0")
		plt.scatter(x[y == 1][:, 0], x[y == 1][:, 1], color="r", label="1")
		(lowerCAmelCase_)   :   List[Any]       =					(x[:, 0].min(), x[:, 0].max())
		(lowerCAmelCase_)   :   Union[str, Any]       =					(x[:, 1].min(), x[:, 1].max())
		(lowerCAmelCase_)   :   Tuple       =					np.meshgrid(np.linspace(xa_min, xa_max), np.linspace(xa_min, xa_max))
		lowerCAmelCase_   :   List[Any]       =					np.c_[xxa.ravel(), xxa.ravel()]
		lowerCAmelCase_   :   str       =					predict_prob(grid).reshape(xxa.shape)
		plt.contour(xxa, xxa, probs, [0.5], linewidths=1, colors="black")

		plt.legend()




		plt.show()










'''simple docstring'''


def    _lowerCamelCase  (__lowerCamelCase  :     int = 400_0000     )   ->    int:
			a__     = [0, 1]
			a__     = 0
			while fib[i] <= n:
						fib.append(fib[i] + fib[i + 1]     )
						if fib[i + 2] > n:
									break
						i += 1
			a__     = 0
			for j in range(len(__lowerCamelCase     ) - 1     ):
						if fib[j] % 2 == 0:
									total += fib[j]

			return total


if __name__ == "__main__":
		print(f"""{solution() = }""")



