moondream 1.0.2__py3-none-any.whl

moondream/__init__.py

@@ -0,0 +1,5 @@
+from .torch.inference import run_inference
+
+__version__ = "1.0.2"
+__all__ = ["run_inference"]
+

moondream/torch/__init__.py

@@ -0,0 +1,9 @@
+# moondream/torch/__init__.py
+from .inference import run_inference
+from .layers import *
+from .rope import *
+from .text import *
+from .vision import *
+from .weights import *
+
+__all__ = ["run_inference"]

moondream/torch/inference.py

@@ -0,0 +1,108 @@
+import torch
+import argparse
+import os
+from PIL import Image
+from transformers import AutoTokenizer
+from .weights import load_from_safetensors
+from .vision import encode_image
+from .text import text_encoder, text_decoder, lm_head
+from .rope import precompute_freqs_cis
+
+def run_inference(image_path: str, prompt: str, model_path: str, max_tokens: int = 200, sampler: str = "greedy"):
+    """
+    Run inference on an image with a given prompt.
+    
+    Args:
+        image_path (str): Path to the image file
+        prompt (str): Question to ask about the image
+        model_path (str): Path to the model weights
+        max_tokens (int, optional): Maximum number of tokens to generate. Defaults to 200.
+        sampler (str, optional): Sampling strategy ("greedy" or "multinomial"). Defaults to "greedy".
+    
+    Returns:
+        str: Generated answer
+    """
+    if torch.cuda.is_available():
+        torch.set_default_device("cuda")
+    elif torch.backends.mps.is_available():
+        torch.set_default_device("mps")
+
+    # Load model
+    if not os.path.exists(model_path):
+        raise FileNotFoundError(f"Model not found at {model_path}")
+    model = load_from_safetensors(model_path)
+
+    # Your existing inference code here...
+    # [Rest of your original code from sample.py goes here, 
+    #  wrapped in the function with appropriate returns]
+    if not os.path.exists(image_path):
+        raise FileNotFoundError(f"Image not found at {image_path}")
+    image = Image.open(image_path)
+    image = image.resize((378, 378))
+    image_tensor = encode_image(image, model.vision)
+
+    # Encode text, and create inputs_embeds.
+    tokenizer = AutoTokenizer.from_pretrained("vikhyatk/moondream2")
+    prompt = f"\n\nQuestion: {prompt}\n\nAnswer:"
+    input_ids = tokenizer(prompt, return_tensors="pt")["input_ids"]
+    input_ids = torch.cat([torch.tensor([[tokenizer.eos_token_id]]), input_ids], dim=1)
+    inputs_embeds = text_encoder(input_ids, model.text)
+    inputs_embeds = torch.cat(
+        [
+            inputs_embeds[:, 0:1, :],
+            image_tensor.unsqueeze(0),
+            inputs_embeds[:, 1:, :],
+        ],
+        dim=1,
+    )
+
+    kv_cache = torch.empty(24, 2, 1, 32, 0, 64, dtype=torch.float16)
+    freqs_cis = precompute_freqs_cis(32, 2048)
+
+    for _ in range(max_tokens):
+        with torch.no_grad():
+            hidden, kv_cache = text_decoder(
+                inputs_embeds, model.text, kv_cache, freqs_cis
+            )
+            logits = lm_head(hidden, model.text)
+
+            if sampler == "multinomial":
+                next_token = torch.multinomial(
+                    torch.softmax(logits, dim=-1), num_samples=1
+                ).squeeze(0)
+            elif sampler == "greedy":
+                next_token = torch.argmax(logits, dim=-1)
+            else:
+                raise ValueError(f"Invalid sampler: {sampler}")
+
+            if next_token == tokenizer.eos_token_id:
+                print()
+                break
+
+            input_ids = next_token.unsqueeze(0)
+            inputs_embeds = text_encoder(input_ids, model.text)
+
+            output_text = tokenizer.batch_decode(input_ids)[0]
+            
+            print(output_text, end="", flush=True)
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--image", "-i", type=str, required=True)
+    parser.add_argument("--prompt", "-p", type=str, required=True)
+    parser.add_argument("--model", "-m", type=str, required=True)
+    parser.add_argument("--max-tokens", "-t", type=int, default=200)
+    parser.add_argument("--sampler", "-s", type=str, default="greedy")
+    args = parser.parse_args()
+    
+    result = run_inference(
+        args.image,
+        args.prompt,
+        args.model,
+        max_tokens=args.max_tokens,
+        sampler=args.sampler
+    )
+    print(result)
+
+if __name__ == "__main__":
+    main()

