ml_ai 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 72d305d5bfb2a41043e31de593461c0b4ab206eaab090c6ff4168e57066206e0
+  data.tar.gz: b0b0e2ef85d517eee9e9d12d58cc329a59ec78d820e0db384f1f37fa6ffcc18a
+SHA512:
+  metadata.gz: b142c7c71b3524c5fc97bb8be4af03098f7ab516e35c7bb1b1712a60fbde757725192b658d2b1cf91d3d8275458f84177fbf46a2f6523bc1ff506dcf7bf6aab4
+  data.tar.gz: b237928b1a3ffcecc610597c341ea7494ac88b9b266343a07064bbc0e1c0a077e8718b3b9ea8a4cd66ae6d8219dc2aeb21836047d455d2d9f72a856a21fe55a6

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-08-26
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 David William Silva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,437 @@
+# MLAI
+
+Algorithms for machine learning and artificial intelligence in [Ruby](https://www.ruby-lang.org/en/).
+
+To check this Ruby implementation, all features are implemented and benchmarked against [scikit-learn](https://scikit-learn.org/), a well-known library in [Python](https://www.python.org/) for machine learning.
+
+## Why?
+
+[Python](https://www.python.org/) is the go-to language for machine learning. But even if you don't plan to use it in production, if you are working with Ruby, you deserve to have ML/AI algorithms available in [Ruby](https://www.ruby-lang.org/en/). :) 
+
+I also know that many libraries are available in Ruby for machine learning and related areas. Here is a [curated list](https://github.com/arbox/machine-learning-with-ruby).
+
+Then why? I could name several reasons, but it will all come down to my interest in the computational challenges associated with machine learning and AI. There is no better way to identify, isolate, and inspect bottlenecks and opportunities for improvement and even the proposal of new ideas than to implement core functionalities from scratch. This will be true for most things in software: if you really want to have a deeper, more precise, and more comprehensive view of some resource, implement that resource yourself. 
+
+Plus, it is a lot of fun! 
+
+## Observations on Benchmarking
+
+Using the `scikit-learn` library in Python as a reference (and also to keep this Ruby implementation in check), allowed me to arrive at some interesting observations.
+
+### Intermediary Results
+
+Throughout the development process, a series of cases were encountered where intermediary computations—such as matrix operations and inversions—differed between the two implementations, sometimes significantly. However, these differences often had no impact on the final results, such as predictions, mean squared error (MSE), or R-squared values. The underlying reason for this lies in how numerical computations are handled in each language.
+
+### Language-Specific Matrix Computations and Precision Matters
+
+First, the way matrices are computed and inverted can vary between Ruby and Python, especially considering the libraries and methods used. Differences in how these operations are optimized and executed can lead to slight variations in intermediate results. Additionally, floating-point arithmetic is handled differently in each language, influenced by factors such as precision, rounding methods, and how numbers are represented internally. Ruby and Python might employ distinct strategies to manage these computations, leading to the observed differences.
+
+### Theory vs Practice
+
+These differences highlight the importance of understanding that while numerical algorithms are deterministic in theory, their practical implementations can introduce variability due to the intricacies of the programming languages and their respective libraries. Despite these variations, the ability of both implementations to yield virtually identical final results speaks the robustness of the underlying mathematical principles. This also emphasizes the value of cross-referencing implementations in different environments to ensure the reliability and accuracy of the models developed. By the way, one more reason for writing a new ML/AI llibrary in Ruby. :) 
+
+## Installation
+
+Run:
+
+    $ gem install ml_ai
+
+If you use Bundler, add the following to your Gemfile:
+
+    gem 'ml_ai'
+
+## Usage
+
+### Simple Linear Regression
+
+The `SimpleLinearRegression` class in the `MLAI` gem allows you to fit a linear model with a single feature, make predictions, and evaluate the model using metrics like Mean Squared Error (MSE) and R-squared. Additionally, it now supports loading data directly from a CSV file using the `Dataset` class.
+
+### Using Raw Arrays
+
+```ruby
+require 'ml_ai'
+
+# Initialize the model
+model = MLAI::SimpleLinearRegression.new
+
+# Define the dataset with a single feature
+x_values = [1, 2, 3, 4, 5]
+y_values = [3, 5, 7, 9, 11]
+
+# Fit the model to the data
+model.fit(x_values: x_values, y_values: y_values)
+
+# Make predictions on the original data
+predictions = model.predict(x_values)
+puts "Predictions: #{predictions}"
+# Output: Predictions: [3.0, 5.0, 7.0, 9.0, 11.0]
+
+# Make predictions on new data
+new_data = [6, 7]
+new_predictions = model.predict(new_data)
+puts "New Predictions: #{new_predictions}"
+# Output: New Predictions: [13.0, 15.0]
+
+# Calculate evaluation metrics
+mse = model.mean_squared_error(y_values, predictions)
+r2 = model.r_squared(y_values, predictions)
+
+puts "Mean Squared Error: #{mse}"
+# Output: Mean Squared Error: 0.0
+
+puts "R-squared: #{r2}"
+# Output: R-squared: 1.0
+```
+
+#### Using a CSV Dataset
+
+```ruby 
+require 'ml_ai'
+
+# Initialize the model
+model = MLAI::SimpleLinearRegression.new
+
+# Create a Dataset from a CSV file
+dataset = MLAI::Dataset.new('data/simple_linear_regression_data.csv')
+
+# Fit the model using the Dataset
+model.fit(dataset: dataset, feature_column: 'Feature', target_column: 'Target')
+
+# Make predictions on new feature values
+new_features = [6, 7]
+new_predictions = model.predict(new_features)
+puts "New Predictions: #{new_predictions}"
+# Output: New Predictions: [13.0, 15.0]
+
+# Evaluate the model using the original dataset
+original_features = dataset.data.map { |row| row[0] } # Assuming 'Feature' is the first column
+original_targets = dataset.data.map { |row| row[1] } # Assuming 'Target' is the second column
+original_predictions = model.predict(original_features)
+
+mse = model.mean_squared_error(original_targets, original_predictions)
+r2 = model.r_squared(original_targets, original_predictions)
+
+puts "Mean Squared Error: #{mse}"
+# Output: Mean Squared Error: 0.0
+
+puts "R-squared: #{r2}"
+# Output: R-squared: 1.0
+```
+
+#### Benchmark
+
+To check the Ruby implementation, run the Python benchmark using the same data:
+
+```
+$ python3 benchmarks/simple_linear_regression_benchmark.py
+```
+
+### Evaluation Metrics
+
+Fit a linear model, make predictions, and evaluate the model using common metrics like Mean Squared Error (MSE) and R-squared.
+
+```ruby
+require 'ml_ai'
+
+# Initialize the model
+model = MLAI::SimpleLinearRegression.new
+
+# Define the dataset
+x_values = [1, 2, 3, 4, 5]
+y_values = [2, 4, 5, 4, 5]
+
+# Fit the model to the data
+model.fit(x_values, y_values)
+
+# Make predictions
+predictions = model.predict(x_values)
+
+# Calculate evaluation metrics
+mse = model.mean_squared_error(y_values, predictions)
+r2 = model.r_squared(y_values, predictions)
+
+# Output the results
+puts "Predictions: #{predictions}"
+puts "Mean Squared Error: #{mse}"
+puts "R-squared: #{r2}"
+
+# Example output:
+# Predictions: [2.8, 3.4, 4.0, 4.6, 5.2]
+# Mean Squared Error: 0.48
+# R-squared: 0.6
+```
+
+#### Benchmark
+
+To check the Ruby implementation, run the Python benchmark using the same data:
+
+```
+$ python3 benchmarks/evaluation_metrics.py
+```
+
+#### Example
+
+Here is an example closer to the real world. Imagine you're working in real estate and want to predict the price of a house based on its size. You've gathered data from various houses, including their sizes in square feet and their prices in thousands of dollars. You want to use this data to predict the price of new houses based on their size.
+
+You can run this example here:
+
+```
+ruby examples/house_price_prediction.rb
+```
+
+and check the results with the following benchmark in Python:
+
+```
+python3 benchmarks/house_price_prediction_benchmark.py
+```
+
+### Multiple Linear Regression
+
+The `MultipleLinearRegression` class in the `MLAI` gem allows you to fit a linear model with multiple features, make predictions, and evaluate the model using metrics like Mean Squared Error (MSE) and R-squared. The class supports loading data directly from a CSV file using the `Dataset` class, as well as passing raw arrays directly.
+
+### Using Raw Arrays
+
+```ruby
+require 'ml_ai'
+
+# Initialize the model
+model = MLAI::MultipleLinearRegression.new
+
+# Define the dataset with multiple features
+x_values = [
+  [1, 2],
+  [2, 3],
+  [3, 4],
+  [4, 5],
+  [5, 6]
+]
+y_values = [5, 7, 9, 11, 13]
+
+# Fit the model to the data
+model.fit(x_values: x_values, y_values: y_values)
+
+# Make predictions on the original data
+predictions = model.predict(x_values)
+puts "Predictions: #{predictions}"
+# Output: Predictions: [5.0, 7.0, 9.0, 11.0, 13.0]
+
+# Make predictions on new data
+new_data = [
+  [6, 7],
+  [7, 8]
+]
+new_predictions = model.predict(new_data)
+puts "New Predictions: #{new_predictions}"
+# Output: New Predictions: [15.0, 17.0]
+
+# Calculate evaluation metrics
+mse = model.mean_squared_error(y_values, predictions)
+r2 = model.r_squared(y_values, predictions)
+
+puts "Mean Squared Error: #{mse}"
+# Output: Mean Squared Error: 0.0
+
+puts "R-squared: #{r2}"
+# Output: R-squared: 1.0
+```
+
+#### Using a CSV Dataset
+
+```ruby
+require 'ml_ai'
+
+# Initialize the model
+model = MLAI::MultipleLinearRegression.new
+
+# Create a Dataset from a CSV file
+dataset = MLAI::Dataset.new('data/multiple_linear_regression_data.csv')
+
+# Fit the model using the Dataset
+model.fit(dataset: dataset, feature_columns: ['Feature1', 'Feature2'], target_column: 'Target')
+
+# Make predictions on new feature values
+new_features = [
+  [6, 7],
+  [7, 8]
+]
+new_predictions = model.predict(new_features)
+puts "New Predictions: #{new_predictions}"
+# Output: New Predictions: [15.0, 17.0]
+
+# Evaluate the model using the original dataset
+original_features = dataset.data.map { |row| row[0..1] } # Assuming 'Feature1' and 'Feature2' are the first two columns
+original_targets = dataset.data.map { |row| row[2] } # Assuming 'Target' is the third column
+original_predictions = model.predict(original_features)
+
+mse = model.mean_squared_error(original_targets, original_predictions)
+r2 = model.r_squared(original_targets, original_predictions)
+
+puts "Mean Squared Error: #{mse}"
+# Output: Mean Squared Error: 0.0
+
+puts "R-squared: #{r2}"
+# Output: R-squared: 1.0
+```
+
+#### Benchmark
+
+To check the Ruby implementation, run the Python benchmark using the same data:
+
+```
+$ python3 benchmarks/multiple_linear_regression.py
+```
+
+#### Example
+
+Here is an example closer to the real world. Imagine you work at a car dealership, and you want to predict the price of used cars based on various features such as the car's age, mileage, and horsepower. You have collected data from previous sales and want to use this data to predict the price of new cars based on these features.
+
+You can run this example here:
+
+```
+ruby examples/car_price_prediction.rb
+```
+
+and check the results with the following benchmark in Python:
+
+```
+python3 benchmarks/car_price_prediction_benchmark.py
+```
+
+### Regularization
+
+Regularization helps prevent overfitting by adding a penalty to large coefficients, making the model more generalizable. In this example, we'll predict advertising revenue based on the amount spent on TV, radio, and newspaper advertisements. Regularization is applied to prevent overfitting and ensure the model generalizes well to new data.
+
+```ruby
+# frozen_string_literal: true
+
+# Example: Predicting Advertising Revenue with Regularization
+
+require_relative '../lib/ml_ai'
+
+# Initialize the model with a regularization parameter
+model = MLAI::MultipleLinearRegression.new(regularization: 0.00083)
+
+# Create a Dataset from a CSV file
+dataset = MLAI::Dataset.new('data/advertising_revenue.csv')
+
+# Fit the model using the Dataset
+model.fit(dataset: dataset, feature_columns: ['TV', 'Radio', 'Newspaper'], target_column: 'Revenue')
+
+# Print coefficients and intercept
+puts "Coefficients: #{model.coefficients.map { |coef| coef.round(2) }}"
+puts "Intercept: #{model.intercept.round(2)}"
+
+# Predict the revenue based on new advertising spends
+new_ad_spend = [[230, 37, 69]] # TV: $230, Radio: $37, Newspaper: $69
+predicted_revenue = model.predict(new_ad_spend).first.round(2)
+puts "Predicted Advertising Revenue: $#{predicted_revenue}"
+
+# Evaluate the model using the original dataset
+original_features = dataset.data.map { |row| row[0..2] } # Extracting 'TV', 'Radio', 'Newspaper'
+original_revenue = dataset.data.map { |row| row[3] } # Extracting 'Revenue'
+predictions = model.predict(original_features).map { |p| p.round(2) }
+
+mse = model.mean_squared_error(original_revenue, predictions).round(2)
+r2 = model.r_squared(original_revenue, predictions).round(2)
+
+puts "Mean Squared Error: #{mse}"
+puts "R-squared: #{r2}"
+```
+
+#### Example
+
+Here is an example closer to the real world. Imagine you're working for a company that wants to predict the salary of employees based on several factors, including their years of experience, level of education, and number of relevant skills. You have collected data from existing employees and want to use this data to predict salaries for new hires.
+
+You can run this example here:
+
+```
+ruby examples/employee_salary_prediction.rb
+```
+
+and check the results with the following benchmark in Python:
+
+```
+python3 benchmarks/employee_salary_prediction_benchmark.py
+```
+
+### Cross-Validation
+
+Cross-validation is a powerful technique to evaluate the performance of your model by splitting your dataset into multiple folds. The model is trained on a subset of the data and tested on the remaining data, and this process is repeated multiple times. The final evaluation metric is the average of all the individual metrics across the folds.
+
+#### Example Usage with Raw Arrays
+
+```ruby
+# Require the necessary files
+require 'ml_ai'
+
+# Initialize the model with regularization
+model = MLAI::MultipleLinearRegression.new(regularization: 0.01)
+
+# Define the input data
+x_values = [
+  [1, 2],
+  [2, 3],
+  [3, 4],
+  [4, 5],
+  [5, 6]
+]
+y_values = [5, 7, 9, 11, 13]
+
+# Perform 3-fold cross-validation
+average_mse = model.cross_validate(x_values: x_values, y_values: y_values, k: 3)
+puts "Average Mean Squared Error across 3 folds: #{average_mse.round(4)}"
+```
+
+#### Example Using a CSV Dataset
+
+```ruby
+# Require the necessary files
+require 'ml_ai'
+
+# Create a Dataset from a CSV file
+dataset = MLAI::Dataset.new('path_to_your_dataset.csv')
+
+# Initialize the model with regularization
+model = MLAI::MultipleLinearRegression.new(regularization: 0.01)
+
+# Perform 3-fold cross-validation
+average_mse = model.cross_validate(dataset: dataset, feature_columns: ["Feature1", "Feature2"], target_column: "Target", k: 3)
+puts "Average Mean Squared Error across 3 folds: #{average_mse.round(4)}"
+```
+
+#### Example
+
+Here is an example closer to the real world. Imagine that we want to predict the energy consumption of a building based on its size, the number of occupants, and the number of computers it houses. We'll use the `MultipleLinearRegression` class with cross-validation.
+
+You can run this example here:
+
+```
+ruby examples/energy_consumption_prediction.rb
+```
+
+and check the results with the following benchmark in Python:
+
+```
+python3 benchmarks/energy_consumption_prediction_benchmark.py
+```
+
+### Dataset
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/davidwilliam/MLAI. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/davidwilliam/MLAI/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the MlAi project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/ml_ai/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/benchmarks/car_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/car_prices.csv"
+data = pd.read_csv(csv_file_path)
+
+# Extract feature and target columns
+x = data[['Age', 'Mileage', 'Horsepower']].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([[4, 55000, 140]])
+new_prediction = model.predict(new_data)
+new_prediction = np.round(new_prediction, 2)  # Limit to two decimal places
+
+print(f"Predicted Price for the car: ${new_prediction[0]}")