ml_ai 0.1.0

data/benchmarks/employee_salary_prediction_benchmark.py

@@ -0,0 +1,38 @@
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import Ridge
+from sklearn.metrics import mean_squared_error, r2_score
+
+# Load data from CSV file
+csv_file_path = "data/employee_salaries.csv"
+data = pd.read_csv(csv_file_path)
+
+# Extract feature and target columns
+x = data[['Experience', 'Education', 'Skills']].values
+y = data['Salary'].values
+
+# Initialize and fit the model with regularization (Ridge Regression)
+model = Ridge(alpha=0.1)
+model.fit(x, y)
+
+# Make predictions on the same data
+predictions = model.predict(x)
+predictions = np.round(predictions, 2)  # Limit to two decimal places
+
+# Calculate evaluation metrics
+mse = mean_squared_error(y, predictions)
+r2 = r2_score(y, predictions)
+
+# Print the results
+print(f"Coefficients: {np.round(model.coef_, 2)}")
+print(f"Intercept: {round(model.intercept_, 2)}")
+print(f"Predictions: {predictions}")
+print(f"MSE: {round(mse, 2)}")
+print(f"R-squared: {round(r2, 2)}")
+
+# Predict on new data
+new_data = np.array([[6, 3, 6]])
+new_prediction = model.predict(new_data)
+new_prediction = np.round(new_prediction, 2)  # Limit to two decimal places
+
+print(f"Predicted Salary for the new employee: ${new_prediction[0]}")

data/benchmarks/energy_consumption_prediction_benchmark.py

@@ -0,0 +1,37 @@
+import pandas as pd
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error, r2_score
+import numpy as np
+
+# Load the dataset
+df = pd.read_csv('data/energy_consumption.csv')
+
+# Prepare the features (X) and the target (y)
+X = df[['Size', 'Occupants', 'Computers']]
+y = df['EnergyConsumption']
+
+# Initialize and fit the model
+model = LinearRegression()
+model.fit(X, y)
+
+# Perform predictions on the same dataset to evaluate the model
+predictions = model.predict(X)
+predictions = np.round(predictions, 2)  # Round predictions to 2 decimal places
+
+# Calculate evaluation metrics
+mse = mean_squared_error(y, predictions)
+r2 = r2_score(y, predictions)
+
+# Print the results
+print(f"Coefficients: {np.round(model.coef_, 2)}")
+print(f"Intercept: {round(model.intercept_, 2)}")
+print(f"Predictions: {predictions}")
+print(f"MSE: {round(mse, 2)}")
+print(f"R-squared: {round(r2, 2)}")
+
+# Predict the energy consumption for a new building
+new_building = pd.DataFrame([[3500, 60, 70]], columns=['Size', 'Occupants', 'Computers'])
+new_prediction = model.predict(new_building)
+new_prediction = round(new_prediction[0], 2)  # Round the prediction to 2 decimal places
+
+print(f"Predicted energy consumption for the new building: {new_prediction} kWh")

data/benchmarks/evaluation_metrics.py

@@ -0,0 +1,32 @@
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error, r2_score
+import numpy as np
+
+# Define the dataset
+x_values = np.array([1, 2, 3, 4, 5]).reshape(-1, 1)
+y_values = np.array([2, 4, 5, 4, 5])
+
+# Initialize and fit the model
+model = LinearRegression()
+model.fit(x_values, y_values)
+
+# Make predictions
+predictions = model.predict(x_values)
+
+# Limit predictions to two decimal digits
+predictions = np.round(predictions, 2)
+
+# Calculate evaluation metrics
+mse = mean_squared_error(y_values, predictions)
+r2 = r2_score(y_values, predictions)
+
+# Limit MSE and R-squared to two decimal digits
+mse = round(mse, 2)
+r2 = round(r2, 2)
+
+# Print results
+print(f"Slope: {round(model.coef_[0], 2)}")
+print(f"Intercept: {round(model.intercept_, 2)}")
+print(f"Predictions: {predictions}")
+print(f"MSE: {mse}")
+print(f"R-squared: {r2}")

