跳到内容

llmcompressor.metrics.logger

包含用于可视化每个修饰器信息的日志记录器代码。

类

  • BaseLogger –

    所有修饰器日志记录器都必须实现的基类。

  • LambdaLogger –

    处理回调 lambda 函数以获取任何日志的日志记录器。

  • LoggerManager –

    日志记录器的包装器，负责日志调度和将日志传递给预期的

  • PythonLogger –

    修饰器指标，负责将值打印到 Python 指标实例。

  • SparsificationGroupLogger –

    修饰器指标，负责将值输出到其他支持的系统。

  • TensorBoardLogger –

    修饰器指标，负责将值输出到 TensorBoard 日志目录

  • WANDBLogger –

    修饰器指标，负责将值输出到 Weights and Biases。

BaseLogger

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

基类：ABC

所有修饰器日志记录器都必须实现的基类。

参数

  • 名称

    (str) –

    用于标识指标的名称

  • enabled

    (bool, 默认值: True ) –

    为 True 时记录，否则为 False

方法

  • log_hyperparams –

    :param params: 字典中的每个键值对是超参数的名称

  • log_scalar –

    :param tag: 用于记录值的标识标签

  • log_scalars –

    :param tag: 用于记录值的标识标签

  • log_string –

    :param tag: 用于记录值的标识标签

  • save –

    :param file_path: 要保存的文件路径

属性

  • enabled (bool) –

    :return: 为 True 时记录，否则为 False

  • name (str) –

    :return: 用于标识指标的名称

源文件 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

返回

  • bool –

    为 True 时记录，否则为 False

name property 

name: str

返回

  • str –

    用于标识指标的名称

log_hyperparams

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

参数

  • params

    (dict[str, float]) –

    字典中的每个键值对是超参数的名称及其对应的值。

返回

  • bool –

    如果记录成功，则为 True，否则为 False。

源文件 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: int | None = None,
    wall_time: float | None = None,
    **kwargs,
) -> bool

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    (float) –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集该值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集该值时的全局墙上时间

  • kwargs

    –

    其他日志参数，用于支持 Python 和自定义日志记录器

返回

  • bool –

    如果记录成功，则为 True，否则为 False。

源文件 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: int | None = None,
    wall_time: float | None = 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: int | None = None,
    wall_time: float | None = None,
    **kwargs,
) -> bool

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    (dict[str, float]) –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集这些值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集这些值时的全局墙上时间

  • kwargs

    –

    其他日志参数，用于支持 Python 和自定义日志记录器

返回

  • bool –

    如果记录成功，则为 True，否则为 False。

源文件 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: int | None = None,
    wall_time: float | None = 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: int | None = None,
    wall_time: float | None = None,
    **kwargs,
) -> bool

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集这些值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集这些值时的全局墙上时间

  • kwargs

    –

    其他日志参数，用于支持 Python 和自定义日志记录器

返回

  • bool –

    如果记录成功，则为 True，否则为 False。

源文件 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: int | None = None,
    wall_time: float | None = 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

参数

  • 文件路径

    (str) –

    要保存的文件路径

  • kwargs

    –

    特定指标可能使用的附加参数

返回

  • bool –

    如果保存成功，则为 True，否则为 False

源文件 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[
        [
            str | None,
            float | str | None,
            dict[str, float] | None,
            int | None,
            float | None,
            int | None,
        ],
        bool,
    ],
    name: str = "lambda",
    enabled: bool = True,
)

Bases: BaseLogger

处理回调 lambda 函数以获取任何日志的日志记录器。

参数

  • lambda_func

    (Callable[[str | None, float | str | None, dict[str, float] | None, int | None, float | None, int | None], bool]) –

    回调 lambda 函数，用于接收任何日志。预期的调用顺序为 (tag, value, values, step, wall_time) -> bool 返回 True 表示已记录，否则返回 False。

  • 名称

    (str, default: 'lambda' ) –

    用于标识指标的名称；默认为 lambda

  • enabled

    (bool, 默认值: True ) –

    为 True 时记录，否则为 False

方法

  • log_hyperparams –

    :param params: 字典中的每个键值对是超参数的名称

  • log_scalar –

    :param tag: 用于记录值的标识标签

  • log_scalars –

    :param tag: 用于记录值的标识标签

