Least angle 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/Bayesian-Regression.py

@@ -0,0 +1,106 @@
+#Import the necessary libraries
+import torch
+import pyro
+import pyro.distributions as dist
+from pyro.infer import SVI, Trace_ELBO, Predictive
+from pyro.optim import Adam
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+
+# Generate some sample data
+torch.manual_seed(0)
+X = torch.linspace(0, 10, 100)
+true_slope = 2
+true_intercept = 1
+Y = true_intercept + true_slope * X + torch.randn(100)
+
+# Define the Bayesian regression model
+def model(X, Y):
+	# Priors for the parameters
+	slope = pyro.sample("slope", dist.Normal(0, 10))
+	intercept = pyro.sample("intercept", dist.Normal(0, 10))
+	sigma = pyro.sample("sigma", dist.HalfNormal(1))
+
+	# Expected value of the outcome
+	mu = intercept + slope * X
+
+	# Likelihood (sampling distribution) of the observations
+	with pyro.plate("data", len(X)):
+		pyro.sample("obs", dist.Normal(mu, sigma), obs=Y)
+
+# Run Bayesian inference using SVI (Stochastic Variational Inference)
+def guide(X, Y):
+	# Approximate posterior distributions for the parameters
+	slope_loc = pyro.param("slope_loc", torch.tensor(0.0))
+	slope_scale = pyro.param("slope_scale", torch.tensor(1.0),
+							constraint=dist.constraints.positive)
+	intercept_loc = pyro.param("intercept_loc", torch.tensor(0.0))
+	intercept_scale = pyro.param("intercept_scale", torch.tensor(1.0),
+								constraint=dist.constraints.positive)
+	sigma_loc = pyro.param("sigma_loc", torch.tensor(1.0), 
+						constraint=dist.constraints.positive)
+
+	# Sample from the approximate posterior distributions
+	slope = pyro.sample("slope", dist.Normal(slope_loc, slope_scale))
+	intercept = pyro.sample("intercept", dist.Normal(intercept_loc, 
+													intercept_scale))
+	sigma = pyro.sample("sigma", dist.HalfNormal(sigma_loc))
+
+# Initialize the SVI and optimizer
+optim = Adam({"lr": 0.01})
+svi = SVI(model, guide, optim, loss=Trace_ELBO())
+
+# Run the inference loop
+num_iterations = 1000
+for i in range(num_iterations):
+	loss = svi.step(X, Y)
+	if (i + 1) % 100 == 0:
+		print(f"Iteration {i + 1}/{num_iterations} - Loss: {loss}")
+
+# Obtain posterior samples using Predictive
+predictive = Predictive(model, guide=guide, num_samples=1000)
+posterior = predictive(X, Y)
+
+# Extract the parameter samples
+slope_samples = posterior["slope"]
+intercept_samples = posterior["intercept"]
+sigma_samples = posterior["sigma"]
+
+# Compute the posterior means
+slope_mean = slope_samples.mean()
+intercept_mean = intercept_samples.mean()
+sigma_mean = sigma_samples.mean()
+
+# Print the estimated parameters
+print("Estimated Slope:", slope_mean.item())
+print("Estimated Intercept:", intercept_mean.item())
+print("Estimated Sigma:", sigma_mean.item())
+
+
+# Create subplots
+fig, axs = plt.subplots(1, 3, figsize=(15, 5))
+
+# Plot the posterior distribution of the slope
+sns.kdeplot(slope_samples, shade=True, ax=axs[0])
+axs[0].set_title("Posterior Distribution of Slope")
+axs[0].set_xlabel("Slope")
+axs[0].set_ylabel("Density")
+
+# Plot the posterior distribution of the intercept
+sns.kdeplot(intercept_samples, shade=True, ax=axs[1])
+axs[1].set_title("Posterior Distribution of Intercept")
+axs[1].set_xlabel("Intercept")
+axs[1].set_ylabel("Density")
+
+# Plot the posterior distribution of sigma
+sns.kdeplot(sigma_samples, shade=True, ax=axs[2])
+axs[2].set_title("Posterior Distribution of Sigma")
+axs[2].set_xlabel("Sigma")
+axs[2].set_ylabel("Density")
+
+# Adjust the layout
+plt.tight_layout()
+
+# Show the plot
+plt.show()

Regression-Techniques/Isotonic-Regression.py

@@ -0,0 +1,23 @@
+from sklearn.isotonic import IsotonicRegression
+import matplotlib.pyplot as plt 
+from matplotlib.collections import LineCollection
+
+ir = IsotonicRegression() # create an instance of the IsotonicRegression class 
+
+# Fit isotonic regression model 
+y_ir = ir.fit_transform(x, y) # fit the model and transform the data 
+print('Isotonic Regression Predictions :\n',y_ir)
+
+# Create LineCollection for the isotonic regression line
+lines = [[[i, y_ir[i]] for i in range(n)]]
+
+# Line to measure the difference between actual and target value
+lc = LineCollection(lines)
+
+plt.plot(x, y_ir, '-', markersize=10, label='isotonic regression')
+
+plt.gca().add_collection(lc)
+plt.legend()  # add a legend
+
+plt.title("Isotonic Regression")
+plt.show()