data/benchmarks/house_price_prediction_benchmark.py

@@ -0,0 +1,38 @@
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error, r2_score
+
+# Load data from CSV file
+csv_file_path = "data/house_prices.csv"
+data = pd.read_csv(csv_file_path)
+
+# Extract feature and target columns
+x = data[['Size']].values
+y = data['Price'].values
+
+# Initialize and fit the model
+model = LinearRegression()
+model.fit(x, y)
+
+# Make predictions on the same data
+predictions = model.predict(x)
+predictions = np.round(predictions, 2)  # Limit to two decimal places
+
+# Calculate evaluation metrics
+mse = mean_squared_error(y, predictions)
+r2 = r2_score(y, predictions)
+
+# Print the results
+print(f"Coefficients: {np.round(model.coef_, 2)}")
+print(f"Intercept: {round(model.intercept_, 2)}")
+print(f"Predictions: {predictions}")
+print(f"MSE: {round(mse, 2)}")
+print(f"R-squared: {round(r2, 2)}")
+
+# Predict on new data
+new_data = np.array([[1600]])
+new_prediction = model.predict(new_data)
+new_prediction = np.round(new_prediction, 2)  # Limit to two decimal places
+
+print(f"Predicted Price for a 1600 sq ft house: {new_prediction[0]} thousand dollars")

data/benchmarks/multiple_linear_regression.py

@@ -0,0 +1,78 @@
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error, r2_score
+
+# Load data from CSV file
+csv_file_path = "data/multiple_linear_regression_data.csv"
+data = pd.read_csv(csv_file_path)
+
+# Extract feature and target columns
+x_csv = data[['Feature1', 'Feature2']].values
+y_csv = data['Target'].values
+
+# Initialize and fit the model using the CSV data
+model_csv = LinearRegression()
+model_csv.fit(x_csv, y_csv)
+
+# Make predictions on the same data
+predictions_csv = model_csv.predict(x_csv)
+predictions_csv = np.round(predictions_csv, 2)  # Limit to two decimal places
+
+# Calculate evaluation metrics
+mse_csv = mean_squared_error(y_csv, predictions_csv)
+r2_csv = r2_score(y_csv, predictions_csv)
+
+# Print the results
+print(f"CSV Coefficients: {np.round(model_csv.coef_, 2)}")
+print(f"CSV Intercept: {round(model_csv.intercept_, 2)}")
+print(f"CSV Predictions: {predictions_csv}")
+print(f"CSV MSE: {round(mse_csv, 2)}")
+print(f"CSV R-squared: {round(r2_csv, 2)}")
+
+# Predict on new data using the model trained on CSV data
+new_data = np.array([
+    [6, 7],
+    [7, 8]
+])
+new_predictions_csv = model_csv.predict(new_data)
+new_predictions_csv = np.round(new_predictions_csv, 2)  # Limit to two decimal places
+
+print(f"New Predictions from CSV: {new_predictions_csv}")
+
+# Original example for comparison
+
+# Define the dataset with multiple features
+x_values = np.array([
+    [1, 2],
+    [2, 3],
+    [3, 4],
+    [4, 5],
+    [5, 6]
+])
+y_values = np.array([5, 7, 9, 11, 13])
+
+# Initialize and fit the model
+model = LinearRegression()
+model.fit(x_values, y_values)
+
+# Make predictions on the same data
+predictions = model.predict(x_values)
+predictions = np.round(predictions, 2)  # Limit to two decimal places
+
+# Calculate evaluation metrics
+mse = mean_squared_error(y_values, predictions)
+r2 = r2_score(y_values, predictions)
+
+# Print the results
+print(f"Coefficients: {np.round(model.coef_, 2)}")
+print(f"Intercept: {round(model.intercept_, 2)}")
+print(f"Predictions: {predictions}")
+print(f"MSE: {round(mse, 2)}")
+print(f"R-squared: {round(r2, 2)}")
+
+# Predict on new data
+new_predictions = model.predict(new_data)
+new_predictions = np.round(new_predictions, 2)  # Limit to two decimal places
+
+print(f"New Predictions: {new_predictions}")

data/benchmarks/simple_linear_regression_benchmark.py

@@ -0,0 +1,55 @@
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LinearRegression
+
+# Load data from CSV file
+csv_file_path = "data/simple_linear_regression_data.csv"
+data = pd.read_csv(csv_file_path)
+
+# Extract feature and target columns
+x_csv = data[['Feature']].values
+y_csv = data['Target'].values
+
+# Initialize the model and fit using the CSV data
+model_csv = LinearRegression().fit(x_csv, y_csv)
+
+# Make predictions on the same data
+predictions_csv = model_csv.predict(x_csv)
+print(f"CSV Dataset Predictions: {predictions_csv}")  # Output will match the Target column
+
+# Make a prediction on new data
+new_data_prediction = model_csv.predict([[6]])
+print(f"New Data Prediction from CSV: {new_data_prediction}")  # Example: [13.]
+
+# Example 1: Basic Usage
+x_basic = np.array([1, 2, 3]).reshape(-1, 1)
+y_basic = np.array([2, 4, 6])
+
+# Initialize the model and fit
+model_basic = LinearRegression().fit(x_basic, y_basic)
+
+# Make a prediction
+prediction_basic = model_basic.predict([[4]])
+print(f"Basic Example Prediction: {prediction_basic}")  # Output: [8.]
+
+# Example 2: Larger Dataset
+x_large = np.array(range(1, 101)).reshape(-1, 1)
+y_large = np.array([3 * x + 5 for x in range(1, 101)])
+
+# Initialize the model and fit
+model_large = LinearRegression().fit(x_large, y_large)
+
+# Make a prediction
+prediction_large = model_large.predict([[150]])
+print(f"Larger Dataset Prediction: {prediction_large}")  # Output: [455.]
+
+# Example 3: Handling Negative and Positive Values
+x_mixed = np.array([-10, -5, 0, 5, 10]).reshape(-1, 1)
+y_mixed = np.array([2 * x - 3 for x in [-10, -5, 0, 5, 10]])
+
+# Initialize the model and fit
+model_mixed = LinearRegression().fit(x_mixed, y_mixed)
+
+# Make a prediction
+prediction_mixed = model_mixed.predict([[15]])
+print(f"Negative and Positive Values Prediction: {prediction_mixed}")  # Output: [27.]

data/data/advertising_revenue.csv

@@ -0,0 +1,6 @@
+TV,Radio,Newspaper,Revenue
+150,23,50,12.5
+120,10,45,10.2
+200,30,60,14.8
+180,28,52,13.6
+240,40,70,16.3

data/data/car_prices.csv

@@ -0,0 +1,6 @@
+Age,Mileage,Horsepower,Price
+3,50000,150,20000
+5,80000,120,15000
+2,30000,200,25000
+7,100000,100,12000
+4,60000,160,18000

data/data/employee_salaries.csv

@@ -0,0 +1,6 @@
+Experience,Education,Skills,Salary
+5,3,5,70000
+7,2,7,85000
+10,1,8,90000
+3,4,4,60000
+8,2,6,80000

data/data/energy_consumption.csv

@@ -0,0 +1,11 @@
+Size,Occupants,Computers,EnergyConsumption
+1000,10,20,3000
+1200,15,25,3500
+1500,20,30,4000
+1700,25,35,4500
+2000,30,40,5000
+2200,35,45,5500
+2500,40,50,6000
+2700,45,55,6500
+3000,50,60,7000
+3200,55,65,7500

data/data/house_prices.csv

