lurn 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b628aa2df6567044144aebc12d52f284b0eb93e9
+  data.tar.gz: 7d6089b8ca48eb371e39288ae034543b6f447e9d
+SHA512:
+  metadata.gz: 0140373cd80d2594c4c34e5c9959f043b1f33ff527b5dd5e8ebcba7173153ee2ed3766b2f49888780040dbbe1b04e6bfce656bf0cd0b21294a9c0e50898bd798
+  data.tar.gz: dd31fabb232408c405fe7e40a630723fa39ab30f28982b8db6f0f6cf3dfeca4fc4bf4dbaae5df889e48c101617208993ee01701b1e2f34e0d550c499299d1789

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.13.7

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lurn.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 daniel.carpenter
+
+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,68 @@
+# Lurn
+
+Lurn is a ruby gem for performing machine learning. The API and design patterns in Lurn are inspired by sklearn, an analogous library for Python.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lurn'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lurn
+
+## Usage
+
+### Bernoulli Naive Bayes
+```ruby
+require 'lurn'
+
+documents = [
+  'ruby is a great programming language',
+  'the giants recently won the world series',
+  'java is a compiled programming language',
+  'the jets are a football team'
+]
+
+labels = ['computers','sports','computers','sports']
+
+# vectorizers take raw data and transform it to a set of features that our
+# model can understand - in this case an array of boolean values representing
+# the presence or absence of a word in text
+vectorizer = Lurn::Text::BernoulliVectorizer.new
+vectorizer.fit(documents)
+vectors = vectorizer.transform(documents)
+
+model = Lurn::NaiveBayes::BernoulliNaiveBayes.new
+model.fit(vectors, labels)
+
+new_vectors = vectorizer.transform(['programming is fun'])
+probabilities = model.predict_probabilities(new_vectors.first)
+# => [0.9715681919147049, 0.028431808085295614]
+
+# to get the class of the maximum probability, look at the same index of the
+# unique_labels attribute on the model
+model.unique_labels[0] # => 'computers'
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` 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 tags, 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/dansbits/lurn.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lurn"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/lurn/evaluation/classifier_evaluator.rb

@@ -0,0 +1,83 @@
+require 'terminal-table'
+require 'csv'
+
+module Lurn
+  module Evaluation
+    class ClassifierEvaluator
+
+      attr_accessor :unique_classes
+
+      def initialize(predicted, actual)
+        @classes = Daru::DataFrame.new(predicted: predicted, actual: actual)
+        @unique_classes = (predicted + actual).uniq
+        preprocess_classes
+      end
+
+      def precision(cls)
+        true_positives = true_positives(cls)
+        false_positives = false_positives(cls)
+        true_positives.to_f / (true_positives + false_positives).to_f
+      end
+
+      def recall(cls)
+        true_positives = true_positives(cls)
+        false_nevatives = false_negatives(cls)
+
+        true_positives.to_f / (true_positives + false_nevatives).to_f
+      end
+
+      def true_positives(cls)
+        @classes.filter_rows { |r| r[:predicted] == r[:actual] && r[:predicted] == cls }.size
+      end
+
+      def false_positives(cls)
+        @classes.filter_rows { |r| r[:predicted] == cls && r[:actual] != cls }.size
+      end
+
+      def false_negatives(cls)
+        @classes.filter_rows { |r| r[:actual] == cls && r[:predicted] != cls }.size
+      end
+
+      def summary
+        headings = ['Class','Precision','Recall']
+
+        ::Terminal::Table.new(rows: summary_rows, headings: headings).to_s
+      end
+
+      def to_csv(file_path)
+        headings = ['Class','Precision','Recall']
+
+        CSV.open file_path, 'w' do |csv|
+          csv << headings
+
+          summary_rows.each do |row|
+            csv << row
+          end
+        end
+      end
+
+      private
+
+      def summary_rows
+        rows = []
+        precision_sum = 0
+        recall_sum = 0
+
+        @unique_classes.each do |cls|
+          rows << [cls, self.precision(cls), self.recall(cls)]
+          precision_sum = precision_sum + self.precision(cls)
+          recall_sum = recall_sum + self.recall(cls)
+        end
+
+        rows << ['Overall Average', precision_sum / @unique_classes.length.to_f, recall_sum / @unique_classes.length.to_f]
+
+        rows
+      end
+
+      def preprocess_classes
+        @classes[:accurately_predicted] = @classes.map_rows { |r| r[:predicted] == r[:actual] }
+      end
+
+    end
+  end
+end

