kiribi-gemma4_e2b 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b816119d78e60fc9147954ffde9bdba6723c979fa76fde28c1ae7fe38e77816c
+  data.tar.gz: 340bf72b9558d98de1f03506a1f0055f5b17ab4580b296d7d94d3e8f34c5bca1
+SHA512:
+  metadata.gz: b1c4fae7b415010072e44245110b2e2a7dd2d3232a3c9324e468dc717d6c17e3a7054b3df5490f5e09981de754df360f905a3c22d49b0e723f70aeebec260532
+  data.tar.gz: 47def9793155eaa399a29a0650bc3e89627e6babe3778f8abcb7d362daba7bd8dc05225a9ac7b330cea9cc90192c4f5987e464176ab553e300dc1e8959e53882

data/README.md

@@ -0,0 +1,101 @@
+# kiribi-gemma4_e2b
+
+Google Gemma 4 E2B (2.3B parameters) multimodal model for text, image, and audio.
+
+Based on [onnx-community/gemma-4-E2B-it-ONNX](https://huggingface.co/onnx-community/gemma-4-E2B-it-ONNX) (ONNX format, FP32).
+
+**!!CAUTION!! :** This gem downloads ~22GB of model files from HuggingFace during installation. Be mindful of disk space and network bandwidth.
+
+## Installation
+
+```sh
+gem install kiribi-gemma4_e2b
+```
+
+Model files (~22GB) are downloaded from HuggingFace during installation.
+
+### Requirements
+
+- Ruby >= 3.4.0
+- `ffmpeg` / `ffprobe` (for image and audio preprocessing by the caller)
+
+## Usage
+
+### Text generation
+
+```ruby
+require "kiribi/gemma4/e2b"
+
+model = Kiribi::Gemma4::E2B.load
+model.generate("Hello!")
+```
+
+### Multi-turn chat
+
+```ruby
+model.chat([
+  { role: "system", content: "You are a helpful assistant." },
+  { role: "user", content: "What is Ruby?" },
+  { role: "model", content: "Ruby is a dynamic programming language." },
+  { role: "user", content: "Who created it?" },
+])
+```
+
+### Image understanding
+
+Preprocessing is the caller's responsibility. Use `ffmpeg`/`ffprobe` to obtain raw RGB pixels:
+
+```ruby
+require "kiribi/gemma4/e2b"
+
+model = Kiribi::Gemma4::E2B.load
+encoder = model.load_vision_encoder  # loads vision_encoder.onnx
+
+# 1. Get original dimensions
+info = IO.popen(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height", "-of", "csv=p=0", "photo.png"], &:read)
+original_width, original_height = info.strip.split(",").map(&:to_i)
+
+# 2. Compute the size to resize to
+input_width, input_height = encoder.input_size_of(original_width, original_height)
+
+# 3. Resize (caller's choice of tool)
+blob = IO.popen(["ffmpeg", "-i", "photo.png", "-vf", "scale=#{input_width}:#{input_height}:flags=bicubic", "-f", "rawvideo", "-pix_fmt", "rgb24", "-v", "error", "-"], "rb", &:read)
+
+# 4. Encode
+features = encoder.encode(blob, input_width, input_height)
+
+model.chat([
+  { role: "user", content: [
+    { type: "image", features: },
+    { type: "text", text: "What is in this image?" },
+  ] },
+])
+```
+
+### Audio transcription
+
+```ruby
+require "kiribi/gemma4/e2b"
+
+model = Kiribi::Gemma4::E2B.load
+encoder = model.load_audio_encoder  # loads audio_encoder.onnx
+
+# 1. Decode to 16kHz mono f32le PCM
+pcm = IO.popen(["ffmpeg", "-i", "audio.mp3", "-f", "f32le", "-acodec", "pcm_f32le", "-ar", "16000", "-ac", "1", "-", err: "/dev/null"], "rb", &:read)
+
+# 2. Encode
+features = encoder.encode(pcm)
+
+model.chat([
+  { role: "user", content: [
+    { type: "audio", features: },
+    { type: "text", text: "Transcribe the following speech segment in its original language." },
+  ] },
+])
+```
+
+## License
+
+This gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+The model weights are licensed under [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) by Google.

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/ext/kiribi-gemma4_e2b/extconf.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "net/http"
+
+GEM_NAME = "kiribi-gemma4_e2b"
+HF_REPO = "matsudai17/gemma-4-E2B-it-ONNX"
+HF_BASE_URL = "https://huggingface.co/#{HF_REPO}/resolve/main/onnx"
+
+MODEL_FILES = %w[
+  embed_tokens.onnx
+  embed_tokens.onnx_data
+  embed_tokens.onnx_data_1
+  decoder_model_merged.onnx
+  decoder_model_merged.onnx_data
+  decoder_model_merged.onnx_data_1
+  decoder_model_merged.onnx_data_2
+  decoder_model_merged.onnx_data_3
+  decoder_model_merged.onnx_data_4
+  vision_encoder.onnx
+  vision_encoder.onnx_data
+  audio_encoder.onnx
+  audio_encoder.onnx_data
+]
+TOKENIZER_FILE = "tokenizer.json"
+TOKENIZER_URL = "https://huggingface.co/#{HF_REPO}/resolve/main/#{TOKENIZER_FILE}"
+
+BUILD_DIRPATH = File.expand_path(File.join(__dir__, "../../lib/#{GEM_NAME}/vendor/build"))
+
+def download_file(url, dest)
+  redirect_count = 0
+  loop do
+    raise "Too many redirects" if redirect_count >= 10
+
+    uri = URI.parse(url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = (uri.scheme == "https")
+    request = Net::HTTP::Get.new(uri.request_uri)
+
+    http.request(request) do |resp|
+      case resp
+      when Net::HTTPSuccess
+        FileUtils.mkdir_p(File.dirname(dest))
+        File.open(dest, "wb") do |f|
+          resp.read_body { |chunk| f.write(chunk) }
+        end
+        return
+      when Net::HTTPRedirection
+        url = resp["Location"]
+        redirect_count += 1
+      else
+        raise "HTTP request failed for #{url} (status code: #{resp.code})"
+      end
+    end
+  end
+end
+
+if Dir.exist?(BUILD_DIRPATH)
+  puts "#{BUILD_DIRPATH} already exists, skipping download."
+else
+  FileUtils.mkdir_p(BUILD_DIRPATH)
+
+  # Download model files
+  MODEL_FILES.each do |filename|
+    dest = File.join(BUILD_DIRPATH, filename)
+    if File.exist?(dest)
+      puts "#{filename} already exists, skipping."
+    else
+      puts "Downloading #{filename}..."
+      download_file("#{HF_BASE_URL}/#{filename}", dest)
+      puts "  -> #{dest}"
+    end
+  end
+
+  # Download tokenizer
+  tokenizer_dest = File.join(BUILD_DIRPATH, TOKENIZER_FILE)
+  unless File.exist?(tokenizer_dest)
+    puts "Downloading #{TOKENIZER_FILE}..."
+    download_file(TOKENIZER_URL, tokenizer_dest)
+    puts "  -> #{tokenizer_dest}"
+  end
+end
+
+File.write("Makefile", "all install clean:\n\t@echo \"Nothing to do for $(TARGET)\"\n")

data/lib/kiribi/gemma4/e2b/audio_encoder.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "onnxruntime"
+
+module Kiribi
+  module Gemma4
+    module E2B
+      AUDIO_ENCODER_FILEPATH = File.expand_path(File.join(__dir__, "../../../kiribi-gemma4_e2b/vendor/build/audio_encoder.onnx"))
+
+      class AudioEncoder
+        def initialize
+          @model = OnnxRuntime::Model.new(AUDIO_ENCODER_FILEPATH)
+        end
+
+        # pcm_samples: 16kHz mono float32 PCM サンプル配列またはバイナリ文字列
+        # audio_features 配列を返す
+        def encode(pcm_samples)
+          pcm = pcm_samples.is_a?(String) ? pcm_samples.unpack("e*") : pcm_samples
+
+          frame_length = 320
+          hop_length = 160
+          fft_length = 512
+          num_mels = 128
+          mel_floor = 0.001
+
+          window = Array.new(frame_length) { 0.5 - 0.5 * Math.cos(2.0 * Math::PI * it / frame_length) }
+          mel_filters = build_mel_filterbank(fft_length / 2 + 1, num_mels, 0.0, 8000.0, 16_000)
+
+          pad_left = frame_length / 2
+          padded = Array.new(pad_left, 0.0) + pcm
+          mask_raw = Array.new(pad_left, false) + Array.new(pcm.length, true)
+
+          frame_size = frame_length + 1
+          num_frames = (padded.length - frame_size) / hop_length + 1
+
+          input_features = []
+          input_features_mask = []
+
+          num_frames.times do |fi|
+            start = fi * hop_length
+            windowed = frame_length.times.map { padded[start + it] * window[it] }
+
+            mag = rfft_magnitude(windowed, fft_length)
+
+            mel = num_mels.times.map do |m|
+              sum = 0.0
+              mag.each_with_index { |v, i| sum += v * mel_filters[i][m] }
+              Math.log(sum + mel_floor)
+            end
+
+            end_idx = fi * hop_length + frame_size - 1
+            valid = end_idx < mask_raw.length && mask_raw[end_idx]
+
+            input_features << (valid ? mel : Array.new(num_mels, 0.0))
+            input_features_mask << valid
+          end
+
+          # pad_to_multiple_of 128
+          padded_frames = ((input_features.length + 127) / 128) * 128
+          while input_features.length < padded_frames
+            input_features << Array.new(num_mels, 0.0)
+            input_features_mask << false
+          end
+
+          @model.predict({
+            "input_features" => [input_features],
+            "input_features_mask" => [input_features_mask],
+          })["audio_features"]
+        end
+
+        private
+
+        def build_mel_filterbank(num_fft_bins, num_mel_filters, min_freq, max_freq, sample_rate)
+          fft_freqs = (0...num_fft_bins).map { it.to_f * sample_rate / ((num_fft_bins - 1) * 2) }
+          mel_min = 2595.0 * Math.log10(1.0 + min_freq / 700.0)
+          mel_max = 2595.0 * Math.log10(1.0 + max_freq / 700.0)
+          mel_points = (0..num_mel_filters + 1).map { mel_min + it * (mel_max - mel_min) / (num_mel_filters + 1) }
+          hz_points = mel_points.map { 700.0 * (10.0**(it / 2595.0) - 1.0) }
+
+          filters = Array.new(num_fft_bins) { Array.new(num_mel_filters, 0.0) }
+          num_mel_filters.times do |m|
+            lower = hz_points[m]
+            center = hz_points[m + 1]
+            upper = hz_points[m + 2]
+            fft_freqs.each_with_index do |f, i|
+              if f >= lower && f <= center && center > lower
+                filters[i][m] = (f - lower) / (center - lower)
+              elsif f > center && f <= upper && upper > center
+                filters[i][m] = (upper - f) / (upper - center)
+              end
+            end
+          end
+          filters
+        end
+
+        def rfft_magnitude(real_signal, n)
+          padded = Array.new(n, 0.0)
+          real_signal.each_with_index { |v, i| padded[i] = v if i < n }
+          imag = Array.new(n, 0.0)
+          r, i = fft(padded, imag)
+          bins = n / 2 + 1
+          bins.times.map { Math.sqrt(r[it]**2 + i[it]**2) }
+        end
+
+        def fft(x_real, x_imag)
+          n = x_real.length
+          return [x_real.dup, x_imag.dup] if n <= 1
+
+          even_r, even_i = fft(
+            (0...n / 2).map { x_real[it * 2] },
+            (0...n / 2).map { x_imag[it * 2] }
+          )
+          odd_r, odd_i = fft(
+            (0...n / 2).map { x_real[it * 2 + 1] },
+            (0...n / 2).map { x_imag[it * 2 + 1] }
+          )
+
+          result_r = Array.new(n)
+          result_i = Array.new(n)
+          half = n / 2
+          half.times do |k|
+            angle = -2.0 * Math::PI * k / n
+            tr = Math.cos(angle) * odd_r[k] - Math.sin(angle) * odd_i[k]
+            ti = Math.sin(angle) * odd_r[k] + Math.cos(angle) * odd_i[k]
+            result_r[k] = even_r[k] + tr
+            result_i[k] = even_i[k] + ti
+            result_r[k + half] = even_r[k] - tr
+            result_i[k + half] = even_i[k] - ti
+          end
+          [result_r, result_i]
+        end
+      end
+    end
+  end
+end

data/lib/kiribi/gemma4/e2b/model.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "onnxruntime"
+require "tokenizers"
+
+module Kiribi
+  module Gemma4
+    module E2B
+      TOKENIZER_FILEPATH = File.expand_path(File.join(__dir__, "../../../kiribi-gemma4_e2b/vendor/build/tokenizer.json"))
+      EMBED_MODEL_FILEPATH = File.expand_path(File.join(__dir__, "../../../kiribi-gemma4_e2b/vendor/build/embed_tokens.onnx"))
+      DECODER_MODEL_FILEPATH = File.expand_path(File.join(__dir__, "../../../kiribi-gemma4_e2b/vendor/build/decoder_model_merged.onnx"))
+
+      class Model
+        EOS_TOKEN_IDS = [1, 106, 50]
+        IMAGE_TOKEN_ID = 258_880
+        AUDIO_TOKEN_ID = 258_881
+
+        attr_reader :tokenizer
+
+        def initialize
+          @tokenizer = Tokenizers.from_file(TOKENIZER_FILEPATH)
+          @embed_model = OnnxRuntime::Model.new(EMBED_MODEL_FILEPATH)
+          @decoder_model = OnnxRuntime::Model.new(DECODER_MODEL_FILEPATH)
+
+          decoder_sess = OnnxRuntime::InferenceSession.new(DECODER_MODEL_FILEPATH)
+          @head_dims = decoder_sess.inputs
+            .select { it[:name].match?(/\Apast_key_values\.\d+\.key\z/) }
+            .sort_by { it[:name][/\d+/].to_i }
+            .map { it[:shape].last }
+          @num_layers = @head_dims.length
+
+          @num_logits_to_keep_1 = OnnxRuntime::OrtValue.from_shape_and_type([], :int64)
+          @num_logits_to_keep_1.data_ptr.write_int64(1)
+        end
+
+        # -------------------------------------------------
+        # 遅延ロード（名前で初期化コストを明示）
+        # -------------------------------------------------
+
+        def load_vision_encoder
+          @vision_encoder ||= VisionEncoder.new
+        end
+
+        def load_audio_encoder
+          @audio_encoder ||= AudioEncoder.new
+        end
+
+        # -------------------------------------------------
+        # 低レベル API: ONNX 呼び出しのみ
+        # -------------------------------------------------
+
+        def embed(input_ids)
+          @embed_model.predict({"input_ids" => [input_ids]})
+        end
+
+        def forward(inputs_embeds:, per_layer_inputs:, attention_mask:, position_ids:, past_key_values: nil)
+          past_kv = past_key_values || init_kv_cache
+          input = {
+            "inputs_embeds" => inputs_embeds,
+            "attention_mask" => attention_mask,
+            "position_ids" => position_ids,
+            "num_logits_to_keep" => @num_logits_to_keep_1,
+            "per_layer_inputs" => per_layer_inputs,
+          }
+          input.merge!(past_kv)
+          out = @decoder_model.predict(input)
+
+          new_kv = {}
+          @num_layers.times do |i|
+            new_kv["past_key_values.#{i}.key"] = out["present.#{i}.key"]
+            new_kv["past_key_values.#{i}.value"] = out["present.#{i}.value"]
+          end
+
+          {logits: out["logits"], past_key_values: new_kv}
+        end
+
+        def init_kv_cache
+          kv = {}
+          @num_layers.times do |i|
+            kv["past_key_values.#{i}.key"] = OnnxRuntime::OrtValue.from_shape_and_type([1, 1, 0, @head_dims[i]], :float)
+            kv["past_key_values.#{i}.value"] = OnnxRuntime::OrtValue.from_shape_and_type([1, 1, 0, @head_dims[i]], :float)
+          end
+          kv
+        end
+
+        # -------------------------------------------------
+        # 高レベル API
+        # -------------------------------------------------
+
+        def generate(prompt, max_new_tokens: 256)
+          chat([{role: "user", content: prompt}], max_new_tokens:)
+        end
+
+        def chat(messages, max_new_tokens: 256)
+          prompt_parts = ["<bos>"]
+          encoded_media = []
+
+          messages.each do |msg|
+            role = msg[:role]
+            content = msg[:content]
+            prompt_parts << "<|turn>#{role}\n"
+
+            if content.is_a?(String)
+              prompt_parts << content
+            elsif content.is_a?(Array)
+              content.each do |part|
+                case part[:type]
+                when "text"
+                  prompt_parts << part[:text]
+                when "image"
+                  features = part[:features]
+                  prompt_parts << "<|image>" + "<|image|>" * features.length + "<image|>\n"
+                  encoded_media << {token_id: IMAGE_TOKEN_ID, features:}
+                when "audio"
+                  features = part[:features]
+                  prompt_parts << "<|audio>" + "<|audio|>" * features.length + "<audio|>\n"
+                  encoded_media << {token_id: AUDIO_TOKEN_ID, features:}
+                end
+              end
+            end
+
+            prompt_parts << "<turn|>\n"
+          end
+          prompt_parts << "<|turn>model\n"
+
+          input_ids = tokenizer.encode(prompt_parts.join).ids
+
+          embeds = []
+          encoded_media.each do |media|
+            positions = input_ids.each_with_index
+              .select { |t, _| t == media[:token_id] }
+              .map(&:last)
+              .reject { |pos| embeds.any? { it[:pos] == pos } }
+            media[:features].each_with_index do |feat, idx|
+              break if idx >= positions.length
+              embeds << {pos: positions[idx], feat:}
+            end
+          end
+
+          past_kv = nil
+          generated = []
+
+          max_new_tokens.times do |step|
+            cur_ids = step == 0 ? input_ids : [generated.last]
+            seq_len = cur_ids.length
+            total_len = input_ids.length + generated.length
+
+            embed_out = embed(cur_ids)
+            inputs_embeds = embed_out["inputs_embeds"]
+            per_layer_inputs = embed_out["per_layer_inputs"]
+
+            if step == 0
+              embeds.each { inputs_embeds[0][it[:pos]] = it[:feat] }
+            end
+
+            result = forward(
+              inputs_embeds:,
+              per_layer_inputs:,
+              attention_mask: [Array.new(total_len, 1)],
+              position_ids: [(total_len - seq_len...total_len).to_a],
+              past_key_values: past_kv,
+            )
+            past_kv = result[:past_key_values]
+
+            next_token = result[:logits][0][-1].each_with_index.max_by { |v, _| v }[1]
+            break if EOS_TOKEN_IDS.include?(next_token)
+            generated << next_token
+          end
+
+          tokenizer.decode(generated)
+        end
+      end
+    end
+  end
+end

data/lib/kiribi/gemma4/e2b/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Kiribi
+  module Gemma4
+    module E2B
+      VERSION = "0.0.1"
+    end
+  end
+end

data/lib/kiribi/gemma4/e2b/vision_encoder.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "onnxruntime"
+
+module Kiribi
+  module Gemma4
+    module E2B
+      VISION_ENCODER_FILEPATH = File.expand_path(File.join(__dir__, "../../../kiribi-gemma4_e2b/vendor/build/vision_encoder.onnx"))
+
+      class VisionEncoder
+        PATCH_SIZE = 16
+        RESCALE_FACTOR = 1.0 / 255
+        MAX_SOFT_TOKENS = 280
+        POOLING_KERNEL = 3
+        MAX_PATCHES = MAX_SOFT_TOKENS * POOLING_KERNEL**2
+        SIDE_MULT = POOLING_KERNEL * PATCH_SIZE
+
+        def initialize
+          @model = OnnxRuntime::Model.new(VISION_ENCODER_FILEPATH)
+        end
+
+        # 元画像サイズ (original_width, original_height) を受け取り、
+        # encode 前にリサイズすべきサイズ [width, height] を返す。
+        def input_size_of(original_width, original_height)
+          target_px = MAX_PATCHES * PATCH_SIZE**2
+          factor = Math.sqrt(target_px.to_f / (original_height * original_width))
+
+          width  = (factor * original_width  / SIDE_MULT).floor * SIDE_MULT
+          height = (factor * original_height / SIDE_MULT).floor * SIDE_MULT
+
+          if width == 0 && height == 0
+            raise "Image too small to resize"
+          elsif height == 0
+            height = SIDE_MULT
+            width = [(original_width / original_height) * SIDE_MULT, MAX_SOFT_TOKENS * SIDE_MULT].min
+          elsif width == 0
+            width = SIDE_MULT
+            height = [(original_height / original_width) * SIDE_MULT, MAX_SOFT_TOKENS * SIDE_MULT].min
+          end
+
+          [width, height]
+        end
+
+        # blob_rgb: RGB24 raw bytes（既に width × height へリサイズ済み）
+        # image_features 配列を返す
+        def encode(blob_rgb, width, height)
+          blob = blob_rgb.is_a?(String) ? blob_rgb.unpack("C*") : blob_rgb
+          patches_w = width / PATCH_SIZE
+          patches_h = height / PATCH_SIZE
+
+          pixel_values = []
+          pixel_position_ids = []
+
+          patches_w.times do |col|
+            patches_h.times do |row|
+              patch = []
+              PATCH_SIZE.times do |dy|
+                PATCH_SIZE.times do |dx|
+                  y = row * PATCH_SIZE + dy
+                  x = col * PATCH_SIZE + dx
+                  idx = (y * width + x) * 3
+                  patch << blob[idx] * RESCALE_FACTOR
+                  patch << blob[idx + 1] * RESCALE_FACTOR
+                  patch << blob[idx + 2] * RESCALE_FACTOR
+                end
+              end
+              pixel_values << patch
+              pixel_position_ids << [col, row]
+            end
+          end
+
+          while pixel_values.length < MAX_PATCHES
+            pixel_values << Array.new(PATCH_SIZE**2 * 3, 0.0)
+            pixel_position_ids << [-1, -1]
+          end
+
+          @model.predict({
+            "pixel_values" => [pixel_values],
+            "pixel_position_ids" => [pixel_position_ids],
+          })["image_features"]
+        end
+      end
+    end
+  end
+end

data/lib/kiribi/gemma4/e2b.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "e2b/version"
+require_relative "e2b/vision_encoder"
+require_relative "e2b/audio_encoder"
+require_relative "e2b/model"
+require "kiribi"
+
+module Kiribi
+  module Gemma4
+    extend Kiribi::Loader
+
+    module E2B
+      extend Kiribi::Loader
+
+      def self.instantiate
+        Model.new
+      end
+    end
+  end
+end
+
+Kiribi.register(Kiribi::Gemma4::E2B, order: 100_300_100)

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: kiribi-gemma4_e2b
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- matsudai
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kiribi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: onnxruntime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: tokenizers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+executables: []
+extensions:
+- ext/kiribi-gemma4_e2b/extconf.rb
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- ext/kiribi-gemma4_e2b/extconf.rb
+- lib/kiribi/gemma4/e2b.rb
+- lib/kiribi/gemma4/e2b/audio_encoder.rb
+- lib/kiribi/gemma4/e2b/model.rb
+- lib/kiribi/gemma4/e2b/version.rb
+- lib/kiribi/gemma4/e2b/vision_encoder.rb
+homepage: https://github.com/matsudai/kiribi
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Easy to use some onnx models.
+test_files: []