docs for
pattern_lensv0.1.0
visualization of LLM attention patterns and things computed about them
pattern-lens makes it easy to:
pip install pattern-lensThe pipeline is as follows:
pattern_lens.activations.acitvations_main(), saving them in
npz filespattern_lens.figures.figures_main() – read the
npz files, pass each attention pattern to each
visualization function, and save the resulting figurespattern_lens.server – web
interface reads metadata in json/jsonl files, then lets the user select
figures to showGenerate attention patterns and default visualizations:
# generate activations
python -m pattern_lens.activations --model gpt2 --prompts data/pile_1k.jsonl --save-path attn_data
# create visualizations
python -m pattern_lens.figures --model gpt2 --save-path attn_dataserve the web UI:
python -m pattern_lens.server --path attn_dataView a demo of the web UI at miv.name/pattern-lens/demo.
Add custom visualization functions by decorating them with
@register_attn_figure_func. You should still generate the
activations first:
python -m pattern_lens.activations --model gpt2 --prompts data/pile_1k.jsonl --save-path attn_dataand then write+run a script/notebook that looks something like this
(see demo.ipynb for a full example):
# imports
import numpy as np
import matplotlib.pyplot as plt
from scipy.linalg import svd
from pattern_lens.figure_util import matplotlib_figure_saver, save_matrix_wrapper
from pattern_lens.attn_figure_funcs import register_attn_figure_func
from pattern_lens.figures import figures_main
# define your own functions
# this one uses `matplotlib_figure_saver` -- define a function that takes matrix and `plt.Axes`, modify the axes
@register_attn_figure_func
@matplotlib_figure_saver(fmt="svgz")
def svd_spectra(attn_matrix: np.ndarray, ax: plt.Axes) -> None:
# Perform SVD
U, s, Vh = svd(attn_matrix)
# Plot singular values
ax.plot(s, "o-")
ax.set_yscale("log")
ax.set_xlabel("Singular Value Index")
ax.set_ylabel("Singular Value")
ax.set_title("Singular Value Spectrum of Attention Matrix")
# run the figures pipelne
# run the pipeline
figures_main(
model_name="pythia-14m",
save_path=Path("docs/demo/"),
n_samples=5,
force=False,
)pattern_lensvisualization of LLM attention patterns and things computed about them
pattern-lens makes it easy to:
pip install pattern-lensThe pipeline is as follows:
pattern_lens.activations.acitvations_main(), saving them in
npz files<a href="pattern_lens/figures.html#figures_main">pattern_lens.figures.figures_main()</a>
– read the npz files, pass each attention pattern to each
visualization function, and save the resulting figures<a href="pattern_lens/server.html">pattern_lens.server</a>
– web interface reads metadata in json/jsonl files, then lets the user
select figures to showGenerate attention patterns and default visualizations:
### generate activations
python -m <a href="pattern_lens/activations.html">pattern_lens.activations</a> --model gpt2 --prompts data/pile_1k.jsonl --save-path attn_data
### create visualizations
python -m <a href="pattern_lens/figures.html">pattern_lens.figures</a> --model gpt2 --save-path attn_dataserve the web UI:
python -m <a href="pattern_lens/server.html">pattern_lens.server</a> --path attn_dataView a demo of the web UI at miv.name/pattern-lens/demo.
Add custom visualization functions by decorating them with
@register_attn_figure_func. You should still generate the
activations first:
python -m <a href="pattern_lens/activations.html">pattern_lens.activations</a> --model gpt2 --prompts data/pile_1k.jsonl --save-path attn_dataand then write+run a script/notebook that looks something like this
(see demo.ipynb for a full example):
### imports
import numpy as np
import matplotlib.pyplot as plt
from scipy.linalg import svd
from <a href="pattern_lens/figure_util.html">pattern_lens.figure_util</a> import matplotlib_figure_saver, save_matrix_wrapper
from <a href="pattern_lens/attn_figure_funcs.html">pattern_lens.attn_figure_funcs</a> import register_attn_figure_func
from <a href="pattern_lens/figures.html">pattern_lens.figures</a> import figures_main
### define your own functions
### this one uses `matplotlib_figure_saver` -- define a function that takes matrix and `plt.Axes`, modify the axes
@register_attn_figure_func
@matplotlib_figure_saver(fmt="svgz")
def svd_spectra(attn_matrix: np.ndarray, ax: plt.Axes) -> None:
# Perform SVD
U, s, Vh = svd(attn_matrix)
# Plot singular values
ax.plot(s, "o-")
ax.set_yscale("log")
ax.set_xlabel("Singular Value Index")
ax.set_ylabel("Singular Value")
ax.set_title("Singular Value Spectrum of Attention Matrix")
### run the figures pipelne
### run the pipeline
figures_main(
model_name="pythia-14m",
save_path=Path("docs/demo/"),
n_samples=5,
force=False,
)docs for
pattern_lensv0.1.0
computing and saving activations given a model and prompts
from the command line:
python -m pattern_lens.activations --model <model_name> --prompts <prompts_path> --save-path <save_path> --min-chars <min_chars> --max-chars <max_chars> --n-samples <n_samples>from a script:
from pattern_lens.activations import activations_main
activations_main(
model_name="gpt2",
save_path="demo/"
prompts_path="data/pile_1k.jsonl",
)pattern_lens.activationscomputing and saving activations given a model and prompts
from the command line:
python -m <a href="">pattern_lens.activations</a> --model <model_name> --prompts <prompts_path> --save-path <save_path> --min-chars <min_chars> --max-chars <max_chars> --n-samples <n_samples>from a script:
from <a href="">pattern_lens.activations</a> import activations_main
activations_main(
model_name="gpt2",
save_path="demo/"
prompts_path="data/pile_1k.jsonl",
)def compute_activations(
prompt: dict,
model: transformer_lens.HookedTransformer.HookedTransformer | None = None,
save_path: pathlib.Path = WindowsPath('attn_data'),
return_cache: bool = True,
names_filter: Union[Callable[[str], bool], re.Pattern] = re.compile('blocks\\.(\\d+)\\.attn\\.hook_pattern')
) -> tuple[pathlib.Path, dict[str, numpy.ndarray] | None]get activations for a given model and prompt, possibly from a cache
if from a cache, prompt_meta must be passed and contain the prompt hash
prompt : dict | None (defaults to
None)model : HookedTransformersave_path : Path (defaults to
Path(DATA_DIR))return_cache : bool will return None as
the second element if False (defaults to
True)names_filter : Callable[[str], bool]|re.Pattern a
filter for the names of the activations to return. if an
re.Pattern, will use
lambda key: names_filter.match(key) is not None (defaults
to ATTN_PATTERN_REGEX)tuple[Path, ActivationCacheNp|None]def get_activations(
prompt: dict,
model: transformer_lens.HookedTransformer.HookedTransformer | str,
save_path: pathlib.Path = WindowsPath('attn_data'),
allow_disk_cache: bool = True,
return_cache: bool = True
) -> tuple[pathlib.Path, dict[str, numpy.ndarray] | None]given a prompt and a model, save or load activations
prompt : dict expected to contain the ‘text’ keymodel : HookedTransformer | str either a
HookedTransformer or a string model name, to be loaded with
HookedTransformer.from_pretrainedsave_path : Path path to save the activations to (and
load from) (defaults to Path(DATA_DIR))allow_disk_cache : bool whether to allow loading from
disk cache (defaults to True)return_cache : bool whether to return the cache. if
False, will return None as the second element
(defaults to True)tuple[Path, ActivationCacheNp | None] the path to the
activations and the cache if return_cache is
Truedef activations_main(
model_name: str,
save_path: str,
prompts_path: str,
raw_prompts: bool,
min_chars: int,
max_chars: int,
force: bool,
n_samples: int,
no_index_html: bool,
shuffle: bool = False
) -> Nonemain function for computing activations
model_name : str name of a model to load with
HookedTransformer.from_pretrainedsave_path : str path to save the activations toprompts_path : str path to the prompts fileraw_prompts : bool whether the prompts are raw, not
filtered by length. load_text_data will be called if
True, otherwise just load the “text” field from each line
in prompts_pathmin_chars : int minimum number of characters for a
promptmax_chars : int maximum number of characters for a
promptforce : bool whether to overwrite existing filesn_samples : int maximum number of samples to
processno_index_html : bool whether to write an index.html
fileshuffle : bool whether to shuffle the prompts (defaults
to False)def main()docs for
pattern_lensv0.1.0
default figure functions
note that for pattern_lens.figures to recognize your
function, you need to use the register_attn_figure_func
decorator which adds your function to
ATTENTION_MATRIX_FIGURE_FUNCS
pattern_lens.attn_figure_funcsdefault figure functions
note that for
<a href="figures.html">pattern_lens.figures</a>
to recognize your function, you need to use the
register_attn_figure_func decorator which adds your
function to ATTENTION_MATRIX_FIGURE_FUNCS
ATTENTION_MATRIX_FIGURE_FUNCS: list[typing.Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx'], pathlib.Path], NoneType]] = [<function raw>]def register_attn_figure_func(
func: Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx'], pathlib.Path], NoneType]
) -> Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx'], pathlib.Path], NoneType]decorator for registering attention matrix figure function
if you want to add a new figure function, you should use this decorator
# Parameters:
- `func : AttentionMatrixFigureFunc`
your function, which should take an attention matrix and path
# Returns:
- `AttentionMatrixFigureFunc`
your function, after we add it to `ATTENTION_MATRIX_FIGURE_FUNCS`@register_attn_figure_func
def my_new_figure_func(attn_matrix: AttentionMatrix, path: Path) -> None:
fig, ax = plt.subplots(figsize=(10, 10))
ax.matshow(attn_matrix, cmap="viridis")
ax.set_title("My New Figure Function")
ax.axis("off")
plt.savefig(path / "my_new_figure_func", format="svgz")
plt.close(fig)def raw(
attn_matrix: jaxtyping.Float[ndarray, 'n_ctx n_ctx']
) -> jaxtyping.Float[ndarray, 'n m']docs for
pattern_lensv0.1.0
implements some constants and types
pattern_lens.constsimplements some constants and types
AttentionMatrix = <class 'jaxtyping.Float[ndarray, 'n_ctx n_ctx']'>type alias for attention matrix
ActivationCacheNp = dict[str, numpy.ndarray]type alias for a cache of attention matrices, subset of ActivationCache
DATA_DIR: str = 'attn_data'default directory for attention data
ATTN_PATTERN_REGEX: re.Pattern = re.compile('blocks\\.(\\d+)\\.attn\\.hook_pattern')regex for finding attention patterns in model state dicts
SPINNER_KWARGS: dict = {'config': {'success': '✔️ '}}default kwargs for muutils.spinner.Spinner
DIVIDER_S1: str = '======================================================================'divider string for separating sections
DIVIDER_S2: str = '--------------------------------------------------'divider string for separating subsections
docs for
pattern_lensv0.1.0
implements a bunch of types, default values, and templates which are useful for figure functions
notably, you can use the decorators
matplotlib_figure_saver, save_matrix_wrapper
to make your functions save figures
AttentionMatrixFigureFuncMatrix2DMatrix2DrgbAttentionMatrixToMatrixFuncMATPLOTLIB_FIGURE_FMTMatrixSaveFormatMATRIX_SAVE_NORMALIZEMATRIX_SAVE_CMAPMATRIX_SAVE_FMTMATRIX_SAVE_SVG_TEMPLATEmatplotlib_figure_savermatrix_to_image_preprocessmatrix2drgb_to_png_bytesmatrix_as_svgsave_matrix_wrapperpattern_lens.figure_utilimplements a bunch of types, default values, and templates which are useful for figure functions
notably, you can use the decorators
matplotlib_figure_saver, save_matrix_wrapper
to make your functions save figures
AttentionMatrixFigureFunc = typing.Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx'], pathlib.Path], NoneType]Type alias for a function that, given an attention matrix, saves a figure
Matrix2D = <class 'jaxtyping.Float[ndarray, 'n m']'>Type alias for a 2D matrix (plottable)
Matrix2Drgb = <class 'jaxtyping.UInt8[ndarray, 'n m rgb=3']'>Type alias for a 2D matrix with 3 channels (RGB)
AttentionMatrixToMatrixFunc = typing.Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx']], jaxtyping.Float[ndarray, 'n m']]Type alias for a function that, given an attention matrix, returns a 2D matrix
MATPLOTLIB_FIGURE_FMT: str = 'svgz'format for saving matplotlib figures
MatrixSaveFormat = typing.Literal['png', 'svg', 'svgz']Type alias for the format to save a matrix as when saving raw matrix, not matplotlib figure
MATRIX_SAVE_NORMALIZE: bool = Falsedefault for whether to normalize the matrix to range [0, 1]
MATRIX_SAVE_CMAP: str = 'viridis'default colormap for saving matrices
MATRIX_SAVE_FMT: Literal['png', 'svg', 'svgz'] = 'svgz'default format for saving matrices
MATRIX_SAVE_SVG_TEMPLATE: str = '<svg xmlns="http://www.w3.org/2000/svg" width="{m}" height="{n}" viewBox="0 0 {m} {n}" image-rendering="pixelated"> <image href="data:image/png;base64,{png_base64}" width="{m}" height="{n}" /> </svg>'template for saving an n by m matrix as an
svg/svgz
def matplotlib_figure_saver(
func: Optional[Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx'], matplotlib.axes._axes.Axes], NoneType]] = None,
*args,
fmt: str = 'svgz'
) -> Union[Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx'], pathlib.Path], NoneType], Callable[[Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx'], matplotlib.axes._axes.Axes], NoneType], str], Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx'], pathlib.Path], NoneType]]]decorator for functions which take an attention matrix and predefined
ax object, making it save a figure
func : Callable[[AttentionMatrix, plt.Axes], None] your
function, which should take an attention matrix and predefined
ax objectfmt : str format for saving matplotlib figures
(defaults to MATPLOTLIB_FIGURE_FMT)AttentionMatrixFigureFunc your function, after we wrap
it to save a figure@register_attn_figure_func
@matplotlib_figure_saver
def raw(attn_matrix: AttentionMatrix, ax: plt.Axes) -> None:
ax.matshow(attn_matrix, cmap="viridis")
ax.set_title("Raw Attention Pattern")
ax.axis("off")def matrix_to_image_preprocess(
matrix: jaxtyping.Float[ndarray, 'n m'],
normalize: bool = False,
cmap: str | matplotlib.colors.Colormap = 'viridis'
) -> jaxtyping.UInt8[ndarray, 'n m rgb=3']preprocess a 2D matrix into a plottable heatmap image
matrix : Matrix2D input matrixnormalize : bool whether to normalize the matrix to
range [0, 1] (defaults to MATRIX_SAVE_NORMALIZE)cmap : str|Colormap the colormap to use for the matrix
(defaults to MATRIX_SAVE_CMAP)Matrix2Drgbdef matrix2drgb_to_png_bytes(
matrix: jaxtyping.UInt8[ndarray, 'n m rgb=3'],
buffer: _io.BytesIO | None = None
) -> bytes | NoneConvert a Matrix2Drgb to valid PNG bytes via PIL
buffer is provided, it will write the PNG bytes to
the buffer and return Nonebuffer is not provided, it will return the PNG
bytesmatrix : Matrix2Drgbbuffer : io.BytesIO | None (defaults to
None, in which case it will return the PNG bytes)bytes|None bytes if buffer is
None, otherwise Nonedef matrix_as_svg(
matrix: jaxtyping.Float[ndarray, 'n m'],
normalize: bool = False,
cmap='viridis'
) -> strquickly convert a 2D matrix to an SVG image, without matplotlib
matrix : Float[np.ndarray, 'n m'] a 2D matrix to
convert to an SVG imagenormalize : bool whether to normalize the matrix to
range [0, 1]. if it’s not in the range [0, 1], this must be
True or it will raise an AssertionError
(defaults to False)cmap : str the colormap to use for the matrix – will
look up in matplotlib.colormaps if it’s a string (defaults
to "viridis")str the SVG content for the matrixdef save_matrix_wrapper(
func: Optional[Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx']], jaxtyping.Float[ndarray, 'n m']]] = None,
*args,
fmt: Literal['png', 'svg', 'svgz'] = 'svgz',
normalize: bool = False,
cmap='viridis'
) -> Union[Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx'], pathlib.Path], NoneType], Callable[[Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx']], jaxtyping.Float[ndarray, 'n m']]], Callable[[jaxtyping.Float[ndarray, 'n_ctx n_ctx'], pathlib.Path], NoneType]]]Decorator for functions that process an attention matrix and save it as an SVGZ image. Can handle both argumentless usage and with arguments.
func : AttentionMatrixToMatrixFunc|None Either the
function to decorate (in the no-arguments case) or None
when used with arguments.fmt : MatrixSaveFormat, keyword-only The format to save
the matrix as. Defaults to MATRIX_SAVE_FMT.normalize : bool, keyword-only Whether to normalize the
matrix to range [0, 1]. Defaults to False.cmap : str, keyword-only The colormap to use for the
matrix. Defaults to MATRIX_SVG_CMAP.AttentionMatrixFigureFunc|Callable[[AttentionMatrixToMatrixFunc], AttentionMatrixFigureFunc]
AttentionMatrixFigureFunc if func is
AttentionMatrixToMatrixFunc (no arguments case)Callable[[AttentionMatrixToMatrixFunc], AttentionMatrixFigureFunc]
if func is None – returns the decorator which
will then be applied to the (with arguments case)@save_matrix_wrapper
def identity_matrix(matrix):
return matrix
@save_matrix_wrapper(normalize=True, fmt="png")
def scale_matrix(matrix):
return matrix * 2
@save_matrix_wrapper(normalize=True, cmap="plasma")
def scale_matrix(matrix):
return matrix * 2docs for
pattern_lensv0.1.0
code for generating figures from attention patterns, using the
functions decorated with register_attn_figure_func
pattern_lens.figurescode for generating figures from attention patterns, using the
functions decorated with register_attn_figure_func
class HTConfigMock:Mock of transformer_lens.HookedTransformerConfig for
type hinting and loading config json
can be initialized with any kwargs, and will update its
__dict__ with them. does, however, require the following
attributes: - n_layers: int - n_heads: int -
model_name: str
HTConfigMock(**kwargs)n_layers: int
n_heads: int
model_name: str
def serialize(self)serialize the config to json. values which aren’t serializable will
be converted via muutils.json_serialize.json_serialize
def load(cls, data: dict)try to load a config from a dict, using the __init__
method
def process_single_head(
layer_idx: int,
head_idx: int,
attn_pattern: jaxtyping.Float[ndarray, 'n_ctx n_ctx'],
save_dir: pathlib.Path,
force_overwrite: bool = False
) -> dict[str, bool | Exception]process a single head’s attention pattern, running all the functions
in ATTENTION_MATRIX_FIGURE_FUNCS on the attention
pattern
layer_idx : inthead_idx : intattn_pattern : AttentionMatrix attention pattern for
the headsave_dir : Path directory to save the figures toforce_overwrite : bool whether to overwrite existing
figures. if False, will skip any functions which have
already saved a figure (defaults to False)dict[str, bool | Exception] a dictionary of the status
of each function, with the function name as the key and the status as
the valuedef compute_and_save_figures(
model_cfg: 'HookedTransformerConfig|HTConfigMock',
activations_path: pathlib.Path,
cache: dict[str, numpy.ndarray],
save_path: pathlib.Path = WindowsPath('attn_data'),
force_overwrite: bool = False,
track_results: bool = False
) -> Nonecompute and save figures for all heads in the model, using the
functions in ATTENTION_MATRIX_FIGURE_FUNCS
model_cfg : HookedTransformerConfig|HTConfigMockcache : ActivationCacheNpsave_path : Path (defaults to
Path(DATA_DIR))force_overwrite : bool force overwrite of existing
figures. if False, will skip any functions which have
already saved a figure (defaults to False)track_results : bool whether to track the results of
each function for each head. Isn’t used for anything yet, but this is a
TODO (defaults to False)def process_prompt(
prompt: dict,
model_cfg: 'HookedTransformerConfig|HTConfigMock',
save_path: pathlib.Path,
force_overwrite: bool = False
) -> Noneprocess a single prompt, loading the activations and computing and saving the figures
basically just calls load_activations and then
compute_and_save_figures
prompt : dictmodel_cfg : HookedTransformerConfig|HTConfigMockforce_overwrite : bool (defaults to
False)def figures_main(
model_name: str,
save_path: str,
n_samples: int,
force: bool,
parallel: bool | int = True
) -> Nonemain function for generating figures from attention patterns, using
the functions in ATTENTION_MATRIX_FIGURE_FUNCS
model_name : str model name to use, used for loading
the model config, prompts, activations, and saving the figuressave_path : str base path to look inn_samples : int max number of samples to processforce : bool force overwrite of existing figures. if
False, will skip any functions which have already saved a
figureparallel : bool | int whether to run in parallel. if
True, will use all available cores. if False,
will run in serial. if an int, will try to use that many cores (defaults
to True)def main()docs for
pattern_lensv0.1.0
writes indexes to the model directory for the frontend to use or for record keeping
generate_prompts_jsonlgenerate_models_jsonlget_func_metadatagenerate_functions_jsonlwrite_html_indexpattern_lens.indexeswrites indexes to the model directory for the frontend to use or for record keeping
def generate_prompts_jsonl(model_dir: pathlib.Path)creates a prompts.jsonl file with all the prompts in the
model directory
looks in all directories in {model_dir}/prompts for a
prompt.json file
def generate_models_jsonl(path: pathlib.Path)creates a models.jsonl file with all the models
def get_func_metadata(func: Callable) -> dict[str, str | None]get metadata for a function
func : Callabledict[str, str | None] dictionary:
name : str : the name of the functiondoc : str : the docstring of the functionfigure_save_fmt : str | None : the format of the figure
that the function saves, using the figure_save_fmt
attribute of the function. None if the attribute does not
existsource : str | None : the source file of the
functioncode : str | None : the source code of the function,
split by line. None if the source file cannot be readdef generate_functions_jsonl(path: pathlib.Path)unions all functions from file and current
ATTENTION_MATRIX_FIGURE_FUNCS into a
functions.jsonl file
def write_html_index(path: pathlib.Path)writes an index.html file to the path
docs for
pattern_lensv0.1.0
loading activations from .npz on disk. implements some custom Exception classes
GetActivationsErrorActivationsMissingErrorActivationsMismatchErrorcompare_prompt_to_loadedaugment_prompt_with_hashload_activationspattern_lens.load_activationsloading activations from .npz on disk. implements some custom Exception classes
class GetActivationsError(builtins.ValueError):base class for errors in getting activations
class ActivationsMissingError(GetActivationsError, builtins.FileNotFoundError):error for missing activations – can’t find the activations file
class ActivationsMismatchError(GetActivationsError):error for mismatched activations – the prompt text or hash do not match
raised by compare_prompt_to_loaded
def compare_prompt_to_loaded(prompt: dict, prompt_loaded: dict) -> Nonecompare a prompt to a loaded prompt, raise an error if they do not match
prompt : dictprompt_loaded : dictNoneActivationsMismatchError : if the prompt text or hash
do not matchdef augment_prompt_with_hash(prompt: dict) -> dictif a prompt does not have a hash, add one
prompt : dictdictthe input prompt dictionary, if it does not have a
"hash" key
def load_activations(
model_name: str,
prompt: dict,
save_path: pathlib.Path,
return_fmt: Literal['torch', 'numpy'] = 'torch'
) -> tuple[pathlib.Path, dict[str, torch.Tensor] | dict[str, numpy.ndarray]]load activations for a prompt and model, from an npz file
model_name : strprompt : dictsave_path : Pathreturn_fmt : Literal["torch", "numpy"] (defaults to
"torch")tuple[Path, dict[str, torch.Tensor]|dict[str, np.ndarray]]
the path to the activations file and the activations as a dictionary of
numpy arrays or torch tensors, depending on return_fmtActivationsMissingError : if the activations file is
missingValueError : if return_fmt is not
"torch" or "numpy"docs for
pattern_lensv0.1.0
implements load_text_data for loading prompts
pattern_lens.promptsimplements load_text_data for loading prompts
def load_text_data(
fname: pathlib.Path,
min_chars: int | None = None,
max_chars: int | None = None,
shuffle: bool = False
) -> list[dict]given fname, the path to a jsonl file, split prompts up
into more reasonable sizes
fname : Path jsonl file with prompts. Expects a list of
dicts with a “text” keymin_chars : int | None (defaults to
None)max_chars : int | None (defaults to
None)shuffle : bool (defaults to False)list[dict] new, processed list of prompts. Each prompt
has a “text” key with a string value, and some metadata. this is not
guaranteed to be the same length as the input list!docs for
pattern_lensv0.1.0
cli for starting the server to show the web ui.
can also run with –rewrite-index to update the index.html file. this is useful for working on the ui.
pattern_lens.servercli for starting the server to show the web ui.
can also run with –rewrite-index to update the index.html file. this is useful for working on the ui.
def main(path: str, port: int = 8000)