Polynomial regression

Clustering Techniques/Affinity-Propagation-Clustering-ALgorithm.py

@@ -0,0 +1,37 @@
+from numpy import unique
+from numpy import where
+from matplotlib import pyplot
+from sklearn.datasets import make_classification
+from sklearn.cluster import AffinityPropagation
+
+# initialize the data set we'll work with
+training_data, _ = make_classification(
+    n_samples=1000,
+    n_features=2,
+    n_informative=2,
+    n_redundant=0,
+    n_clusters_per_class=1,
+    random_state=4
+)
+
+# define the model
+model = AffinityPropagation(damping=0.7)
+
+# train the model
+model.fit(training_data)
+
+# assign each data point to a cluster
+result = model.predict(training_data)
+
+# get all of the unique clusters
+clusters = unique(result)
+
+# plot the clusters
+for cluster in clusters:
+    # get data points that fall in this cluster
+    index = where(result == cluster)
+    # make the plot
+    pyplot.scatter(training_data[index, 0], training_data[index, 1])
+
+# show the plot
+pyplot.show()

Clustering Techniques/Agglomerative-Clustering-Algorithm.py

@@ -0,0 +1,34 @@
+from numpy import unique
+from numpy import where
+from matplotlib import pyplot
+from sklearn.datasets import make_classification
+from sklearn.cluster import AgglomerativeClustering
+
+# initialize the data set we'll work with
+training_data, _ = make_classification(
+    n_samples=1000,
+    n_features=2,
+    n_informative=2,
+    n_redundant=0,
+    n_clusters_per_class=1,
+    random_state=4
+)
+
+# define the model
+agglomerative_model = AgglomerativeClustering(n_clusters=2)
+
+# assign each data point to a cluster
+agglomerative_result = agglomerative_model.fit_predict(training_data)
+
+# get all of the unique clusters
+agglomerative_clusters = unique(agglomerative_result)
+
+# plot the clusters
+for agglomerative_cluster in agglomerative_clusters:
+    # get data points that fall in this cluster
+    index = where(agglomerative_result == agglomerative_clusters)
+    # make the plot
+    pyplot.scatter(training_data[index, 0], training_data[index, 1])
+
+# show the Agglomerative Hierarchy plot
+pyplot.show()

Clustering Techniques/BIRCH-Algorithm.py

@@ -0,0 +1,37 @@
+from numpy import unique
+from numpy import where
+from matplotlib import pyplot
+from sklearn.datasets import make_classification
+from sklearn.cluster import Birch
+
+# initialize the data set we'll work with
+training_data, _ = make_classification(
+    n_samples=1000,
+    n_features=2,
+    n_informative=2,
+    n_redundant=0,
+    n_clusters_per_class=1,
+    random_state=4
+)
+
+# define the model
+birch_model = Birch(threshold=0.03, n_clusters=2)
+
+# train the model
+birch_model.fit(training_data)
+
+# assign each data point to a cluster
+birch_result = birch_model.predict(training_data)
+
+# get all of the unique clusters
+birch_clusters = unique(birch_result)
+
+# plot the BIRCH clusters
+for birch_cluster in birch_clusters:
+    # get data points that fall in this cluster
+    index = where(birch_result == birch_clusters)
+    # make the plot
+    pyplot.scatter(training_data[index, 0], training_data[index, 1])
+
+# show the BIRCH plot
+pyplot.show()

Clustering Techniques/DBSCAN-Model.py

@@ -0,0 +1,37 @@
+from numpy import unique
+from numpy import where
+from matplotlib import pyplot
+from sklearn.datasets import make_classification
+from sklearn.cluster import DBSCAN
+
+# initialize the data set we'll work with
+training_data, _ = make_classification(
+    n_samples=1000,
+    n_features=2,
+    n_informative=2,
+    n_redundant=0,
+    n_clusters_per_class=1,
+    random_state=4
+)
+
+# define the model
+dbscan_model = DBSCAN(eps=0.25, min_samples=9)
+
+# train the model
+dbscan_model.fit(training_data)
+
+# assign each data point to a cluster
+dbscan_result = dbscan_model.predict(training_data)
+
+# get all of the unique clusters
+dbscan_cluster = unique(dbscan_result)
+
+# plot the DBSCAN clusters
+for dbscan_cluster in dbscan_clusters:
+    # get data points that fall in this cluster
+    index = where(dbscan_result == dbscan_clusters)
+    # make the plot
+    pyplot.scatter(training_data[index, 0], training_data[index, 1])
+
+# show the DBSCAN plot
+pyplot.show()

Clustering Techniques/Gaussain-Mixture-Model.py