@@ -0,0 +1,6 @@
+Size,Price
+800,150
+1000,200
+1200,240
+1500,300
+1800,360

data/data/multiple_linear_regression_data.csv

@@ -0,0 +1,6 @@
+Feature1,Feature2,Target
+1,2,5
+2,3,7
+3,4,9
+4,5,11
+5,6,13

data/data/simple_linear_regression_data.csv

@@ -0,0 +1,6 @@
+Feature,Target
+1,3
+2,5
+3,7
+4,9
+5,11

data/examples/car_price_prediction.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Example: Predicting Car Prices Based on Multiple Features
+
+require_relative '../lib/ml_ai'
+
+# Initialize the model
+model = MLAI::MultipleLinearRegression.new
+
+# Create a Dataset from the CSV file
+dataset = MLAI::Dataset.new('data/car_prices.csv')
+
+# Fit the model using the Dataset
+model.fit(dataset: dataset, feature_columns: ['Age', 'Mileage', 'Horsepower'], target_column: 'Price')
+
+# Predict the price of a new car
+new_car_features = [[4, 55000, 140]] # Age: 4 years, Mileage: 55,000 miles, Horsepower: 140
+predicted_price = model.predict(new_car_features).first.round(2)
+puts "Predicted Price for the car: $#{predicted_price}"
+
+# Evaluate the model using the original dataset
+original_features = dataset.data.map { |row| row[0..2] } # Assuming 'Age', 'Mileage', 'Horsepower' are the first three columns
+original_prices = dataset.data.map { |row| row[3] } # Assuming 'Price' is the fourth column
+predictions = model.predict(original_features).map { |p| p.round(2) }
+
+mse = model.mean_squared_error(original_prices, predictions).round(2)
+r2 = model.r_squared(original_prices, predictions).round(2)
+
+puts "Mean Squared Error: #{mse}"
+puts "R-squared: #{r2}"

data/examples/employee_salary_prediction.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Example: Predicting Employee Salaries Based on Experience, Education, and Skills
+
+require_relative '../lib/ml_ai'
+
+# Initialize the model with a smaller regularization parameter
+model = MLAI::MultipleLinearRegression.new(regularization: 0.00083)
+
+# Create a Dataset from the CSV file
+dataset = MLAI::Dataset.new('data/employee_salaries.csv')
+
+# Fit the model using the Dataset
+model.fit(dataset: dataset, feature_columns: ['Experience', 'Education', 'Skills'], target_column: 'Salary')
+
+# Print coefficients and intercept for comparison
+puts "Coefficients: #{model.coefficients.map { |coef| coef.round(2) }}"
+puts "Intercept: #{model.intercept.round(2)}"
+
+# Predict the salary of a new employee
+new_employee_features = [[6, 3, 6]] # Experience: 6 years, Education: Master's, Skills: 6
+predicted_salary = model.predict(new_employee_features).first.round(2)
+puts "Predicted Salary for the new employee: $#{predicted_salary}"
+
+# Evaluate the model using the original dataset
+original_features = dataset.data.map { |row| row[0..2] } # Assuming 'Experience', 'Education', 'Skills' are the first three columns
+original_salaries = dataset.data.map { |row| row[3] } # Assuming 'Salary' is the fourth column
+predictions = model.predict(original_features).map { |p| p.round(2) }
+
+mse = model.mean_squared_error(original_salaries, predictions).round(2)
+r2 = model.r_squared(original_salaries, predictions).round(2)
+
+puts "Mean Squared Error: #{mse}"
+puts "R-squared: #{r2}"

data/examples/energy_consumption_prediction.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../lib/ml_ai'
+
+# Load the dataset
+dataset = MLAI::Dataset.new('data/energy_consumption.csv')
+
+# Initialize the MultipleLinearRegression model with slight regularization to avoid singular matrix
+model = MLAI::MultipleLinearRegression.new(regularization: 1e-9)
+
+# Perform 5-fold cross-validation
+average_mse = model.cross_validate(dataset: dataset, feature_columns: ["Size", "Occupants", "Computers"], target_column: "EnergyConsumption", k: 5)
+
+# Fit the model on the entire dataset
+model.fit(dataset: dataset, feature_columns: ["Size", "Occupants", "Computers"], target_column: "EnergyConsumption")
+
+# Get the coefficients and intercept
+coefficients = model.coefficients.map { |coef| coef.round(2) }
+intercept = model.intercept.round(2)
+
+# Perform predictions on the same dataset to evaluate the model
+predictions = model.predict(dataset.data.map { |row| row[0..2] })
+predictions = predictions.map { |pred| pred.round(2) }  # Round predictions to 2 decimal places
+
+# Calculate evaluation metrics
+mse = model.mean_squared_error(dataset.data.map { |row| row[3] }, predictions)
+r_squared = model.r_squared(dataset.data.map { |row| row[3] }, predictions)
+
+# Print the results in the desired format
+puts "Coefficients: #{coefficients.inspect}"
+puts "Intercept: #{intercept}"
+puts "Predictions: #{predictions.inspect}"
+puts "MSE: #{mse.round(2)}"
+puts "R-squared: #{r_squared.round(2)}"
+
+# Predict the energy consumption for a new building
+new_building = [[3500, 60, 70]]  # A building with 3500 sq ft, 60 occupants, and 70 computers
+predicted_energy_consumption = model.predict(new_building).first
+puts "Predicted energy consumption for the new building: #{predicted_energy_consumption.round(2)} kWh"

data/examples/house_price_prediction.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Example: Predicting House Prices Based on Size
+
+require_relative '../lib/ml_ai'
+
+# Initialize the model
+model = MLAI::SimpleLinearRegression.new
+
+# Create a Dataset from the CSV file
+dataset = MLAI::Dataset.new('data/house_prices.csv')
+
+# Fit the model using the Dataset
+model.fit(dataset: dataset, feature_column: 'Size', target_column: 'Price')
+
+# Predict the price of a new house
+new_house_size = [1600] # Size of the new house in square feet
+predicted_price = model.predict(new_house_size).first.round(2)
+puts "Predicted Price for a 1600 sq ft house: #{predicted_price} thousand dollars"
+
+# Evaluate the model using the original dataset
+original_sizes = dataset.data.map { |row| row[0] } # Assuming 'Size' is the first column
+original_prices = dataset.data.map { |row| row[1] } # Assuming 'Price' is the second column
+predictions = model.predict(original_sizes).map { |p| p.round(2) }
+
+mse = model.mean_squared_error(original_prices, predictions).round(2)
+r2 = model.r_squared(original_prices, predictions).round(2)
+
+puts "Mean Squared Error: #{mse}"
+puts "R-squared: #{r2}"

data/lib/ml_ai/dataset.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module MLAI
+  class Dataset
+    attr_reader :data, :headers
+
+    def initialize(filename)
+      @filename = filename
+      @data = []
+      @headers = []
+
+      load_csv
+    end
+
+    private
+
+    def load_csv
+      csv_data = CSV.read(@filename, headers: true)
+      @headers = csv_data.headers
+      @data = csv_data.map { |row| row.fields.map(&:to_f) } # Convert all fields to floats
+    end
+  end
+end