属性

  • lambda_func (Callable[[str | None, float | str | None, dict[str, float] | None, int | None, float | None, int | None], bool]) –

    :return: 回调 lambda 函数，用于接收任何日志。

源文件 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[
        [
            str | None,
            float | str | None,
            dict[str, float] | None,
            int | None,
            float | None,
            int | None,
        ],
        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[
    [
        str | None,
        float | str | None,
        dict[str, float] | None,
        int | None,
        float | None,
        int | None,
    ],
    bool,
]

返回

  • Callable[[str | None, float | str | None, dict[str, float] | None, int | None, float | None, int | None], bool] –

    回调 lambda 函数，用于接收任何日志。预期的调用顺序为 (tag, value, values, step, wall_time)

log_hyperparams

log_hyperparams(
    params: dict[str, float], level: int | str | None = None
) -> bool

参数

  • params

    (dict[str, float]) –

    字典中的每个键值对是超参数的名称及其对应的值。

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

返回

  • bool –

    如果记录成功，则为 True，否则为 False。

源文件 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[str, float],
    level: int | str | None = 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: int | None = None,
    wall_time: float | None = None,
    level: int | str | None = None,
) -> bool

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    (float) –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集该值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集值时的全局墙上时间，默认为 time.time()

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

  • kwargs

    –

    其他日志参数，用于支持 Python 和自定义日志记录器

返回

  • bool –

    如果记录成功，则为 True，否则为 False。

源文件 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: int | None = None,
    wall_time: float | None = None,
    level: int | str | None = 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: int | None = None,
    wall_time: float | None = None,
    level: int | str | None = None,
) -> bool

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    (dict[str, float]) –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集这些值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集这些值时的全局墙上时间，默认为 time.time()

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

  • kwargs

    –

    其他日志参数，用于支持 Python 和自定义日志记录器

返回

  • bool –

    如果记录成功，则为 True，否则为 False。

源文件 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: int | None = None,
    wall_time: float | None = None,
    level: int | str | None = 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: list[BaseLogger] | None = None,
    log_frequency: float | None = 0.1,
    log_python: bool = True,
    name: str = "manager",
    mode: LoggingModeType = "exact",
    frequency_type: FrequencyType = "epoch",
)

基类：ABC

日志记录器的包装器，负责日志调度和将日志传递给预期的日志记录器。

参数

  • loggers

    (list[BaseLogger] | None, default: None ) –

    分配给此管理器的日志记录器列表

  • 日志频率

    (float | None, default: 0.1 ) –

    日志之间的步数或步数比例

  • 模式

    (LoggingModeType, default: 'exact' ) –

    使用的日志模式，可以是 "on_change" 或 "exact"。 "on_change" 将在模型自上次日志以来更新时进行记录，"exact" 将在给定频率下进行记录，而不管模型更新。默认为 "exact"

  • 频率类型

    (FrequencyType, default: 'epoch' ) –

    要使用的频率类型，可以是 "epoch"、"step" 或 "batch" 来控制频率管理器跟踪的内容，例如，如果频率类型是 "epoch"，则频率管理器将跟踪自上次日志记录以来已过的 epoch 数，如果频率类型是 "step"，则频率管理器将跟踪优化器步骤数