moondream/torch/layers.py

@@ -0,0 +1,68 @@
+import torch
+import math
+from typing import Literal
+from torch import nn
+from torch.nn import functional as F
+from dataclasses import dataclass
+
+
+def gelu_approx(x):
+    return F.gelu(x, approximate="tanh")
+
+
+@dataclass
+class LinearWeights:
+    weight: torch.Tensor
+    bias: torch.Tensor
+
+
+def linear(x: torch.Tensor, w: LinearWeights) -> torch.Tensor:
+    return F.linear(x, w.weight, w.bias)
+
+
+@dataclass
+class LayerNormWeights:
+    weight: torch.Tensor
+    bias: torch.Tensor
+
+
+def layer_norm(x: torch.Tensor, w: LayerNormWeights) -> torch.Tensor:
+    return F.layer_norm(x, w.bias.shape, w.weight, w.bias)
+
+
+@dataclass
+class MLPWeights:
+    fc1: LinearWeights
+    fc2: LinearWeights
+    act: Literal["gelu_approx"] = "gelu_approx"
+
+
+def mlp(x: torch.Tensor, w: MLPWeights) -> torch.Tensor:
+    x = linear(x, w.fc1)
+    if w.act == "gelu_approx":
+        x = gelu_approx(x)
+    else:
+        raise NotImplementedError(f"Activation function {w.act} not implemented.")
+    x = linear(x, w.fc2)
+    return x
+
+
+@dataclass
+class AttentionWeights:
+    qkv: LinearWeights
+    proj: LinearWeights
+    n_heads: int
+
+
+def attn(x: torch.Tensor, w: AttentionWeights) -> torch.Tensor:
+    bsz, q_len, d_model = x.shape
+    n_heads, head_dim = w.n_heads, d_model // w.n_heads
+
+    q, k, v = [
+        t.view(bsz, q_len, n_heads, head_dim).transpose(1, 2)
+        for t in linear(x, w.qkv).chunk(3, dim=-1)
+    ]
+    out = F.scaled_dot_product_attention(q, k, v)
+    out = out.transpose(1, 2).reshape(bsz, q_len, d_model)
+    out = linear(out, w.proj)
+    return out

moondream/torch/rope.py