data/lib/lurn/naive_bayes/bernoulli_naive_bayes.rb

@@ -0,0 +1,107 @@
+require 'matrix'
+
+module Lurn
+  module NaiveBayes
+    class BernoulliNaiveBayes
+
+      attr_accessor :probability_matrix, :label_probabilities, :unique_labels
+
+      def initialize
+        @k = 1.0
+      end
+
+      def fit(vectors, labels)
+        vectors = Matrix.rows(vectors)
+
+        @unique_labels = labels.uniq
+        @feature_count = vectors.column_size
+
+        document_count_matrix = build_document_count_matrix(vectors, labels)
+        @probability_matrix = build_probability_matrix(document_count_matrix, labels)
+
+        @label_probabilities = @unique_labels.map { |l1| labels.select { |l2| l1 == l2 }.count.to_f / labels.count.to_f }
+      end
+
+      def predict_probabilities(vector)
+        log_probabilties = predict_log_probabilities(vector)
+
+        log_probabilties.map { |p| Math.exp(p) }
+      end
+
+      def predict_log_probabilities(vector)
+
+        probabilities = @unique_labels.map do |label|
+          joint_log_likelihood(vector, label)
+        end
+
+        log_prob_x = Math.log(probabilities.map { |v| Math.exp(v) }.sum)
+
+        probabilities.map { |p| p - log_prob_x }
+      end
+
+      def max_class(vector)
+        log_probs = predict_log_probabilities(vector)
+
+        max_index = log_probs.index(log_probs.max)
+
+        unique_labels[max_index]
+      end
+
+      def max_probability(vector)
+        probs = predict_probabilities(vector)
+
+        probs.max
+      end
+
+      def to_h
+        {
+          probability_matrix: probability_matrix.to_a,
+          label_probabilities: label_probabilities,
+          unique_labels: unique_labels
+        }
+      end
+
+      private
+
+      def build_probability_matrix(document_count_matrix, labels)
+        probability_matrix = Array.new(@unique_labels.count) { Array.new(@feature_count) { 0.0 } }
+
+        document_count_matrix.each_with_index do |value, row, col|
+          label = @unique_labels[row]
+          label_frequency = labels.select { |l| l == label }.count
+
+          probability_matrix[row][col] = Math.log((value.to_f + @k) / (label_frequency.to_f + (2.0 * @k)))
+        end
+
+        Matrix.rows(probability_matrix)
+      end
+
+      def build_document_count_matrix(vectors, labels)
+        matrix = Array.new(@unique_labels.count) { Array.new(@feature_count) { 0 } }
+
+        vectors.each_with_index do |value, row, col|
+          if value == true
+            label = labels[row]
+            label_index = @unique_labels.index(label)
+            matrix[label_index][col] += 1
+          end
+        end
+
+        Matrix.rows(matrix)
+      end
+
+      def joint_log_likelihood(vector, label)
+        label_index = @unique_labels.index(label)
+
+        vector = Vector.elements(vector.map { |e| e == true ? 1 : 0 })
+        probabilities = @probability_matrix.row(label_index)
+        neg_probs = probabilities.map { |prb| Math.log(1.0 - Math.exp(prb)) }
+        jll = vector.dot(probabilities - neg_probs)
+        jll += Math.log(@label_probabilities[label_index]) + neg_probs.sum
+
+        jll
+      end
+
+    end
+  end
+end

data/lib/lurn/text/bernoulli_vectorizer.rb

