bigdl-core-cpp 2.5.0rc1__py3-none-win_amd64.whl → 2.6.0__py3-none-win_amd64.whl

bigdl/cpp/gguf-py/gguf/vocab.py

@@ -1,10 +1,15 @@
 from __future__ import annotations
 
+import re
 import logging
 import json
 import os
 from pathlib import Path
-from typing import Any, Callable, Sequence, Mapping, Iterable
+from typing import Any, Callable, Sequence, Mapping, Iterable, Protocol, ClassVar, runtime_checkable
+
+from sentencepiece import SentencePieceProcessor
+
+import gguf
 
 from .gguf_writer import GGUFWriter
 
@@ -117,8 +122,30 @@ class SpecialVocab:
                 tokenizer = json.load(f)
             if self.load_merges:
                 merges = tokenizer.get('model', {}).get('merges')
-                if isinstance(merges, list) and merges and isinstance(merges[0], str):
-                    self.merges = merges
+                if isinstance(merges, list) and merges:
+                    if isinstance(merges[0], str):
+                        self.merges = merges
+                    elif isinstance(merges[0], list) and len(merges[0]) == 2 and isinstance(merges[0][0], str):
+                        # New format since transformers 4.45 to support spaces in merges
+                        # ref: https://github.com/ggml-org/llama.cpp/issues/9692
+                        # TODO: internally store as the new format instead of converting to old
+                        if any(' ' in s for pair in merges for s in pair):
+                            logger.warning(f'Spaces in merges detected, encoding as {chr(ord(" ") + 256)!r}')
+                        self.merges = [
+                            ' '.join(
+                                [
+                                    # ensure the spaces are properly encoded
+                                    ''.join(
+                                        chr(ord(c) + 256) if c == ' ' else c
+                                        for c in part
+                                    )
+                                    for part in pair
+                                ]
+                            )
+                            for pair in merges
+                        ]
+                    else:
+                        raise ValueError("Unknown tokenizer merges format")
             added_tokens = tokenizer.get('added_tokens', {})
         else:
             added_tokens = {}
@@ -163,3 +190,298 @@ class SpecialVocab:
         for typ in self.special_token_types:
             self._set_special_token(typ, config.get(f'{typ}_token_id'))
         return True
