def normalizeOutput(self, o: Vector) -> Vector:
"""
The normalizeOutput method takes an input {@link Vector} o, gets the result for e^o of each element of o,
then sums them up. At the end, divides the each e^o by the summation.
PARAMETERS
----------
o : Vector
Vector to normalize.
RETURNS
-------
Vector
Normalized vector.
"""
total = 0.0
values = []
for i in range(o.size()):
if o.getValue(i) > 500:
total += math.exp(500)
else:
total += math.exp(o.getValue(i))
for i in range(o.size()):
if o.getValue(i) > 500:
values.append(math.exp(500) / total)
else:
values.append(math.exp(o.getValue(i)) / total)
return Vector(values)
def multiplyWithVectorFromRight(self, v: Vector) -> Vector:
"""
The multiplyWithVectorFromRight method takes a Vector as an input and creates a result list.
Then, multiplies values of input Vector starting from the right side with the values list,
accumulates the multiplication, and assigns to the result list. If the sizes of both Vector
and row number do not match, it throws MatrixColumnMismatch exception.
PARAMETERS
----------
v : Vector
Vector type input.
RETURNS
-------
Vector
Vector that holds the result.
"""
if self.__col != v.size():
raise MatrixColumnMismatch
result = Vector()
for i in range(self.__row):
total = 0.0
for j in range(self.__col):
total += v.getValue(j) * self.__values[i][j]
result.add(total)
return result
def addVectorAttribute(self, vector: Vector):
"""
Adds a Vector of continuous attributes.
PARAMETERS
----------
vector : Vector
Vector that has the continuous attributes.
"""
for i in range(vector.size()):
self.__attributes.append(ContinuousAttribute(vector.getValue(i)))
def addRowVector(self, rowNo: int, v: Vector):
"""
The add method which takes a row number and a Vector as inputs. It sums up the corresponding values at the given
row of values list and given Vector. If the sizes of both Matrix and values list do not match, it throws
MatrixColumnMismatch exception.
PARAMETERS
----------
rowNo : int
integer input for row number.
v : Vector
Vector type input.
"""
if self.__col != v.size():
raise MatrixColumnMismatch
for i in range(self.__col):
self.__values[rowNo][i] += v.getValue(i)
def calculateOneMinusHidden(self, hidden: Vector) -> Vector:
"""
The calculateOneMinusHidden method takes a {@link java.util.Vector} as input. It creates a Vector of ones and
returns the difference between given Vector.
PARAMETERS
----------
hidden : Vector
Vector to find difference.
RETURNS
-------
Vector
Returns the difference between ones Vector and input Vector.
"""
one = Vector()
one.initAllSame(hidden.size(), 1.0)
return one.difference(hidden)
class VectorTest(unittest.TestCase):
data1 = [2, 3, 4, 5, 6]
def setUp(self):
data2 = [8, 7, 6, 5, 4]
self.smallVector1 = Vector(self.data1)
self.smallVector2 = Vector(data2)
largeData1 = []
for i in range(1, 1001):
largeData1.append(i)
self.largeVector1 = Vector(largeData1)
largeData2 = []
for i in range(1, 1001):
largeData2.append(1000 - i + 1)
self.largeVector2 = Vector(largeData2)
def test_Biased(self):
biased = self.smallVector1.biased()
self.assertEqual(1, biased.getValue(0))
self.assertEqual(self.smallVector1.size() + 1, biased.size())
def test_ElementAdd(self):
self.smallVector1.add(7)
self.assertEqual(7, self.smallVector1.getValue(5))
self.assertEqual(6, self.smallVector1.size())
self.smallVector1.remove(5)
def test_Insert(self):
self.smallVector1.insert(3, 6)
self.assertEqual(6, self.smallVector1.getValue(3))
self.assertEqual(6, self.smallVector1.size())
self.smallVector1.remove(3)
def test_Remove(self):
self.smallVector1.remove(2)
self.assertEqual(5, self.smallVector1.getValue(2))
self.assertEqual(4, self.smallVector1.size())
self.smallVector1.insert(2, 4)
def test_SumOfElementsSmall(self):
self.assertEqual(20, self.smallVector1.sumOfElements())
self.assertEqual(30, self.smallVector2.sumOfElements())
def test_SumOfElementsLarge(self):
self.assertEqual(20, self.smallVector1.sumOfElements())
self.assertEqual(30, self.smallVector2.sumOfElements())
self.assertEqual(500500, self.largeVector1.sumOfElements())
self.assertEqual(500500, self.largeVector2.sumOfElements())
def test_MaxIndex(self):
self.assertEqual(4, self.smallVector1.maxIndex())
self.assertEqual(0, self.smallVector2.maxIndex())
def test_Sigmoid(self):
smallVector3 = Vector(self.data1)
smallVector3.sigmoid()
self.assertAlmostEqual(0.8807971, smallVector3.getValue(0), 6)
self.assertAlmostEqual(0.9975274, smallVector3.getValue(4), 6)
def test_SkipVectorSmall(self):
smallVector3 = self.smallVector1.skipVector(2, 0)
self.assertEqual(2, smallVector3.getValue(0))
self.assertEqual(6, smallVector3.getValue(2))
smallVector3 = self.smallVector1.skipVector(3, 1)
self.assertEqual(3, smallVector3.getValue(0))
self.assertEqual(6, smallVector3.getValue(1))
def test_SkipVectorLarge(self):
largeVector3 = self.largeVector1.skipVector(2, 0)
self.assertEqual(250000, largeVector3.sumOfElements())
largeVector3 = self.largeVector1.skipVector(5, 3)
self.assertEqual(100300, largeVector3.sumOfElements())
def test_VectorAddSmall(self):
self.smallVector1.addVector(self.smallVector2)
self.assertEqual(50, self.smallVector1.sumOfElements())
self.smallVector1.subtract(self.smallVector2)
def test_VectorAddLarge(self):
self.largeVector1.addVector(self.largeVector2)
self.assertEqual(1001000, self.largeVector1.sumOfElements())
self.largeVector1.subtract(self.largeVector2)
def test_SubtractSmall(self):
self.smallVector1.subtract(self.smallVector2)
self.assertEqual(-10, self.smallVector1.sumOfElements())
self.smallVector1.addVector(self.smallVector2)
def test_SubtractLarge(self):
self.largeVector1.subtract(self.largeVector2)
self.assertEqual(0, self.largeVector1.sumOfElements())
self.largeVector1.addVector(self.largeVector2)
def test_DifferenceSmall(self):
smallVector3 = self.smallVector1.difference(self.smallVector2)
self.assertEqual(-10, smallVector3.sumOfElements())
def test_DifferenceLarge(self):
largeVector3 = self.largeVector1.difference(self.largeVector2)
self.assertEqual(0, largeVector3.sumOfElements())
def test_DotProductWithVectorSmall(self):
dotProduct = self.smallVector1.dotProduct(self.smallVector2)
self.assertEqual(110, dotProduct)
def test_DotProductWithVectorLarge(self):
dotProduct = self.largeVector1.dotProduct(self.largeVector2)
self.assertEqual(167167000, dotProduct)
def test_DotProductWithItselfSmall(self):
dotProduct = self.smallVector1.dotProductWithSelf()
self.assertEqual(90, dotProduct)
def test_DotProductWithItselfLarge(self):
dotProduct = self.largeVector1.dotProductWithSelf()
self.assertEqual(333833500, dotProduct)
def test_ElementProductSmall(self):
smallVector3 = self.smallVector1.elementProduct(self.smallVector2)
self.assertEqual(110, smallVector3.sumOfElements())
def test_ElementProductLarge(self):
largeVector3 = self.largeVector1.elementProduct(self.largeVector2)
self.assertEqual(167167000, largeVector3.sumOfElements())
def test_Divide(self):
self.smallVector1.divide(10.0)
self.assertEqual(2, self.smallVector1.sumOfElements())
self.smallVector1.multiply(10.0)
def test_Multiply(self):
self.smallVector1.multiply(10.0)
self.assertEqual(200, self.smallVector1.sumOfElements())
self.smallVector1.divide(10.0)
def test_Product(self):
smallVector3 = self.smallVector1.product(7.0)
self.assertEqual(140, smallVector3.sumOfElements())
def test_L1NormalizeSmall(self):
self.smallVector1.l1Normalize()
self.assertEqual(1.0, self.smallVector1.sumOfElements())
self.smallVector1.multiply(20)
def test_L1NormalizeLarge(self):
self.largeVector1.l1Normalize()
self.assertEqual(1.0, self.largeVector1.sumOfElements())
self.largeVector1.multiply(500500)
def test_L2NormSmall(self):
norm = self.smallVector1.l2Norm()
self.assertEqual(norm, math.sqrt(90))
def test_L2NormLarge(self):
norm = self.largeVector1.l2Norm()
self.assertEqual(norm, math.sqrt(333833500))
def test_cosineSimilaritySmall(self):
similarity = self.smallVector1.cosineSimilarity(self.smallVector2)
self.assertAlmostEqual(0.8411910, similarity, 6)
def test_cosineSimilarityLarge(self):
similarity = self.largeVector1.cosineSimilarity(self.largeVector2)
self.assertAlmostEqual(0.5007497, similarity, 6)
