Skip to content

llmcompressor.metrics.logger

Contains code for loggers that help visualize the information from each modifier.

Classes:

  • BaseLogger –

    Base class that all modifier loggers must implement.

  • LambdaLogger –

    Logger that handles calling back to a lambda function with any logs.

  • LoggerManager –

    Wrapper around loggers that handles log scheduling and handing off logs to intended

  • PythonLogger –

    Modifier metrics that handles printing values into a python metrics instance.

  • SparsificationGroupLogger –

    Modifier metrics that handles outputting values to other supported systems.

  • TensorBoardLogger –

    Modifier metrics that handles outputting values into a TensorBoard log directory

  • WANDBLogger –

    Modifier metrics that handles outputting values to Weights and Biases.

BaseLogger 

BaseLogger(name: str, enabled: bool = True)

Bases: ABC

Base class that all modifier loggers must implement.

Parameters:

  • name

    (str) –

    name given to the metrics, used for identification

  • enabled

    (bool, default: True ) –

    True to log, False otherwise

Methods:

  • log_hyperparams –

    :param params: Each key-value pair in the dictionary is the name of the

  • log_scalar –

    :param tag: identifying tag to log the value with

  • log_scalars –

    :param tag: identifying tag to log the values with

  • log_string –

    :param tag: identifying tag to log the values with

  • save –

    :param file_path: path to a file to be saved

Attributes:

  • enabled (bool) –

    :return: True to log, False otherwise

  • name (str) –

    :return: name given to the metrics, used for identification

Source code in llmcompressor/metrics/logger.py 
69
70
71
def __init__(self, name: str, enabled: bool = True):
    self._name = name
    self._enabled = enabled

enabled property writable 

enabled: bool

Returns:

  • bool –

    True to log, False otherwise

name property 

name: str

Returns:

  • str –

    name given to the metrics, used for identification

log_hyperparams 

log_hyperparams(params: Dict[str, float]) -> bool

Parameters:

  • params

    (Dict[str, float]) –

    Each key-value pair in the dictionary is the name of the hyper parameter and it's corresponding value.

Returns:

  • bool –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
 97
 98
 99
100
101
102
103
def log_hyperparams(self, params: Dict[str, float]) -> bool:
    """
    :param params: Each key-value pair in the dictionary is the name of the
        hyper parameter and it's corresponding value.
    :return: True if logged, False otherwise.
    """
    return False

log_scalar 

log_scalar(
    tag: str,
    value: float,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    **kwargs,
) -> bool

Parameters:

  • tag

    (str) –

    identifying tag to log the value with

  • value

    (float) –

    value to save

  • step

    (Optional[int], default: None ) –

    global step for when the value was taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the value was taken

  • kwargs

    –

    additional logging arguments to support Python and custom loggers

Returns:

  • bool –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
def log_scalar(
    self,
    tag: str,
    value: float,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    **kwargs,
) -> bool:
    """
    :param tag: identifying tag to log the value with
    :param value: value to save
    :param step: global step for when the value was taken
    :param wall_time: global wall time for when the value was taken
    :param kwargs: additional logging arguments to support Python and custom loggers
    :return: True if logged, False otherwise.
    """
    return False

log_scalars 

log_scalars(
    tag: str,
    values: Dict[str, float],
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    **kwargs,
) -> bool

Parameters:

  • tag

    (str) –

    identifying tag to log the values with

  • values

    (Dict[str, float]) –

    values to save

  • step

    (Optional[int], default: None ) –

    global step for when the values were taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the values were taken

  • kwargs

    –

    additional logging arguments to support Python and custom loggers

Returns:

  • bool –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
def log_scalars(
    self,
    tag: str,
    values: Dict[str, float],
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    **kwargs,
) -> bool:
    """
    :param tag: identifying tag to log the values with
    :param values: values to save
    :param step: global step for when the values were taken
    :param wall_time: global wall time for when the values were taken
    :param kwargs: additional logging arguments to support Python and custom loggers
    :return: True if logged, False otherwise.
    """
    return False

log_string 

log_string(
    tag: str,
    string: str,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    **kwargs,
) -> bool

Parameters:

  • tag

    (str) –

    identifying tag to log the values with

  • values

    –

    values to save

  • step

    (Optional[int], default: None ) –

    global step for when the values were taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the values were taken

  • kwargs

    –

    additional logging arguments to support Python and custom loggers

Returns:

  • bool –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
def log_string(
    self,
    tag: str,
    string: str,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    **kwargs,
) -> bool:
    """
    :param tag: identifying tag to log the values with
    :param values: values to save
    :param step: global step for when the values were taken
    :param wall_time: global wall time for when the values were taken
    :param kwargs: additional logging arguments to support Python and custom loggers
    :return: True if logged, False otherwise.
    """
    return False

save 

save(file_path: str, **kwargs) -> bool

Parameters:

  • file_path

    (str) –

    path to a file to be saved

  • kwargs

    –

    additional arguments that a specific metrics might use

Returns:

  • bool –

    True if saved, False otherwise

Source code in llmcompressor/metrics/logger.py 
159
160
161
162
163
164
165
166
167
168
169
def save(
    self,
    file_path: str,
    **kwargs,
) -> bool:
    """
    :param file_path: path to a file to be saved
    :param kwargs: additional arguments that a specific metrics might use
    :return: True if saved, False otherwise
    """
    return False

LambdaLogger 

LambdaLogger(
    lambda_func: Callable[
        [
            Optional[str],
            Optional[Union[float, str]],
            Optional[Dict[str, float]],
            Optional[int],
            Optional[float],
            Optional[int],
        ],
        bool,
    ],
    name: str = "lambda",
    enabled: bool = True,
)

Bases: BaseLogger

Logger that handles calling back to a lambda function with any logs.

Parameters:

  • lambda_func

    (Callable[[Optional[str], Optional[Union[float, str]], Optional[Dict[str, float]], Optional[int], Optional[float], Optional[int]], bool]) –

    the lambda function to call back into with any logs. The expected call sequence is (tag, value, values, step, wall_time) -> bool The return type is True if logged and False otherwise.

  • name

    (str, default: 'lambda' ) –

    name given to the metrics, used for identification; defaults to lambda

  • enabled

    (bool, default: True ) –

    True to log, False otherwise

