ML_Ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 34dae184f4e016ff1bb096a526d3d6c0b90c258611764d878937421dff40588d
+  data.tar.gz: d04bc3f0684709b0facc19789493ab4fecad51c549fc0c059143c4e74f3ee029
+SHA512:
+  metadata.gz: 8d537746a497cd52caf070ee0c7ee429cbe910d6d870a7f8deb5608cb481131c14e95ae5b80fa7e1d0dbd3f81f0880ac132440f8351cbdd9d77e356f8d67067e
+  data.tar.gz: 1c25a49ff36920de1a361bacf64dd3b27f18aaa1d0117dec0f103fbe7a4673372c3f49137c5633adf1961d7ed4fc817eed442c8245ec6b34563ba4d064b2a6de

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/ML_Ruby.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/ML_Ruby/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ML_Ruby"
+  spec.version = MLRuby::VERSION
+  spec.authors = ["Abdul Barek"]
+  spec.email = ["barek2k2@gmail.com"]
+
+  spec.summary = "Ruby gem uses Machine Learning(ML) techniques to make predictions and classifications, and it's powered by Python3 under the hood."
+  spec.description = "This Ruby gem leverages Machine Learning(ML) techniques to make predictions(forecasts) and classifications in various applications. It provides capabilities such as predicting next month's billing, forecasting upcoming sales orders, determining user approval status, classifying text, generating similarity scores, and making recommendations. It uses Python3 under the hood, powered by popular machine learning techniques including NLP(Natural Language Processing), Decision Tree, K-Nearest Neighbors and Linear Regression algorithms."
+  spec.homepage = "https://github.com/barek2k2/ML_Ruby"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org/"
+
+  spec.metadata["homepage_uri"] = "https://github.com/barek2k2/ML_Ruby"
+  spec.metadata["source_code_uri"] = "https://github.com/barek2k2/ML_Ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/barek2k2/ML_Ruby"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/README.md

@@ -0,0 +1,135 @@
+# MLRuby
+
+This Ruby gem leverages Machine Learning(ML) techniques to make predictions(forecasts) and classifications in various applications. It provides capabilities such as predicting next month's billing, forecasting upcoming sales orders, determining user approval status, classifying text, generating similarity scores, and making recommendations. It uses Python3 under the hood, powered by popular machine learning techniques including NLP(Natural Language Processing), Decision Tree, K-Nearest Neighbors and Linear Regression algorithms.
+
+
+# Pre-requisite
+1. Please make sure you have Python3 installed in your Machine. The gem will run `which python3` to locate your installed python3 in your Machine. Usually it is installed at `/usr/bin/python3`
+
+2. Please make sure you have `scikit-learn` and `pandas` python libraries are installed in Machine.
+
+Here are examples of how to install these python libraries via the command line in MacOS. Install `nltk` if you really need to work with Natural Language Processing(NLP)
+
+`/usr/bin/python3 -m pip install scikit-learn`
+
+`/usr/bin/python3 -m pip install pandas`
+
+`/usr/bin/python3 -m pip install nltk`
+
+# Installation
+
+    $ gem install ML_Ruby
+
+# Usage
+ - ### Linear Regression Algorithm - Sales Order Prediction Example
+ 
+    Imagine you have three days' worth of sales order data represented as input features [1, 2, 3] and the corresponding sales amounts [100, 400, 430] as target variables. Now, you want to predict your sales order for day 4.
+```
+ ml = MLRuby::LinearRegression::Model.new([[1],[2],[3]], [[100], [400], [430]])
+ prediction = ml.predict([[4]])
+ puts prediction
+```
+
+ - ### Decision Tree Algorithm - User Approval Status  Example
+
+   Suppose you have a dataset that includes features such as social credit score, yearly income, and approval status (where 1 represents approval, and 0 represents non-approval). Now, you want to classify the approval status of a new person.
+
+```
+data =  [[720, 60000, 1],
+        [650, 40000, 0],
+        [780, 80000, 1],
+        [600, 30000, 0],
+        [700, 55000, 1],
+        [750, 70000, 1]]
+
+ml = MLRuby::DecisionTreeClassifier::Model.new(data)
+prediction1 = ml.predict([[180, 10000]])
+prediction2 = ml.predict([[5000, 50000]])
+```
+ - ### K-Nearest Neighbors Algorithm - Example on Recommended/Similar products in E-Commerce based application
+
+   Imagine you have a training dataset representing various products in an e-commerce platform, each characterized by specific features. Now, you want to find similar products to a given product (let's say, product ID 4) based on these features.
+
+```
+    products = [
+      {
+        "id": 1,
+        "name": "iPhone 12",
+        "price": 799,
+        "screen_size": 6.1,
+        "camera_quality": 12,
+        "battery_capacity": 2815
+      },
+      {
+        "id": 2,
+        "name": "Samsung Galaxy S21",
+        "price": 799,
+        "screen_size": 6.2,
+        "camera_quality": 12,
+        "battery_capacity": 4000
+      },
+      {
+        "id": 3,
+        "name": "Google Pixel 6",
+        "price": 699,
+        "screen_size": 6.0,
+        "camera_quality": 16,
+        "battery_capacity": 3700
+      },
+      {
+        "id": 4,
+        "name": "OnePlus 9 Pro",
+        "price": 799,
+        "screen_size": 6.7,
+        "camera_quality": 16,
+        "battery_capacity": 4500
+      },
+      {
+        "id": 5,
+        "name": "Xiaomi Mi 11",
+        "price": 699,
+        "screen_size": 6.81,
+        "camera_quality": 12,
+        "battery_capacity": 4600
+      }
+    ]
+```
+```
+feature_names = ["price", "screen_size", "camera_quality", "battery_capacity"]
+ml = MLRuby::KNearestNeighbors::Model.new(products, feature_names, 2) # 2 is the maximum number of nearest similar/recommended items
+similar_products = ml.similar_with(4)
+```
+
+```
+feature_names = ["price", "camera_quality"]
+ml = MLRuby::KNearestNeighbors::Model.new(products, feature_names, 2)
+similar_products = ml.similar_with(4)
+```
+
+ - ### Natural Language Processing(NLP): Naive Bayes Algorithm - Spam Detection in a Messaging System
+
+    In a messaging system, it's essential to identify and filter out spam text messages to ensure a smooth and secure user experience. With the capabilities of this gem, you can effectively detect spam text and take appropriate actions.
+```
+training_messages = [
+      ["Hey, congratulations! You have won a free iPhone.", "spam"],
+      ["Meeting canceled, see you later.", "not_spam"],
+      ["Buy one get one free. Limited time offer!", "spam"],
+      ["Can you please send me the report?", "not_spam"],
+      ["Meeting at 3 PM today.", "not_spam"],
+      ["Claim your prize now. You have won $1000!", "spam"],
+      ["Please reschedule the meeting on the next following day", "not_spam"],
+    ]
+
+  ml = MLRuby::NaturalLanguageProcessing::TextClassifier::Model.new(training_messages)
+  new_messages = [
+      "Welcome!, you have won 2.5 million dollars",
+      "Hello, can we schedule a meeting?",
+      "Important report attached.",
+      "Have your 50% discount on the next deal!",
+    ]
+  predictions = ml.predict(new_messages)
+```
+It's important to note that the size of your training dataset plays a significant role in enhancing the accuracy of the model's predictions. By incorporating real-world, authentic data and expanding the amount of training data for the model, it gains a better understanding of patterns and trends within the data which leads to more precise and reliable predictions.
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/barek2k2/ML_Ruby/.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/ML_Ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MLRuby
+  VERSION = "0.1.0"
+end

data/lib/ML_Ruby.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "ML_Ruby/version"
+require 'json'
+
+module MLRuby
+  PYTHON_PATH = `which python3`.gsub("\n","")
+  module LinearRegression
+    class Model
+      def initialize(x, y)
+        @x = x
+        @y = y
+      end
+      def predict(next_x)
+        script_path = "#{Gem.loaded_specs['ML_Ruby'].gem_dir}/lib/python/linear_regression.py"
+        result = `#{MLRuby::PYTHON_PATH} #{script_path} "#{@x}, #{@y}, #{next_x}"`
+        result.to_f
+      end
+    end
+  end
+
+  module DecisionTreeClassifier
+    class Model
+      def initialize(data)
+        @data = data
+      end
+      def predict(next_x)
+        script_path = "#{Gem.loaded_specs['ML_Ruby'].gem_dir}/lib/python/decision_tree_classifier.py"
+        result = `#{MLRuby::PYTHON_PATH} #{script_path} "#{@data}, #{next_x}"`
+        result.to_i
+      end
+    end
+  end
+
+  module KNearestNeighbors
+    class Model
+      def initialize(items, features=[], n_neighbors=3)
+        @items = items.to_json
+        @features = features
+        @n_neighbors = n_neighbors
+      end
+      def similar_with(id)
+        script_path = "#{Gem.loaded_specs['ML_Ruby'].gem_dir}/lib/python/k_nearest_neighbors.py"
+        result = `#{MLRuby::PYTHON_PATH} #{script_path} '#{@items}' '#{@features}' '#{id}' '#{@n_neighbors}'`
+        JSON.parse(result.gsub(/'([^']+)'/, '"\1"'))
+      end
+    end
+  end
+
+  module NaturalLanguageProcessing
+    module TextClassifier
+      class Model
+        def initialize(training_data)
+          @training_data = training_data
+        end
+        def predict(new_data=[])
+          script_path = "#{Gem.loaded_specs['ML_Ruby'].gem_dir}/lib/python/natural_language_processing/text_classifier.py"
+          result = `#{MLRuby::PYTHON_PATH} #{script_path} '#{@training_data}' '#{new_data}'`
+          JSON.parse(result.gsub("'", "\""))
+        end
+      end
+    end
+  end
+
+end

data/lib/python/decision_tree_classifier.py

@@ -0,0 +1,29 @@
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+import sys
+import ast
+
+class DecisionTreeClassifierModel:
+  def __init__(self, data):
+    self.data = data
+
+  def process_data(self):
+    self.X = [row[:2] for row in self.data[0]]
+    self.y = [row[2] for row in self.data[0]]
+    self.new_prediction = self.data[1]
+
+  def train(self):
+    self.model = DecisionTreeClassifier()
+    self.model.fit(self.X, self.y)
+
+  def predict(self):
+    prediction = self.model.predict(self.new_prediction)
+    return prediction[0]
+
+data = ast.literal_eval(sys.argv[1])
+decision_tree_classifier_model = DecisionTreeClassifierModel(data)
+decision_tree_classifier_model.process_data()
+decision_tree_classifier_model.train()
+predicted_class = decision_tree_classifier_model.predict()
+print(predicted_class)

data/lib/python/k_nearest_neighbors.py

@@ -0,0 +1,61 @@
+from sklearn.neighbors import NearestNeighbors
+import sys
+import ast
+
+class Recommendation:
+    def __init__(self, items, feature_names, n_neighbors=3):
+        self.n_neighbors = int(n_neighbors)
+        self.items = items  # List of product JSON objects
+        self.feature_names = feature_names  # List of feature property names
+        self.features = self.extract_features()  # Extract features dynamically
+        self.nn_model = NearestNeighbors(n_neighbors=self.n_neighbors)  # KNN model with k=3 default
+        self.nn_model.fit(self.features)  # Fit the KNN model during initialization
+
+    def extract_features(self):
+        # Extract features dynamically based on feature property names
+        features = []
+        for product in self.items:
+            feature_vector = [product.get(feature, 0) for feature in self.feature_names]
+            features.append(feature_vector)
+        return features
+
+    def find_similar_products(self, product_id):
+        # Find the index of the product with the given ID
+        product_index = None
+        for i, product in enumerate(self.items):
+            if product["id"] == product_id:
+                product_index = i
+                break
+
+        if product_index is None:
+            return None  # Product ID not found
+
+        # Find the k-nearest neighbors to the given product
+        distances, indices = self.nn_model.kneighbors([self.features[product_index]])
+
+        # Create a list of similar items
+        similar_products = []
+        for i in indices[0]:
+            if i != product_index:
+                similar_products.append(self.items[i])
+
+        return similar_products
+
+# Sample data as an array of JSON objects
+items = ast.literal_eval(sys.argv[1])
+
+# Define the feature property names to be extracted dynamically
+feature_names = ast.literal_eval(sys.argv[2])
+
+# id of item
+id = ast.literal_eval(sys.argv[3])
+
+# Number of neighbors to fetch from
+n_neighbors = ast.literal_eval(sys.argv[4])
+
+# Create a Recommendation instance
+recommendation = Recommendation(items, feature_names, n_neighbors)
+
+# Find similar items to a specific product by ID (e.g., ID 2)
+similar_products = recommendation.find_similar_products(id)
+print(similar_products)

data/lib/python/linear_regression.py

@@ -0,0 +1,29 @@
+import pandas as pd
+from sklearn.linear_model import LinearRegression
+import datetime
+import sys
+import ast
+
+class LinearRegressionModel:
+  def __init__(self, data):
+    self.data = data
+
+  def process_data(self):
+    self.X = self.data[0]
+    self.y = self.data[1]
+    self.new_prediction = self.data[2]
+
+  def train(self):
+    self.model = LinearRegression()
+    self.model.fit(self.X, self.y)
+
+  def predict(self):
+    prediction = self.model.predict(self.new_prediction)
+    return prediction[0][0]
+
+data = ast.literal_eval(sys.argv[1])
+linear_regression_model = LinearRegressionModel(data)
+linear_regression_model.process_data()
+linear_regression_model.train()
+forecast = linear_regression_model.predict()
+print(f"{forecast:.2f}")

data/lib/python/natural_language_processing/text_classifier.py

@@ -0,0 +1,59 @@
+import nltk
+import random
+from nltk.corpus import stopwords
+from nltk.tokenize import word_tokenize
+import sys
+import ast
+
+# Download NLTK data if not already downloaded
+nltk.download('stopwords')
+nltk.download('punkt')
+
+class TextClassifier:
+    def __init__(self):
+        self.vectorizer = None
+        self.classifier = None
+
+    def extract_features(self, text):
+        words = set(word_tokenize(text))
+        features = {word: (word not in stopwords.words('english')) for word in words}
+        return features
+
+    def train(self, texts):
+        random.shuffle(texts)
+
+        # Create feature sets
+        labeled_data = [(self.extract_features(text), label) for text, label in texts]
+
+        # Train the Naive Bayes classifier
+        self.classifier = nltk.NaiveBayesClassifier.train(labeled_data)
+
+    def test_accuracy(self, texts):
+        # Create feature sets
+        labeled_data = [(self.extract_features(text), label) for text, label in texts]
+
+        # Calculate accuracy
+        accuracy = nltk.classify.accuracy(self.classifier, labeled_data)
+        return accuracy
+
+    def classify_text(self, text):
+        features = self.extract_features(text)
+        prediction = self.classifier.classify(features)
+        return prediction
+
+# Sample dataset: spam and ham texts
+texts = ast.literal_eval(sys.argv[1])
+
+# Create and train the text_classifier
+text_classifier = TextClassifier()
+text_classifier.train(texts)
+
+# Make predictions on new texts
+new_texts = ast.literal_eval(sys.argv[2])
+
+new_prediction = []
+for text in new_texts:
+    prediction = text_classifier.classify_text(text)
+    new_prediction.append([text, prediction])
+
+print(new_prediction)

data/sig/ML_Ruby.rbs

@@ -0,0 +1,4 @@
+module MLRuby
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: ML_Ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Abdul Barek
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-09-04 00:00:00.000000000 Z
+dependencies: []
+description: This Ruby gem leverages Machine Learning(ML) techniques to make predictions(forecasts)
+  and classifications in various applications. It provides capabilities such as predicting
+  next month's billing, forecasting upcoming sales orders, determining user approval
+  status, classifying text, generating similarity scores, and making recommendations.
+  It uses Python3 under the hood, powered by popular machine learning techniques including
+  NLP(Natural Language Processing), Decision Tree, K-Nearest Neighbors and Linear
+  Regression algorithms.
+email:
+- barek2k2@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ML_Ruby.gemspec
+- README.md
+- Rakefile
+- lib/ML_Ruby.rb
+- lib/ML_Ruby/version.rb
+- lib/python/decision_tree_classifier.py
+- lib/python/k_nearest_neighbors.py
+- lib/python/linear_regression.py
+- lib/python/natural_language_processing/text_classifier.py
+- sig/ML_Ruby.rbs
+homepage: https://github.com/barek2k2/ML_Ruby
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org/
+  homepage_uri: https://github.com/barek2k2/ML_Ruby
+  source_code_uri: https://github.com/barek2k2/ML_Ruby
+  changelog_uri: https://github.com/barek2k2/ML_Ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby gem uses Machine Learning(ML) techniques to make predictions and classifications,
+  and it's powered by Python3 under the hood.
+test_files: []