accelforge 0.0.1__py3-none-any.whl

docs/_build/html/_sources/fastfusion.frontend.rst.txt

@@ -0,0 +1,70 @@
+fastfusion.frontend package
+===========================
+
+Subpackages
+-----------
+
+.. toctree::
+   :maxdepth: 4
+
+   fastfusion.frontend.mapper
+   fastfusion.frontend.workload
+
+Submodules
+----------
+
+fastfusion.frontend.arch module
+-------------------------------
+
+.. automodule:: fastfusion.frontend.arch
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+fastfusion.frontend.config module
+---------------------------------
+
+.. automodule:: fastfusion.frontend.config
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+fastfusion.frontend.mapping module
+----------------------------------
+
+.. automodule:: fastfusion.frontend.mapping
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+fastfusion.frontend.renames module
+----------------------------------
+
+.. automodule:: fastfusion.frontend.renames
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+fastfusion.frontend.spec module
+-------------------------------
+
+.. automodule:: fastfusion.frontend.spec
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+fastfusion.frontend.variables module
+------------------------------------
+
+.. automodule:: fastfusion.frontend.variables
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+Module contents
+---------------
+
+.. automodule:: fastfusion.frontend
+   :members:
+   :show-inheritance:
+   :undoc-members:

docs/_build/html/_sources/fastfusion.frontend.workload.rst.txt

@@ -0,0 +1,21 @@
+fastfusion.frontend.workload package
+====================================
+
+Submodules
+----------
+
+fastfusion.frontend.workload.workload module
+--------------------------------------------
+
+.. automodule:: fastfusion.frontend.workload.workload
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+Module contents
+---------------
+
+.. automodule:: fastfusion.frontend.workload
+   :members:
+   :show-inheritance:
+   :undoc-members:

docs/_build/html/_sources/fastfusion.mapper.FFM.rst.txt

@@ -0,0 +1,37 @@
+fastfusion.mapper.FFM package
+=============================
+
+Submodules
+----------
+
+fastfusion.mapper.FFM.main module
+---------------------------------
+
+.. automodule:: fastfusion.mapper.FFM.main
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+fastfusion.mapper.FFM.mappings module
+-------------------------------------
+
+.. automodule:: fastfusion.mapper.FFM.mappings
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+fastfusion.mapper.FFM.pmappings module
+--------------------------------------
+
+.. automodule:: fastfusion.mapper.FFM.pmappings
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+Module contents
+---------------
+
+.. automodule:: fastfusion.mapper.FFM
+   :members:
+   :show-inheritance:
+   :undoc-members:

docs/_build/html/_sources/fastfusion.mapper.rst.txt

@@ -0,0 +1,18 @@
+fastfusion.mapper package
+=========================
+
+Subpackages
+-----------
+
+.. toctree::
+   :maxdepth: 4
+
+   fastfusion.mapper.FFM
+
+Module contents
+---------------
+
+.. automodule:: fastfusion.mapper
+   :members:
+   :show-inheritance:
+   :undoc-members:

docs/_build/html/_sources/fastfusion.rst.txt

@@ -0,0 +1,20 @@
+fastfusion package
+==================
+
+Subpackages
+-----------
+
+.. toctree::
+   :maxdepth: 4
+
+   fastfusion.frontend
+   fastfusion.mapper
+   fastfusion.util
+
+Module contents
+---------------
+
+.. automodule:: fastfusion
+   :members:
+   :show-inheritance:
+   :undoc-members:

docs/_build/html/_sources/fastfusion.util.rst.txt

@@ -0,0 +1,21 @@
+fastfusion.util package
+=======================
+
+Submodules
+----------
+
+fastfusion.util.parallel module
+-------------------------------
+
+.. automodule:: fastfusion.util.parallel
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+Module contents
+---------------
+
+.. automodule:: fastfusion.util
+   :members:
+   :show-inheritance:
+   :undoc-members:

docs/_build/html/_sources/index.rst.txt

@@ -0,0 +1,87 @@
+FastFusion
+==========
+
+FastFusion is a framework to model tensor algebra accelerators. It includes flexible,
+user-defined specifications for components, architectures, and workloads, and, given
+these specifications, quickly finds optimal fused mappings to program the workloads onto
+the architectures.
+
+FastFusion is based on multiple other projects. If you use FastFusion in your work,
+please refer to :doc:`notes/citation` for how to cite the relevant projects.
+
+
+This page includes the following:
+
+.. contents::
+   :depth: 1
+   :local:
+   :backlinks: none
+
+Installation
+------------
+
+For native installation, install the package from PyPI:
+
+.. code-block:: bash
+
+   pip install fastfusion
+
+Examples
+--------
+
+Example notebooks can be found by cloning the repository and navigating to the
+``notebooks/examples`` directory.
+
+.. code-block:: bash
+
+   git clone https://github.com/Accelergy-Project/fastfusion.git
+   cd fastfusion/notebooks/examples
+   jupyter notebook
+
+Additionally, example input files can be found in the ``examples`` directory.
+
+.. code-block:: bash
+
+   git clone https://github.com/Accelergy-Project/fastfusion.git
+   cd fastfusion/examples
+   ls
+
+
+Documentation Overview
+----------------------
+
+Documentation is organized into the following sections:
+
+- :doc:`Input Specifications <notes/spec>` - Overview of the inputs to fastfusion,
+  including specifications of architectures, workloads, and mappings.
+- :doc:`Modeling <notes/modeling>` - How FastFusion models the energy, area, and latency
+  of an accelerator running a workload.
+- :doc:`Citation <notes/citation>` - How to cite FastFusion in your work
+- :doc:`Definitions <notes/definitions>` - Definitions of key concepts in FastFusion
+- :doc:`Parsing <notes/parsing>` - Parsing of input specifications
+- :doc:`Frequently Asked Questions <notes/faqs>` - Frequently asked questions about FastFusion
+
+API Reference
+-------------
+
+The complete API reference is available in the :doc:`modules` section, which includes:
+
+- :doc:`fastfusion.frontend <fastfusion.frontend>` - The input specifications for fastfusion
+- :doc:`fastfusion.mapper <fastfusion.mapper>` - Algorithms that map workloads onto architectures
+- :doc:`fastfusion.util <fastfusion.util>` - Utility functions and helpers
+
+For detailed API documentation, see the :doc:`modules` section.
+
+.. toctree::
+   :maxdepth: 2
+   :caption: API Reference
+   :hidden:
+
+   modules
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Documentation
+   :glob:
+
+   notes/*

docs/_build/html/_sources/modules.rst.txt

@@ -0,0 +1,7 @@
+fastfusion
+==========
+
+.. toctree::
+   :maxdepth: 4
+
+   fastfusion

docs/_build/html/_sources/notes/citation.rst.txt

@@ -0,0 +1,45 @@
+Citing This Work
+================
+
+**Please cite all of the following papers if you use this work.** This work is the
+combination of the following:
+
+- **CiMLoop**: The architecture and component specification.
+- **Fast & Fusiest**: The multi-Einsum mapper.
+- **LoopTree**: The mapping specification.
+- **LoopForest**: The mapspace specification.
+- **Turbo-Charged**: The single-Einsum mapper (and an essential first step for Fast &
+  Fusiest).
+
+They are available as the following:
+
+.. code-block:: latex
+
+    \cite{cimloop, fast_fusiest, turbo_charged, loop_tree, loopforest}
+
+.. code-block:: bibtex
+
+    @INPROCEEDINGS{cimloop,
+    author={Andrulis, Tanner and Emer, Joel S. and Sze, Vivienne},
+    booktitle={2024 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS)},
+    title={CiMLoop: A Flexible, Accurate, and Fast Compute-In-Memory Modeling Tool},
+    year={2024},
+    volume={},
+    number={},
+    pages={10-23},
+    keywords={Performance evaluation;Accuracy;Computational modeling;Computer architecture;Artificial neural networks;In-memory computing;Data models;Compute-In-Memory;Processing-In-Memory;Analog;Deep Neural Networks;Systems;Hardware;Modeling;Open-Source},
+    doi={10.1109/ISPASS61541.2024.00012}}
+
+    @INPROCEEDINGS{10158176,
+    author={Gilbert, Michael and Wu, Yannan Nellie and Parashar, Angshuman and Sze, Vivienne and Emer, Joel S.},
+    booktitle={2023 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS)},
+    title={LoopTree: Enabling Exploration of Fused-layer Dataflow Accelerators},
+    year={2023},
+    volume={},
+    number={},
+    pages={316-318},
+    keywords={Deep learning;Analytical models;Systematics;Neural networks;Bandwidth;Software;Energy efficiency;analytical modeling;layer fusion;accelerators},
+    doi={10.1109/ISPASS57527.2023.00038}}
+
+
+TODO: More citations

docs/_build/html/_sources/notes/definitions.rst.txt

@@ -0,0 +1,43 @@
+Definitions
+===========
+
+Action
+  An action is something performed by a hardware unit. For example, a read or a compute.
+
+Mapping
+  A *mapping* is a schedule that maps operations and data movement onto the hardware.
+
+Component
+  A component is a hardware unit in the architecture. For example, a memory or a compute
+  unit.
+
+Dataflow
+  The order in which a mappings iterates over tiles, noting that tiles may be abstract
+  before the mapping is fully defined. :ref:`Tile`.
+
+Dataplacement
+  Which tile(s) are stored in each memory level of the accelerator, and for what time
+  period, noting that tiles and time periods may be abstract before the mapping is fully
+  defined. :ref:`Tile`.
+
+Pmapping
+  A *partial mapping*, or *pmapping*, is a mapping of a subset of the workload to the
+  hardware.
+
+Pmapping Template
+  A *pmapping template* is a template for a pmapping. It includes all storage nodes
+  (dataplacement) and loop nodes (dataflow), but does not have loop bounds defined (tile
+  shapes).
+
+Reuse
+  Reuse occurs when a piece of data is used used in multiple computations, but fetched
+  fewer times from some memory. For example, we may fetch a piece of data from DRAM to
+  on-chip memory once, then use it in ten computations. This would incur nine reuses of
+  the piece of data.
+
+Reuse Opportunity
+  Reuse opportunity is when a piece of data is used multiple times by the workload. It
+  may or may not be turned into reuse if the hardware successfully leverages it.
+
+Tile
+  TODO

docs/_build/html/_sources/notes/faqs.rst.txt

@@ -0,0 +1,39 @@
+Frequently Asked Questions
+==========================
+
+.. contents::
+   :depth: 1
+   :local:
+   :backlinks: none
+
+What unit is ... specified in?
+------------------------------
+We use un-prefixed units for all values. Joules, seconds, meters, square meters, bits,
+etc.
+
+Why are some attributes underscored?
+------------------------------------
+
+.. _underscore-discussion:
+
+Underscore prefixes are used to indicate that a value is recognized by the frontend.
+They are used in places where there may be a mix of recognized and unrecognized values,
+such as in a :py:class:`~fastfusion.frontend.arch.Component` ``attributes`` dictionary,
+where ``attributes`` may contain recognized fields (such as
+:py:obj:`~fastfusion.frontend.arch.ComponentAttributes.energy`) and
+unrecognized fields (a field that may be used by `hwcomponents
+<https://github.com/Accelergy-Project/hwcomponents>`_, but not this package).
+
+When a value is underscored, this package will check whether it is recognized and raise
+an error if it is not. In places where fields may or may not be recognized (e.g.,
+:py:class:`~fastfusion.frontend.arch.ComponentAttributes`,
+:py:class:`~fastfusion.frontend.arch.ActionArguments`), we recommend
+underscore-prefixing all fields that are going to be used by this package.
+
+As a result, you may see attributes dictionaries that have a mix of underscored and
+non-underscored fields. The underscored fields will be used by this package, and the
+non-underscored fields will only be used by other parsers of the object (such as
+`hwcomponents <https://github.com/Accelergy-Project/hwcomponents>`_).
+
+When an object is initialized with underscore-prefixed fields, all underscores are
+dropped after checking validity.

docs/_build/html/_sources/notes/modeling/accelerator_energy_latency.rst.txt

@@ -0,0 +1,72 @@
+Accelerator Energy, Area, and Latency
+=====================================
+
+.. _accelerator-energy-latency:
+
+To calculate energy and latency, we first need to look at the number of actions incurred
+by each :py:class:`~fastfusion.frontend.arch.Component` in the architecture.
+
+Calculating Number of Actions from A Mapping
+--------------------------------------------
+
+.. _calculating-num-actions:
+
+Except for :py:class:`~fastfusion.frontend.arch.Compute`\ components (whose number of
+compute actions, barring recomputation, depends only on workload), the number of actions
+incurred by most :py:class:`~fastfusion.frontend.arch.Component`\ s depends on the
+component type, the workload, and the mapping.
+
+For :py:class:`~fastfusion.frontend.arch.Memory` and
+:py:class:`~fastfusion.frontend.arch.ProcessingStage` components, the number of actions
+depends on the number of accesses to the component. They may be accessed in two ways:
+
+- ``read``: The component is read from a lower-level component, or output values are read
+  up to a higher-level component.
+- ``write``: The component is written to a lower-level component, or input values are
+  written from a higher-level component.
+
+The number of actions incurred by accesses for each tensor are equal to the number of
+values accessed times the datawidth of the tensor (determined by that component's
+:py:class:`~fastfusion.frontend.arch.TensorHolderAttributes`), divided by the
+:py:class:`~fastfusion.frontend.arch.ActionArguments` ``bits_per_action`` attribute. For
+example, if 1024 values are accessed with a datawidth of 16 bits and ``bits_per_action``
+is 32, then 1024 * 16 / 32 = 512 actions are incurred.
+
+Read+Modify+Writes (RMWs) to a component are counted as a read and a write. The first
+read of output data is skipped because the value has not been written yet.
+
+By default, the ``datawidth`` and ``bits_per_action`` attributes are set to 1.
+Generally, it works to leave these as 1. For example:
+
+- If ``bits_per_action`` is 1, then each action accesses one bit, so we can define
+  actions in terms of bits accessed
+- If ``datawidth`` is 1 and ``bits_per_action`` is 1, then each action accesses one
+  value, so we can define actions in terms of values accessed. Additionally, ``size``
+  will then be in terms of number of values that can be held, rather than number of
+  bits.
+
+The latter case is the default, and you may often see ``datawidth`` and
+``bits_per_action`` un-set, ``size`` set to the number of values in the tensor, and
+actions defined in terms of values accessed rather than bits.
+
+
+Calculating Latency from a Pmapping
+-----------------------------------
+
+The :py:obj:`~fastfusion.frontend.arch.ComponentAttributes.latency` of a component, defined
+in the class's `attributes.latency` field, is a Python expression that is evaluated
+using the component's actions.
+
+The :py:obj:`~fastfusion.frontend.arch.ComponentAttributes.latency` field is
+:docstring-lower:`fastfusion.frontend.arch.ComponentAttributes.latency`
+
+
+Calculating Area and Leak Power
+-------------------------------
+
+After :ref:`component-modeling` is completed, we can get area with the
+:py:meth:`~fastfusion.frontend.arch.Arch.per_component_total_area` and
+:py:meth:`~fastfusion.frontend.arch.Arch.total_area` methods. Similarly, we can get
+leak power with the
+:py:meth:`~fastfusion.frontend.arch.Arch.per_component_total_leak_power` and
+:py:meth:`~fastfusion.frontend.arch.Arch.total_leak_power` methods.

docs/_build/html/_sources/notes/modeling/component_energy_area.rst.txt

@@ -0,0 +1,96 @@
+Component Energy and Area
+=========================
+
+.. _component-modeling:
+
+The energy and area of components in the architecture:ref:`architecture` can either be
+specified directly, or by calls to the `HWComponents
+<https://github.com/Accelergy-Project/hwcomponents>`_ library.
+
+Calculating Energy and Area
+---------------------------
+
+Component energy and area calculations will populate the following fields for each
+component. If these fields are pre-specified, then they may be used as input to the
+energy and area calculations.
+
+- ``attributes.area``: :docstring:`fastfusion.frontend.arch.Component.attributes.area`
+- ``attributes.leak_power``: :docstring:`fastfusion.frontend.arch.Component.attributes.leak_power`
+- ``actions[<action name>].arguments.energy``: :docstring:`fastfusion.frontend.arch.ActionArguments.energy`
+- ``attributes.total_area``: :docstring:`fastfusion.frontend.arch.Component.attributes.total_area`
+- ``attributes.total_leak_power``: :docstring:`fastfusion.frontend.arch.Component.attributes.total_leak_power`
+- ``energy_area_log``: :docstring:`fastfusion.frontend.arch.Component.energy_area_log`
+- ``component_model``: :docstring:`fastfusion.frontend.arch.Component.component_model`
+
+Additionally, the following fields will affect the energy and area calculations:
+
+- ``attributes.energy``: :docstring:`fastfusion.frontend.arch.Component.attributes.energy`
+- ``attributes.energy_scale``: :docstring:`fastfusion.frontend.arch.Component.attributes.energy_scale`
+- ``attributes.leak_power_scale``: :docstring:`fastfusion.frontend.arch.Component.attributes.leak_power_scale`
+- ``attributes.area_scale``: :docstring:`fastfusion.frontend.arch.Component.attributes.area_scale`
+- ``actions[<action name>].arguments.energy_scale``: :docstring:`fastfusion.frontend.arch.ActionArguments.energy_scale`
+
+The energy and area of a all components in the architecture can be calculated by calling
+:py:meth:`~fastfusion.spec.Spec.calculate_component_energy_area`.
+
+.. include-notebook:: notebooks/tutorials/component_energy_area.ipynb
+   :name: spec_energy_area
+   :language: python
+
+We can also calculate the energy and area of individual components by calling
+:py:meth:`~fastfusion.arch.Component.calculate_energy_area` on them.
+
+.. include-notebook:: notebooks/tutorials/component_energy_area.ipynb
+   :name: single_component_energy_area
+   :language: python
+
+There are additional `Spec.config` fields that affect the energy and area
+calculations:
+
+.. include-attrs:: fastfusion.frontend.config.Config
+
+Specifying Energy and Area
+---------------------------
+
+One way to specify the area and energy of each component is to directly set the
+``attributes.area``, ``attributes.leak_power``, or ``actions[<action
+name>].arguments.energy`` fields. The following example from the TPU v4i example
+architecture shows uses this approach:
+
+.. include-yaml:: examples/arches/tpu_v4i_like.arch.yaml
+   :startfrom: GlobalBuffer
+   :same-indent:
+
+If any value is omitted, it will raise an appropriate error when
+:py:meth:`~fastfusion.spec.Spec.calculate_component_energy_area` is called, so you may call this
+function to check whether you've missed anything. ``hwcomponents`` is invoked
+automatically if any of the fields are missing. If you don't want it to be called, then
+you can do one of the following:
+
+- If calling :py:meth:`~fastfusion.spec.Spec.calculate_component_energy_area`, then you
+  can set ``spec.config.component_models`` and
+  ``spec.config.use_installed_component_models`` to an empty list and ``False``,
+  respectively.
+- If calling :py:meth:`~fastfusion.arch.Component.calculate_energy_area`, then you can set ``models`` to an
+  empty list.
+
+
+Using the ``hwcomponents`` Library
+-----------------------------------
+
+``hwcomponents`` is invoked automatically when area and energy are not specified. The
+following shows the fields used by ``hwcomponents``:
+
+.. include:: ../../../examples/misc/component_annotated.yaml
+   :code: yaml
+
+When ``hwcomponents`` has been used to calculate the energy and area of a component,
+then the ``component_model`` field will be set to the `hwcomponents` model used to
+calculate the energy and area.
+
+In addition to looking at the ``energy_area_log`` field, we can further inspect the
+``component_model`` field to see more information about the model.
+
+.. include-notebook:: notebooks/tutorials/component_energy_area.ipynb
+   :name: hwcomponents
+   :language: python

docs/_build/html/_sources/notes/modeling/mapping.rst.txt

@@ -0,0 +1,100 @@
+Mapping with Fast & Fusiest
+===========================
+
+Mapping workloads onto accelerators uses the Fast and Fusiest Mapper (FFM), which
+includes of two parts:
+
+- The Turbo-Charged Pmapper: This part makes all Pareto-optimal pmappings for all
+  Einsums.
+- Fast and Fusiest Mapper (FFM): This part takes the Pareto-optimal pmappings and joins
+  them into full mappings.
+
+This document will walk you through how to use FFM to map a workload onto an
+accelerator.
+
+This document follows the `notebooks/tutorials/FFM.ipynb` notebook.
+
+Creating a Spec
+------------------------
+
+Before we dive into the mapper, we need to set up a
+:py:class:`~fastfusion.frontend.spec.Spec` object with the input
+spec. We can initialize
+:py:class:`~fastfusion.frontend.spec.Spec` objects from YAML files.
+
+.. include-notebook:: notebooks/tutorials/FFM.ipynb
+   :name: make_spec
+   :language: python
+
+We can set optimization metrics for the mapper by setting the `spec.mapper.ffm.metrics`
+attribute to one of the :py:class:`~fastfusion.mapper.FFM.Metrics` enum values or a
+logical OR (|) of multiple values.
+
+The following optimization metrics are available:
+
+.. include-attrs:: fastfusion.mapper.FFM.Metrics
+
+Making Partial Mappings
+-----------------------
+
+We call the Turbo-Charged Pmapper with the
+:py:func:`~fastfusion.mapper.FFM.main.make_pmappings` function. This function returns a
+:py:class:`~fastfusion.mapper.FFM.main.MultiEinsumPmappings` object, which contains all
+Pareto-optimal pmappings for all Einsums.
+
+.. include-notebook:: notebooks/tutorials/FFM.ipynb
+   :name: make_pmappings
+   :language: python
+
+In this code, there is a ``max_fused_loops`` parameter that makes mapping faster by
+limiting the number of fused loops that can exist in a single pmapping. The
+``spec.mapper.ffm`` object has a variety of knobs that can be used to speed up mapping:
+
+.. include-attrs:: fastfusion.frontend.mapper.FFM
+
+To help with debugging, the :py:func:`~fastfusion.mapper.FFM.main.make_pmappings`
+function will output all pmapping templates that it generates. A pmapping template is a
+pmapping that has not been filled in with tile shapes; meaning that it is a stack of
+loop nodes and storage nodes with loop bounds left unfilled.
+
+If no valid pmappings are found for a given Einsum, it may be helpful to inspect the
+pmapping templates outputted. The
+:py:class:`~fastfusion.mapper.FFM.pmappings.MultiEinsumPmappings` object has additional
+functions that can be used to help with debugging:
+
+.. include-functions:: fastfusion.mapper.FFM.pmappings.MultiEinsumPmappings
+
+Joining Partial Mappings
+------------------------
+
+After we have all Pareto-optimal pmappings for all Einsums, we can join them into full
+mappings with the :py:func:`~fastfusion.mapper.FFM.main.join_pmappings` function. This
+function returns a :py:class:`~fastfusion.mapper.FFM.mappings.Mappings` object, which
+contains all Pareto-optimal mappings found for the given cascade of Einsums.
+
+.. include-notebook:: notebooks/tutorials/FFM.ipynb
+   :name: join_pmappings
+   :language: python
+
+Interpreting the Output
+-----------------------
+
+The :py:class:`~fastfusion.mapper.FFM.mappings.Mappings` object includes stats for the
+mappings that were found, including, for each pmapping, resource usage and objective
+metrics.
+
+To access the stats, we can use the :py:meth:`~fastfusion.mapper.FFM.mappings.Mappings.access`
+method, which will return a :py:class:`~fastfusion.mapper.FFM.mappings.Mappings` object
+with only the columns that match the given key, and with the key removed from the column
+names.
+
+For example, if there are three columns ``Total<SEP>Energy``, ``Total<SEP>Area``, and
+``EinsumA<SEP>Energy``, then ``mapping.access("Total")`` will return a Mappings object
+with columns ``Energy`` and ``Area``, and ``mapping.access("Energy")`` will return a
+Mappings object with columns ``Total`` and ``EinsumA``.
+
+To render a mapping, we can use the
+:py:meth:`~fastfusion.mapper.FFM.mappings.Mappings.render` method, which will return a
+string representation of the mapping. In a Jupyter notebook, the mapping will render
+automatically if it is the last object in the cell. Note that if there is more than one
+Pareto-optimal mapping, you must index into a single mapping to render it.