for i in range(K):
kdatos = np.array(
[X.T[j] for j in range(len(X.T)) if self.clusters[j] == i])
C[i] = np.mean(kdatos, axis=0)
error = np.linalg.norm(C - C_old)
self.clustercentroids = C
if __name__ == '__main__':
colors = ['r', 'g', 'b', 'y', 'm', '#0ff0f0', '#112f1f', '#fff000']
D = 2
numClusters = 8
X, _ = create_Dd_data(D, 1, 3.2, 0.2, 1300, 1400)
cls = KMeansClustering()
cls.clusterData(X, numClusters)
if D == 2:
for i in range(numClusters):
pointsink = np.array(
[X.T[j] for j in range(len(X.T)) if cls.clusters[j] == i])
plt.plot(pointsink[:, 0],
pointsink[:, 1],
'o',
markersize=4,
c=colors[i])
plt.plot(cls.clustercentroids[:, 0],
cls.clustercentroids[:, 1],
def train(self, X, t):
self.wg = np.zeros(X.shape[0] + 1)
X = np.vstack((np.ones(X.shape[1]), X))
for i in range(self.epochs):
for j in range(len(X.T)):
score = self.wg.dot(X.T[j]) * t[j] > 0
if score == False:
self.wg += self.l_rate * X.T[j] * t[j]
if __name__ == '__main__':
D = 5
K = 2
X, tags = create_Dd_data(D, K, 4, 0.2, 1000, 1100)
# Change tags for -1, 1
tags = [1 if tags[i] == 0 else -1 for i in range(len(tags))]
# Shuffle data
ds = list(zip(X.T, tags))
shuffle(ds)
X = np.array([x for (x, _) in ds]).T
tags = np.array([t for (_, t) in ds])
cls = Perceptron(1)
# Train with 75% of the data
fl = floor(len(X.T) * 0.75)
cls.train(X.T[0:fl].T, tags[0:fl])
print(cls.wg)
'''
denom = sum(singVals**2)
# From those values that are below epsilon,
# get the index of the maximum
lista = [(sum(singVals[d+1:D]**2)/denom) \
if (sum(singVals[d+1:D]**2)/denom) < Epsilon \
else -1 for d in range(D)]
return np.argmax(lista)
if __name__ == '__main__':
colors = ['r', 'g', 'b', 'y', 'm', '#0ff0f0', '#112f1f', '#fff000']
D = 5
D_p = 2
K = 8
X,tags = create_Dd_data(D, K, 0.5, 0.2)
print(X.shape)
cls = Fisher_Reduction(D_p)
cls.computeW(D, K, X)
# Get the projected data
projection = cls.getProjection(X)
print('Data has been reduced from %d to %d' %(D, cls.D_p))
print('The projected data is: ')
print(projection)
# Plot the projected data in case of 1D and 2D
for i in range(len(projection.T)):
if cls.D_p == 1:
for n in range(len(Xtest.T)):
_, neigtags = self.getNeighbours(Xtrain, Xtest.T[n], tags, K)
counts = [neigtags.count(c) for c in range(C)]
predictions.append(np.argmax(counts))
return predictions
if __name__ == '__main__':
colors = ['r', 'g', 'b', 'y', 'm', '#0ff0f0', '#112f1f', '#fff000']
D = 5
C = 4
K = 20
X, tags = create_Dd_data(D, C, 3.2, 0.2, 130, 140)
# Shuffle data
ds = list(zip(X.T, tags))
shuffle(ds)
X = np.array([x for (x, _) in ds]).T
tags = np.array([t for (_, t) in ds])
cls = KNeighbours()
fl = floor(len(X.T) * 0.75)
# Test with 25%
predictions = cls.predict(X.T[0:fl].T, X.T[fl:len(X.T)].T, tags[0:fl], K,
C)
score = [tags[fl + i] == predictions[i] for i in range(len(X.T) - fl)]
print('Score of test dataset: %d/%d' % (score.count(True), len(score)))
denom = sum(singVals**2)
# From those values that are below epsilon,
# get the index of the maximum
lista = [(sum(singVals[d+1:D]**2)/denom) \
if (sum(singVals[d+1:D]**2)/denom) < Epsilon \
else -1 for d in range(D)]
return np.argmax(lista)
if __name__ == '__main__':
colors = ['r', 'g', 'b', 'y', 'm', '#0ff0f0', '#112f1f', '#fff000']
D = 4
Epsilon = 0.15
K = 5
X, tags = create_Dd_data(D, K, 1.2, 0.2)
cls = PCA_Reduction()
cls.computeW(D, X, Epsilon)
# Get the projected data
projection = cls.getProjection(X)
compression = cls.getCompression(X)
normalization = cls.getNormalization(X)
print('Original data is:\n')
print(X)
print('\nData has been reduced from %d to %d\n' % (D, cls.D_p))
print('\nThe projected data is: \n')
print(projection)
self.ksigmas[k] = self.ksigmas[k] / self.num_datos_clase_k[k]
def predict(self, X):
predictions = []
for n in range(len(X.T)):
predictions.append(np.argmin( \
[(X.T[n] - self.kmeans[k]).dot(np.linalg.inv(self.ksigmas[k])).dot((X.T[n] - self.kmeans[k]).T) + log(np.linalg.det(self.ksigmas[k])) - 2*log(self.num_datos_clase_k[k] / len(X.T)) for k in range(len(self.kmeans))]))
return predictions
if __name__ == '__main__':
colors = ['r', 'g', 'b', 'y', 'm', '#0ff0f0', '#112f1f', '#fff000']
D = 2
K = 4
X, tags = create_Dd_data(D, K, 1, 0.2, 1300, 1400)
# Shuffle data
ds = list(zip(X.T, tags))
shuffle(ds)
X = np.array([x for (x, _) in ds]).T
tags = np.array([t for (_, t) in ds])
cls = BayesClassifier()
fl = floor(len(X.T) * 0.75)
cls.train(X.T[0:fl].T, tags[0:fl], K)
# Test with 25%
predictions = cls.predict(X.T[fl:len(X.T)].T)
score = [tags[fl + i] == predictions[i] for i in range(len(X.T) - fl)]
print('Score of test dataset: %d/%d' % (score.count(True), len(score)))