方法

  • add_logger –

    将 BaseLogger 实现添加到此管理器的日志记录器中

  • log_hyperparams –

    (注意：此方法已弃用，将在未来版本中删除，

  • log_ready –

    检查是否有指标已准备好接受日志

  • log_scalar –

    (注意：此方法已弃用，将在未来版本中删除，

  • log_scalars –

    (注意：此方法已弃用，将在未来版本中删除，

  • log_string –

    (注意：此方法已弃用，将在未来版本中删除，

  • log_written –

    使用上一个写入的日志步数更新频率管理器

  • model_updated –

    使用上一个模型更新步数更新频率管理器

  • save –

    :param file_path: 要保存的文件路径

  • time –

    上下文管理器，用于记录代码块运行所需的时间

属性

  • log_frequency (str | float | None) –

    :return: 日志之间的 epoch 数或 epoch 数比例

  • loggers (list[BaseLogger]) –

    :return: 分配给此管理器的日志记录器列表

  • name (str) –

    :return: 用于标识指标的名称

  • wandb (ModuleType | None) –

    :return: 如果已初始化，则为 wandb 模块

源文件 llmcompressor/metrics/logger.py 
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
def __init__(
    self,
    loggers: list[BaseLogger] | None = None,
    log_frequency: 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 = SystemLoggingWrapper(
        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: str | float | None

返回

  • str | float | None –

    日志之间的 epoch 数或 epoch 数比例

loggers property writable 

loggers: list[BaseLogger]

返回

  • list[BaseLogger] –

    分配给此管理器的日志记录器列表

name property 

name: str

返回

  • str –

    用于标识指标的名称

wandb property 

wandb: ModuleType | None

返回

  • ModuleType | None –

    如果已初始化，则为 wandb 模块

add_logger

add_logger(logger: BaseLogger)

将 BaseLogger 实现添加到此管理器的日志记录器中

参数

  • logger

    (BaseLogger) –

    要添加的指标对象

源文件 llmcompressor/metrics/logger.py 
834
835
836
837
838
839
840
841
842
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: str | list[str] = ALL_TOKEN,
    level: int | str | None = None,
)

(注意：此方法已弃用，将在未来版本中删除，请使用 LoggerManager().metric.log_hyperparams 代替)

参数

  • params

    (dict) –

    字典中的每个键值对是超参数的名称及其对应的值。

源文件 llmcompressor/metrics/logger.py 
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
def log_hyperparams(
    self,
    params: dict,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = 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,
)

检查是否有指标已准备好接受日志

参数

  • 当前日志步骤

    –

    请求日志的当前步数

  • 上次日志步骤

    –

    上一次为此对象记录日志的时间。（已弃用）

  • 检查模型更新

    (bool, 默认值: False ) –

    如果为 True，将检查模型是否已更新；如果为 False，则仅检查日志频率

返回

  • –

    如果指标已准备好接受日志，则为 True。

源文件 llmcompressor/metrics/logger.py 
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
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: int | None = None,
    wall_time: float | None = None,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = None,
)

(注意：此方法已弃用，将在未来版本中删除，请使用 LoggerManager().metric.log_scalar 代替)

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    (float) –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集该值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集该值时的全局墙上时间

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

  • kwargs

    –

    其他日志参数，用于支持 Python 和自定义日志记录器

返回

  • –

    如果记录成功，则为 True，否则为 False。

源文件 llmcompressor/metrics/logger.py 
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
def log_scalar(
    self,
    tag: str,
    value: float,
    step: int | None = None,
    wall_time: float | None = None,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = 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: int | None = None,
    wall_time: float | None = None,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = None,
)

(注意：此方法已弃用，将在未来版本中删除，请使用 LoggerManager().metric.log_scalars 代替)

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    (dict[str, float]) –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集这些值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集这些值时的全局墙上时间

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

  • kwargs

    –

    其他日志参数，用于支持 Python 和自定义日志记录器

返回

  • –

    如果记录成功，则为 True，否则为 False。

源文件 llmcompressor/metrics/logger.py 
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
def log_scalars(
    self,
    tag: str,
    values: dict[str, float],
    step: int | None = None,
    wall_time: float | None = None,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = 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: int | None = None,
    wall_time: float | None = None,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = None,
)

(注意：此方法已弃用，将在未来版本中删除，请使用 LoggerManager().system.log_string 代替)

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集这些值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集这些值时的全局墙上时间

  • kwargs

    –

    其他日志参数，用于支持 Python 和自定义日志记录器

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

返回

  • –

    如果记录成功，则为 True，否则为 False。

源文件 llmcompressor/metrics/logger.py 
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
def log_string(
    self,
    tag: str,
    string: str,
    step: int | None = None,
    wall_time: float | None = None,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = 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)

使用上一个写入的日志步数更新频率管理器

参数

  • 步骤

    (LogStepType) –

    上次记录的步数

源文件 llmcompressor/metrics/logger.py 
865
866
867
868
869
870
871
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)

使用上一个模型更新步数更新频率管理器

参数

  • 步骤

    (LogStepType) –

    上次记录的步数

源文件 llmcompressor/metrics/logger.py 
873
874
875
876
877
878
879
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)

参数

  • 文件路径

    (str) –

    要保存的文件路径

  • kwargs

    –

    特定指标可能使用的附加参数

源文件 llmcompressor/metrics/logger.py 
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
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: str | None = None, *args, **kwargs)

上下文管理器，用于记录代码块运行所需的时间

用法

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

参数

  • tag

    (str | None, 默认值: None ) –

    用于记录值的标识标签

源文件 llmcompressor/metrics/logger.py 
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
@contextmanager
def time(self, tag: str | None = 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,
)

保存对日志记录器和频率管理器的引用的基类

源文件 llmcompressor/metrics/logger.py 
1080
1081
1082
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

包装用于将指标记录到系统的实用程序和便捷方法

方法

  • add_scalar –

    将标量值添加到指标

  • add_scalars –

    将多个标量值添加到指标

  • log –

    :param data: 一个字典，包含可序列化的 Python 对象，例如 str，

  • log_hyperparams –

    :param params: 字典中的每个键值对是超参数的名称

  • log_scalar –

    :param tag: 用于记录值的标识标签

  • log_scalars –

    :param tag: 用于记录值的标识标签

源文件 llmcompressor/metrics/logger.py 
1080
1081
1082
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: int | None = None,
    wall_time: int | float | None = None,
    **kwargs,
)

将标量值添加到指标

参数

  • 值

    –

    要记录的值

  • tag

    (str, default: DEFAULT_TAG ) –

    用于记录值的标签，默认为 DEFAULT_TAG

  • 步骤

    (int | None, 默认值: None ) –

    采集该值时的全局步数

  • wall_time

    (int | float | None, default: None ) –

    采集该值时的全局墙上时间

  • kwargs

    –

    要传递给指标的其他日志参数

源文件 llmcompressor/metrics/logger.py 
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
def add_scalar(
    self,
    value,
    tag: str = DEFAULT_TAG,
    step: int | None = None,
    wall_time: 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: int | None = None,
    wall_time: int | float | None = None,
    **kwargs,
)

将多个标量值添加到指标

参数

  • 值

    (dict[str, Any]) –

    要记录的值，必须是可序列化的 Python 对象字典，例如 str、ints、floats、Tensors、dicts 等。

  • tag

    (str, default: DEFAULT_TAG ) –

    用于记录值的标签，默认为 DEFAULT_TAG

  • 步骤

    (int | None, 默认值: None ) –

    采集该值时的全局步数

  • wall_time

    (int | float | None, default: None ) –

    采集该值时的全局墙上时间

  • kwargs

    –

    要传递给指标的其他日志参数

源文件 llmcompressor/metrics/logger.py 
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
def add_scalars(
    self,
    values: dict[str, Any],
    tag: str = DEFAULT_TAG,
    step: int | None = None,
    wall_time: 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: int | None = None,
    tag: str | None = DEFAULT_TAG,
    **kwargs,
) -> None

参数

  • data

    (dict[str, Any]) –

    可序列化的 Python 对象字典，例如 str、ints、floats、Tensors、dicts 等。

  • 步骤

    (int | None, 默认值: None ) –

    采集这些值时的全局步数

  • tag

    (str | None, default: DEFAULT_TAG ) –

    用于记录值的标识标签，默认为 DEFAULT_TAG

  • kwargs

    –

    其他日志参数，用于支持 Python 和自定义日志记录器

源文件 llmcompressor/metrics/logger.py 
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
def log(
    self,
    data: dict[str, Any],
    step: int | None = None,
    tag: str | None = 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[str, float],
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = None,
)

参数

  • params

    (dict[str, float]) –

    字典中的每个键值对是超参数的名称及其对应的值。

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

源文件 llmcompressor/metrics/logger.py 
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
def log_hyperparams(
    self,
    params: dict[str, float],
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = 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: int | None = None,
    wall_time: float | None = None,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = None,
)

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    (float) –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集该值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集该值时的全局墙上时间

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

  • kwargs

    –

    其他日志参数，用于支持 Python 和自定义日志记录器

返回

  • –

    如果记录成功，则为 True，否则为 False。

源文件 llmcompressor/metrics/logger.py 
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
def log_scalar(
    self,
    tag: str,
    value: float,
    step: int | None = None,
    wall_time: float | None = None,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = 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: int | None = None,
    wall_time: float | None = None,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = None,
)

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    (dict[str, float]) –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集这些值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集这些值时的全局墙上时间

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

  • kwargs

    –

    其他日志参数，用于支持 Python 和自定义日志记录器

