




import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)




class       _A				(		unittest.TestCase     ):






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Vector([1, 2, 3]			)
								self.assertEqual(x.component(0			)						,		1			)
								self.assertEqual(x.component(2			)						,		3			)
								_UpperCAmelCase      =			Vector()






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Vector([0, 0, 0, 0, 0, 1]			)
								self.assertEqual(str(_SCREAMING_SNAKE_CASE			)						,		"""(0,0,0,0,0,1)"""			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Vector([1, 2, 3, 4]			)
								self.assertEqual(len(_SCREAMING_SNAKE_CASE			)						,		4			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Vector([1, 2]			)
								_UpperCAmelCase      =			Vector([1, 2, 3, 4, 5]			)
								_UpperCAmelCase      =			Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]			)
								_UpperCAmelCase      =			Vector([1, -1, 1, -1, 2, -3, 4, -5]			)
								self.assertAlmostEqual(x.euclidean_length()						,		2.236						,		3			)
								self.assertAlmostEqual(y.euclidean_length()						,		7.416						,		3			)
								self.assertEqual(z.euclidean_length()						,		0			)
								self.assertAlmostEqual(w.euclidean_length()						,		7.616						,		3			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Vector([1, 2, 3]			)
								_UpperCAmelCase      =			Vector([1, 1, 1]			)
								self.assertEqual((x + y).component(0			)						,		2			)
								self.assertEqual((x + y).component(1			)						,		3			)
								self.assertEqual((x + y).component(2			)						,		4			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Vector([1, 2, 3]			)
								_UpperCAmelCase      =			Vector([1, 1, 1]			)
								self.assertEqual((x - y).component(0			)						,		0			)
								self.assertEqual((x - y).component(1			)						,		1			)
								self.assertEqual((x - y).component(2			)						,		2			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Vector([1, 2, 3]			)
								_UpperCAmelCase      =			Vector([2, -1, 4]			)  # for test of dot product
								_UpperCAmelCase      =			Vector([1, -2, -1]			)
								self.assertEqual(str(x * 3.0			)						,		"""(3.0,6.0,9.0)"""			)
								self.assertEqual((a * b)						,		0			)






		def 				UpperCAmelCase (    self			):
								self.assertEqual(str(zero_vector(10			)			).count("""0"""			)						,		10			)






		def 				UpperCAmelCase (    self			):
								self.assertEqual(str(unit_basis_vector(3						,		1			)			)						,		"""(0,1,0)"""			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Vector([1, 2, 3]			)
								_UpperCAmelCase      =			Vector([1, 0, 1]			)
								self.assertEqual(str(axpy(2						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			)			)						,		"""(3,4,7)"""			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Vector([1, 0, 0, 0, 0, 0]			)
								_UpperCAmelCase      =			x.copy()
								self.assertEqual(str(_SCREAMING_SNAKE_CASE			)						,		str(_SCREAMING_SNAKE_CASE			)			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Vector([1, 0, 0]			)
								x.change_component(0						,		0			)
								x.change_component(1						,		1			)
								self.assertEqual(str(_SCREAMING_SNAKE_CASE			)						,		"""(0,1,0)"""			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,		3						,		3			)
								self.assertEqual("""|1,2,3|\n|2,4,5|\n|6,7,8|\n"""						,		str(_SCREAMING_SNAKE_CASE			)			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,		3						,		3			)
								_UpperCAmelCase      =			[[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
								for x in range(a.height()			):
														for y in range(a.width()			):
																				self.assertEqual(minors[x][y]						,		a.minor(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			)			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,		3						,		3			)
								_UpperCAmelCase      =			[[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
								for x in range(a.height()			):
														for y in range(a.width()			):
																				self.assertEqual(cofactors[x][y]						,		a.cofactor(_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE			)			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,		3						,		3			)
								self.assertEqual(-5						,		a.determinant()			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]						,		3						,		3			)
								_UpperCAmelCase      =			Vector([1, 2, 3]			)
								self.assertEqual("""(14,32,50)"""						,		str(a * x			)			)
								self.assertEqual("""|2,4,6|\n|8,10,12|\n|14,16,18|\n"""						,		str(a * 2			)			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,		3						,		3			)
								a.change_component(0						,		2						,		5			)
								self.assertEqual("""|1,2,5|\n|2,4,5|\n|6,7,8|\n"""						,		str(_SCREAMING_SNAKE_CASE			)			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,		3						,		3			)
								self.assertEqual(7						,		a.component(2						,		1			)						,		0.01			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,		3						,		3			)
								_UpperCAmelCase      =			Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]						,		3						,		3			)
								self.assertEqual("""|2,4,10|\n|4,8,10|\n|12,14,18|\n"""						,		str(a + b			)			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,		3						,		3			)
								_UpperCAmelCase      =			Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]						,		3						,		3			)
								self.assertEqual("""|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"""						,		str(a - b			)			)






		def 				UpperCAmelCase (    self			):
								self.assertEqual(
								    """|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"""						,		str(square_zero_matrix(5			)			)						,		)


if __name__ == "__main__":
				unittest.main()





# Logistic Regression from scratch

# In[62]:

# In[63]:

# importing all the required libraries

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




def        _SCREAMING_SNAKE_CASE      (		snake_case       )						->				List[str]:
						return 1 / (1 + np.exp(-z       ))




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case       )						->				Tuple:
						return (-y * np.log(snake_case       ) - (1 - y) * np.log(1 - h       )).mean()




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case       )						->				List[Any]:
						_UpperCAmelCase      =			np.dot(snake_case			,     snake_case       )
						return np.sum(y * scores - np.log(1 + np.exp(snake_case       )       )       )




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case			,     snake_case=7_0_0_0_0       )						->				Tuple:
						_UpperCAmelCase      =			np.zeros(x.shape[1]       )

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


# In[68]:

if __name__ == "__main__":
				a													=			datasets.load_iris()
				a													=			iris.data[:, :2]
				a													=			(iris.target != 0) * 1

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




				def        _SCREAMING_SNAKE_CASE      (		snake_case       )						->				List[Any]:
										return sigmoid_function(
										    np.dot(snake_case			,     snake_case       )       )  # 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")
				((a)							,  (a))													=			(x[:, 0].min(), x[:, 0].max())
				((a)							,  (a))													=			(x[:, 1].min(), x[:, 1].max())
				((a)							,  (a))													=			np.meshgrid(np.linspace(xa_min, xa_max), np.linspace(xa_min, xa_max))
				a													=			np.c_[xxa.ravel(), xxa.ravel()]
				a													=			predict_prob(grid).reshape(xxa.shape)
				plt.contour(xxa, xxa, probs, [0.5], linewidths=1, colors="black")

				plt.legend()

				plt.show()