@@ -0,0 +1,49 @@
+# Ethically sourced from https://github.com/xjdr-alt/entropix
+
+import torch
+from typing import Tuple
+
+
+def precompute_freqs_cis(
+    dim: int,
+    end: int,
+    theta: float = 10000.0,
+    use_scaled: bool = False,
+    dtype: torch.dtype = torch.float32,
+) -> torch.Tensor:
+    freqs = 1.0 / (theta ** (torch.arange(0, dim, 2, dtype=dtype)[: (dim // 2)] / dim))
+    t = torch.arange(end, dtype=dtype).unsqueeze(1)
+    freqs = t * freqs.unsqueeze(0)
+    freqs = torch.exp(1j * freqs)
+    return torch.stack([freqs.real, freqs.imag], dim=-1)
+
+
+def apply_rotary_emb(
+    xq: torch.Tensor,
+    xk: torch.Tensor,
+    freqs_cis: torch.Tensor,
+    interleave: bool = False,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    if interleave:
+        xq_r = xq.float().reshape(*xq.shape[:-1], -1, 2)[..., 0]
+        xq_i = xq.float().reshape(*xq.shape[:-1], -1, 2)[..., 1]
+        xk_r = xk.float().reshape(*xk.shape[:-1], -1, 2)[..., 0]
+        xk_i = xk.float().reshape(*xk.shape[:-1], -1, 2)[..., 1]
+    else:
+        d_q, d_k = xq.shape[-1] // 2, xk.shape[-1] // 2
+        xq_r, xq_i = xq[..., :d_q], xq[..., d_q:]
+        xk_r, xk_i = xk[..., :d_k], xk[..., d_k:]
+
+    freqs_cos = freqs_cis[..., 0].unsqueeze(0).unsqueeze(0)
+    freqs_sin = freqs_cis[..., 1].unsqueeze(0).unsqueeze(0)
+
+    # Complex multiplication: (a + bi) * (c + di) = (ac - bd) + (ad + bc)i
+    xq_out_r = xq_r * freqs_cos - xq_i * freqs_sin
+    xq_out_i = xq_r * freqs_sin + xq_i * freqs_cos
+    xk_out_r = xk_r * freqs_cos - xk_i * freqs_sin
+    xk_out_i = xk_r * freqs_sin + xk_i * freqs_cos
+
+    xq_out = torch.stack((xq_out_r, xq_out_i), dim=-1).flatten(-2)
+    xk_out = torch.stack((xk_out_r, xk_out_i), dim=-1).flatten(-2)
+
+    return xq_out.to(xq.dtype), xk_out.to(xk.dtype)

moondream/torch/text.py

@@ -0,0 +1,92 @@
+import torch
+from typing import Dict, Tuple, Optional, List
+from torch.nn import functional as F
+
+from .rope import apply_rotary_emb, precompute_freqs_cis
+from .layers import layer_norm, linear, mlp
+from .weights import TextModel, AttentionWeights, load_from_safetensors
+
+
+def text_encoder(input_ids: torch.Tensor, w: TextModel):
+    return F.embedding(input_ids, w.wte)
+
+
+def attn_mask(pos, seq_len):
+    """
+    Create an attention mask that aligns with the bottom right of the
+    attention matrix. For example, if q_len = 2 and kv_len = 5, we want the
+    following:
+
+         1 1 1 1 0
+         1 1 1 1 1
+
+    and not this, which is what we get by default if we just set is_causal.
+
+         1 0 0 0 0
+         1 1 0 0 0
+    """
+    mask = torch.ones(seq_len, pos + seq_len, dtype=torch.bool)
+    mask[:, pos:] = torch.tril(torch.ones(seq_len, seq_len, dtype=torch.bool))
+    mask = mask.unsqueeze(0).unsqueeze(0)  # Add batch and head dimensions
+    return mask
+
+
+def attn(
+    x: torch.Tensor,
+    w: AttentionWeights,
+    freqs_cis: torch.Tensor,
+    layer_kv_cache: torch.Tensor,
+):
+    bsz, q_len, d_model = x.shape
+    pos = 0 if layer_kv_cache is None else layer_kv_cache.shape[3]
+    n_heads, head_dim = w.n_heads, d_model // w.n_heads
+
+    q, k, v = [
+        t.view(bsz, q_len, n_heads, head_dim).transpose(1, 2)
+        for t in linear(x, w.qkv).chunk(3, dim=-1)
+    ]
+
+    q_rot, q_pass = q.chunk(2, dim=-1)
+    k_rot, k_pass = k.chunk(2, dim=-1)
+    q_rot, k_rot = apply_rotary_emb(q_rot, k_rot, freqs_cis[pos : pos + q_len])
+    q = torch.cat([q_rot, q_pass], dim=-1)
+    k = torch.cat([k_rot, k_pass], dim=-1)
+
+    if layer_kv_cache is not None:
+        k = torch.cat([layer_kv_cache[0], k], dim=2)
+        v = torch.cat([layer_kv_cache[1], v], dim=2)
+
+    out = F.scaled_dot_product_attention(q, k, v, attn_mask=attn_mask(pos, q_len)).to(
+        # This type conversion isn't needed when running in PyTorch directly, but the
+        # ONNX export runs attention in float32 because the attention mask is cast to
+        # float32.
+        x.dtype
+    )
+    out = out.transpose(1, 2).reshape(bsz, q_len, d_model)
+    out = linear(out, w.proj)
+    return out, torch.stack([k, v])
+
+
+def text_decoder(
+    inputs_embeds: torch.Tensor,
+    w: TextModel,
+    kv_cache: torch.Tensor,
+    freqs_cis: torch.Tensor,
+):
+    hidden_BTC = inputs_embeds
+    new_kv_cache = [torch.empty(0)] * len(w.blocks)
+
+    for i, block in enumerate(w.blocks):
+        l_in = layer_norm(hidden_BTC, block.ln)
+        l_attn, new_kv_cache[i] = attn(l_in, block.attn, freqs_cis, kv_cache[i])
+        l_mlp = mlp(l_in, block.mlp)
+        hidden_BTC = hidden_BTC + l_attn + l_mlp
+
+    return hidden_BTC, torch.stack(new_kv_cache)
+
+
+def lm_head(hidden_BTC: torch.Tensor, w: TextModel):
+    hidden_BC = hidden_BTC[:, -1, :]
+    hidden_BC = layer_norm(hidden_BC, w.post_ln)
+    logits = linear(hidden_BC, w.lm_head)
+    return logits

moondream/torch/vision.py

@@ -0,0 +1,107 @@
+import torch
+import math
+from typing import List, Tuple, Union
+from einops import rearrange
+from torch.nn import functional as F
+from PIL import Image
+from torchvision.transforms.v2 import InterpolationMode
+from torchvision.transforms.v2.functional import (
+    resize as tv_resize,
+    to_image,
+    to_dtype,
+    normalize,
+)
+
+from .weights import VisionModel, load_from_safetensors
+from .layers import attn, linear, layer_norm, mlp
+
+
+def im_resize(
+    image: Image.Image,
+    size: List[int],
+    interpolation: InterpolationMode = InterpolationMode.BICUBIC,
+) -> Image.Image:
+    """
+    The 'resize' function from torchvision has bad type signatures.
+    it accepts both PIL images and torch tensors,  but the type signature
+    only allows tensors.
+    """
+    return tv_resize(
+        image,  # type: ignore
+        size,
+        InterpolationMode.BICUBIC,
+    )
+
+
+def create_patches(
+    image: Image.Image, image_patch_size=378
+) -> Tuple[List[Image.Image], Tuple[int, int]]:
+    """
+    Split the given image into a variable number of patches depending upon its
+    resolution.
+    """
+    # Start off with the global patch.
+    patches = [im_resize(image, [image_patch_size, image_patch_size])]
+
+    # Find the closest resolution template.
+    res_templates = [(1, 2), (2, 1), (2, 2)]
+    im_width, im_height = image.size
+    max_dim = max(im_width, im_height)
+    if max_dim < image_patch_size * 1.4:
+        # If the image is already small, we just do a single patch that is a
+        # duplicate of the global patch. This creates a small amount of
+        # redundant computation now, but it is simpler and future-proofs us
+        # if/when we condition the vision encoder on the patch type.
+        res_template = (1, 1)
+        patches.append(patches[0])
+    else:
+        aspect_ratio = im_width / im_height
+        res_template = min(
+            res_templates, key=lambda size: abs((size[1] / size[0]) - aspect_ratio)
+        )
+        # TODO: Actually implement patching... just going to put in the global
+        # patch for now to make progress on other aspects.
+        patches.append(patches[0])
+
+    return patches, res_template
+
+
+def encode_image(image: Image.Image, weights: VisionModel) -> torch.Tensor:
+    patches, res_template = create_patches(image.convert("RGB"))
+    patches = torch.stack(
+        [
+            normalize(
+                to_dtype(to_image(patch), torch.float16, scale=True),
+                mean=[0.5, 0.5, 0.5],
+                std=[0.5, 0.5, 0.5],
+            )
+            for patch in patches
+        ]
+    )
+
+    outputs = vision_encoder(patches, weights)
+
+    # TODO: Merge sub-image patch outputs properly... for now we'll just assume
+    # that the global patch is repeated.
+    assert outputs.shape[0] == 2, "Expected single image patch."
+    outputs = torch.cat([outputs[0], outputs[1]], dim=-1)
+
+    return mlp(outputs, weights.proj_mlp)
+
+
+def vision_encoder(input_BCHW: torch.Tensor, w: VisionModel):
+    x = rearrange(
+        input_BCHW,
+        "b c (h p1) (w p2) -> b (h w) (c p1 p2)",
+        p1=w.patch_size,
+        p2=w.patch_size,
+    )  # B3HW -> B(HxW)(3xP1xP2), aka BTC
+
+    x = linear(x, w.patch_emb)
+    x = x + w.pos_emb
+    for block in w.blocks:
+        x = x + attn(layer_norm(x, block.ln1), block.attn)
+        x = x + mlp(layer_norm(x, block.ln2), block.mlp)
+    x = layer_norm(x, w.post_ln)
+
+    return x

moondream/torch/weights.py

@@ -0,0 +1,189 @@
+import torch
+import math
+import safetensors
+from typing import Dict, Union, Literal, List, Any
+from contextlib import contextmanager
+from dataclasses import dataclass
+
+from .layers import LinearWeights, LayerNormWeights, MLPWeights, AttentionWeights
+
+
+@dataclass
+class VisionBlock:
+    ln1: LayerNormWeights
+    attn: AttentionWeights
+    ln2: LayerNormWeights
+    mlp: MLPWeights
+
+
+@dataclass
+class VisionModel:
+    patch_size: int
+    patch_emb: LinearWeights
+    pos_emb: torch.Tensor
+    blocks: List[VisionBlock]
+    post_ln: LayerNormWeights
+    proj_mlp: MLPWeights
+
+
+@dataclass
+class TextBlock:
+    ln: LayerNormWeights
+    attn: AttentionWeights
+    mlp: MLPWeights
+
+
+@dataclass
+class TextModel:
+    wte: torch.Tensor
+    blocks: List[TextBlock]
+    post_ln: LayerNormWeights
+    lm_head: LinearWeights
+
+
+@dataclass
+class MoondreamModel:
+    vision: VisionModel
+    text: TextModel
+
+
+@contextmanager
+def safetensors_open(safetensors_file: str):
+    """
+    Simplify interfacing with safetensors files. Eliminates the need to ignore
+    type errors when using the `safe_open` function.
+    """
+    with safetensors.safe_open(
+        safetensors_file, framework="pt"
+    ) as st:  # pyright: ignore
+
+        def get_tensor(name: str) -> torch.Tensor:
+            return st.get_tensor(name)
+
+        yield get_tensor
+
+
+def load_from_safetensors(
+    safetensors_file: str,
+    vision_blocks: int = 27,
+    text_blocks: int = 24,
+) -> MoondreamModel:
+    with safetensors_open(safetensors_file) as get_tensor:
+        ## Vision encoder
+        prefix = "vision_encoder.encoder.model.visual.patch_embed.linear"
+        patch_emb = LinearWeights(
+            weight=get_tensor(f"{prefix}.weight"), bias=get_tensor(f"{prefix}.bias")
+        )
+        patch_size = int(math.sqrt(patch_emb.weight.shape[1] // 3))
+        pos_emb = get_tensor("vision_encoder.encoder.model.visual.pos_embed")
+        post_ln = LayerNormWeights(
+            weight=get_tensor("vision_encoder.encoder.model.visual.norm.weight"),
+            bias=get_tensor("vision_encoder.encoder.model.visual.norm.bias"),
+        )
+        blocks = []
+        for i in range(vision_blocks):
+            prefix = f"vision_encoder.encoder.model.visual.blocks.{i}"
+            blocks.append(
+                VisionBlock(
+                    ln1=LayerNormWeights(
+                        weight=get_tensor(f"{prefix}.norm1.weight"),
+                        bias=get_tensor(f"{prefix}.norm1.bias"),
+                    ),
+                    attn=AttentionWeights(
+                        qkv=LinearWeights(
+                            weight=get_tensor(f"{prefix}.attn.qkv.weight"),
+                            bias=get_tensor(f"{prefix}.attn.qkv.bias"),
+                        ),
+                        proj=LinearWeights(
+                            weight=get_tensor(f"{prefix}.attn.proj.weight"),
+                            bias=get_tensor(f"{prefix}.attn.proj.bias"),
+                        ),
+                        n_heads=16,
+                    ),
+                    ln2=LayerNormWeights(
+                        weight=get_tensor(f"{prefix}.norm2.weight"),
+                        bias=get_tensor(f"{prefix}.norm2.bias"),
+                    ),
+                    mlp=MLPWeights(
+                        fc1=LinearWeights(
+                            weight=get_tensor(f"{prefix}.mlp.fc1.weight"),
+                            bias=get_tensor(f"{prefix}.mlp.fc1.bias"),
+                        ),
+                        fc2=LinearWeights(
+                            weight=get_tensor(f"{prefix}.mlp.fc2.weight"),
+                            bias=get_tensor(f"{prefix}.mlp.fc2.bias"),
+                        ),
+                    ),
+                )
+            )
+        proj_mlp = MLPWeights(
+            fc1=LinearWeights(
+                weight=get_tensor("vision_encoder.projection.mlp.fc1.weight"),
+                bias=get_tensor("vision_encoder.projection.mlp.fc1.bias"),
+            ),
+            fc2=LinearWeights(
+                weight=get_tensor("vision_encoder.projection.mlp.fc2.weight"),
+                bias=get_tensor("vision_encoder.projection.mlp.fc2.bias"),
+            ),
+            act="gelu_approx",
+        )
+        vision = VisionModel(
+            patch_size=patch_size,
+            patch_emb=patch_emb,
+            pos_emb=pos_emb,
+            blocks=blocks,
+            post_ln=post_ln,
+            proj_mlp=proj_mlp,
+        )
+
+        ## Text decoder model
+        wte = get_tensor("text_model.transformer.embd.wte.weight")
+        post_ln = LayerNormWeights(
+            weight=get_tensor("text_model.lm_head.ln.weight"),
+            bias=get_tensor("text_model.lm_head.ln.bias"),
+        )
+        lm_head = LinearWeights(
+            weight=get_tensor("text_model.lm_head.linear.weight"),
+            bias=get_tensor("text_model.lm_head.linear.bias"),
+        )
+        blocks = []
+        for i in range(text_blocks):
+            prefix = f"text_model.transformer.h.{i}"
+            blocks.append(
+                TextBlock(
+                    ln=LayerNormWeights(
+                        weight=get_tensor(f"{prefix}.ln.weight"),
+                        bias=get_tensor(f"{prefix}.ln.bias"),
+                    ),
+                    attn=AttentionWeights(
+                        qkv=LinearWeights(
+                            weight=get_tensor(f"{prefix}.mixer.Wqkv.weight"),
+                            bias=get_tensor(f"{prefix}.mixer.Wqkv.bias"),
+                        ),
+                        proj=LinearWeights(
+                            weight=get_tensor(f"{prefix}.mixer.out_proj.weight"),
+                            bias=get_tensor(f"{prefix}.mixer.out_proj.bias"),
+                        ),
+                        n_heads=32,
+                    ),
+                    mlp=MLPWeights(
+                        fc1=LinearWeights(
+                            weight=get_tensor(f"{prefix}.mlp.fc1.weight"),
+                            bias=get_tensor(f"{prefix}.mlp.fc1.bias"),
+                        ),
+                        fc2=LinearWeights(
+                            weight=get_tensor(f"{prefix}.mlp.fc2.weight"),
+                            bias=get_tensor(f"{prefix}.mlp.fc2.bias"),
+                        ),
+                        act="gelu_approx",
+                    ),
+                )
+            )
+        text = TextModel(wte=wte, blocks=blocks, post_ln=post_ln, lm_head=lm_head)
+
+    return MoondreamModel(vision=vision, text=text)
+
+
+if __name__ == "__main__":
+    weights = load_from_safetensors("model.safetensors")
+    print(weights)

moondream-1.0.2.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Moondream
+
+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.

moondream-1.0.2.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: moondream
+Version: 1.0.2
+Summary: A package for image-based question answering using Moondream
+Home-page: https://github.com/1997MarsRover/moondream
+Author: 1997marsrover
+Author-email: antonygithinji11156@gmail.com
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: Pillow
+Requires-Dist: transformers
+

moondream-1.0.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+moondream/__init__.py,sha256=E3ndp0duYUi6CLWsoIFpltrlvf-OK4QQfrCbgT4Kf6A,95
+moondream/torch/__init__.py,sha256=AttwzPDVjIPtRGFHq83__VI2i2pemSCblQ4C1pyo1ek,202
+moondream/torch/inference.py,sha256=IrzYiSU-YF6beOevyng-BmwEGWECFRh_zWtx5bJPawc,3847
+moondream/torch/layers.py,sha256=u6E-0JmMuKryzpMPWmxI_n5SRXFRlPXc-slKg-501UE,1556
+moondream/torch/rope.py,sha256=FU017lf51z7iSS2bs_4KDk7-frz8P4pVEl-0pUWhNQA,1741
+moondream/torch/text.py,sha256=4JodKX937h9ghWm4oNyhQgKtZVogV8CvxyfyEg2OUVQ,2920
+moondream/torch/vision.py,sha256=4RfTFvtNYpM005XDklqAeZebgVWtJAF9zhF4Igl-Q9M,3393
+moondream/torch/weights.py,sha256=C5whBJPmrKacRAwmylQnz6H-m8z36T6YFF43FcwlwD0,6599
+moondream-1.0.2.dist-info/LICENSE,sha256=6LnNiERg1JyLVd1l0jpDHgTAeNouDbfhXrAnVfEDTCA,1065
+moondream-1.0.2.dist-info/METADATA,sha256=yr43jlIOrQ9fvNpRlHrSlgXsoDj8sw1-m4gvliju3UI,750
+moondream-1.0.2.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+moondream-1.0.2.dist-info/entry_points.txt,sha256=iuQDF-fzfsB8YXZ0XxhGecvZ1c6lyibrL_D67EWCE6w,61
+moondream-1.0.2.dist-info/top_level.txt,sha256=m_eOqzX4m1xP9Njpi_vHQeOP5B720mGJazO2gurLn28,10
+moondream-1.0.2.dist-info/RECORD,,

moondream-1.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

moondream-1.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+moondream = moondream.torch.inference:main

moondream-1.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+moondream