返回

  • –

    如果记录成功，则为 True，否则为 False。

源文件 llmcompressor/metrics/logger.py 
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
def log_scalars(
    self,
    tag: str,
    values: dict[str, float],
    step: int | None = None,
    wall_time: float | None = None,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = 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

修饰器指标，负责将值打印到 Python 指标实例。

参数

  • 名称

    (str, default: 'python' ) –

    用于标识指标的名称；默认为 python

  • enabled

    (bool, 默认值: True ) –

    为 True 时记录，否则为 False

方法

  • log_string –

    :param tag: 用于记录值的标识标签

源文件 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: str | None,
    string: str | None,
    step: int | None,
    wall_time: float | None = None,
    level: int | str | None = None,
) -> bool

参数

  • tag

    (str | None) –

    用于记录值的标识标签

  • string

    (str | None) –

    要记录的字符串

  • 步骤

    (int | None) –

    采集这些值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集这些值时的全局墙上时间，默认为 time.time()

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

返回

  • bool –

    如果记录成功，则为 True，否则为 False。

源文件 llmcompressor/metrics/logger.py 
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
def log_string(
    self,
    tag: str | None,
    string: str | None,
    step: int | None,
    wall_time: float | None = None,
    level: int | str | None = 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: Callable[
        [
            str | None,
            float | None,
            dict[str, float] | None,
            int | None,
            float | None,
        ],
        bool,
    ]
    | None = None,
    python: bool = False,
    python_log_level: int | str | None = "INFO",
    tensorboard: bool | str | SummaryWriter = None,
    wandb_: bool | dict | None = None,
    name: str = "sparsification",
    enabled: bool = True,
)

Bases: BaseLogger

修饰器指标，负责将值输出到其他支持的系统。支持的系统包括：- Python 日志- Tensorboard- Weights and Biases- Lambda 回调

所有这些都是可选的，并且可以由根节点批量禁用和启用。

参数

  • lambda_func

    (Callable[[str | None, float | None, dict[str, float] | None, int | None, float | None], bool] | None, default: None ) –

    可选的 lambda 函数，用于回调接收任何日志。预期的调用顺序为 (tag, value, values, step, wall_time) -> bool 返回 True 表示已记录，否则返回 False。

  • python

    (bool, 默认值: False ) –

    用于将数据记录到 Python 指标的布尔参数。如果为 True，则创建一个指标实例，否则不记录任何内容

  • python_log_level

    (int | str | None, default: 'INFO' ) –

    如果 python 为 True，则是在 loguru.logger 实例上记录任何传入数据的级别

  • tensorboard

    (bool | str | SummaryWriter, default: None ) –

    用于记录到 tensorboard writer 的可选参数。可以是用于记录的 SummaryWriter 实例，表示用于创建新的 SummaryWriter 进行记录的目录的字符串，True 表示创建新的 SummaryWriter，或者非真值表示不记录任何内容 (False, None)

  • wandb_

    (bool | dict | None, default: None ) –

    用于记录到 wandb 的可选参数。可以是传递给 wandb.init 的字典，True 表示记录到 wandb (将不调用 init)，或者非真值表示不记录任何内容 (False, None)

  • 名称

    (str, default: 'sparsification' ) –

    用于标识指标的名称；默认为 sparsification

  • enabled

    (bool, 默认值: True ) –

    为 True 时记录，否则为 False

方法

  • enabled –

    :param value: 为 True 时记录，否则为 False

  • log_hyperparams –

    :param params: 字典中的每个键值对是超参数的名称

  • log_scalar –

    :param tag: 用于记录值的标识标签

  • log_scalars –

    :param tag: 用于记录值的标识标签

属性

源文件 llmcompressor/metrics/logger.py 
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
703
704
705
706
707
708
709
710
711
def __init__(
    self,
    lambda_func: Callable[
        [
            str | None,
            float | None,
            dict[str, float] | None,
            int | None,
            float | None,
        ],
        bool,
    ]
    | None = None,
    python: bool = False,
    python_log_level: int | str | None = "INFO",
    tensorboard: bool | str | SummaryWriter = None,
    wandb_: bool | dict | None = 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]

返回

  • list[BaseLogger] –

    为此指标创建的指标子实例

