TimeSeriesAnalyzer 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 445a8aee4cb146c0e1d35db4e76ab8cc9f9aea6fd99126d0b23efa4e8071e44f
-  data.tar.gz: a36c59cf65e3897efc8b35d1cf4ff0c9b615fe086aa15d3038b84b5857cde430
+  metadata.gz: 981015ef45222f0f9e674f4b2fe73ba988f0c118eaaaad5ee53fe07b59cc0721
+  data.tar.gz: 8697be20bf0edf3a7acea9fbcc1471f1fed58a60a4d66900805920d3298af0e2
 SHA512:
-  metadata.gz: 96de7319cbdf8cdac27613e2378bb1d0cdac56ba433970e71b738d5240689059e5ac8d03f8576cdf4747e79f56b6d46e55578cee2e5e5de011c76315cce737ab
-  data.tar.gz: 5f026244fc2c2ac060ebafd512eacf9e9154ce9f48ee4723657c747a9fb521a3cdf72c289eff3dbfa6218f78796e238eee12c50d18421a76f812c5964a3d65aa
+  metadata.gz: 18b3fa937f73beef940e540b3e75a851cb76ee7e536b0ce759c487ef20afd0bfea774a283ddc7a9e4120d1104d827cfb1bcfbe0acfa7e233cb7948ae0a109a66
+  data.tar.gz: 52fe905ca00a582a17a623d5008b01e34de3b6c5d97c1f5384fa0a82b705c4f51c7a5b8df6d55c3f0b2f9084d3107ab5f7d7eb3730fadc55ce796e3c327a37ef

data/README.md