@@ -0,0 +1,37 @@
+from numpy import unique
+from numpy import where
+from matplotlib import pyplot
+from sklearn.datasets import make_classification
+from sklearn.mixture import GaussianMixture
+
+# initialize the data set we'll work with
+training_data, _ = make_classification(
+    n_samples=1000,
+    n_features=2,
+    n_informative=2,
+    n_redundant=0,
+    n_clusters_per_class=1,
+    random_state=4
+)
+
+# define the model
+gaussian_model = GaussianMixture(n_components=2)
+
+# train the model
+gaussian_model.fit(training_data)
+
+# assign each data point to a cluster
+gaussian_result = gaussian_model.predict(training_data)
+
+# get all of the unique clusters
+gaussian_clusters = unique(gaussian_result)
+
+# plot Gaussian Mixture the clusters
+for gaussian_cluster in gaussian_clusters:
+    # get data points that fall in this cluster
+    index = where(gaussian_result == gaussian_clusters)
+    # make the plot
+    pyplot.scatter(training_data[index, 0], training_data[index, 1])
+
+# show the Gaussian Mixture plot
+pyplot.show()

Clustering Techniques/Mean-Shift-Clustering-algorithm.py

@@ -0,0 +1,34 @@
+from numpy import unique
+from numpy import where
+from matplotlib import pyplot
+from sklearn.datasets import make_classification
+from sklearn.cluster import MeanShift
+
+# initialize the data set we'll work with
+training_data, _ = make_classification(
+    n_samples=1000,
+    n_features=2,
+    n_informative=2,
+    n_redundant=0,
+    n_clusters_per_class=1,
+    random_state=4
+)
+
+# define the model
+mean_model = MeanShift()
+
+# assign each data point to a cluster
+mean_result = mean_model.fit_predict(training_data)
+
+# get all of the unique clusters
+mean_clusters = unique(mean_result)
+
+# plot Mean-Shift the clusters
+for mean_cluster in mean_clusters:
+    # get data points that fall in this cluster
+    index = where(mean_result == mean_cluster)
+    # make the plot
+    pyplot.scatter(training_data[index, 0], training_data[index, 1])
+
+# show the Mean-Shift plot
+pyplot.show()

Clustering Techniques/OPTICS-algorithm.py

@@ -0,0 +1,34 @@
+from numpy import unique
+from numpy import where
+from matplotlib import pyplot
+from sklearn.datasets import make_classification
+from sklearn.cluster import OPTICS
+
+# initialize the data set we'll work with
+training_data, _ = make_classification(
+    n_samples=1000,
+    n_features=2,
+    n_informative=2,
+    n_redundant=0,
+    n_clusters_per_class=1,
+    random_state=4
+)
+
+# define the model
+optics_model = OPTICS(eps=0.75, min_samples=10)
+
+# assign each data point to a cluster
+optics_result = optics_model.fit_predict(training_data)
+
+# get all of the unique clusters
+optics_clusters = unique(optics_clusters)
+
+# plot OPTICS the clusters
+for optics_cluster in optics_clusters:
+    # get data points that fall in this cluster
+    index = where(optics_result == optics_clusters)
+    # make the plot
+    pyplot.scatter(training_data[index, 0], training_data[index, 1])
+
+# show the OPTICS plot
+pyplot.show()

Regression-Techniques/Multiple-Linear-Regression.py

@@ -0,0 +1,49 @@
+def mse(coef, x, y):
+	return np.mean((np.dot(x, coef) - y)**2)/2
+
+
+def gradients(coef, x, y):
+	return np.mean(x.transpose()*(np.dot(x, coef) - y), axis=1)
+
+
+def multilinear_regression(coef, x, y, lr, b1=0.9, b2=0.999, epsilon=1e-8):
+	prev_error = 0
+	m_coef = np.zeros(coef.shape)
+	v_coef = np.zeros(coef.shape)
+	moment_m_coef = np.zeros(coef.shape)
+	moment_v_coef = np.zeros(coef.shape)
+	t = 0
+
+	while True:
+		error = mse(coef, x, y)
+		if abs(error - prev_error) <= epsilon:
+			break
+		prev_error = error
+		grad = gradients(coef, x, y)
+		t += 1
+		m_coef = b1 * m_coef + (1-b1)*grad
+		v_coef = b2 * v_coef + (1-b2)*grad**2
+		moment_m_coef = m_coef / (1-b1**t)
+		moment_v_coef = v_coef / (1-b2**t)
+
+		delta = ((lr / moment_v_coef**0.5 + 1e-8) *
+				(b1 * moment_m_coef + (1-b1)*grad/(1-b1**t)))
+
+		coef = np.subtract(coef, delta)
+	return coef
+
+
+coef = np.array([0, 0, 0])
+c = multilinear_regression(coef, x, y, 1e-1)
+fig = plt.figure()
+ax = fig.add_subplot(projection='3d')
+
+ax.scatter(x[:, 1], x[:, 2], y, label='y',
+		s=5, color="dodgerblue")
+
+ax.scatter(x[:, 1], x[:, 2], c[0] + c[1]*x[:, 1] + c[2]*x[:, 2],
+		label='regression', s=5, color="orange")
+
+ax.view_init(45, 0)
+ax.legend()
+plt.show()