data/lib/ml_ai/multiple_linear_regression.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'matrix'
+require_relative 'dataset'
+
+module MLAI
+  class MultipleLinearRegression
+    attr_reader :coefficients, :intercept, :regularization
+
+    def initialize(alpha = 1e-8, regularization: 0.0)
+      @coefficients = nil
+      @intercept = nil
+      @alpha = alpha # Small value to avoid singular matrix in inversion
+      @regularization = regularization # Regularization strength for Ridge Regression
+    end
+
+    # Fit method accepts either x_values and y_values or a Dataset object with specified columns
+    def fit(x_values: nil, y_values: nil, dataset: nil, feature_columns: nil, target_column: nil)
+      if dataset
+        # Extract feature and target columns from the dataset
+        feature_indices = feature_columns.map { |col| dataset.headers.index(col) }
+        target_index = dataset.headers.index(target_column)
+    
+        x_values = dataset.data.map { |row| feature_indices.map { |i| row[i] } }
+        y_values = dataset.data.map { |row| row[target_index] }
+      end
+    
+      raise "Input arrays must have the same length" unless x_values.length == y_values.length
+    
+      # Convert x_values to a matrix and add a column of ones for the intercept
+      x_matrix = Matrix[*x_values.map { |x| [1] + x }]
+      y_vector = Vector.elements(y_values)
+    
+      # Calculate coefficients using the normal equation with regularization: (X^T * X + λI)^-1 * X^T * Y
+      x_transpose = x_matrix.transpose
+      regularization_matrix = Matrix.build(x_matrix.column_count) { |i, j| i == j ? @regularization : 0 }
+      
+      xtx = x_transpose * x_matrix + regularization_matrix
+    
+      begin
+        theta = xtx.inverse * x_transpose * y_vector
+      rescue ExceptionForMatrix::ErrNotRegular
+        raise "Matrix is singular or nearly singular, consider increasing regularization"
+      end
+    
+      @intercept = theta[0]
+      @coefficients = theta.to_a[1..-1]
+    end
+    
+    def predict(x_values)
+      raise "Model has not been fitted yet" if @coefficients.nil? || @intercept.nil?
+
+      x_values.map do |x|
+        @coefficients.each_with_index.reduce(@intercept) do |sum, (coef, i)|
+          sum + coef * x[i]
+        end
+      end
+    end
+
+    def mean_squared_error(y_true, y_pred)
+      raise "Input arrays must have the same length" unless y_true.length == y_pred.length
+
+      n = y_true.length
+      sum_squared_errors = y_true.each_with_index.map { |y, i| (y - y_pred[i]) ** 2 }.sum
+      sum_squared_errors / n.to_f
+    end
+
+    def r_squared(y_true, y_pred)
+      raise "Input arrays must have the same length" unless y_true.length == y_pred.length
+
+      mean_y = y_true.sum / y_true.length.to_f
+      ss_total = y_true.map { |y| (y - mean_y) ** 2 }.sum
+      ss_residual = y_true.each_with_index.map { |y, i| (y - y_pred[i]) ** 2 }.sum
+
+      1 - (ss_residual / ss_total.to_f)
+    end
+
+    # Cross-validation method to evaluate model performance
+    def cross_validate(x_values: nil, y_values: nil, dataset: nil, feature_columns: nil, target_column: nil, k: 5)
+      if dataset
+        # Extract feature and target columns from the dataset
+        feature_indices = feature_columns.map { |col| dataset.headers.index(col) }
+        target_index = dataset.headers.index(target_column)
+    
+        x_values = dataset.data.map { |row| feature_indices.map { |i| row[i] } }
+        y_values = dataset.data.map { |row| row[target_index] }
+      end
+    
+      raise "Input arrays must have the same length" unless x_values.length == y_values.length
+    
+      fold_size = x_values.length / k
+      errors = []
+
+      k.times do |i|
+        test_start = i * fold_size
+        test_end = test_start + fold_size
+
+        x_train = x_values[0...test_start] + x_values[test_end..-1]
+        y_train = y_values[0...test_start] + y_values[test_end..-1]
+
+        x_test = x_values[test_start...test_end]
+        y_test = y_values[test_start...test_end]
+
+        fit(x_values: x_train, y_values: y_train)
+        predictions = predict(x_test)
+
+        errors << mean_squared_error(y_test, predictions)
+      end
+
+      errors.sum / errors.size.to_f
+    end
+  end
+end