+
+
+@runtime_checkable
+class BaseVocab(Protocol):
+    tokenizer_model: ClassVar[str]
+    name: ClassVar[str]
+
+
+@runtime_checkable
+class Vocab(BaseVocab, Protocol):
+    vocab_size: int
+    added_tokens_dict: dict[str, int]
+    added_tokens_list: list[str]
+    fname_tokenizer: Path
+
+    def __init__(self, base_path: Path): ...
+    def all_tokens(self) -> Iterable[tuple[bytes, float, gguf.TokenType]]: ...
+
+
+class NoVocab(BaseVocab):
+    tokenizer_model = "no_vocab"
+    name = "no_vocab"
+
+    def __repr__(self) -> str:
+        return "<NoVocab for a model without integrated vocabulary>"
+
+
+class BpeVocab(Vocab):
+    tokenizer_model = "gpt2"
+    name = "bpe"
+
+    def __init__(self, base_path: Path):
+        added_tokens: dict[str, int] = {}
+
+        if (fname_tokenizer := base_path / 'vocab.json').exists():
+            # "slow" tokenizer
+            with open(fname_tokenizer, encoding="utf-8") as f:
+                self.vocab = json.load(f)
+
+            try:
+                # FIXME: Verify that added tokens here _cannot_ overlap with the main vocab.
+                with open(base_path / 'added_tokens.json', encoding="utf-8") as f:
+                    added_tokens = json.load(f)
+            except FileNotFoundError:
+                pass
+        else:
+            # "fast" tokenizer
+            fname_tokenizer = base_path / 'tokenizer.json'
+
+            # if this fails, FileNotFoundError propagates to caller
+            with open(fname_tokenizer, encoding="utf-8") as f:
+                tokenizer_json = json.load(f)
+
+            tokenizer_model: dict[str, Any] = tokenizer_json['model']
+            if (
+                tokenizer_model['type'] != 'BPE' or tokenizer_model.get('byte_fallback', False)
+                or tokenizer_json['decoder']['type'] != 'ByteLevel'
+            ):
+                raise FileNotFoundError('Cannot find GPT-2 BPE tokenizer')
+
+            self.vocab = tokenizer_model["vocab"]
+
+            if (added := tokenizer_json.get('added_tokens')) is not None:
+                # Added tokens here can be duplicates of the main vocabulary.
+                added_tokens = {item['content']: item['id']
+                                for item in added
+                                if item['content'] not in self.vocab}
+
+        vocab_size   = len(self.vocab)
+        expected_ids = list(range(vocab_size, vocab_size + len(added_tokens)))
+        actual_ids   = sorted(added_tokens.values())
+        if expected_ids != actual_ids:
+            expected_end_id = vocab_size + len(actual_ids) - 1
+            raise ValueError(f"Expected the {len(actual_ids)} added token ID(s) to be sequential in the range "
+                             f"{vocab_size} - {expected_end_id}; got {actual_ids}")
+
+        items = sorted(added_tokens.items(), key=lambda text_idx: text_idx[1])
+        self.added_tokens_dict    = added_tokens
+        self.added_tokens_list    = [text for (text, idx) in items]
+        self.vocab_size_base      = vocab_size
+        self.vocab_size           = self.vocab_size_base + len(self.added_tokens_list)
+        self.fname_tokenizer      = fname_tokenizer
+
+    def bpe_tokens(self) -> Iterable[tuple[bytes, float, gguf.TokenType]]:
+        reverse_vocab = {id: encoded_tok for encoded_tok, id in self.vocab.items()}
+
+        for i, _ in enumerate(self.vocab):
+            yield reverse_vocab[i], 0.0, gguf.TokenType.NORMAL
+
+    def added_tokens(self) -> Iterable[tuple[bytes, float, gguf.TokenType]]:
+        for text in self.added_tokens_list:
+            score = -1000.0
+            yield text.encode("utf-8"), score, gguf.TokenType.CONTROL
+
+    def all_tokens(self) -> Iterable[tuple[bytes, float, gguf.TokenType]]:
+        yield from self.bpe_tokens()
+        yield from self.added_tokens()
+
+    def __repr__(self) -> str:
+        return f"<BpeVocab with {self.vocab_size_base} base tokens and {len(self.added_tokens_list)} added tokens>"
+
+
+class SentencePieceVocab(Vocab):
+    tokenizer_model = "llama"
+    name = "spm"
+
+    def __init__(self, base_path: Path):
+        added_tokens: dict[str, int] = {}
+        if (fname_tokenizer := base_path / 'tokenizer.model').exists():
+            # normal location
+            try:
+                with open(base_path / 'added_tokens.json', encoding="utf-8") as f:
+                    added_tokens = json.load(f)
+            except FileNotFoundError:
+                pass
+        elif not (fname_tokenizer := base_path.parent / 'tokenizer.model').exists():
+            # not found in alternate location either
+            raise FileNotFoundError('Cannot find tokenizer.model')
+
+        self.sentencepiece_tokenizer = SentencePieceProcessor()
+        self.sentencepiece_tokenizer.LoadFromFile(str(fname_tokenizer))
+        vocab_size = self.sentencepiece_tokenizer.vocab_size()
+
+        new_tokens       = {id: piece for piece, id in added_tokens.items() if id >= vocab_size}
+        expected_new_ids = list(range(vocab_size, vocab_size + len(new_tokens)))
+        actual_new_ids   = sorted(new_tokens.keys())
+
+        if expected_new_ids != actual_new_ids:
+            raise ValueError(f"Expected new token IDs {expected_new_ids} to be sequential; got {actual_new_ids}")
+
+        # Token pieces that were added to the base vocabulary.
+        self.added_tokens_dict  = added_tokens
+        self.added_tokens_list  = [new_tokens[id] for id in actual_new_ids]
+        self.vocab_size_base    = vocab_size
+        self.vocab_size         = self.vocab_size_base + len(self.added_tokens_list)
+        self.fname_tokenizer    = fname_tokenizer
+
+    def sentencepiece_tokens(self) -> Iterable[tuple[bytes, float, gguf.TokenType]]:
+        tokenizer = self.sentencepiece_tokenizer
+        for i in range(tokenizer.vocab_size()):
+            piece = tokenizer.IdToPiece(i)
+            text         = piece.encode("utf-8")
+            score: float = tokenizer.GetScore(i)
+
+            toktype = gguf.TokenType.NORMAL
+            if tokenizer.IsUnknown(i):
+                toktype = gguf.TokenType.UNKNOWN
+            if tokenizer.IsControl(i):
+                toktype = gguf.TokenType.CONTROL
+
+            # NOTE: I think added_tokens are user defined.
+            # ref: https://github.com/google/sentencepiece/blob/master/src/sentencepiece_model.proto
+            # if tokenizer.is_user_defined(i): toktype = gguf.TokenType.USER_DEFINED
+
+            if tokenizer.IsUnused(i):
+                toktype = gguf.TokenType.UNUSED
+            if tokenizer.IsByte(i):
+                toktype = gguf.TokenType.BYTE
+
+            yield text, score, toktype
+
+    def added_tokens(self) -> Iterable[tuple[bytes, float, gguf.TokenType]]:
+        for text in self.added_tokens_list:
+            score = -1000.0
+            yield text.encode("utf-8"), score, gguf.TokenType.USER_DEFINED
+
+    def all_tokens(self) -> Iterable[tuple[bytes, float, gguf.TokenType]]:
+        yield from self.sentencepiece_tokens()
+        yield from self.added_tokens()
+
+    def __repr__(self) -> str:
+        return f"<SentencePieceVocab with {self.vocab_size_base} base tokens and {len(self.added_tokens_list)} added tokens>"
+
+
+class LlamaHfVocab(Vocab):
+    tokenizer_model = "llama"
+    name = "hfft"
+
+    def __init__(self, base_path: Path):
+        fname_tokenizer = base_path / 'tokenizer.json'
+        # if this fails, FileNotFoundError propagates to caller
+        with open(fname_tokenizer, encoding='utf-8') as f:
+            tokenizer_json = json.load(f)
+
+        # pre-check so we know if we need transformers
+        tokenizer_model: dict[str, Any] = tokenizer_json['model']
+        is_llama3 = (
+            tokenizer_model['type'] == 'BPE' and tokenizer_model.get('ignore_merges', False)
+            and not tokenizer_model.get('byte_fallback', True)
+        )
+        if is_llama3:
+            raise TypeError('Llama 3 must be converted with BpeVocab')
+
+        if not is_llama3 and (
+            tokenizer_model['type'] != 'BPE' or not tokenizer_model.get('byte_fallback', False)
+            or tokenizer_json['decoder']['type'] != 'Sequence'
+        ):
+            raise FileNotFoundError('Cannot find Llama BPE tokenizer')
+
+        try:
+            from transformers import AutoTokenizer
+        except ImportError as e:
+            raise ImportError(
+                "To use LlamaHfVocab, please install the `transformers` package. "
+                "You can install it with `pip install transformers`."
+            ) from e
+
+        # Allow the tokenizer to default to slow or fast versions.
+        # Explicitly set tokenizer to use local paths.
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            base_path,
+            cache_dir=base_path,
+            local_files_only=True,
+        )
+        assert self.tokenizer.is_fast  # assume tokenizer.json is used
+
+        # Initialize lists and dictionaries for added tokens
+        self.added_tokens_list = []
+        self.added_tokens_dict = dict()
+        self.added_tokens_ids  = set()
+
+        # Process added tokens
+        for tok, tokidx in sorted(
+            self.tokenizer.get_added_vocab().items(), key=lambda x: x[1]
+        ):
+            # Only consider added tokens that are not in the base vocabulary
+            if tokidx >= self.tokenizer.vocab_size:
+                self.added_tokens_list.append(tok)
+                self.added_tokens_dict[tok] = tokidx
+                self.added_tokens_ids.add(tokidx)
+
+        # Store special tokens and their IDs
+        self.specials = {
+            tok: self.tokenizer.get_vocab()[tok]
+            for tok in self.tokenizer.all_special_tokens
+        }
+        self.special_ids = set(self.tokenizer.all_special_ids)
+
+        # Set vocabulary sizes
+        self.vocab_size_base = self.tokenizer.vocab_size
+        self.vocab_size      = self.vocab_size_base + len(self.added_tokens_list)
+
+        self.fname_tokenizer = fname_tokenizer
+
+    def hf_tokens(self) -> Iterable[tuple[bytes, float, gguf.TokenType]]:
+        reverse_vocab = {
+            id: encoded_tok for encoded_tok, id in self.tokenizer.get_vocab().items()
+        }
+
+        for token_id in range(self.vocab_size_base):
+            # Skip processing added tokens here
+            if token_id in self.added_tokens_ids:
+                continue
+
+            # Convert token text to bytes
+            token_text = reverse_vocab[token_id].encode("utf-8")
+
+            # Yield token text, score, and type
+            yield token_text, self.get_token_score(token_id), self.get_token_type(
+                token_id, token_text, self.special_ids  # Reuse already stored special IDs
+            )
+
+    def get_token_type(self, token_id: int, token_text: bytes, special_ids: set[int]) -> gguf.TokenType:
+        # Special case for byte tokens
+        if re.fullmatch(br"<0x[0-9A-Fa-f]{2}>", token_text):
+            return gguf.TokenType.BYTE
+
+        # Determine token type based on whether it's a special token
+        return gguf.TokenType.CONTROL if token_id in special_ids else gguf.TokenType.NORMAL
+
+    def get_token_score(self, token_id: int) -> float:
+        # Placeholder for actual logic to determine the token's score
+        # This needs to be implemented based on specific requirements
+        return -1000.0  # Default score
+
+    def added_tokens(self) -> Iterable[tuple[bytes, float, gguf.TokenType]]:
+        for text in self.added_tokens_list:
+            if text in self.specials:
+                toktype = self.get_token_type(self.specials[text], b'', self.special_ids)
+                score = self.get_token_score(self.specials[text])
+            else:
+                toktype = gguf.TokenType.USER_DEFINED
+                score = -1000.0
+
+            yield text.encode("utf-8"), score, toktype
+
+    def has_newline_token(self):
+        return "<0x0A>" in self.tokenizer.vocab or "\n" in self.tokenizer.vocab
+
+    def all_tokens(self) -> Iterable[tuple[bytes, float, gguf.TokenType]]:
+        yield from self.hf_tokens()
+        yield from self.added_tokens()
+
+    def __repr__(self) -> str:
+        return f"<LlamaHfVocab with {self.vocab_size_base} base tokens and {len(self.added_tokens_list)} added tokens>"

