Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· OpenAIAi2 WildChat-4.8M (AI2)

findtiedparameters(model)函数解析

  1. User

    find_tied_parameters(model)函数解析

  2. Assistant

    find_tied_parameters 函数的功能是在神经网络模型中查找被“绑定”或“共享”的参数。参数被“绑”或“共享”的意思是,两个或多个网络层使用相同的参数,即这些层的参数在内存中是相同的对象。这种参数共享是实现某些网络架构的关键技术之一,比如在循环神经网络(RNNs)或某些自注意力模型中非常常见。共享参数可以减少模型的总参数数量,有助于减轻过拟合并减少内存占用。

    然而,并没有一个标准库函数叫做 find_tied_parameters。根据你的描述,这个函数很可能是一个定制函数,用于遍历模型的参数并找出哪些参数是通过某种方式共享的。因为不同的框架(如PyTorch、TensorFlow等)对模型和参数的管理方式有所不同,所以具体的实现细节会因框架而异。

    以下是一个在PyTorch中实现查找共享参数的基本方法。注意,这只是一个示例,具体实现可能会因需求而变化:

    import torch
    import torch.nn as nn
    
    def find_tied_parameters(model):
        seen = set()
        shared = []
    
        for name, param in model.named_parameters():
            # 如果参数已经看过了,则它可能是共享的
            if param in seen:
                shared.append(name)
            else:
                seen.add(param)
    
        return shared
    
    # 示例模型
    class SharedLinearModel(nn.Module):
        def __init__(self):
            super(SharedLinearModel, self).__init__()
            self.linear1 = nn.Linear(10, 10)
            # 共享linear1的参数
            self.linear2 = self.linear1
    
    model = SharedLinearModel()
    tied_parameters = find_tied_parameters(model)
    print("Tied (shared) parameters:", tied_parameters)
    

    在这个示例中,find_tied_parameters函数通过追踪是否有多个层引用了相同的参数对象来确定哪些参数是共享的。我们构造了一个简单的模型,其中linear2层直接使用linear1层的参数,模拟参数共享的情况。此函数在实际应用中可能要复杂得多,尤其是在处理更复杂的网络结构时。

    要注意的是,这个函数假设你的模型已经初始化并且可能已经有一些参数被共享。它不会修改模型或其参数,只是帮助你了解模型中哪些参数是共享的,这可以用于调试或模型分析目的。

  3. User

    tied weight在模型中的作用】

  4. Assistant

    在神经网络模型中,使用"tied weights"(或权重共享)是一种减小模型大小、降低过拟合风险并提高模型训练效率的有效方法。权重共享指的是在模型的不同部分使用相同的权重,而不是为每部分单独学习一套参数。这种技术在多种网络架构中都有应用,下面是一些主要的用途和好处:

    自编码器(Autoencoders)

    自编码器是一种用于数据编码的神经网络,由编码器(encoder)和解码器(decoder)两部分组成。编码器负责将输入数据转换为一个更低维度的表示,而解码器则将这个表示恢复成原始数据。在某些自编码器的变体中,解码器的权重是编码器权重的转置,这种情况下就用到了权重共享(tied weights)。这样做不仅减少了模型的总参数数量,也提供了一种正则化形式,可以帮助模型学到更有用的数据表示。

    循环神经网络(RNNs)

    循环神经网络通过在序列的每个时间点复用相同的网络权重来处理序列数据,这本质上也是一种权重共享。在这种情况下,权重共享有助于模型泛化到不同长度的序列,并降低模型复杂性。

    卷积神经网络(CNNs)

    在卷积神经网络中,卷积核(或滤波器)在整个输入图像上移动以捕获局部特征,这些卷积核的权重在不同的位置上是共享的。这使得CNN非常适合处理图像数据,因为图像的一些基本特性(如边缘或角落)可以在图像的任何部分出现。权重共享让CNN能够用相对较少的参数处理大型图像,减少了训练成本并提高了模型的泛化能力。

    优点

    • 减少参数数量:权重共享显著减少了模型的参数数量,从而减少了存储需求和计算成本。
    • 防止过拟合:减少参数的另一个重要好处是减轻了过拟合的风险,使模型更容易泛化到未见过的数据。
    • 增强泛化能力:通过强制模型在多个位置或场景中使用相同的参数,权重共享能够帮助模型学习到更通用的特征表示。

    总结

    在设计神经网络模型时,权重共享是一种强大而灵活的工具,能够提高模型效率、减小大小并提升泛化性能。通过恰当地使用权重共享,可以构建出既高效又强大的深度学习模型。

  5. User

    tied weight代码举例

  6. Assistant

    为了展示在神经网络中如何实现tied weights(权重共享),我们可以使用PyTorch框架来构建一个简单的线性自编码器,其中解码器的权重是编码器权重的转置。这个例子会非常直观地展示tied weights的概念。

    首先,我们定义一个带有一个隐藏层的线性自编码器。在编码器部分,我们将输入数据降维到一个低维空间;在解码器部分,我们再将这个低维表示恢复为原始数据的维度。通过使解码器的权重为编码器权重的转置(即实现权重共享),我们可以减少模型的参数量,同时约束模型学习到更加有意义的数据表示。

    以下是具体的实现代码:

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    class TiedAutoencoder(nn.Module):
        def __init__(self, input_size, hidden_size):
            super(TiedAutoencoder, self).__init__()
            
            # 编码器部分
            self.encoder = nn.Linear(input_size, hidden_size)
            # 注意:解码器将使用编码器权重的转置,因此我们不需要为解码器定义新的权重
    
        def forward(self, x):
            # 编码
            encoded = F.relu(self.encoder(x))
            # 解码;使用编码器的权重(转置)
            decoded = F.linear(encoded, self.encoder.weight.t())
            return decoded
    
    # 定义模型参数
    input_size = 784  # 假设我们处理的是28x28的扁平化图像(如MNIST数据集)
    hidden_size = 128  # 隐藏层大小
    
    # 创建模型实例
    model = TiedAutoencoder(input_size=input_size, hidden_size=hidden_size)
    
    print(model)
    

    在这个模型中,encoder有它自己的权重和偏置,但是解码器直接使用encoder权重的转置来进行其操作,而没有单独的权重参数。这意味着编码器和解码器之间的权重是绑定(tied)的。这样的自编码器比起有独立权重的自编码器来说参数更少,从而更容易训练,同时也能够更有效地学习数据的低维有效表示。

    要注意,此代码示例仅为了展示如何在PyTorch中实现tied weights,并未包含训练逻辑和数据加载部分。实际应用中,还需要编写相应的数据加载、模型训练和评估代码。

  7. User

    no_init_weights(_enable=_fast_init)代码解析

  8. Assistant

    基于您提供的上下文,no_init_weights(_enable=_fast_init) 看起来像是一个专门设计的函数或方法,可能用于控制在某些情况下初始化神经网络权重的行为。但是,需要注意的是,这不是一个通用或广泛认可的Python、PyTorch、TensorFlow等主流深度学习框架中的函数。由于缺少直接的上下文和来源信息,我将提供一个一般性的解释和一个如何实现类似功能的示例。

    在深度学习模型中,权重初始化对于模型训练的成功至关重要。不同的初始化方法可能会导致模型训练的巨大差异。有时,在某些特定情况下,您可能希望暂时禁用自动权重初始化的过程,可能是因为您想手动设置权重,或者因为您正在使用一种特定的预训练模型,其中权重已经初始化。

    核心概念

    • 权重初始化:是指在训练深度学习模型之前,为模型中的每个参数(权重和偏置)设置初始值的过程。

    • 快速初始化:某些情况下可能希望快速地初始化模型,为权重设置一些简单的值(如全部为零),或者使用某种特殊模式,这通常用于测试或特定场景。

    模拟 no_init_weights 实现

    假设我们使用 PyTorch,并希望实现一种方法,允许我们控制模型的权重初始化。下面的代码是一个概念性的示例,说明如何定义这样的功能。

    import torch
    import torch.nn as nn
    
    class MyModel(nn.Module):
        def __init__(self, _enable_fast_init=False):
            super(MyModel, self).__init__()
            self._enable_fast_init = _enable_fast_init
            self.layer1 = nn.Linear(100, 50)
            self.layer2 = nn.Linear(50, 10)
            
            if not self._enable_fast_init:
                self.init_weights()
            else:
                self.fast_init_weights()
    
        def init_weights(self):
            for m in self.modules():
                if isinstance(m, nn.Linear):
                    nn.init.normal_(m.weight, mean=0.0, std=0.02)
                    nn.init.constant_(m.bias, 0)
                    
        def fast_init_weights(self):
            for m in self.modules():
                if isinstance(m, nn.Linear):
                    nn.init.constant_(m.weight, 0.0)  # 快速初始化为 0
                    nn.init.constant_(m.bias, 0)
    
    model = MyModel(_enable_fast_init=True)
    

    在这个例子中,MyModel 类接受一个参数 _enable_fast_init。如果这个参数为 True,模型将使用 fast_init_weights 方法来初始化权重,这里我们假设快速初始化就是将所有权重设置为 0。如果 _enable_fast_init 为 False,则使用更标准的 init_weights 方法,这里假设使用正态分布来初始化权重。

    这只是一个基础的例子,实际使用中,权重初始化的策略可以根据需要进行更复杂的定制。此外,没有直接的 no_init_weights 函数示例,因为这种具体实现会依赖于使用的框架和特定的模型设计需求。

  9. User

    bnb.nn.Linear8bitLt()函数解析

  10. Assistant

    截至我最后的更新(2023年),bnb.nn.Linear8bitLt() 函数并不是Python标准库、PyTorch、TensorFlow或其他主流深度学习框架的一部分。根据命名约定,这个函数似乎来自一个特定的、可能是定制的库或框架,bnb 很可能是库的命名空间,而这个函数本身看起来像是执行某种8位线性变换的操作。

    可能的解释

    虽然缺乏具体的上下文,但根据函数的命名,我们可以进行一些合理的推测:

    1. 8-bit Quantization: Linear8bit 部分暗示这个函数可能在实现权重和激活的8位量化。在深度学习中,量化是一种降低模型大小和加速推理的技术,它通过减少模型参数的位宽来实现。具体到8位量化,这意味着模型的权重、偏置和激活值被量化成8位整数,这通常有助于在不牺牲太多精度的情况下减少计算资源需求。

    2. Linear Layer Transformation: 从 Linear 可以推测,这个函数可能是一个线性层(或全连接层)的变种,它在内部执行标准的线性变换(y = Wx + b),其中 W 是权重矩阵,x 是输入向量,b 是偏置向量。不过,它是以一种特殊的8位精度来执行这一计算的。

    3. Lt Suffix: Lt 后缀的含义不太清楚,可能是作者用来指明这个特定版本或实现的线性层有某些特性或用途。它可能表示“低精度”、“轻量级”或特定的技术名称。

    示例与类似函数

    虽然不能直接提供bnb.nn.Linear8bitLt()的确切代码(因为它很可能是特定库的一部分),但我们可以提供一个类似概念的简单例子来演示8位量化的线性层可能长什么样,在PyTorch中:

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    class Linear8bit(nn.Module):
        def __init__(self, in_features, out_features):
            super(Linear8bit, self).__init__()
            # 初始化权重和偏置,这里还是以float32存储
            self.weight = nn.Parameter(torch.randn(out_features, in_features))
            self.bias = nn.Parameter(torch.randn(out_features))
        
        def forward(self, x):
            # 模拟量化过程,这里的量化实现很简单且不实用,仅为演示
            weight_q = torch.clamp((self.weight * 127).round(), min=-128, max=127) / 127.0
            bias_q = torch.clamp((self.bias * 127).round(), min=-128, max=127) / 127.0
            # 执行线性变换
            return F.linear(x, weight_q, bias_q)
    
    # 使用示例
    linear = Linear8bit(in_features=10, out_features=5)
    input = torch.randn(1, 10)
    output = linear(input)
    

    这个示例仅仅是为了演示如何在没有特定库支持的情况下,手动实现一个简化版本的8位量化线性层。实际应用中的量化通常更加复杂,需要更细致的操作,可能包括量化参数的校准步骤、跟踪量化误差等。如果你在使用的是某个特定的库或框架,我建议查阅该库的文档或源代码以获取Linear8bitLt具体实现的详细信息。

  11. User

    AlignDevicesHook(io_same_device=True)函数在大模型中的作用解析

  12. Assistant

    AlignDevicesHook(io_same_device=True) 看起来像是一个特定框架或库中的配置函数或方法,用于控制大规模深度学习模型训练过程中的设备对齐行为。由于这不是一个通用的、广泛认识的函数(截至2023年),我将依据函数名提供一个推测性的解释。

    在大规模模型训练、特别是分布式训练环境中,设备对齐是一个重要的概念。它涉及确保数据、计算任务和模型参数在多个处理单元(如CPU、GPU或TPU)之间正确、高效地分配和同步。

    设备对齐(Device Alignment)

    • 在深度学习训练过程中,尤其是在使用多个设备(如多个GPU)进行模型训练时,确保操作和数据在各个设备上正确对齐是至关重要的。
    • 设备对齐包括但不限于确保输入输出(I/O)操作在期望的设备上执行,参数和中间计算结果在适当的设备上同步,以及计算任务高效负载均衡等。

    解析函数 AlignDevicesHook(io_same_device=True)

    • AlignDevicesHook 根据名称推测,可能是一个配置钩子(hook)或回调,专门设计用于处理设备对齐相关的配置或自动化。

    • 参数 io_same_device=True 暗示这个钩子或回调的行为会确保输入/输出(I/O)操作在同一个设备上进行。这在某些情况下可以提高数据处理的效率,减少数据在不同设备或计算节点之间传输的开销。特别是在处理极大规模的模型和数据集时,减少设备间的数据转移可以显著地提升整体训练速度和效率。

    应用场景

    • 在分布式训练场景下,这种设备对齐的钩子可能被用于优化数据流动,确保训练过程中的数据传输和处理尽可能高效。
    • 对于需要大量数据交换的模型,如大规模的自然语言处理(NLP)模型,翻译模型或图像生成模型(GPT系列、BERT系列、CNN变体等),合理的设备对齐策略能够提高速度和降低延迟。

    结论

    虽然没有对特定框架或库的直接参考,AlignDevicesHook(io_same_device=True) 的推测功能点出了在高性能、大规模深度学习训练任务中优化设备使用策略的重要性。真实的函数或方法可能具有更多的选项和配置,用于针对不同的训练和模型需求调整设备对齐行为。如果你正在使用一个具有此功能的框架,查阅特定文档会提供更准确的细节和最佳实践。

  13. User

    AlignDevicesHook()函数在llama中的作用

  14. Assistant

    截至目前(2023年),AlignDevicesHook() 函数在 LLaMA (Large Language Model – Meta AI) 或相关上下文中的直接文档或公共源代码提及可能有限,特别是考虑到LLaMA是由Meta AI(原Facebook AI)发布的一系列大型语言模型。不过,考虑到钩子(Hook)模式在深度学习训练流程中的作用,我可以提供一种通用的解释,这也可能适用于LLaMA或类似的大型模型框架。

    钩子(Hooks)的一般作用

    在深度学习框架中(如PyTorch、TensorFlow等),钩子是一种高级特性,允许用户在训练的特定阶段插入自定义操作,例如在每个epoch开始、每次迭代后、梯度更新前后等。这允许进行日志记录、自定义梯度操作(如梯度剪切或梯度规范化)、动态学习率调整等。因此,AlignDevicesHook() 函数可能是一个为了确保模型训练过程中的设备对齐而设计的钩子。

    设备对齐在大型模型训练中的作用

    在用于训练大型模型(如LLaMA等语言模型)的设置中,确保计算资源(如CPU、GPU)使用高效对齐是非常重要的,尤其是在分布式训练环境中。正确地对齐设备可以:

    • 减少训练中的通信开销。
    • 提高数据加载和处理的效率。
    • 优化并行计算任务的执行。

    设备对齐可能包括确保模型参数、输入输出数据和中间状态在预期的设备上(通常是特定的GPU或TPU)。这样可以避免不必要的数据传输,从而加速训练过程。

    AlignDevicesHook() 的可能用途

    虽然没有具体的AlignDevicesHook()实现细节,但根据函数名和深度学习训练的常见需求,我们可以假设AlignDevicesHook() 可能具有如下作用:

    • 自动设备对齐:自动调整数据和模型参数,使其在分布式训练环境中正确地分配到指定的设备上。
    • 优化数据流:在数据加载和预处理阶段,确保数据流动(从磁盘到CPU,然后到GPU)尽可能高效,减少I/O瓶颈。
    • 性能调优:在模型训练过程中,根据资源可用性和计算需求动态调整设备使用策略,以优化整体训练性能。

    在实际应用中,AlignDevicesHook() 的具体实现和用途可能会依据使用的具体框架、库版本和训练配置有所不同。考虑到LLaMA模型和相关训练工具可能被设计用于在高度优化和可能是定制化的分布式系统上运行,这种类型的钩子可以提供关键的性能优化和资源管理能力。如果你在一个具体的项目或框架中遇到了AlignDevicesHook(),查阅该项目或框架的官方文档或源码注释将提供更准确和详细的信息。

  15. User

    AlignDevicesHook()类在llama中的作用

  16. Assistant

    截至目前的知识更新(2023年),AlignDevicesHook() 类在官方的LLaMA (Large Language Model by Meta AI) 文档或公共资源中没有特定的说明或引用。这可能意味着你所提到的 AlignDevicesHook() 类是特定于一个定制实现、第三方库,或者是某个特殊版本的LLaMA模型训练工具中的部分,而不是广泛认知的、标准的工具或方法。

    然而,基于钩子(Hooks)在深度学习和模型训练框架中的一般作用,以及你的问题背景,我们可以推断 AlignDevicesHook() 类可能是用于在使用LLaMA模型或其他大型语言模型进行训练时管理和优化设备(如GPU或TPU)的使用。

    可能的作用和目的:

    1. 设备对齐和优化:

      • 在分布式训练环境中,确保所有的计算任务和数据处理过程都在适当的设备上执行是至关重要的,AlignDevicesHook() 可能就是用于这种设备间的任务对齐和优化。
      • 可能涉及在模型训练前配置设备使用策略,如指定特定的GPU/TPU用于特定的训练任务,或者确保数据加载和预处理在正确的设备上执行以避免不必要的数据传输。
    2. 性能提升:

      • 通过确保计算资源的高效使用,AlignDevicesHook() 可能有助于提升模型训练的速度和整体效率。这对于需要大量计算资源的大型语言模型尤其重要。
    3. 资源管理:

      • 管理高性能计算资源在大规模训练作业中非常关键,AlignDevicesHook() 可能帮助用户或系统自动管理资源,如动态分配和回收GPU资源,或者调整任务负载以匹配设备能力。

    由于缺乏具体的上下文或详细文档引用,以上内容主要基于对钩子作用的一般理解和在深度学习框架中对设备管理的通常需求。实际的 AlignDevicesHook() 类可能包含更具体的功能和设置。

    建议的后续步骤:

    • 查阅文档:如果AlignDevicesHook() 是部分特定框架、库或工具的一部分,请尽可能查找该工具的官方文档或源代码,以获得最准确的信息。

    • 社区和源码:如果AlignDevicesHook() 属于开源项目,GitHub等平台上的源代码和讨论区是获取更多信息和使用样例的好地方。

    • 专业论坛和社群:深度学习和机器学习社群(如Reddit的r/MachineLearning、Stack Overflow和专门的AI论坛)可能有更多用户或开发者分享使用或实现AlignDevicesHook() 的经验。

  17. User

    AlignDevicesHook()对齐钩子在大模型中的作用

  18. Assistant

    截至目前,AlignDevicesHook() 直接的具体信息和用途不是公共知识内的一个常见组件,尤其是在主流的深度学习框架和大模型工作流中。没有具体文献或官方框架文档直接描述这个名称的钩子。然而,基于名称和深度学习中常见的最佳实践,我们可以从一般性的角度推测其潜在的作用和目的,尤其是在大规模模型如LLaMA等的训练和部署环境中。

    设备对齐的一般意义

    在大规模深度学习模型的训练和推理中,尤其是使用了多GPU或多TPU等分布式计算资源的情形下,确保计算任务、数据流、和模型参数在不同设备间高效、正确地分配和同步是非常关键的。

    “对齐”钩子(如假设名为AlignDevicesHook())可能被设计来自动处理某些与设备对齐相关的任务,比如:

    • 确保数据和模型的对齐:自动将数据批次、模型参数等在训练或推理过程中正确地分配到指定的设备上。这能减少设备间的通信延迟,提高总体计算效率。
    • 优化内存使用:通过合理地分配任务和数据,最大化每个设备的内存和计算资源的使用效率,尤其是在资源有限的环境下。
    • 减少数据迁移:在多设备环境下,数据需要从CPU内存移动到GPU内存中,不当的数据移动会产生额外的开销。合理的对齐策略可以减少这种开销,尤其是在训练大规模数据集时。
    • 动态调整:在训练过程中,根据模型的训练状态和设备的运行状态,动态调整数据和任务的分配,从而优化性能和资源利用率。

    在大模型工作流中的具体应用

    对于特别设计来处理大型语言模型(如GPT、BERT、LLaMA等)的AlignDevicesHook()或类似功能,可能还包括了一些额外的特定逻辑来处理这些模型特有的挑战,比如:

    • 处理大量的模型参数,可能会涉及参数分片(Sharding)和跨设备的参数同步机制。
    • 在模型并行(Model Parallelism)设置中,确保层与层之间或模块与模块之间的数据流正确无误地进行跨设备计算。
    • 在数据并行(Data Parallelism)场景下,协助同步模型更新或梯度,确保所有设备的模型保持一致。

    结论

    虽然对于名为AlignDevicesHook()的具体实例或功能的详细描述在公开信息中可能尚不明确,其命名和深度学习中的相关概念表明,这可能是一个设计用于优化和管理在分布式训练或推理环境中多设备上的任务、数据和模型参数对齐的工具或方法。在实践中,各种深度学习框架和工具包可能通过不同的接口和机制提供了解决这一问题的能力,理解这些概念有助于在构建和优化大规模深学习系统时做出更好的决策。

  19. User

    实例解析Accelerate向模型添加hooks

  20. Assistant

    截至最后更新(2023年),Accelerate 是由Hugging Face推出的一个库,旨在简化深度学习模型尤其是在PyTorch中的分布式训练和推理过程。Accelerate 库提供了一套易于使用的接口,使得无论是在CPU、单GPU、多GPU还是TPU环境下,开发者都能够以相同的代码执行模型的训练和推理,极大地降低了处理不同训练环境下的复杂性。

    在深度学习中,"hooks"(钩子)是一种强大的机制,它可以让我们在模型的训练过程中的特定阶段插入或执行某些自定义的操作或逻辑,例如在正向传播前后、反向传播前后等,而不需要修改模型的内部实现。

    向模型添加Hooks

    虽然Accelerate库主要关注于简化分布式训练的配置和执行,使用Accelerate时添加hooks的过程基本遵循PyTorch中添加hooks的标准方式。在PyTorch中,可以在任何nn.Module实例上注册前向或后向hooks,以下是一些基本的示例:

    添加前向传播的Hook

    import torch
    
    def forward_pre_hook(module, input):
        print("Before forward pass")
    
    def forward_hook(module, input, output):
        print("After forward pass")
    
    model = torch.nn.Linear(10, 5)
    model.register_forward_pre_hook(forward_pre_hook)
    model.register_forward_hook(forward_hook)
    
    x = torch.randn(1, 10)
    output = model(x)
    

    添加后向传播的Hook

    def backward_hook(module, grad_input, grad_output):
        print("During backward pass")
    
    model.register_backward_hook(backward_hook)
    # 向后的钩子需要在反向传播时被触发,所以你需要确保有梯度回传
    output.sum().backward()
    

    在Accelerate中应用Hooks

    使用Accelerate并不改变上述添加hooks的方式。Accelerate处理的是分布式环境配置、加速器选择等,而你仍然可以按照标准PyTorch的方式对你的模型添加hooks。不过,当在训练和开发大模型时,特别是利用Accelerate进行分布式训练时,需要确保你添加的hooks操作是分布式"友好"的,意味着它们的操作不会干扰不同设备间的同步或数据传输。

    例如,如果你在hook中输出一些日志,这个操作通常是分布式友好的,因为它不会修改任何参与计算的数据。但如果你的hook改变了梯度或其他参与反向传播的数据,你就需要谨慎确保这种改变能够在整个分布式系统中一致地执行。

    结论

    Accelerate简化了分布式和加速训练的配置,但添加模型hooks的方式仍然遵循PyTorch的标准实践。重要的是,当在分布式训练环境中工作时,确保你的hooks实现是分布式环境友好的。