@@ -2,36 +2,106 @@
 
 [![Testing](https://github.com/sinatra/sinatra/actions/workflows/test.yml/badge.svg)](https://github.com/KuryataDanil/TimeSeriesAnalyzer/actions/workflows/main.yml)
 
-
-TODO: Delete this and the text below, and describe your gem
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/TimeSeriesAnalyzer`. To experiment with that code, run `bin/console` for an interactive prompt.
+TimeSeriesAnalyzer is designed for solving and visualizing numerical series
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
-Install the gem and add to the application's Gemfile by executing:
+```shell
+gem install TimeSeriesAnalyzer
+```
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+The rmagick gem must be installed for it to work properly https://imagemagick.org/script/download.php#windows
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+<img width="75%" src="https://github.com/rmagick/rmagick/assets/199156/494e7963-cca5-4cb5-b28a-6c4d76adce5d" />
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+Then you need to go to the project terminal
+```shell
+set CPATH="C:\Program Files (x86)\ImageMagick-[VERSION]-Q16\include"
+set LIBRARY_PATH="C:\Program Files (x86)\ImageMagick-[VERSION]-Q16\lib"
+em install rmagick 
+```
 
 ## Usage
 
-TODO: Write usage instructions here
-
-## 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 the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Uploading data from a CSV file:
+```ruby
+time_series = TimeSeriesAnalyzer::TimeSeries.load_from_csv(file_path)
+# the second variable "period" determines the seasonality of the data
+# by default -1, which means the seasonality is determined automatically
+```
+
+Visualization of a time series:
+```ruby
+time_series.plot(file_name)
+# the second variable "title" indicates the title of the graph
+```
+
+Decomposition of a time series:
+```ruby
+decomposed = time_series.decompose
+
+print(decomposed[:trend].data) # trend
+puts ""
+print(decomposed[:seasonal].data) # seasonal component
+puts ""
+print(decomposed[:residual].data) # remains
+puts ""
+
+decomposed[:trend].plot('trend.png')
+decomposed[:seasonal].plot('seasonal.png')
+decomposed[:residual].plot('residual.png')
+```
+
+Application of the moving average:
+```ruby
+moving_average(window_size)
+#Returns a numeric series representing the moving average of the original
+#parameter window_size is the size
+
+
+smoothed_series = time_series.moving_average(3)
+print(smoothed_series.data)
+puts ""
+smoothed_series.plot('moving_average.png')
+```
+
+Applying exponential smoothing:
+```ruby
+exponential_smoothing(alpha)
+#Returns a numeric series representing the exponential smoothing of the original one
+#The value of alpha represents the smoothing factor, which determines the weight of the current
+#observation compared to the smoothed previous value.
+
+
+smoothed_series = time_series.exponential_smoothing(0.3)
+print(smoothed_series.data)
+puts ""
+smoothed_series.plot('exponential_smoothing.png')
+```
+
+Anomaly detection:
+```ruby
+detect_anomalies
+#Function that returns detected anomalies in the numeric series
+#Anomalies found are returned as dictionaries with timestamps and values.
+
+anomalies = time_series.detect_anomalies
+anomalies.each { |anomaly| puts "Anomaly detected at #{anomaly[:timestamp]}: #{anomaly[:value]}" }
+```
+
+Forecasting:
+```ruby
+forecast(steps)
+#Function that predicts the following values (prediction based on the subsequent change of residues only)
+#steps - number of steps for which it is necessary to forecast
+
+forecasted_values = time_series.forecast(10)
+puts "Forecasted values: #{forecasted_values}"
+```
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/TimeSeriesAnalyzer. 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/[USERNAME]/TimeSeriesAnalyzer/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/KuryataDanil/TimeSeriesAnalyzer. 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/KuryataDanil/TimeSeriesAnalyzer/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 

data/lib/TimeSeriesAnalyzer.rb

@@ -1,8 +1,312 @@
 # frozen_string_literal: true
-
+require 'csv'
+require 'rmagick'
+require 'time'
+require 'matrix'
 require_relative "TimeSeriesAnalyzer/version"
 
 module TimeSeriesAnalyzer
-  class Error < StandardError; end
-  # Your code goes here...
+  #Числовой ряд
+  class TimeSeries
+    attr_accessor :data, :timestamps
+
+    def initialize(data, timestamps, period = -1)
+      @data = data
+      @timestamps = timestamps
+      @period = period
+    end
+
+    #Чтение ряда из .csv файла
+    def self.load_from_csv(file_path, period = -1)
+      data = []
+      timestamps = []
+      CSV.foreach(file_path, headers: true) do |row|
+        timestamps << Time.parse(row['timestamp'])
+        data << row['value'].to_f
+      end
+      new(data, timestamps, period)
+    end
+
+    #Функция для запуска визуализации ряда в .png файл, file_name - путь к нему
+    def plot(file_name = 'time_series.png', title = "")
+      draw_plot(@data, @timestamps, title, file_name)
+    end
+
+    #Возращает числовой ряд, отображающий скользящее среднее исходного
+    def moving_average(window_size)
+      ma_data = @data.each_cons(window_size).map { |window| window.sum / window_size }
+      padding = Array.new(window_size - 1, nil)
+      TimeSeries.new(padding + ma_data, @timestamps)
+    end
+
+    #Возращает числовой ряд, отображающий экспоненциальное сглаживание исходного
+    def exponential_smoothing(alpha)
+      smoothed_data = [@data.first]
+      @data.each_cons(2) do |_, current|
+        smoothed_data << alpha * current + (1 - alpha) * smoothed_data.last
+      end
+      TimeSeries.new(smoothed_data, @timestamps)
+    end
+
+    #Разложение ряда на тренд, сезонную компоненту и остаток
+    def decompose
+      trend = TrendComponent.new(@data).fit
+      seasonal = SeasonalComponent.new(@data, @period).fit
+      residual = @data.zip(trend, seasonal).map { |d, t, s| d - t - s }
+      {
+        trend: TimeSeries.new(TrendComponent.new(@data).accurate_fit, @timestamps),
+        seasonal: TimeSeries.new(seasonal, @timestamps),
+        residual: TimeSeries.new(residual, @timestamps)
+      }
+    end
+
+    #Функция, возвращающая найденные аномалии в числовом ряду
+    def detect_anomalies
+      threshold = 3 * Math.sqrt(variance(@data))
+      mean = mean(@data)
+      @data.each_with_index.select do |value, _|
+        (value - mean).abs > threshold
+      end.map { |value, index| { timestamp: @timestamps[index], value: value } }
+    end
+
+    #Функция, прогнозирующая следующие значения (прогноз на основе последующего изменения только остатков)
+    def forecast(steps)
+      trend = TrendComponent.new(@data).fit
+      seasonal = SeasonalComponent.new(@data, @period).fit
+
+      trend_seasonal = trend.zip(seasonal).map { |t, s| t + s.to_f }
+      residuals = @data.zip(trend_seasonal).map { |d, ts| d - ts }
+
+      forecast_residuals = forecast_arima(residuals, steps)
+      last_trend = trend.last
+      last_seasonal = seasonal.last
+
+      (1..steps).map do |step|
+        last_trend + last_seasonal + forecast_residuals[step - 1]
+      end
+    end
+
+    private
+    def forecast_arima(data, steps)
+      phi = mean(data.each_cons(2).map { |x, y| y / x.to_f })
+
+      last_value = data.last
+      (1..steps).map { |step| last_value * (phi**step) }
+    end
+
+    #Визуализация ряда в .png файл
+    def draw_plot(data, timestamps, title, file_name)
+      width = 200 + timestamps.size * 50
+      height = 400
+      padding = 50
+      plot_area_width = width - 2 * padding
+      plot_area_height = height - 2 * padding
+
+      min_value = data.compact.min.to_f
+      max_value = data.compact.max.to_f
+      value_range = max_value - min_value
+
+      canvas = Magick::Image.new(width, height) {background_color = 'white' }
+      draw = Magick::Draw.new
+
+      # Draw title
+      draw.annotate(canvas, 0, 0, 0, padding / 2, title) { |options|
+        options.font_weight = Magick::BoldWeight
+        options.pointsize = 20
+        options.gravity = Magick::NorthGravity
+      }
+
+      # Draw axes
+      draw.line(padding, padding, padding, height - padding)
+      draw.line(padding, height - padding, width - padding, height - padding)
+
+      # Set line width
+      draw.stroke('#506DFF')
+      draw.stroke_linecap('round')
+      draw.stroke_width(4)
+      draw.stroke_linejoin('round')
+
+      # Draw data
+      data.each_with_index.each_cons(2) do |(value1, index1), (value2, index2)|
+        next if value1.nil? || value2.nil?
+
+        x1 = padding + index1 * plot_area_width / (data.size - 1)
+        y1 = height - padding - (value1 - min_value) * plot_area_height / value_range
+        x2 = padding + index2 * plot_area_width / (data.size - 1)
+        y2 = height - padding - (value2 - min_value) * plot_area_height / value_range
+
+        draw.line(x1, y1, x2, y2)
+      end
+
+      # Draw labels on Y axis
+      count_y = 10
+      label_interval = value_range / count_y
+      (0..count_y).each do |i|
+        value = (min_value + (count_y - i) * label_interval)
+        y = i * plot_area_height / count_y - plot_area_height / 2
+        draw.annotate(canvas, 0, 0, width - padding + 10, y, sprintf('%.2f', value)) { |options|
+          options.gravity = Magick::EastGravity
+          options.pointsize = plot_area_height / 33.3
+        }
+      end
+
+      # Draw labels
+      timestamps.each_with_index do |timestamp, index|
+        x = index * plot_area_width / (timestamps.size == 1 ? 1 : timestamps.size - 1) - plot_area_width / 2
+        draw.annotate(canvas, 0, 0, x, height - padding / 2, timestamp.strftime('%Y-%m-%d')) { |options|
+          options.gravity = Magick::NorthGravity
+          options.pointsize = 10 > plot_area_width / 144.4 ? 10 : plot_area_width / 144.4
+        }
+      end
+
+      draw.draw(canvas)
+      canvas.write(file_name)
+    end
+
+    class TrendComponent
+      def initialize(data)
+        @data = data
+      end
+
+      def fit
+        # Пример использования
+        x = (0...@data.size).to_a # Массив значений x (0, 1, 2, ...)
+        y = @data # Массив значений y (данные)
+
+        max_degree = x.size >= 8 ? 8 : x.size - 1
+        best_degree = best_polynomial_degree(x, y, max_degree)# Степень полинома
+
+        # Получаем коэффициенты полинома
+        coefficients = polynomial_coefficients(x, y, best_degree)
+
+        # Вычисляем значения полиномиального тренда
+        polynomial_trend(x, coefficients)
+      end
+
+      def accurate_fit
+        # Пример использования
+        x = (0...@data.size).to_a # Массив значений x (0, 1, 2, ...)
+        y = @data # Массив значений y (данные)
+
+        max_degree = x.size >= 8 ? 8 : x.size - 1
+        best_degree = best_polynomial_degree(x, y, max_degree)# Степень полинома
+
+        # Получаем коэффициенты полинома
+        coefficients = polynomial_coefficients(x, y, best_degree)
+
+        accurate_x = (0...@data.size*10-9).map { |xx| xx.to_f/10 }
+        # Вычисляем значения полиномиального тренда
+        polynomial_trend(accurate_x, coefficients)
+      end
+
+      private
+
+      # Функция для вычисления RMSE
+      def rmse(y_true, y_pred)
+        Math.sqrt(y_true.zip(y_pred).map { |y_t, y_p| (y_t - y_p)**2 }.sum / y_true.size)
+      end
+
+      # Функция для определения лучшей степени полинома
+      def best_polynomial_degree(x, y, max_degree)
+        best_degree = 0
+        best_rmse = Float::INFINITY
+
+        (1..max_degree).each do |degree|
+          coefficients = polynomial_coefficients(x, y, degree)
+          trend = polynomial_trend(x, coefficients)
+          current_rmse = rmse(y, trend)
+
+          if current_rmse < best_rmse
+            best_rmse = current_rmse
+            best_degree = degree
+          end
+        end
+
+        best_degree
+      end
+
+      def polynomial_coefficients(x, y, degree)
+        n = x.size
+        x_data = Array.new(n) { Array.new(degree + 1, 0.0) }
+
+        # Заполняем матрицу значениями x, x^2, x^3 и т.д.
+        (0...n).each do |i|
+          (0..degree).each do |j|
+            x_data[i][j] = x[i]**j
+          end
+        end
+
+        x_matrix = Matrix[*x_data]
+        y_matrix = Matrix.column_vector(y)
+
+        # Оцениваем коэффициенты полинома
+        ((x_matrix.t * x_matrix).inverse * x_matrix.t * y_matrix).transpose.to_a[0]
+      end
+
+      # Функция для вычисления значений полиномиального тренда
+      def polynomial_trend(x, coefficients)
+        trend = Array.new(x.size, 0.0)
+        x.each_with_index do |x_val, index|
+          coefficients.each_with_index do |coeff, i|
+            trend[index] += coeff * (x_val**i)
+          end
+        end
+        trend
+      end
+    end
+
+    class SeasonalComponent
+      def initialize(data, period = -1)
+        @data = data
+        @period = period == -1 ? detect_period : period
+      end
+
+      def fit
+        if @period == 1
+          return @data.map {|| 0.0}
+        end
+        period_means = Array.new(@period) { |i| mean(@data.each_slice(@period).map { |slice| slice[i] }.compact) }
+        @data.each_with_index.map { |_, index| period_means[index % @period] }
+      end
+
+      private
+
+      def detect_period
+        max_lag = @data.size / 2 # Максимальное значение лага
+        autocorrelation = (1..max_lag).map { |lag| calculate_autocorrelation(lag) }
+
+        # Определяем период сезонности
+        autocorrelation.index(autocorrelation.max) + 1
+      end
+
+      private
+
+      def calculate_autocorrelation(lag)
+        mean = mean(@data)
+        n = @data.size
+
+        numerator = (0...n - lag).map { |i| (@data[i] - mean) * (@data[i + lag] - mean) }.sum
+        denominator = (0...n).map { |i| (@data[i] - mean)**2 }.sum
+
+        numerator / denominator
+      end
+
+      #Среднее арифметическое значений в массиве
+      def mean(arr)
+        arr.sum.to_f / arr.size
+      end
+    end
+
+
+    #Среднее арифметическое значений в массиве
+    def mean(arr)
+      arr.sum.to_f / arr.size
+    end
+
+    #Вычисление дисперсии значений в массиве
+    def variance(arr)
+      m = mean(arr)
+      arr.map { |v| (v - m)**2 }.sum / (arr.size - 1)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: TimeSeriesAnalyzer
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - KuryataDanil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-06-03 00:00:00.000000000 Z
+date: 2024-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec