import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Random data generation
np.random.seed(42)  # To reproduce the same results on each run
n_samples = 50  # Number of samples
purity = np.random.rand(n_samples)  # Random purity values between 0 and 1
gold_price = 1000 + 500 * purity + np.random.normal(0, 50, n_samples)  # Gold price based on purity

# Creating the data array
data = np.column_stack((purity, gold_price))

# Creating a Pandas DataFrame for the table
df = pd.DataFrame(data, columns=['Purity', 'Gold Price'])

# Calculate a non-optimal linear regression line
x = data[:, 0]
non_optimal_line = 600 * x + 1000

# Creating the plot
plt.figure(figsize=(10, 6))
plt.scatter(data[:, 0], data[:, 1], label='Data')

# Adding the non-optimal linear regression line in red
plt.plot(x, non_optimal_line, color='red', label='Non-Optimal Linear Regression Line')


plt.xlabel('Gold Purity')
plt.ylabel('Gold Price')
plt.title('Relationship between Gold Purity and Price')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Random data generation
np.random.seed(42)  # To reproduce the same results on each run
n_samples = 50  # Number of samples
purity = np.random.rand(n_samples)  # Random purity values between 0 and 1
gold_price = 1000 + 500 * purity + np.random.normal(0, 50, n_samples)  # Gold price based on purity

# Creating the data array
data = np.column_stack((purity, gold_price))

# Creating a Pandas DataFrame for the table
df = pd.DataFrame(data, columns=['Purity', 'Gold Price'])

# Calculate a non-optimal linear regression line
x = data[:, 0]
non_optimal_line = 600 * x + 1000

# Creating the plot
plt.figure(figsize=(10, 6))
plt.scatter(data[:, 0], data[:, 1], label='Data')

# Adding the non-optimal linear regression line in red
plt.plot(x, non_optimal_line, color='red', label='Non-Optimal Linear Regression Line')

# Adding lines indicating errors for each point relative to the non-optimal line
for i in range(n_samples):
    plt.plot([x[i], x[i]], [data[i, 1], non_optimal_line[i]], color='green', linestyle='--', linewidth=1)

# Adding a single entry in the legend for the error lines
plt.legend(['Data', 'Non-Optimal Linear Regression Line', 'Error'])

plt.xlabel('Gold Purity')
plt.ylabel('Gold Price')
plt.title('Relationship between Gold Purity and Price')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Define the sigmoid function
def sigmoid(x, a, b):
    return 1 / (1 + np.exp(-(a * x + b)))

# Define the gradient descent function for sigmoid
def gradient_descent_sigmoid(X, y, P, learning_rate, n_iterations):
    m = len(y)
    cost_history = np.zeros(n_iterations)
    for i in range(n_iterations):
        P = P - learning_rate * (1/m) * X.T.dot(sigmoid(X.dot(P), 1, 0) - y)
        cost_history[i] = cost_function_sigmoid(X, y, P)
    return P, cost_history

# Define the cost function for sigmoid
def cost_function_sigmoid(X, y, P):
    m = len(y)
    return -1 / m * np.sum(y * np.log(sigmoid(X.dot(P), 1, 0)) + (1 - y) * np.log(1 - sigmoid(X.dot(P), 1, 0)))

# Random data generation for classification
np.random.seed(42)
n_samples = 50
density = np.random.uniform(0.8, 2.0, n_samples)
threshold = 1.4
material = np.where(density > threshold, 1, 0)

# Creating the design matrix X for classification
X_class = np.column_stack((np.ones(n_samples), density))

# Creating the target vector y for classification
y_class = material.reshape(material.shape[0], 1)

# Initialize P for sigmoid classification
P_class = np.random.randn(2, 1)

# Setting the learning rate and number of iterations for sigmoid classification
learning_rate_class = 0.5
n_iterations_class = 1000000

# Performing gradient descent for sigmoid classification
P_final_class, cost_history_class = gradient_descent_sigmoid(X_class, y_class, P_class, learning_rate_class, n_iterations_class)

# Calculate the sigmoid classification curve
x_range_class = np.linspace(0.8, 2.0, 100)
y_pred_sigmoid_class = sigmoid(x_range_class, P_final_class[1], P_final_class[0])

# Creating the plot for sigmoid classification
plt.figure(figsize=(10, 6))
plt.scatter(density, material, label='Data')
plt.plot(x_range_class, y_pred_sigmoid_class, color='red', label='Fitted Sigmoid Classification')
plt.xlabel('Density')
plt.ylabel('Material (Metal: 1, Plastic: 0)')
plt.title('Classification Using Fitted Sigmoid Curve')
plt.legend()
plt.grid(True)
plt.show()

# Display the fitted parameters and cost history for sigmoid classification
print("Fitted Sigmoid Classification Parameters (a, b):", P_final_class)
plt.plot(range(n_iterations_class), cost_history_class)
plt.xlabel('Number of Iterations')
plt.ylabel('Cost')
plt.title('Cost History during Gradient Descent (Sigmoid Classification)')
plt.show()

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Random data generation
np.random.seed(42)
n_samples = 50
purity = np.random.rand(n_samples)
gold_price = 1000 + 500 * purity + np.random.normal(0, 50, n_samples)  # Linear model

# Creating the data array
data = np.column_stack((purity, gold_price))

# Creating a Pandas DataFrame for the table
df = pd.DataFrame(data, columns=['Purity', 'Gold Price'])

# Define the linear function
def linear(x, a, b):
    return a * x + b

# Define the gradient descent function
def gradient_descent(X, y, P, learning_rate, n_iterations):
    m = len(y)
    cost_history = np.zeros(n_iterations)
    for i in range(n_iterations):
        P = P - learning_rate * (1/m) * X.T.dot(X.dot(P) - y)
        cost_history[i] = cost_function(X, y, P)
    return P, cost_history

# Define the cost function
def cost_function(X, y, P):
    m = len(y)
    return 1 / (2 * m) * np.sum((X.dot(P) - y) ** 2)

# Creating the design matrix X
X = np.column_stack((np.ones(n_samples), purity))

# Creating the target vector y
y = gold_price.reshape(gold_price.shape[0], 1)

# Initialize P
P = np.random.randn(2, 1)

# Setting the learning rate and number of iterations
learning_rate = 0.1
n_iterations = 1000

# Performing gradient descent
P_final, cost_history = gradient_descent(X, y, P, learning_rate, n_iterations)

# Calculate the linear regression line
x_range = np.linspace(0, 1, 100)
y_pred = linear(x_range, P_final[1], P_final[0])

# Creating the plot
plt.figure(figsize=(10, 6))
plt.scatter(purity, gold_price, label='Data')
plt.plot(x_range, y_pred, color='red', label='Optimal Linear Regression')
plt.xlabel('Gold Purity')
plt.ylabel('Gold Price')
plt.title('Linear Relationship between Gold Purity and Price with Linear Regression')
plt.legend()
plt.grid(True)
plt.show()