{bigdl_core_cpp-2.5.0rc1.data → bigdl_core_cpp-2.6.0.data}/scripts/init-llama-cpp.bat

@@ -9,11 +9,16 @@ set "destination_folder=%cd%"
 pushd "%lib_dir%"
 for %%f in (*) do (
     if not "%%f"=="ollama.exe" (
+        if exist "%destination_folder%\%%~nxf" (
+            del /f "%destination_folder%\%%~nxf"
+        )
         mklink "%destination_folder%\%%~nxf" "%%~ff"
     )
 )
 popd
 
-copy "%cpp_dir%\convert.py" .
-copy "%cpp_dir%\convert-hf-to-gguf.py" .
+copy "%cpp_dir%\convert_hf_to_gguf.py" .
+copy "%cpp_dir%\convert_hf_to_gguf_update.py" .
+copy "%cpp_dir%\convert_llama_ggml_to_gguf.py" .
+copy "%cpp_dir%\convert_lora_to_gguf.py" .
 xcopy /E /I "%cpp_dir%\gguf-py\" .\gguf-py

bigdl_core_cpp-2.6.0.data/scripts/init-ollama.bat

@@ -0,0 +1,16 @@
+@echo off
+for /f "delims=" %%i in ('python -c "import bigdl.cpp; print(bigdl.cpp.__file__)"') do set "cpp_file=%%i"
+for %%a in ("%cpp_file%") do set "cpp_dir=%%~dpa"
+
+set "cpp_dir=%cpp_dir:~0,-1%"
+set "lib_dir=%cpp_dir%\libs"
+
+:: Create symlinks for DLLs and EXE
+for %%f in (ollama.exe ollama-lib.exe ollama_llama.dll ollama_ggml.dll ollama_llava_shared.dll ollama-ggml-base.dll ollama-ggml-cpu.dll ollama-ggml-sycl.dll libc++.dll) do (
+    if exist "%cd%\%%f" del /f "%cd%\%%f"
+    mklink "%cd%\%%f" "%lib_dir%\%%f"
+)
+
+:: Create symlink for dist directory
+if exist "%cd%\dist" rmdir /s /q "%cd%\dist"
+mklink /D "%cd%\dist" "%lib_dir%\dist"