Methods:

  • log_hyperparams –

    :param params: Each key-value pair in the dictionary is the name of the

  • log_scalar –

    :param tag: identifying tag to log the value with

  • log_scalars –

    :param tag: identifying tag to log the values with

Attributes:

  • lambda_func (Callable[[Optional[str], Optional[Union[float, str]], Optional[Dict[str, float]], Optional[int], Optional[float], Optional[int]], bool]) –

    :return: the lambda function to call back into with any logs.

Source code in llmcompressor/metrics/logger.py 
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
def __init__(
    self,
    lambda_func: Callable[
        [
            Optional[str],
            Optional[Union[float, str]],
            Optional[Dict[str, float]],
            Optional[int],
            Optional[float],
            Optional[int],
        ],
        bool,
    ],
    name: str = "lambda",
    enabled: bool = True,
):
    super().__init__(name, enabled)
    self._lambda_func = lambda_func
    assert lambda_func, "lambda_func must be set to a callable function"

lambda_func property 

lambda_func: Callable[
    [
        Optional[str],
        Optional[Union[float, str]],
        Optional[Dict[str, float]],
        Optional[int],
        Optional[float],
        Optional[int],
    ],
    bool,
]

Returns:

  • Callable[[Optional[str], Optional[Union[float, str]], Optional[Dict[str, float]], Optional[int], Optional[float], Optional[int]], bool] –

    the lambda function to call back into with any logs. The expected call sequence is (tag, value, values, step, wall_time)

log_hyperparams 

log_hyperparams(
    params: Dict, level: Optional[Union[int, str]] = None
) -> bool

Parameters:

  • params

    (Dict) –

    Each key-value pair in the dictionary is the name of the hyper parameter and it's corresponding value.

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

Returns:

  • bool –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
def log_hyperparams(
    self,
    params: Dict,
    level: Optional[Union[int, str]] = None,
) -> bool:
    """
    :param params: Each key-value pair in the dictionary is the name of the
        hyper parameter and it's corresponding value.
    :param level: minimum severity level for the log message
    :return: True if logged, False otherwise.
    """
    if not self.enabled:
        return False

    return self._lambda_func(
        tag=None,
        value=None,
        values=params,
        step=None,
        wall_time=None,
        level=level,
    )

log_scalar 

log_scalar(
    tag: str,
    value: float,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    level: Optional[Union[int, str]] = None,
) -> bool

Parameters:

  • tag

    (str) –

    identifying tag to log the value with

  • value

    (float) –

    value to save

  • step

    (Optional[int], default: None ) –

    global step for when the value was taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the value was taken, defaults to time.time()

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

  • kwargs

    –

    additional logging arguments to support Python and custom loggers

Returns:

  • bool –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
def log_scalar(
    self,
    tag: str,
    value: float,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    level: Optional[Union[int, str]] = None,
) -> bool:
    """
    :param tag: identifying tag to log the value with
    :param value: value to save
    :param step: global step for when the value was taken
    :param wall_time: global wall time for when the value was taken,
        defaults to time.time()
    :param level: minimum severity level for the log message
    :param kwargs: additional logging arguments to support Python and custom loggers
    :return: True if logged, False otherwise.
    """
    if not wall_time:
        wall_time = time.time()

    return self._lambda_func(
        tag=tag,
        value=value,
        values=None,
        step=step,
        wall_time=wall_time,
        level=level,
    )

log_scalars 

log_scalars(
    tag: str,
    values: Dict[str, float],
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    level: Optional[Union[int, str]] = None,
) -> bool

Parameters:

  • tag

    (str) –

    identifying tag to log the values with

  • values

    (Dict[str, float]) –

    values to save

  • step

    (Optional[int], default: None ) –

    global step for when the values were taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the values were taken, defaults to time.time()

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

  • kwargs

    –

    additional logging arguments to support Python and custom loggers

Returns:

  • bool –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
def log_scalars(
    self,
    tag: str,
    values: Dict[str, float],
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    level: Optional[Union[int, str]] = None,
) -> bool:
    """
    :param tag: identifying tag to log the values with
    :param values: values to save
    :param step: global step for when the values were taken
    :param wall_time: global wall time for when the values were taken,
        defaults to time.time()
    :param level: minimum severity level for the log message
    :param kwargs: additional logging arguments to support Python and custom loggers
    :return: True if logged, False otherwise.
    """
    if not wall_time:
        wall_time = time.time()

    return self._lambda_func(
        tag=tag,
        value=None,
        values=values,
        step=step,
        wall_time=wall_time,
        level=level,
    )

LoggerManager 

LoggerManager(
    loggers: Optional[List[BaseLogger]] = None,
    log_frequency: Union[float, None] = 0.1,
    log_python: bool = True,
    name: str = "manager",
    mode: LoggingModeType = "exact",
    frequency_type: FrequencyType = "epoch",
)

Bases: ABC

Wrapper around loggers that handles log scheduling and handing off logs to intended loggers.

Parameters:

  • loggers

    (Optional[List[BaseLogger]], default: None ) –

    list of loggers assigned to this manager

  • log_frequency

    (Union[float, None], default: 0.1 ) –

    number of stes or fraction of steps to wait between logs

  • mode

    (LoggingModeType, default: 'exact' ) –

    The logging mode to use, either "on_change" or "exact", "on_change" will log when the model has been updated since the last log, "exact" will log at the given frequency regardless of model updates. Defaults to "exact"

  • frequency_type

    (FrequencyType, default: 'epoch' ) –

    The frequency type to use, either "epoch", "step", or "batch" controls what the frequency manager is tracking, e.g. if the frequency type is "epoch", then the frequency manager will track the number of epochs that have passed since the last log, if the frequency type is "step", then the frequency manager will track the number of optimizer steps

Methods:

  • add_logger –

    add a BaseLogger implementation to the loggers of this manager

  • log_hyperparams –

    (Note: this method is deprecated and will be removed in a future version,

  • log_ready –

    Check if there is a metrics that is ready to accept a log

  • log_scalar –

    (Note: this method is deprecated and will be removed in a future version,

  • log_scalars –

    (Note: this method is deprecated and will be removed in a future version,

  • log_string –

    (Note: this method is deprecated and will be removed in a future version,

  • log_written –

    Update the frequency manager with the last log step written

  • model_updated –

    Update the frequency manager with the last model update step

  • save –

    :param file_path: path to a file to be saved

  • time –

    Context manager to log the time it takes to run the block of code

Attributes:

  • log_frequency (Union[str, float, None]) –

    :return: number of epochs or fraction of epochs to wait between logs

  • loggers (List[BaseLogger]) –

    :return: list of loggers assigned to this manager

  • name (str) –

    :return: name given to the metrics, used for identification

  • wandb (Optional[ModuleType]) –

    :return: wandb module if initialized

Source code in llmcompressor/metrics/logger.py 
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
def __init__(
    self,
    loggers: Optional[List[BaseLogger]] = None,
    log_frequency: Union[float, None] = 0.1,
    log_python: bool = True,
    name: str = "manager",
    mode: LoggingModeType = "exact",
    frequency_type: FrequencyType = "epoch",
):
    self._name = name
    self._loggers = (
        loggers
        or SparsificationGroupLogger(
            python=log_python,
            name=name,
            tensorboard=False,
            wandb_=False,
        ).loggers
    )

    self.frequency_manager = FrequencyManager(
        mode=mode,
        frequency_type=frequency_type,
        log_frequency=log_frequency,
    )

    self.system = SystemLoggingWraper(
        loggers=self._loggers, frequency_manager=self.frequency_manager
    )
    self.metric = MetricLoggingWrapper(
        loggers=self._loggers, frequency_manager=self.frequency_manager
    )

log_frequency property writable 

log_frequency: Union[str, float, None]

Returns:

  • Union[str, float, None] –

    number of epochs or fraction of epochs to wait between logs

loggers property writable 

loggers: List[BaseLogger]

Returns:

  • List[BaseLogger] –

    list of loggers assigned to this manager

name property 

name: str

Returns:

  • str –

    name given to the metrics, used for identification

wandb property 

wandb: Optional[ModuleType]

Returns:

  • Optional[ModuleType] –

    wandb module if initialized

add_logger 

add_logger(logger: BaseLogger)

add a BaseLogger implementation to the loggers of this manager

Parameters:

Source code in llmcompressor/metrics/logger.py 
825
826
827
828
829
830
831
832
833
def add_logger(self, logger: BaseLogger):
    """
    add a BaseLogger implementation to the loggers of this manager

    :param logger: metrics object to add
    """
    if not isinstance(logger, BaseLogger):
        raise ValueError(f"metrics {type(logger)} must be of type BaseLogger")
    self._loggers.append(logger)

log_hyperparams 

log_hyperparams(
    params: Dict,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
)

(Note: this method is deprecated and will be removed in a future version, use LoggerManager().metric.log_hyperparams instead)

Parameters:

  • params

    (Dict) –

    Each key-value pair in the dictionary is the name of the hyper parameter and it's corresponding value.

Source code in llmcompressor/metrics/logger.py 
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
def log_hyperparams(
    self,
    params: Dict,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
):
    """
    (Note: this method is deprecated and will be removed in a future version,
    use LoggerManager().metric.log_hyperparams instead)

    :param params: Each key-value pair in the dictionary is the name of the
        hyper parameter and it's corresponding value.
    """

    self.metric.log_hyperparams(
        params=params,
        log_types=log_types,
        level=level,
    )

log_ready 

log_ready(
    current_log_step,
    last_log_step=None,
    check_model_update: bool = False,
)

Check if there is a metrics that is ready to accept a log

Parameters:

  • current_log_step

    –

    current step log is requested at

  • last_log_step

    –

    last time a log was recorder for this object. (Deprecated)

  • check_model_update

    (bool, default: False ) –

    if True, will check if the model has been updated, if False, will only check the log frequency

Returns:

  • –

    True if a metrics is ready to accept a log.

Source code in llmcompressor/metrics/logger.py 
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
def log_ready(
    self, current_log_step, last_log_step=None, check_model_update: bool = False
):
    """
    Check if there is a metrics that is ready to accept a log

    :param current_log_step: current step log is requested at
    :param last_log_step: last time a log was recorder for this object. (Deprecated)
    :param check_model_update: if True, will check if the model has been updated,
        if False, will only check the log frequency
    :return: True if a metrics is ready to accept a log.
    """
    log_enabled = any(logger.enabled for logger in self.loggers)
    if last_log_step is not None:
        self.frequency_manager.log_written(step=last_log_step)

    return log_enabled and self.frequency_manager.log_ready(
        current_log_step=current_log_step,
        check_model_update=check_model_update,
    )

log_scalar 

log_scalar(
    tag: str,
    value: float,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
)

(Note: this method is deprecated and will be removed in a future version, use LoggerManager().metric.log_scalar instead)

Parameters:

  • tag

    (str) –

    identifying tag to log the value with

  • value

    (float) –

    value to save

  • step

    (Optional[int], default: None ) –

    global step for when the value was taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the value was taken

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

  • kwargs

    –

    additional logging arguments to support Python and custom loggers

Returns:

  • –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
def log_scalar(
    self,
    tag: str,
    value: float,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
):
    """
    (Note: this method is deprecated and will be removed in a future version,
    use LoggerManager().metric.log_scalar instead)

    :param tag: identifying tag to log the value with
    :param value: value to save
    :param step: global step for when the value was taken
    :param wall_time: global wall time for when the value was taken
    :param level: minimum severity level for the log message
    :param kwargs: additional logging arguments to support Python and custom loggers
    :return: True if logged, False otherwise.
    """

    self.metric.log_scalar(
        tag=tag,
        value=value,
        step=step,
        wall_time=wall_time,
        log_types=log_types,
        level=level,
    )

log_scalars 

log_scalars(
    tag: str,
    values: Dict[str, float],
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
)

(Note: this method is deprecated and will be removed in a future version, use LoggerManager().metric.log_scalars instead)

Parameters:

  • tag

    (str) –

    identifying tag to log the values with

  • values

    (Dict[str, float]) –

    values to save

  • step

    (Optional[int], default: None ) –

    global step for when the values were taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the values were taken

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

  • kwargs

    –

    additional logging arguments to support Python and custom loggers

Returns:

  • –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
def log_scalars(
    self,
    tag: str,
    values: Dict[str, float],
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
):
    """
    (Note: this method is deprecated and will be removed in a future version,
    use LoggerManager().metric.log_scalars instead)

    :param tag: identifying tag to log the values with
    :param values: values to save
    :param step: global step for when the values were taken
    :param wall_time: global wall time for when the values were taken
    :param level: minimum severity level for the log message
    :param kwargs: additional logging arguments to support Python and custom loggers
    :return: True if logged, False otherwise.
    """

    self.metric.log_scalars(
        tag=tag,
        values=values,
        step=step,
        wall_time=wall_time,
        log_types=log_types,
        level=level,
    )

log_string 

log_string(
    tag: str,
    string: str,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
)

(Note: this method is deprecated and will be removed in a future version, use LoggerManager().system.log_string instead)

Parameters:

  • tag

    (str) –

    identifying tag to log the values with

  • values

    –

    values to save

  • step

    (Optional[int], default: None ) –

    global step for when the values were taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the values were taken

  • kwargs

    –

    additional logging arguments to support Python and custom loggers

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

Returns:

  • –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
def log_string(
    self,
    tag: str,
    string: str,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
):
    """
    (Note: this method is deprecated and will be removed in a future version,
    use LoggerManager().system.log_string instead)

    :param tag: identifying tag to log the values with
    :param values: values to save
    :param step: global step for when the values were taken
    :param wall_time: global wall time for when the values were taken
    :param kwargs: additional logging arguments to support Python and custom loggers
    :param level: minimum severity level for the log message
    :return: True if logged, False otherwise.
    """
    self.system.log_string(
        tag=tag,
        string=string,
        step=step,
        wall_time=wall_time,
        log_types=log_types,
        level=level,
    )

log_written 

log_written(step: LogStepType)

Update the frequency manager with the last log step written

Parameters:

  • step

    (LogStepType) –

    step that was last logged

Source code in llmcompressor/metrics/logger.py 
856
857
858
859
860
861
862
def log_written(self, step: LogStepType):
    """
    Update the frequency manager with the last log step written

    :param step: step that was last logged
    """
    self.frequency_manager.log_written(step=step)

model_updated 

model_updated(step: LogStepType)

Update the frequency manager with the last model update step

Parameters:

  • step

    (LogStepType) –

    step that was last logged

Source code in llmcompressor/metrics/logger.py 
864
865
866
867
868
869
870
def model_updated(self, step: LogStepType):
    """
    Update the frequency manager with the last model update step

    :param step: step that was last logged
    """
    self.frequency_manager.model_updated(step=step)

save 

save(file_path: str, **kwargs)

Parameters:

  • file_path

    (str) –

    path to a file to be saved

  • kwargs

    –

    additional arguments that a specific metrics might use

Source code in llmcompressor/metrics/logger.py 
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
def save(
    self,
    file_path: str,
    **kwargs,
):
    """
    :param file_path: path to a file to be saved
    :param kwargs: additional arguments that a specific metrics might use
    """
    for log in self._loggers:
        if log.enabled:
            log.save(file_path, **kwargs)

time 

time(tag: Optional[str] = None, *args, **kwargs)

Context manager to log the time it takes to run the block of code

Usage:

with LoggerManager().time("my_block"): time.sleep(1)

Parameters:

  • tag

    (Optional[str], default: None ) –

    identifying tag to log the values with

Source code in llmcompressor/metrics/logger.py 
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
@contextmanager
def time(self, tag: Optional[str] = None, *args, **kwargs):
    """
    Context manager to log the time it takes to run the block of code

    Usage:
    >>> with LoggerManager().time("my_block"):
    >>>    time.sleep(1)

    :param tag: identifying tag to log the values with
    """

    start = time.time()
    yield
    elapsed = time.time() - start
    if not tag:
        tag = f"{DEFAULT_TAG}_time_secs"
    self.log_scalar(tag=tag, value=float(f"{elapsed:.3f}"), *args, **kwargs)

LoggingWrapperBase 

LoggingWrapperBase(
    loggers: List[BaseLogger],
    frequency_manager: FrequencyManager,
)

Base class that holds a reference to the loggers and frequency manager

Source code in llmcompressor/metrics/logger.py 
1071
1072
1073
def __init__(self, loggers: List[BaseLogger], frequency_manager: FrequencyManager):
    self.loggers = loggers
    self._frequency_manager = frequency_manager

MetricLoggingWrapper 

MetricLoggingWrapper(
    loggers: List[BaseLogger],
    frequency_manager: FrequencyManager,
)

Bases: LoggingWrapperBase

Wraps utilities and convenience methods for logging metrics to the system

Methods:

  • add_scalar –

    Add a scalar value to the metrics

  • add_scalars –

    Adds multiple scalar values to the metrics

  • log –

    :param data: A dict of serializable python objects i.e str,

  • log_hyperparams –

    :param params: Each key-value pair in the dictionary is the name of the

  • log_scalar –

    :param tag: identifying tag to log the value with

  • log_scalars –

    :param tag: identifying tag to log the values with

Source code in llmcompressor/metrics/logger.py 
1071
1072
1073
def __init__(self, loggers: List[BaseLogger], frequency_manager: FrequencyManager):
    self.loggers = loggers
    self._frequency_manager = frequency_manager

add_scalar 

add_scalar(
    value,
    tag: str = DEFAULT_TAG,
    step: Optional[int] = None,
    wall_time: Union[int, float, None] = None,
    **kwargs,
)

Add a scalar value to the metrics

Parameters:

  • value

    –

    value to log

  • tag

    (str, default: DEFAULT_TAG ) –

    tag to log the value with, defaults to DEFAULT_TAG

  • step

    (Optional[int], default: None ) –

    global step for when the value was taken

  • wall_time

    (Union[int, float, None], default: None ) –

    global wall time for when the value was taken

  • kwargs

    –

    additional logging arguments to to pass through to the metrics

Source code in llmcompressor/metrics/logger.py 
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
def add_scalar(
    self,
    value,
    tag: str = DEFAULT_TAG,
    step: Optional[int] = None,
    wall_time: Union[int, float, None] = None,
    **kwargs,
):
    """
    Add a scalar value to the metrics

    :param value: value to log
    :param tag: tag to log the value with, defaults to DEFAULT_TAG
    :param step: global step for when the value was taken
    :param wall_time: global wall time for when the value was taken
    :param kwargs: additional logging arguments to to pass through to the
        metrics
    """
    self.log_scalar(tag=tag, value=value, step=step, wall_time=wall_time, **kwargs)

add_scalars 

add_scalars(
    values: Dict[str, Any],
    tag: str = DEFAULT_TAG,
    step: Optional[int] = None,
    wall_time: Union[int, float, None] = None,
    **kwargs,
)

Adds multiple scalar values to the metrics

Parameters:

  • values

    (Dict[str, Any]) –

    values to log, must be A dict of serializable python objects i.e str, ints, floats, Tensors, dicts, etc

  • tag

    (str, default: DEFAULT_TAG ) –

    tag to log the value with, defaults to DEFAULT_TAG

  • step

    (Optional[int], default: None ) –

    global step for when the value was taken

  • wall_time

    (Union[int, float, None], default: None ) –

    global wall time for when the value was taken

  • kwargs

    –

    additional logging arguments to to pass through to the metrics

Source code in llmcompressor/metrics/logger.py 
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
def add_scalars(
    self,
    values: Dict[str, Any],
    tag: str = DEFAULT_TAG,
    step: Optional[int] = None,
    wall_time: Union[int, float, None] = None,
    **kwargs,
):
    """
    Adds multiple scalar values to the metrics

    :param values: values to log, must be A dict of serializable
        python objects i.e `str`, `ints`, `floats`, `Tensors`, `dicts`, etc
    :param tag: tag to log the value with, defaults to DEFAULT_TAG
    :param step: global step for when the value was taken
    :param wall_time: global wall time for when the value was taken
    :param kwargs: additional logging arguments to to pass through to the
        metrics
    """
    self.log_scalars(
        tag=tag, values=values, step=step, wall_time=wall_time, **kwargs
    )

log 

log(
    data: Dict[str, Any],
    step: Optional[int] = None,
    tag: Optional[str] = DEFAULT_TAG,
    **kwargs,
) -> None

Parameters:

  • data

    (Dict[str, Any]) –

    A dict of serializable python objects i.e str, ints, floats, Tensors, dicts, etc

  • step

    (Optional[int], default: None ) –

    global step for when the values were taken

  • tag

    (Optional[str], default: DEFAULT_TAG ) –

    identifying tag to log the values with, defaults to DEFAULT_TAG

  • kwargs

    –

    additional logging arguments to support Python and custom loggers

Source code in llmcompressor/metrics/logger.py 
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
def log(
    self,
    data: Dict[str, Any],
    step: Optional[int] = None,
    tag: Optional[str] = DEFAULT_TAG,
    **kwargs,
) -> None:
    """
    :param data:  A dict of serializable python objects i.e `str`,
            `ints`, `floats`, `Tensors`, `dicts`, etc
    :param step: global step for when the values were taken
    :param tag: identifying tag to log the values with, defaults to DEFAULT_TAG
    :param kwargs: additional logging arguments to support
        Python and custom loggers
    """
    self.log_scalars(tag=tag, values=data, step=step, **kwargs)

log_hyperparams 

log_hyperparams(
    params: Dict,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
)

Parameters:

  • params

    (Dict) –

    Each key-value pair in the dictionary is the name of the hyper parameter and it's corresponding value.

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

Source code in llmcompressor/metrics/logger.py 
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
def log_hyperparams(
    self,
    params: Dict,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
):
    """
    :param params: Each key-value pair in the dictionary is the name of the
        hyper parameter and it's corresponding value.
    :param level: minimum severity level for the log message
    """
    for log in self.loggers:
        if log.enabled and (log_types == ALL_TOKEN or log.name in log_types):
            log.log_hyperparams(params, level)

log_scalar 

log_scalar(
    tag: str,
    value: float,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
)

Parameters:

  • tag

    (str) –

    identifying tag to log the value with

  • value

    (float) –

    value to save

  • step

    (Optional[int], default: None ) –

    global step for when the value was taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the value was taken

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

  • kwargs

    –

    additional logging arguments to support Python and custom loggers

Returns:

  • –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
def log_scalar(
    self,
    tag: str,
    value: float,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
):
    """
    :param tag: identifying tag to log the value with
    :param value: value to save
    :param step: global step for when the value was taken
    :param wall_time: global wall time for when the value was taken
    :param level: minimum severity level for the log message
    :param kwargs: additional logging arguments to support Python and custom loggers
    :return: True if logged, False otherwise.
    """
    for log in self.loggers:
        if log.enabled and (log_types == ALL_TOKEN or log.name in log_types):
            log.log_scalar(
                tag=tag,
                value=value,
                step=step,
                wall_time=wall_time,
                level=level,
            )

log_scalars 

log_scalars(
    tag: str,
    values: Dict[str, float],
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
)

Parameters:

  • tag

    (str) –

    identifying tag to log the values with

  • values

    (Dict[str, float]) –

    values to save

  • step

    (Optional[int], default: None ) –

    global step for when the values were taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the values were taken

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

  • kwargs

    –

    additional logging arguments to support Python and custom loggers

Returns:

  • –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
def log_scalars(
    self,
    tag: str,
    values: Dict[str, float],
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
):
    """
    :param tag: identifying tag to log the values with
    :param values: values to save
    :param step: global step for when the values were taken
    :param wall_time: global wall time for when the values were taken
    :param level: minimum severity level for the log message
    :param kwargs: additional logging arguments to support Python and custom loggers
    :return: True if logged, False otherwise.
    """
    for log in self.loggers:
        if log.enabled and (log_types == ALL_TOKEN or log.name in log_types):
            log.log_scalars(
                tag=tag,
                values=values,
                step=step,
                wall_time=wall_time,
                level=level,
            )

PythonLogger 

PythonLogger(name: str = 'python', enabled: bool = True)

Bases: LambdaLogger

Modifier metrics that handles printing values into a python metrics instance.

Parameters:

  • name

    (str, default: 'python' ) –

    name given to the metrics, used for identification; defaults to python

  • enabled

    (bool, default: True ) –

    True to log, False otherwise

Methods:

  • log_string –

    :param tag: identifying tag to log the values with

Source code in llmcompressor/metrics/logger.py 
320
321
322
323
324
325
326
327
328
329
330
331
def __init__(
    self,
    name: str = "python",
    enabled: bool = True,
):
    self._create_default_logger()

    super().__init__(
        lambda_func=self._log_lambda,
        name=name,
        enabled=enabled,
    )

log_string 

log_string(
    tag: Optional[str],
    string: Optional[str],
    step: Optional[int],
    wall_time: Optional[float] = None,
    level: Optional[Union[int, str]] = None,
) -> bool

Parameters:

  • tag

    (Optional[str]) –

    identifying tag to log the values with

  • string

    (Optional[str]) –

    string to log

  • step

    (Optional[int]) –

    global step for when the values were taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the values were taken, defaults to time.time()

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

Returns:

  • bool –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
def log_string(
    self,
    tag: Optional[str],
    string: Optional[str],
    step: Optional[int],
    wall_time: Optional[float] = None,
    level: Optional[Union[int, str]] = None,
) -> bool:
    """
    :param tag: identifying tag to log the values with
    :param string: string to log
    :param step: global step for when the values were taken
    :param wall_time: global wall time for when the values were taken,
        defaults to time.time()
    :param level: minimum severity level for the log message
    :return: True if logged, False otherwise.
    """
    if not wall_time:
        wall_time = time.time()

    return self._lambda_func(
        tag=tag,
        value=string,
        values=None,
        step=step,
        level=level,
        wall_time=wall_time,
    )

SparsificationGroupLogger 

SparsificationGroupLogger(
    lambda_func: Optional[
        Callable[
            [
                Optional[str],
                Optional[float],
                Optional[Dict[str, float]],
                Optional[int],
                Optional[float],
            ],
            bool,
        ]
    ] = None,
    python: bool = False,
    python_log_level: Optional[Union[int, str]] = "INFO",
    tensorboard: Optional[
        Union[bool, str, SummaryWriter]
    ] = None,
    wandb_: Optional[Union[bool, Dict]] = None,
    name: str = "sparsification",
    enabled: bool = True,
)

Bases: BaseLogger

Modifier metrics that handles outputting values to other supported systems. Supported ones include: - Python logging - Tensorboard - Weights and Biases - Lambda callback

All are optional and can be bulk disabled and enabled by this root.

Parameters:

  • lambda_func

    (Optional[Callable[[Optional[str], Optional[float], Optional[Dict[str, float]], Optional[int], Optional[float]], bool]], default: None ) –

    an optional lambda function to call back into with any logs. The expected call sequence is (tag, value, values, step, wall_time) -> bool The return type is True if logged and False otherwise.

  • python

    (bool, default: False ) –

    an bool argument for logging to a python metrics. True to create a metrics instance, or False to not log anything

  • python_log_level

    (Optional[Union[int, str]], default: 'INFO' ) –

    if python, the level to log any incoming data at on the loguru.logger instance

  • tensorboard

    (Optional[Union[bool, str, SummaryWriter]], default: None ) –

    an optional argument for logging to a tensorboard writer. May be a SummaryWriter instance to log to, a string representing the directory to create a new SummaryWriter to log to, True to create a new SummaryWriter, or non truthy to not log anything (False, None)

  • wandb_

    (Optional[Union[bool, Dict]], default: None ) –

    an optional argument for logging to wandb. May be a dictionary to pass to the init call for wandb, True to log to wandb (will not call init), or non truthy to not log anything (False, None)

  • name

    (str, default: 'sparsification' ) –

    name given to the metrics, used for identification; defaults to sparsification

  • enabled

    (bool, default: True ) –

    True to log, False otherwise

Methods:

  • enabled –

    :param value: True to log, False otherwise

  • log_hyperparams –

    :param params: Each key-value pair in the dictionary is the name of the

  • log_scalar –

    :param tag: identifying tag to log the value with

  • log_scalars –

    :param tag: identifying tag to log the values with

Attributes:

  • loggers (List[BaseLogger]) –

    :return: the created metrics sub instances for this metrics

Source code in llmcompressor/metrics/logger.py 
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
def __init__(
    self,
    lambda_func: Optional[
        Callable[
            [
                Optional[str],
                Optional[float],
                Optional[Dict[str, float]],
                Optional[int],
                Optional[float],
            ],
            bool,
        ]
    ] = None,
    python: bool = False,
    python_log_level: Optional[Union[int, str]] = "INFO",
    tensorboard: Optional[Union[bool, str, SummaryWriter]] = None,
    wandb_: Optional[Union[bool, Dict]] = None,
    name: str = "sparsification",
    enabled: bool = True,
):
    super().__init__(name, enabled)
    self._loggers: List[BaseLogger] = []

    if lambda_func:
        self._loggers.append(
            LambdaLogger(lambda_func=lambda_func, name=name, enabled=enabled)
        )

    if python:
        self._loggers.append(
            PythonLogger(
                name=name,
                enabled=enabled,
            )
        )

    if tensorboard and TensorBoardLogger.available():
        self._loggers.append(
            TensorBoardLogger(
                log_path=tensorboard if isinstance(tensorboard, str) else None,
                writer=(
                    tensorboard if isinstance(tensorboard, SummaryWriter) else None
                ),
                name=name,
                enabled=enabled,
            )
        )

    if wandb_ and WANDBLogger.available():
        self._loggers.append(
            WANDBLogger(
                init_kwargs=wandb_ if isinstance(wandb_, Dict) else None,
                name=name,
                enabled=enabled,
            )
        )

loggers property 

loggers: List[BaseLogger]

Returns:

  • List[BaseLogger] –

    the created metrics sub instances for this metrics

enabled 

enabled(value: bool)

Parameters:

  • value

    (bool) –

    True to log, False otherwise

Source code in llmcompressor/metrics/logger.py 
704
705
706
707
708
709
710
711
712
@BaseLogger.enabled.setter
def enabled(self, value: bool):
    """
    :param value: True to log, False otherwise
    """
    self._enabled = value

    for log in self._loggers:
        log.enabled = value

log_hyperparams 

log_hyperparams(
    params: Dict, level: Optional[Union[int, str]] = None
)

Parameters:

  • params

    (Dict) –

    Each key-value pair in the dictionary is the name of the hyper parameter and it's corresponding value.

Source code in llmcompressor/metrics/logger.py 
721
722
723
724
725
726
727
def log_hyperparams(self, params: Dict, level: Optional[Union[int, str]] = None):
    """
    :param params: Each key-value pair in the dictionary is the name of the
        hyper parameter and it's corresponding value.
    """
    for log in self._loggers:
        log.log_hyperparams(params, level)

log_scalar 

log_scalar(
    tag: str,
    value: float,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    level: Optional[Union[int, str]] = None,
)

Parameters:

  • tag

    (str) –

    identifying tag to log the value with

  • value

    (float) –

    value to save

  • step

    (Optional[int], default: None ) –

    global step for when the value was taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the value was taken, defaults to time.time()

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

Source code in llmcompressor/metrics/logger.py 
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
def log_scalar(
    self,
    tag: str,
    value: float,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    level: Optional[Union[int, str]] = None,
):
    """
    :param tag: identifying tag to log the value with
    :param value: value to save
    :param step: global step for when the value was taken
    :param wall_time: global wall time for when the value was taken,
        defaults to time.time()
    :param level: minimum severity level for the log message
    """
    for log in self._loggers:
        log.log_scalar(tag, value, step, wall_time, level)

log_scalars 

log_scalars(
    tag: str,
    values: Dict[str, float],
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    level: Optional[Union[int, str]] = None,
)

Parameters:

  • tag

    (str) –

    identifying tag to log the values with

  • values

    (Dict[str, float]) –

    values to save

  • step

    (Optional[int], default: None ) –

    global step for when the values were taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the values were taken, defaults to time.time()

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

Source code in llmcompressor/metrics/logger.py 
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
def log_scalars(
    self,
    tag: str,
    values: Dict[str, float],
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    level: Optional[Union[int, str]] = None,
):
    """
    :param tag: identifying tag to log the values with
    :param values: values to save
    :param step: global step for when the values were taken
    :param wall_time: global wall time for when the values were taken,
        defaults to time.time()
    :param level: minimum severity level for the log message
    """
    for log in self._loggers:
        log.log_scalars(tag, values, step, wall_time, level)

SystemLoggingWraper 

SystemLoggingWraper(
    loggers: List[BaseLogger],
    frequency_manager: FrequencyManager,
)

Bases: LoggingWrapperBase

Wraps utilities and convenience methods for logging strings to the system

Methods:

  • critical –

    logs a string message with level CRITICAL on all

  • debug –

    logs a string message with level DEBUG on all

  • error –

    logs a string message with level ERROR on all

  • info –

    logs a string message with level INFO on all

  • log_string –

    :param tag: identifying tag to log the values with

  • warning –

    logs a string message with level WARNING on all

Source code in llmcompressor/metrics/logger.py 
1071
1072
1073
def __init__(self, loggers: List[BaseLogger], frequency_manager: FrequencyManager):
    self.loggers = loggers
    self._frequency_manager = frequency_manager

critical 

critical(tag, string, *args, **kwargs)

logs a string message with level CRITICAL on all loggers that are enabled

Parameters:

  • tag

    –

    Identifying tag to log the string with

  • string

    –

    The string to log

  • args

    –

    additional arguments to pass to the metrics, see log_string for more details

  • kwargs

    –

    additional arguments to pass to the metrics, see log_string for more details

Source code in llmcompressor/metrics/logger.py 
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
def critical(self, tag, string, *args, **kwargs):
    """
    logs a string message with level CRITICAL on all
    loggers that are enabled

    :param tag: Identifying tag to log the string with
    :param string: The string to log
    :param args: additional arguments to pass to the metrics,
        see `log_string` for more details
    :param kwargs: additional arguments to pass to the metrics,
        see `log_string` for more details
    """
    kwargs["level"] = "CRITICAL"
    self.log_string(tag=tag, string=string, *args, **kwargs)

debug 

debug(tag, string, *args, **kwargs)

logs a string message with level DEBUG on all loggers that are enabled

Parameters:

  • tag

    –

    Identifying tag to log the string with

  • string

    –

    The string to log

  • args

    –

    additional arguments to pass to the metrics, see log_string for more details

  • kwargs

    –

    additional arguments to pass to the metrics, see log_string for more details

Source code in llmcompressor/metrics/logger.py 
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
def debug(self, tag, string, *args, **kwargs):
    """
    logs a string message with level DEBUG on all
    loggers that are enabled

    :param tag: Identifying tag to log the string with
    :param string: The string to log
    :param args: additional arguments to pass to the metrics,
        see `log_string` for more details
    :param kwargs: additional arguments to pass to the metrics,
        see `log_string` for more details
    """
    kwargs["level"] = "DEBUG"
    self.log_string(tag=tag, string=string, *args, **kwargs)

error 

error(tag, string, *args, **kwargs)

logs a string message with level ERROR on all loggers that are enabled

Parameters:

  • tag

    –

    Identifying tag to log the string with

  • string

    –

    The string to log

  • args

    –

    additional arguments to pass to the metrics, see log_string for more details

  • kwargs

    –

    additional arguments to pass to the metrics, see log_string for more details

Source code in llmcompressor/metrics/logger.py 
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
def error(self, tag, string, *args, **kwargs):
    """
    logs a string message with level ERROR on all
    loggers that are enabled

    :param tag: Identifying tag to log the string with
    :param string: The string to log
    :param args: additional arguments to pass to the metrics,
        see `log_string` for more details
    :param kwargs: additional arguments to pass to the metrics,
        see `log_string` for more details
    """
    kwargs["level"] = "ERROR"
    self.log_string(tag=tag, string=string, *args, **kwargs)

info 

info(tag, string, *args, **kwargs)

logs a string message with level INFO on all loggers that are enabled

Parameters:

  • tag

    –

    Identifying tag to log the string with

  • string

    –

    The string to log

  • args

    –

    additional arguments to pass to the metrics, see log_string for more details

  • kwargs

    –

    additional arguments to pass to the metrics, see log_string for more details

Source code in llmcompressor/metrics/logger.py 
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
def info(self, tag, string, *args, **kwargs):
    """
    logs a string message with level INFO on all
    loggers that are enabled

    :param tag: Identifying tag to log the string with
    :param string: The string to log
    :param args: additional arguments to pass to the metrics,
        see `log_string` for more details
    :param kwargs: additional arguments to pass to the metrics,
        see `log_string` for more details
    """
    kwargs["level"] = "INFO"
    self.log_string(tag=tag, string=string, *args, **kwargs)

log_string 

log_string(
    tag: str,
    string: str,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
)

Parameters:

  • tag

    (str) –

    identifying tag to log the values with

  • values

    –

    values to save

  • step

    (Optional[int], default: None ) –

    global step for when the values were taken

  • wall_time

    (Optional[float], default: None ) –

    global wall time for when the values were taken

  • level

    (Optional[Union[int, str]], default: None ) –

    minimum severity level for the log message

  • kwargs

    –

    additional logging arguments to support Python and custom loggers

Returns:

  • –

    True if logged, False otherwise.

Source code in llmcompressor/metrics/logger.py 
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
def log_string(
    self,
    tag: str,
    string: str,
    step: Optional[int] = None,
    wall_time: Optional[float] = None,
    log_types: Union[str, List[str]] = ALL_TOKEN,
    level: Optional[Union[int, str]] = None,
):
    """
    :param tag: identifying tag to log the values with
    :param values: values to save
    :param step: global step for when the values were taken
    :param wall_time: global wall time for when the values were taken
    :param level: minimum severity level for the log message
    :param kwargs: additional logging arguments to support Python and custom loggers
    :return: True if logged, False otherwise.
    """
    for log in self.loggers:
        if log.enabled and (log_types == ALL_TOKEN or log.name in log_types):
            log.log_string(
                tag=tag,
                string=string,
                step=step,
                wall_time=wall_time,
                level=level,
            )

warning 

warning(tag, string, *args, **kwargs)

logs a string message with level WARNING on all loggers that are enabled

Parameters:

  • tag

    –

    Identifying tag to log the string with

  • string

    –

    The string to log

  • args

    –

    additional arguments to pass to the metrics, see log_string for more details

  • kwargs

    –

    additional arguments to pass to the metrics, see log_string for more details

Source code in llmcompressor/metrics/logger.py 
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
def warning(self, tag, string, *args, **kwargs):
    """
    logs a string message with level WARNING on all
    loggers that are enabled

    :param tag: Identifying tag to log the string with
    :param string: The string to log
    :param args: additional arguments to pass to the metrics,
        see `log_string` for more details
    :param kwargs: additional arguments to pass to the metrics,
        see `log_string` for more details
    """
    kwargs["level"] = "WARNING"
    self.log_string(tag=tag, string=string, *args, **kwargs)

TensorBoardLogger 

TensorBoardLogger(
    log_path: str = None,
    writer: SummaryWriter = None,
    name: str = "tensorboard",
    enabled: bool = True,
)

Bases: LambdaLogger

Modifier metrics that handles outputting values into a TensorBoard log directory for viewing in TensorBoard.

Parameters:

  • log_path

    (str, default: None ) –

    the path to create a SummaryWriter at. writer must be None to use if not supplied (and writer is None), will create a TensorBoard dir in cwd

  • writer

    (SummaryWriter, default: None ) –

    the writer to log results to, if none is given creates a new one at the log_path

  • name

    (str, default: 'tensorboard' ) –

    name given to the metrics, used for identification; defaults to tensorboard

  • enabled

    (bool, default: True ) –

    True to log, False otherwise

Methods:

  • available –

    :return: True if tensorboard is available and installed, False, otherwise

Attributes:

  • writer (SummaryWriter) –

    :return: the writer to log results to,

Source code in llmcompressor/metrics/logger.py 
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
def __init__(
    self,
    log_path: str = None,
    writer: SummaryWriter = None,
    name: str = "tensorboard",
    enabled: bool = True,
):
    if tensorboard_import_error:
        raise tensorboard_import_error

    if writer and log_path:
        raise ValueError(
            (
                "log_path given:{} and writer object passed in, "
                "to create a writer at the log path set writer=None"
            ).format(log_path)
        )
    elif not writer and not log_path:
        log_path = os.path.join("", "tensorboard")

    if os.environ.get("NM_TEST_MODE"):
        test_log_root = os.environ.get("NM_TEST_LOG_DIR")
        log_path = (
            os.path.join(test_log_root, log_path) if log_path else test_log_root
        )

    if log_path:
        _create_dirs(log_path)

    self._writer = writer if writer is not None else SummaryWriter(log_path)
    super().__init__(
        lambda_func=self._log_lambda,
        name=name,
        enabled=enabled,
    )

writer property 

writer: SummaryWriter

Returns:

  • SummaryWriter –

    the writer to log results to, if none is given creates a new one at the log_path

available staticmethod 

available() -> bool

Returns:

  • bool –

    True if tensorboard is available and installed, False, otherwise

Source code in llmcompressor/metrics/logger.py 
491
492
493
494
495
496
@staticmethod
def available() -> bool:
    """
    :return: True if tensorboard is available and installed, False, otherwise
    """
    return not tensorboard_import_error

WANDBLogger 

WANDBLogger(
    init_kwargs: Optional[Dict] = None,
    name: str = "wandb",
    enabled: bool = True,
    wandb_err: Optional[Exception] = wandb_err,
)

Bases: LambdaLogger

Modifier metrics that handles outputting values to Weights and Biases.

Parameters:

  • init_kwargs

    (Optional[Dict], default: None ) –

    the args to call into wandb.init with; ex: wandb.init(**init_kwargs). If not supplied, then init will not be called

  • name

    (str, default: 'wandb' ) –

    name given to the metrics, used for identification; defaults to wandb

  • enabled

    (bool, default: True ) –

    True to log, False otherwise

Methods:

  • available –

    :return: True if wandb is available and installed, False, otherwise

  • save –

    :param file_path: path to a file to be saved

Source code in llmcompressor/metrics/logger.py 
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
def __init__(
    self,
    init_kwargs: Optional[Dict] = None,
    name: str = "wandb",
    enabled: bool = True,
    wandb_err: Optional[Exception] = wandb_err,
):
    if wandb_err:
        raise wandb_err

    super().__init__(
        lambda_func=self._log_lambda,
        name=name,
        enabled=enabled,
    )

    if os.environ.get("NM_TEST_MODE"):
        test_log_path = os.environ.get("NM_TEST_LOG_DIR")
        _create_dirs(test_log_path)
        if init_kwargs:
            init_kwargs["dir"] = test_log_path
        else:
            init_kwargs = {"dir": test_log_path}

    if wandb_err:
        raise wandb_err

    if init_kwargs:
        wandb.init(**init_kwargs)
    else:
        wandb.init()

    self.wandb = wandb

available staticmethod 

available() -> bool

Returns:

  • bool –

    True if wandb is available and installed, False, otherwise

Source code in llmcompressor/metrics/logger.py 
539
540
541
542
543
544
@staticmethod
def available() -> bool:
    """
    :return: True if wandb is available and installed, False, otherwise
    """
    return wandb_available

save 

save(file_path: str) -> bool

Parameters:

  • file_path

    (str) –

    path to a file to be saved

Source code in llmcompressor/metrics/logger.py 
604
605
606
607
608
609
610
611
612
def save(
    self,
    file_path: str,
) -> bool:
    """
    :param file_path: path to a file to be saved
    """
    wandb.save(file_path)
    return True