enabled

enabled(value: bool)

参数

  • 值

    (bool) –

    为 True 时记录，否则为 False

源文件 llmcompressor/metrics/logger.py 
713
714
715
716
717
718
719
720
721
@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: int | str | None = None
)

参数

  • params

    (dict) –

    字典中的每个键值对是超参数的名称及其对应的值。

源文件 llmcompressor/metrics/logger.py 
730
731
732
733
734
735
736
def log_hyperparams(self, params: dict, level: int | str | None = 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: int | None = None,
    wall_time: float | None = None,
    level: int | str | None = None,
)

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    (float) –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集该值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集值时的全局墙上时间，默认为 time.time()

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

源文件 llmcompressor/metrics/logger.py 
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
def log_scalar(
    self,
    tag: str,
    value: float,
    step: int | None = None,
    wall_time: float | None = None,
    level: int | str | None = 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: int | None = None,
    wall_time: float | None = None,
    level: int | str | None = None,
)

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    (dict[str, float]) –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集这些值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集这些值时的全局墙上时间，默认为 time.time()

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

源文件 llmcompressor/metrics/logger.py 
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
def log_scalars(
    self,
    tag: str,
    values: dict[str, float],
    step: int | None = None,
    wall_time: float | None = None,
    level: int | str | None = 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)

SystemLoggingWrapper

SystemLoggingWrapper(
    loggers: list[BaseLogger],
    frequency_manager: FrequencyManager,
)

Bases: LoggingWrapperBase

包装用于将字符串记录到系统的实用程序和便捷方法

方法

  • critical –

    以 CRITICAL 级别记录一个字符串消息到所有

  • debug –

    以 DEBUG 级别记录一个字符串消息到所有

  • error –

    以 ERROR 级别记录一个字符串消息到所有

  • info –

    以 INFO 级别记录一个字符串消息到所有

  • log_string –

    :param tag: 用于记录值的标识标签

  • warning –

    以 WARNING 级别记录一个字符串消息到所有

源文件 llmcompressor/metrics/logger.py 
1080
1081
1082
def __init__(self, loggers: list[BaseLogger], frequency_manager: FrequencyManager):
    self.loggers = loggers
    self._frequency_manager = frequency_manager

critical

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

以 CRITICAL 级别记录一个字符串消息到所有启用的日志记录器

参数

  • tag

    –

    用于记录字符串的标识标签

  • string

    –

    要记录的字符串

  • args

    –

    要传递给指标的其他参数，请参阅 log_string 以获取更多详细信息

  • kwargs

    –

    要传递给指标的其他参数，请参阅 log_string 以获取更多详细信息

源文件 llmcompressor/metrics/logger.py 
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
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)

以 DEBUG 级别记录一个字符串消息到所有启用的日志记录器

参数

  • tag

    –

    用于记录字符串的标识标签

  • string

    –

    要记录的字符串

  • args

    –

    要传递给指标的其他参数，请参阅 log_string 以获取更多详细信息

  • kwargs

    –

    要传递给指标的其他参数，请参阅 log_string 以获取更多详细信息

源文件 llmcompressor/metrics/logger.py 
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
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)

以 ERROR 级别记录一个字符串消息到所有启用的日志记录器

参数

  • tag

    –

    用于记录字符串的标识标签

  • string

    –

    要记录的字符串

  • args

    –

    要传递给指标的其他参数，请参阅 log_string 以获取更多详细信息

  • kwargs

    –

    要传递给指标的其他参数，请参阅 log_string 以获取更多详细信息

源文件 llmcompressor/metrics/logger.py 
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
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)

以 INFO 级别记录一个字符串消息到所有启用的日志记录器

参数

  • tag

    –

    用于记录字符串的标识标签

  • string

    –

    要记录的字符串

  • args

    –

    要传递给指标的其他参数，请参阅 log_string 以获取更多详细信息

  • kwargs

    –

    要传递给指标的其他参数，请参阅 log_string 以获取更多详细信息

源文件 llmcompressor/metrics/logger.py 
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
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: int | None = None,
    wall_time: float | None = None,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = None,
)