{bigdl_core_cpp-2.5.0rc1.dist-info → bigdl_core_cpp-2.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: bigdl-core-cpp
-Version: 2.5.0rc1
+Version: 2.6.0
 Summary: Large Language Model Develop Toolkit
 Author: BigDL Authors
 License: Apache License, Version 2.0
@@ -10,9 +10,13 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: torch==2.2.0
 Requires-Dist: numpy==1.26.4
-Requires-Dist: transformers<5.0.0,>=4.35.2
+Requires-Dist: transformers==4.44.2
 Requires-Dist: sentencepiece~=0.1.98
-Requires-Dist: accelerate==0.21.0
+Requires-Dist: accelerate==0.33.0
 Requires-Dist: protobuf<5.0.0,>=4.21.0
 Requires-Dist: gguf>=0.1.0
-
+Dynamic: author
+Dynamic: classifier
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary

bigdl_core_cpp-2.6.0.dist-info/RECORD

@@ -0,0 +1,57 @@
+bigdl/cpp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bigdl/cpp/convert_hf_to_gguf.py,sha256=GB6mGc_deGraPhQfUgU8i33odUb6WfMw0vVPcgZ_-ow,240529
+bigdl/cpp/convert_hf_to_gguf_update.py,sha256=1BFKEkj0BMDB90lUB5p_-iR9rSVcjgYPGWmEw28avB8,17721
+bigdl/cpp/convert_llama_ggml_to_gguf.py,sha256=0dKjRhmFzvWV4e-cuLmaeW14JrWUtZwerBmz8mYyMvI,19556
+bigdl/cpp/convert_lora_to_gguf.py,sha256=sHrcutdgzrDR5H7ZiLPOLoMnkJKg8uZ7OcFhAZhPrLo,19073
+bigdl/cpp/gguf-py/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bigdl/cpp/gguf-py/gguf/__init__.py,sha256=h5GWs6SMXYR8giWZ7MTZzAc3hYsIJF-HAkdxtgXLOPo,228
+bigdl/cpp/gguf-py/gguf/constants.py,sha256=CJ0LigNqlnEqYP8IhnJsKcst9fIm-huE4RccvkTYUbg,69188
+bigdl/cpp/gguf-py/gguf/gguf.py,sha256=QpLc-xU055W2d7CEFvJp2gLIfGO63bdM24ZndZCH6rw,493
+bigdl/cpp/gguf-py/gguf/gguf_reader.py,sha256=PUrx08ZwaUOz1gLw5JQ459Hi7JIeCdlHgZX7wXcTqbI,12702
+bigdl/cpp/gguf-py/gguf/gguf_writer.py,sha256=pFgnwrsDupKxI3SHNQbfiuz7dUopCOqj3ERBPuZMkMo,39955
+bigdl/cpp/gguf-py/gguf/lazy.py,sha256=YIYxGBWD-oKXU4HOvpHs9eiEn81HUgeSmt1mmHJlbdM,8814
+bigdl/cpp/gguf-py/gguf/metadata.py,sha256=oBTb4DXi_h1L_gYm8x_JRVuEPR4GHlVHuM-iN0OxWoY,33244
+bigdl/cpp/gguf-py/gguf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bigdl/cpp/gguf-py/gguf/quants.py,sha256=2z6vcK-kBefqZbYNmSEVmdZF_tXHeVb5NC6jCbBdgKc,62040
+bigdl/cpp/gguf-py/gguf/tensor_mapping.py,sha256=w1JZkRIKHj2tKYADLDUvCOsQfVf8y7Y0ZwqmtmrtLBA,39549
+bigdl/cpp/gguf-py/gguf/utility.py,sha256=Mx4mqamXtatL15LCH04mG-7SNBwPzP2T75ts0uBnEuI,3002
+bigdl/cpp/gguf-py/gguf/vocab.py,sha256=QTdt4HZrn7onHqm2tpHTaEq2sL3yG07zbHqQR9iVfu8,20815
+bigdl/cpp/libs/common.lib,sha256=n3K_h5QgdLN21tyOm6M1z-ZZ1iYsimm-QFdEe9Q2sr4,8645952
+bigdl/cpp/libs/ggml-base.dll,sha256=7jigx8yb4yeHco7_H6SyDr35JVykjLgdX3dSLGXHcsk,643584
+bigdl/cpp/libs/ggml-cpu.dll,sha256=9H7R6KXPOjgCDYC5MDxmIx1x1fISG7bHomsRR9ibqc8,1114624
+bigdl/cpp/libs/ggml-sycl.dll,sha256=ABoeB-9mzloJlpvOFHF3I51Ij1Mz8jXR-ZJZUJZyXTE,5581312
+bigdl/cpp/libs/ggml.dll,sha256=kKryD7z4T-GXpzJyuT9hDY_Z5F7KZrTJdoK7tGrk6uc,118272
+bigdl/cpp/libs/libc++.dll,sha256=U0TVK2WfFQIJPP6Bz9SeJmgskm2iqZWJorx_DGdfKIw,1561600
+bigdl/cpp/libs/llama-batched.exe,sha256=qBYxGqaeT-XkIbTtvH5NVoe-uimcgdbciP5EvWOq7n0,1741824
+bigdl/cpp/libs/llama-bench.exe,sha256=ji47toe9jinMvm4mW_0ZdLu2U7b7RmqIRThcwDjJvR4,279552
+bigdl/cpp/libs/llama-cli.exe,sha256=X-RXhTcprd737MAZLbGhtJZ4xajeS1M2iUEMjNHvVoA,1814016
+bigdl/cpp/libs/llama-embedding.exe,sha256=fLt-tw5sebRVo0H_12RimAt0mgAeMfxP-AxD4fMSvic,1766912
+bigdl/cpp/libs/llama-gemma3-cli.exe,sha256=5c8HNzHCro5sg9lGKnwnGViXjXjEj9LK-DXl-U-4XYM,2035200
+bigdl/cpp/libs/llama-gguf.exe,sha256=dCF2umZIjaXz5kgvDmPfezR0jl5rZ4sOrsN1ej-YJ2M,59392
+bigdl/cpp/libs/llama-llava-cli.exe,sha256=nHYQlifa5GoUkEt_-9TqFm0HXAKX5fFO3Md7uHVSPfo,2019840
+bigdl/cpp/libs/llama-lookup.exe,sha256=W_2PzuonWgF1Vct6WjvFYZCLVvGJU-__6XBESMK-ooU,1802752
+bigdl/cpp/libs/llama-ls-sycl-device.exe,sha256=Cm3518SDBhfC3hPirFZXbUyZX07uCERwuLH-OPuY7Vw,10240
+bigdl/cpp/libs/llama-minicpmv-cli.exe,sha256=0hpPOtoMocOl3wfXh-ompCfDTP9GabnSuImxWU9aDO4,2017792
+bigdl/cpp/libs/llama-perplexity.exe,sha256=b6MclCeblDWC7-DWxMmOO480fy2tPQadkG2D5gTCqAo,1888256
+bigdl/cpp/libs/llama-quantize.exe,sha256=vu_aapO5lD9-qavOvkYpsQ0tOspZW9sMnrJZ5WnzC64,122880
+bigdl/cpp/libs/llama-server.exe,sha256=HSrW7uChCv3tWBe-aMG0-NJQIh1-io_XwnKkgvMCJS8,4132352
+bigdl/cpp/libs/llama-simple.exe,sha256=SuRTJXmgwRoxgUka2MFYArkofJawNXX5mATauGeqdTU,62464
+bigdl/cpp/libs/llama-speculative.exe,sha256=P3dLyjIq59HDuk--OVfsaCAsPSCLS0az3Fd4TqiLx0c,1805312
+bigdl/cpp/libs/llama-tokenize.exe,sha256=lcVOzsGgKe2SuJqNiQtDWRZqseiwNUBLGm3isyySfkY,89088
+bigdl/cpp/libs/llama.dll,sha256=rK9b2_9b2BdMw501PNjV2B4DldVdNs1NGZVG7F2fvbY,1470464
+bigdl/cpp/libs/llava_shared.dll,sha256=78Ez5oen9amLMNKDmOSn2bUVvL8TNArcl_Z7RM9cY7E,380416
+bigdl/cpp/libs/ollama-ggml-base.dll,sha256=bFmhyKn_PvO13I2e68pjg16Q_aeh6Y6TGGOjL0ob_RM,523776
+bigdl/cpp/libs/ollama-ggml-cpu.dll,sha256=aSrOt-Y7eRw0gE0YJjO4hf3tEtV4ijRxD4U4CDMHVRE,549376
+bigdl/cpp/libs/ollama-ggml-sycl.dll,sha256=AeZf7VoQL40uQJ9FPLjYuWLlpJfsMqroUwzxN7ykhkc,5346816
+bigdl/cpp/libs/ollama-lib.exe,sha256=eBr3NVdSehqMI3mySFkwzgVkGrfE__vU1k7KoSNnsxQ,25918464
+bigdl/cpp/libs/ollama.exe,sha256=SBi5T85BNQ8SkmexhoN1FNrzcLNKVQcq0oPc6HpUbjQ,207360
+bigdl/cpp/libs/ollama_ggml.dll,sha256=S94zaU79qeHmM0oGkVGZeAcIc7OEaJOovQSF2heJDDg,113152
+bigdl/cpp/libs/ollama_llama.dll,sha256=6l48cWLrziagipsm96EN7Z9cKWB3mNCqISPTQukwfuk,1421312
+bigdl/cpp/libs/ollama_llava_shared.dll,sha256=O9AMvxRljh_xwGOlNJNniuqmaNb4d55m5ueQkWHpejo,398336
+bigdl_core_cpp-2.6.0.data/scripts/init-llama-cpp.bat,sha256=U0h6RifZxL3GGJp-0dxdZapQIvXUATSj644CURJL-lg,751
+bigdl_core_cpp-2.6.0.data/scripts/init-llama-cpp.ps1,sha256=JFOylLxO4MKpllHhdbPuJ1xHi9azxDpzdJns8JtZpkU,501
+bigdl_core_cpp-2.6.0.data/scripts/init-ollama.bat,sha256=0I2iBOFv3kR9hvEySGMRUU52-qwVhE7oRZnyWz-2z_U,657
+bigdl_core_cpp-2.6.0.dist-info/METADATA,sha256=G5HIXXKcV0yN66dgaZhhUgnCOIMbjr0ugN9d9MZID_o,741
+bigdl_core_cpp-2.6.0.dist-info/WHEEL,sha256=GRAwO4abswPoD8u6X5Ix8yKoy-wTIXRf_V-PAIDNIsM,97
+bigdl_core_cpp-2.6.0.dist-info/top_level.txt,sha256=iGuLfZARD_qANcIMfy0tbbrC3EtCg6BSiH8icc3dLWs,6
+bigdl_core_cpp-2.6.0.dist-info/RECORD,,

{bigdl_core_cpp-2.5.0rc1.dist-info → bigdl_core_cpp-2.6.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-win_amd64