mirror of
https://github.com/ggerganov/llama.cpp.git
synced 2024-10-31 07:00:16 +01:00
a2ac89d6ef
* convert.py: add python logging instead of print() * convert.py: verbose flag takes priority over dump flag log suppression * convert.py: named instance logging * convert.py: use explicit logger id string * convert.py: convert extra print() to named logger * convert.py: sys.stderr.write --> logger.error * *.py: Convert all python scripts to use logging module * requirements.txt: remove extra line * flake8: update flake8 ignore and exclude to match ci settings * gh-actions: add flake8-no-print to flake8 lint step * pre-commit: add flake8-no-print to flake8 and also update pre-commit version * convert-hf-to-gguf.py: print() to logger conversion * *.py: logging basiconfig refactor to use conditional expression * *.py: removed commented out logging * fixup! *.py: logging basiconfig refactor to use conditional expression * constant.py: logger.error then exit should be a raise exception instead * *.py: Convert logger error and sys.exit() into a raise exception (for atypical error) * gguf-convert-endian.py: refactor convert_byteorder() to use tqdm progressbar * verify-checksum-model.py: This is the result of the program, it should be printed to stdout. * compare-llama-bench.py: add blank line for readability during missing repo response * reader.py: read_gguf_file() use print() over logging * convert.py: warning goes to stderr and won't hurt the dump output * gguf-dump.py: dump_metadata() should print to stdout * convert-hf-to-gguf.py: print --> logger.debug or ValueError() * verify-checksum-models.py: use print() for printing table * *.py: refactor logging.basicConfig() * gguf-py/gguf/*.py: use __name__ as logger name Since they will be imported and not run directly. * python-lint.yml: use .flake8 file instead * constants.py: logger no longer required * convert-hf-to-gguf.py: add additional logging * convert-hf-to-gguf.py: print() --> logger * *.py: fix flake8 warnings * revert changes to convert-hf-to-gguf.py for get_name() * convert-hf-to-gguf-update.py: use triple quoted f-string instead * *.py: accidentally corrected the wrong line * *.py: add compilade warning suggestions and style fixes
96 lines
4.0 KiB
Python
Executable File
96 lines
4.0 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
import logging
|
|
import argparse
|
|
import os
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
# Necessary to load the local gguf package
|
|
if "NO_LOCAL_GGUF" not in os.environ and (Path(__file__).parent.parent.parent / 'gguf-py').exists():
|
|
sys.path.insert(0, str(Path(__file__).parent.parent))
|
|
|
|
from gguf import GGUFReader # noqa: E402
|
|
|
|
logger = logging.getLogger("gguf-set-metadata")
|
|
|
|
|
|
def minimal_example(filename: str) -> None:
|
|
reader = GGUFReader(filename, 'r+')
|
|
field = reader.fields['tokenizer.ggml.bos_token_id']
|
|
if field is None:
|
|
return
|
|
part_index = field.data[0]
|
|
field.parts[part_index][0] = 2 # Set tokenizer.ggml.bos_token_id to 2
|
|
#
|
|
# So what's this field.data thing? It's helpful because field.parts contains
|
|
# _every_ part of the GGUF field. For example, tokenizer.ggml.bos_token_id consists
|
|
# of:
|
|
#
|
|
# Part index 0: Key length (27)
|
|
# Part index 1: Key data ("tokenizer.ggml.bos_token_id")
|
|
# Part index 2: Field type (4, the id for GGUFValueType.UINT32)
|
|
# Part index 3: Field value
|
|
#
|
|
# Note also that each part is an NDArray slice, so even a part that
|
|
# is only a single value like the key length will be a NDArray of
|
|
# the key length type (numpy.uint32).
|
|
#
|
|
# The .data attribute in the Field is a list of relevant part indexes
|
|
# and doesn't contain internal GGUF details like the key length part.
|
|
# In this case, .data will be [3] - just the part index of the
|
|
# field value itself.
|
|
|
|
|
|
def set_metadata(reader: GGUFReader, args: argparse.Namespace) -> None:
|
|
field = reader.get_field(args.key)
|
|
if field is None:
|
|
logger.error(f'! Field {repr(args.key)} not found')
|
|
sys.exit(1)
|
|
# Note that field.types is a list of types. This is because the GGUF
|
|
# format supports arrays. For example, an array of UINT32 would
|
|
# look like [GGUFValueType.ARRAY, GGUFValueType.UINT32]
|
|
handler = reader.gguf_scalar_to_np.get(field.types[0]) if field.types else None
|
|
if handler is None:
|
|
logger.error(f'! This tool only supports changing simple values, {repr(args.key)} has unsupported type {field.types}')
|
|
sys.exit(1)
|
|
current_value = field.parts[field.data[0]][0]
|
|
new_value = handler(args.value)
|
|
logger.info(f'* Preparing to change field {repr(args.key)} from {current_value} to {new_value}')
|
|
if current_value == new_value:
|
|
logger.info(f'- Key {repr(args.key)} already set to requested value {current_value}')
|
|
sys.exit(0)
|
|
if args.dry_run:
|
|
sys.exit(0)
|
|
if not args.force:
|
|
logger.warning('*** Warning *** Warning *** Warning **')
|
|
logger.warning('* Changing fields in a GGUF file can make it unusable. Proceed at your own risk.')
|
|
logger.warning('* Enter exactly YES if you are positive you want to proceed:')
|
|
response = input('YES, I am sure> ')
|
|
if response != 'YES':
|
|
logger.info("You didn't enter YES. Okay then, see ya!")
|
|
sys.exit(0)
|
|
field.parts[field.data[0]][0] = new_value
|
|
logger.info('* Field changed. Successful completion.')
|
|
|
|
|
|
def main() -> None:
|
|
parser = argparse.ArgumentParser(description="Set a simple value in GGUF file metadata")
|
|
parser.add_argument("model", type=str, help="GGUF format model filename")
|
|
parser.add_argument("key", type=str, help="Metadata key to set")
|
|
parser.add_argument("value", type=str, help="Metadata value to set")
|
|
parser.add_argument("--dry-run", action="store_true", help="Don't actually change anything")
|
|
parser.add_argument("--force", action="store_true", help="Change the field without confirmation")
|
|
parser.add_argument("--verbose", action="store_true", help="increase output verbosity")
|
|
|
|
args = parser.parse_args(None if len(sys.argv) > 1 else ["--help"])
|
|
|
|
logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO)
|
|
|
|
logger.info(f'* Loading: {args.model}')
|
|
reader = GGUFReader(args.model, 'r' if args.dry_run else 'r+')
|
|
set_metadata(reader, args)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|