参数

  • tag

    (str) –

    用于记录值的标识标签

  • 值

    –

    要保存的值

  • 步骤

    (int | None, 默认值: None ) –

    采集这些值时的全局步数

  • wall_time

    (float | None, 默认值: None ) –

    采集这些值时的全局墙上时间

  • 级别

    (int | str | None, default: None ) –

    日志消息的最低严重性级别

  • kwargs

    –

    其他日志参数，用于支持 Python 和自定义日志记录器

返回

  • –

    如果记录成功，则为 True，否则为 False。

源文件 llmcompressor/metrics/logger.py 
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
def log_string(
    self,
    tag: str,
    string: str,
    step: int | None = None,
    wall_time: float | None = None,
    log_types: str | list[str] = ALL_TOKEN,
    level: int | str | None = 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)

以 WARNING 级别记录一个字符串消息到所有启用的日志记录器

参数

  • tag

    –

    用于记录字符串的标识标签

  • string

    –

    要记录的字符串

  • args

    –

    要传递给指标的其他参数，请参阅 log_string 以获取更多详细信息

  • kwargs

    –

    要传递给指标的其他参数，请参阅 log_string 以获取更多详细信息

源文件 llmcompressor/metrics/logger.py 
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
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

修饰器指标，负责将值输出到 TensorBoard 日志目录，以便在 TensorBoard 中查看。

参数

  • log_path

    (str, default: None ) –

    用于创建 SummaryWriter 的路径。如果未提供，则必须将 writer 设置为 None。如果未提供（且 writer 为 None），则会在当前工作目录中创建一个 TensorBoard 目录。

  • writer

    (SummaryWriter, default: None ) –

    用于记录结果的 writer，如果未提供，则创建一个新的 writer，位于 log_path。

  • 名称

    (str, default: 'tensorboard' ) –

    用于标识指标的名称；默认为 tensorboard

  • enabled

    (bool, 默认值: True ) –

    为 True 时记录，否则为 False

方法

  • available –

    :return: 如果 tensorboard 可用且已安装，则返回 True，否则返回 False

属性

  • writer (SummaryWriter) –

    :return: 用于记录结果的 writer，

源文件 llmcompressor/metrics/logger.py 
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
490
491
492
493
494
495
496
497
498
499
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

返回

  • SummaryWriter –

    用于记录结果的 writer，如果未提供，则创建一个新的 writer，位于 log_path。

available staticmethod 

available() -> bool

返回

  • bool –

    如果 tensorboard 可用且已安装，则返回 True，否则返回 False

源文件 llmcompressor/metrics/logger.py 
501
502
503
504
505
506
@staticmethod
def available() -> bool:
    """
    :return: True if tensorboard is available and installed, False, otherwise
    """
    return not tensorboard_import_error

WANDBLogger

WANDBLogger(
    init_kwargs: dict | None = None,
    name: str = "wandb",
    enabled: bool = True,
    wandb_err: Exception | None = wandb_err,
)

Bases: LambdaLogger

修饰器指标，负责将值输出到 Weights and Biases。

参数

  • init_kwargs

    (dict | None, default: None ) –

    调用 wandb.init 的参数；例如：wandb.init(**init_kwargs)。如果未提供，则不会调用 init。

  • 名称

    (str, default: 'wandb' ) –

    用于标识指标的名称；默认为 wandb

  • enabled

    (bool, 默认值: True ) –

    为 True 时记录，否则为 False

方法

  • available –

    :return: 如果 wandb 可用且已安装，则返回 True，否则返回 False

  • save –

    :param file_path: 要保存的文件路径

源文件 llmcompressor/metrics/logger.py 
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
def __init__(
    self,
    init_kwargs: dict | None = None,
    name: str = "wandb",
    enabled: bool = True,
    wandb_err: Exception | None = 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

返回

  • bool –

    如果 wandb 可用且已安装，则返回 True，否则返回 False

源文件 llmcompressor/metrics/logger.py 
549
550
551
552
553
554
@staticmethod
def available() -> bool:
    """
    :return: True if wandb is available and installed, False, otherwise
    """
    return wandb_available

save

save(file_path: str) -> bool

参数

  • 文件路径

    (str) –

    要保存的文件路径

源文件 llmcompressor/metrics/logger.py 
614
615
616
617
618
619
620
621
622
def save(
    self,
    file_path: str,
) -> bool:
    """
    :param file_path: path to a file to be saved
    """
    wandb.save(file_path)
    return True