@@ -0,0 +1,68 @@
+module Lurn
+  module Text
+    class BernoulliVectorizer
+
+      attr_accessor :tokenizer
+      attr_accessor :vocabulary
+
+      def initialize(options = {})
+        @tokenizer = options[:tokenizer] || WordTokenizer.new
+        @vocabulary = []
+
+        options[:max_df] ||= 50
+        options[:min_df] ||= 0
+        @options = options
+      end
+
+      def fit(documents)
+        @vocabulary = []
+        tokenized_docs = tokenize_documents(documents)
+        @vocabulary = tokenized_docs.flatten.uniq.sort
+        reduce_features(tokenized_docs)
+      end
+
+      def to_h
+        {
+          tokenizer_options: @tokenizer.to_h,
+          vocabulary: @vocabulary
+        }
+      end
+
+      def transform(documents)
+        documents.map do |document|
+          tokens = @tokenizer.tokenize(document)
+          @vocabulary.map do |word|
+            tokens.include? word
+          end
+        end
+      end
+
+      private
+
+      def reduce_features(tokenized_docs)
+        doc_frequencies = Array.new(@vocabulary.length, 0)
+
+        tokenized_docs.each do |tokens|
+          tokens.each do |token|
+            vocab_index = @vocabulary.index(token)
+            doc_frequencies[vocab_index] += 1
+          end
+        end
+
+        reduced_features = []
+        @vocabulary.each_with_index do |token, index|
+          freq = doc_frequencies[index]
+          if freq < @options[:max_df] && freq > @options[:min_df]
+            reduced_features.push token
+          end
+        end
+
+        @vocabulary = reduced_features
+      end
+
+      def tokenize_documents(documents)
+        documents.map { |doc| @tokenizer.tokenize(doc).uniq }
+      end
+    end
+  end
+end

data/lib/lurn/text/word_tokenizer.rb

@@ -0,0 +1,43 @@
+require 'lingua/stemmer'
+
+module Lurn
+  module Text
+    class WordTokenizer
+
+      attr_accessor :options
+
+      STOP_WORDS = %w[
+        a about above after again against all am an and any are aren't as at be
+        because been before being below between both but by can't cannot could
+        couldn't did didn't do does doesn't doing don't down during each few for
+        from further had hadn't has hasn't have haven't having he he'd he'll
+        he's her here here's hers herself him himself his how how's i i'd i'll
+        i'm i've if in into is isn't it it's its itself let's me more most
+        mustn't my myself no nor not of off on once only or other ought our ours
+      ]
+
+      def initialize(options = {})
+        @options = options
+        @options[:strip_punctuation] ||= false
+        @options[:strip_stopwords] ||= false
+        @options[:stem_words] ||= false
+      end
+
+      def tokenize(document)
+        document = document.gsub(/[[:punct:]]/, '') if @options[:strip_punctuation] == true
+        document = document.gsub(/\s+/, ' ').split(" ")
+
+        if(@options[:stem_words])
+          stemmer = Lingua::Stemmer.new(language: :en)
+          document = document.map { |word| stemmer.stem(word) }
+        end
+
+        document
+      end
+
+      def to_h
+        options
+      end
+    end
+  end
+end

data/lib/lurn/version.rb

@@ -0,0 +1,3 @@
+module Lurn
+  VERSION = "0.1.1"
+end

data/lib/lurn.rb

@@ -0,0 +1,10 @@
+require "daru"
+require "lurn/version"
+require "lurn/text/word_tokenizer"
+require "lurn/text/bernoulli_vectorizer"
+require "lurn/naive_bayes/bernoulli_naive_bayes"
+require "lurn/evaluation/classifier_evaluator"
+
+module Lurn
+    # Your code goes here...
+end

data/lurn.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lurn/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lurn"
+  spec.version       = Lurn::VERSION
+  spec.authors       = ["daniel.carpenter"]
+  spec.email         = ["daniel.carpenter01@gmail.com"]
+
+  spec.summary       = %q{ A gem with tools for machine learning. }
+  spec.description   = %q{ A gem with tools for machine learning. }
+  spec.homepage      = "https://www.github.com/dansbits/lurn"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "terminal-table", "~> 1.7.3"
+  spec.add_dependency "ruby-stemmer", "~> 0.9.6"
+  spec.add_dependency "daru", '~> 0.1.6'
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "byebug"
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: lurn
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- daniel.carpenter
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.3
+- !ruby/object:Gem::Dependency
+  name: ruby-stemmer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+- !ruby/object:Gem::Dependency
+  name: daru
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.6
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: " A gem with tools for machine learning. "
+email:
+- daniel.carpenter01@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/lurn.rb
+- lib/lurn/evaluation/classifier_evaluator.rb
+- lib/lurn/naive_bayes/bernoulli_naive_bayes.rb
+- lib/lurn/text/bernoulli_vectorizer.rb
+- lib/lurn/text/word_tokenizer.rb
+- lib/lurn/version.rb
+- lurn.gemspec
+homepage: https://www.github.com/dansbits/lurn
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A gem with tools for machine learning.
+test_files: []