离群点检测算法——LOF(Local Outlier Factor)

异常检测算法之LOF 前言: LOF:Local outlier factor,即局部异常因子。LOF主要是通过比较每个点p和其邻域点的密度来判断该点是否为异常点,如果点p的密度越低,越可能被认定是异常点。至于密度,是通过点之间的距离来计算的,点之间距离越远,密度越低,距离越近,密度越高,完全符合我们的理解。而且,因为lof对密度的计算是通过点的k邻域来计算,而不是全局计算,因此得名为“局部”异常因子。即LOF是基于密度分析,通过局部的数据密度来检测异常。 原理 LOF算法,是基于密度的离群点检测方法中一个比较有代表性的算法。该 阅读详情

异常检测

异常检测的实质是寻找观测值和参照值之间有意义的偏差。数据库中的数据由于各种原因常常会包含一些异常记录,对这些异常记录的检测和解释有很重要的意义。异常检测目前在入侵检测、金融欺诈、股票分析等领域都有着比较好的实际应用效果。
离群点检测是异常检测中最常用的方法之一。离群点检测的主要目的是为了检测出那些与正常数据行为或特征属性差别较大的异常数据或行为,在一些文献中,这些数据和行为又被叫做孤立点、噪音、异常点或离群点,这些叫法中离群点的叫法较为普遍。

离群点检测算法分类

总的来说,目前主要的离群点检测技术包括:基于统计的离群检测方法、基于聚类的离群检测方法、基于分类的离群检测方法、基于距离的离群检测方法、基于密度的离群检测方法和基于信息熵的离群检测方法。
而LOF算法就是基于距离的离群检测方法之一。

LOF简介

LOF算法(Local Outlier Factor),全称又叫局部异常因子,是一种基于距离的异常点检测算法。
用视觉直观的感受一下,如下图,对于 C 1 C_1 C1​集合的点,整体间距、密度、分散情况较为均匀一致,可以认为是同一簇;对于 C 2 C_2 C2​集合的点,同样可认为是一簇。 o 1 、 o 2 o_1、o_2 o1​、o2​点相对孤立,可以认为是异常点或离散点。现在的问题是,如何实现算法的通用性,可以满足 C 1 C_1 C1​和 C 2 C_2 C2​这种密度分散情况迥异的集合的异常点识别。LOF可以实现我们的目标。
在这里插入图片描述
下面介绍LOF算法的重要概念:
1) d ( p , o ) d(p,o) d(p,o): p p p和 o o o两点之间的距离;
2) k − d i s t a n c e k-distance k−distance:第 k k k距离;
对于点 p p p的第 k k k距离 d k ( p ) d_k(p) dk​(p)定义如下: d k ( p ) = d ( p , o ) d_k(p)=d(p,o) dk​(p)=d(p,o),并且满足:
a)在集合中至少有不包括 p p p在内的 k k k个点 o ′ ∈ C { x ≠ p } , 满 足 d ( p , o ′ ) ≤ d ( p , o ) {o}'\in C\{x\ne p\},满足d(p,{o}')\le d(p,o) o′∈C{x̸​=p},满足d(p,o′)≤d(p,o);
b)在集合中最多有不包括 p p p在内的 k − 1 k−1 k−1个点 o ′ ∈ C { x ≠ p } , 满 足 d ( p , o ′ ) &lt; d ( p , o ) {o}&#x27;\in C\{x\ne p\},满足d(p,{o}&#x27;)&lt; d(p,o) o′∈C{x̸​=p},满足d(p,o′)<d(p,o);
p p p的第 k k k距离,也就是距离 p p p第 k k k远的点的距离,不包括 p p p,如图
在这里插入图片描述
3) k − d i s t a n c e k-distance k−distance n e i g h b o r h o o d neighborhood neighborhood o f of of p p p:第 k k k距离邻域
点 p p p的第 k k k距离邻域 N k ( p ) N_k(p) Nk​(p),就是 p p p的第 k k k距离即以内的所有点,包括第 k k k距离。因此 p p p的第 k k k邻域点的个数 ∣ N k ( p ) ∣ ≥ k |{{N}_{k}}(p)|\ge k ∣Nk​(p)∣≥k。
4) r e a c h reach reach d i s t a n c e distance distance:可达距离
点 o o o到点 p p p的第 k k k可达距离定义为:
r e a c h − d i s t a n c e k ( p , o ) = m a x { k − d i s tan ⁡ c e ( o ) , d ( p , o ) } reach-distance_k(p,o)=max \{k-dis\tan ce(o),d(p,o)\} reach−distancek​(p,o)=max{k−distance(o),d(p,o)}
也就是,点 o o o到点 p p p的第 k k k可达距离,至少是 o o o的第 k k k距离,或者为 o 、 p o、p o、p间的真实距离。这也意味着,离点 o o o最近的 k k k个点, o o o到他们的可达距离被认为相等,且都等于 d k ( o ) d_k(o) dk​(o)。如图, o 1 o_1 o1​到 p p p的第5可达距离为 d ( p , o 1 ) d(p,o_1) d(p,o1​), o 2 o_2 o2​到 p p p的第5可达距离为 d 5 ( o 2 ) d_5(o_2) d5​(o2​)。
在这里插入图片描述
5) l o c a l local local r e a c h a b i l i t y reachability reachability d e n s i t y density density:局部可达密度
点 p p p的局部可达密度表示为:
l r d k ( p ) = 1 / ( ∑ o ∈ N k ( p ) r e a c h − d i s t k ( p , o ) ∣ N k ( p ) ∣ ) lr{{d}_{k}}(p)=1/(\frac{\sum\nolimits_{o\in {{N}_{k}}(p)}{reach-dis{{t}_{k}}(p,o)}}{|{{N}_{k}}(p)|}) lrdk​(p)=1/(∣Nk​(p)∣∑o∈Nk​(p)​reach−distk​(p,o)​)
表示点 p p p的第 k k k邻域内点到 p p p的平均可达距离的倒数。
注意,是 p p p的邻域点 N k ( p ) N_k(p) Nk​(p)到 p p p的可达距离,不是 p p p到 N k ( p ) N_k(p) Nk​(p)的可达距离,一定要弄清楚关系。
这个值的含义可以这样理解,首先这代表一个密度,密度越高,我们认为越可能属于同一簇,密度越低,越可能是离群点。如果 p p p和周围邻域点是同一簇,那么可达距离越可能为较小的 d k ( o ) d_k(o) dk​(o),导致可达距离之和较小,密度值较高;如果 p p p和周围邻居点较远,那么可达距离可能都会取较大值 d p ( o ) d_p(o) dp​(o),导致密度较小,越可能是离群点。
6) l o c a l local local o u t l i e r outlier outlier o u t l i e r outlier outlier:局部离群因子
点 p p p的局部离群因子表示为:
L O F k ( p ) = ∑ o ∈ N k ( p ) l r d k ( o ) l r d k ( p ) ∣ N k ( p ) ∣ = ∑ o ∈ N k ( p ) l r d k ( o ) ∣ N k ( p ) ∣ / l r d k ( p ) LO{{F}_{k}}(p)=\frac{\sum\nolimits_{o\in {{N}_{k}}(p)}{\frac{lr{{d}_{k}}(o)}{lr{{d}_{k}}(p)}}}{|{{N}_{k}}(p)|}=\frac{\sum\nolimits_{o\in {{N}_{k}}(p)}{lr{{d}_{k}}(o)}}{|{{N}_{k}}(p)|}/lr{{d}_{k}}(p) LOFk​(p)=∣Nk​(p)∣∑o∈Nk​(p)​lrdk​(p)lrdk​(o)​​=∣Nk​(p)∣∑o∈Nk​(p)​lrdk​(o)​/lrdk​(p)
表示点 p p p的邻域点 N k ( p ) N_k(p) Nk​(p)的局部可达密度与点 p p p的局部可达密度之比的平均数。
如果这个比值越接近1,说明 p p p的其邻域点密度差不多, p p p可能和邻域同属一簇;如果这个比值越小于1,说明 p p p的密度高于其邻域点密度, p p p为密集点;如果这个比值越大于1,说明 p p p的密度小于其邻域点密度, p p p越可能是异常点。

小结

现在概念定义已经介绍完了,现在再回过头来看一下LOF的思想,主要是通过比较每个点 p p p和其邻域点的密度来判断该点是否为异常点,如果点 p p p的密度越低,越可能被认定是异常点。至于密度,是通过点之间的距离来计算的,点之间距离越远,密度越低,距离越近,密度越高,完全符合我们的理解。而且,因为LOF对密度的是通过点的第 k k k邻域来计算,而不是全局计算,因此得名为“局部”异常因子,这样,对于图1的两种数据集 C 1 C_1 C1​和 C 2 C_2 C2​,LOF完全可以正确处理,而不会因为数据密度分散情况不同而错误的将正常点判定为异常点。

LOF算法的python实现

下述代码在python2.7中测试通过。
lof.py如下:

#!/usr/bin/python
# -*- coding: utf8 -*-
from __future__ import division

def distance_euclidean(instance1, instance2):
    """Computes the distance between two instances. Instances should be tuples of equal length.
    Returns: Euclidean distance
    Signature: ((attr_1_1, attr_1_2, ...), (attr_2_1, attr_2_2, ...)) -> float"""
    def detect_value_type(attribute):
        """Detects the value type (number or non-number).
        Returns: (value type, value casted as detected type)
        Signature: value -> (str or float type, str or float value)"""
        from numbers import Number
        attribute_type = None
        if isinstance(attribute, Number):
            attribute_type = float
            attribute = float(attribute)
        else:
            attribute_type = str
            attribute = str(attribute)
        return attribute_type, attribute
    # check if instances are of same length
    if len(instance1) != len(instance2):
        raise AttributeError("Instances have different number of arguments.")
    # init differences vector
    differences = [0] * len(instance1)
    # compute difference for each attribute and store it to differences vector
    for i, (attr1, attr2) in enumerate(zip(instance1, instance2)):
        type1, attr1 = detect_value_type(attr1)
        type2, attr2 = detect_value_type(attr2)
        # raise error is attributes are not of same data type.
        if type1 != type2:
            raise AttributeError("Instances have different data types.")
        if type1 is float:
            # compute difference for float
            differences[i] = attr1 - attr2
        else:
            # compute difference for string
            if attr1 == attr2:
                differences[i] = 0
            else:
                differences[i] = 1
    # compute RMSE (root mean squared error)
    rmse = (sum(map(lambda x: x**2, differences)) / len(differences))**0.5
    return rmse

class LOF:
    """Helper class for performing LOF computations and instances normalization."""
    def __init__(self, instances, normalize=True, distance_function=distance_euclidean):
        self.instances = instances
        self.normalize = normalize
        self.distance_function = distance_function
        if normalize:
            self.normalize_instances()

    def compute_instance_attribute_bounds(self):
        min_values = [float("inf")] * len(self.instances[0]) #n.ones(len(self.instances[0])) * n.inf 
        max_values = [float("-inf")] * len(self.instances[0]) #n.ones(len(self.instances[0])) * -1 * n.inf
        for instance in self.instances:
            min_values = tuple(map(lambda x,y: min(x,y), min_values,instance)) #n.minimum(min_values, instance)
            max_values = tuple(map(lambda x,y: max(x,y), max_values,instance)) #n.maximum(max_values, instance)
        self.max_attribute_values = max_values
        self.min_attribute_values = min_values
            
    def normalize_instances(self):
        """Normalizes the instances and stores the infromation for rescaling new instances."""
        if not hasattr(self, "max_attribute_values"):
            self.compute_instance_attribute_bounds()
        new_instances = []
        for instance in self.instances:
            new_instances.append(self.normalize_instance(instance)) # (instance - min_values) / (max_values - min_values)
        self.instances = new_instances
        
    def normalize_instance(self, instance):
        return tuple(map(lambda value,max,min: (value-min)/(max-min) if max-min > 0 else 0, 
                         instance, self.max_attribute_values, self.min_attribute_values))
        
    def local_outlier_factor(self, min_pts, instance):
        """The (local) outlier factor of instance captures the degree to which we call instance an outlier.
        min_pts is a parameter that is specifying a minimum number of instances to consider for computing LOF value.
        Returns: local outlier factor
        Signature: (int, (attr1, attr2, ...), ((attr_1_1, ...),(attr_2_1, ...), ...)) -> float"""
        if self.normalize:
            instance = self.normalize_instance(instance)
        return local_outlier_factor(min_pts, instance, self.instances, distance_function=self.distance_function)

def k_distance(k, instance, instances, distance_function=distance_euclidean):
    #TODO: implement caching
    """Computes the k-distance of instance as defined in paper. It also gatheres the set of k-distance neighbours.
    Returns: (k-distance, k-distance neighbours)
    Signature: (int, (attr1, attr2, ...), ((attr_1_1, ...),(attr_2_1, ...), ...)) -> (float, ((attr_j_1, ...),(attr_k_1, ...), ...))"""
    distances = {}
    for instance2 in instances:
        distance_value = distance_function(instance, instance2)
        if distance_value in distances:
            distances[distance_value].append(instance2)
        else:
            distances[distance_value] = [instance2]
    distances = sorted(distances.items())
    neighbours = []
    k_sero = 0
    k_dist = None
    for dist in distances:
        k_sero += len(dist[1])
        neighbours.extend(dist[1])
        k_dist = dist[0]
        if k_sero >= k:
            break
    return k_dist, neighbours

def reachability_distance(k, instance1, instance2, instances, distance_function=distance_euclidean):
    """The reachability distance of instance1 with respect to instance2.
    Returns: reachability distance
    Signature: (int, (attr_1_1, ...),(attr_2_1, ...)) -> float"""
    (k_distance_value, neighbours) = k_distance(k, instance2, instances, distance_function=distance_function)
    return max([k_distance_value, distance_function(instance1, instance2)])

def local_reachability_density(min_pts, instance, instances, **kwargs):
    """Local reachability density of instance is the inverse of the average reachability 
    distance based on the min_pts-nearest neighbors of instance.
    Returns: local reachability density
    Signature: (int, (attr1, attr2, ...), ((attr_1_1, ...),(attr_2_1, ...), ...)) -> float"""
    (k_distance_value, neighbours) = k_distance(min_pts, instance, instances, **kwargs)
    reachability_distances_array = [0]*len(neighbours) #n.zeros(len(neighbours))
    for i, neighbour in enumerate(neighbours):
        reachability_distances_array[i] = reachability_distance(min_pts, instance, neighbour, instances, **kwargs) 
    sum_reach_dist = sum(reachability_distances_array)
    if sum_reach_dist == 0:
        return float('inf')
    return len(neighbours) / sum_reach_dist

def local_outlier_factor(min_pts, instance, instances, **kwargs):
    """The (local) outlier factor of instance captures the degree to which we call instance an outlier.
    min_pts is a parameter that is specifying a minimum number of instances to consider for computing LOF value.
    Returns: local outlier factor
    Signature: (int, (attr1, attr2, ...), ((attr_1_1, ...),(attr_2_1, ...), ...)) -> float"""
    (k_distance_value, neighbours) = k_distance(min_pts, instance, instances, **kwargs)
    instance_lrd = local_reachability_density(min_pts, instance, instances, **kwargs)
    lrd_ratios_array = [0]* len(neighbours)
    for i, neighbour in enumerate(neighbours):
        instances_without_instance = set(instances)
        instances_without_instance.discard(neighbour)
        neighbour_lrd = local_reachability_density(min_pts, neighbour, instances_without_instance, **kwargs)
        lrd_ratios_array[i] = neighbour_lrd / instance_lrd
    return sum(lrd_ratios_array) / len(neighbours)

def outliers(k, instances, **kwargs):
    """Simple procedure to identify outliers in the dataset."""
    instances_value_backup = instances
    outliers = []
    for i, instance in enumerate(instances_value_backup):
        instances = list(instances_value_backup)
        instances.remove(instance)
        l = LOF(instances, **kwargs)
        value = l.local_outlier_factor(k, instance)
        if value > 1:
            outliers.append({"lof": value, "instance": instance, "index": i})
    outliers.sort(key=lambda o: o["lof"], reverse=True)
    return outliers

测试上述代码,测试脚本test_lof.py:

# -*- coding: utf8 -*-
instances = [
 (-4.8447532242074978, -5.6869538132901658),
 (1.7265577109364076, -2.5446963280374302),
 (-1.9885982441038819, 1.705719643962865),
 (-1.999050026772494, -4.0367551415711844),
 (-2.0550860126898964, -3.6247409893236426),
 (-1.4456945632547327, -3.7669258809535102),
 (-4.6676062022635554, 1.4925324371089148),
 (-3.6526420667796877, -3.5582661345085662),
 (6.4551493172954029, -0.45434966683144573),
 (-0.56730591589443669, -5.5859532963153349),
 (-5.1400897823762239, -1.3359248994019064),
 (5.2586932439960243, 0.032431285797532586),
 (6.3610915734502838, -0.99059648246991894),
 (-0.31086913190231447, -2.8352818694180644),
 (1.2288582719783967, -1.1362795178325829),
 (-0.17986204466346614, -0.32813130288006365),
 (2.2532002509929216, -0.5142311840491649),
 (-0.75397166138399296, 2.2465141276038754),
 (1.9382517648161239, -1.7276112460593251),
 (1.6809250808549676, -2.3433636210337503),
 (0.68466572523884783, 1.4374914487477481),
 (2.0032364431791514, -2.9191062023123635),
 (-1.7565895138024741, 0.96995712544043267),
 (3.3809644295064505, 6.7497121359292684),
 (-4.2764152718650896, 5.6551328734397766),
 (-3.6347215445083019, -0.85149861984875741),
 (-5.6249411288060385, -3.9251965527768755),
 (4.6033708001912093, 1.3375110154658127),
 (-0.685421751407983, -0.73115552984211407),
 (-2.3744241805625044, 1.3443896265777866)]

from lof import outliers
lof = outliers(5, instances)

for outlier in lof:
    print outlier["lof"],outlier["instance"]

from matplotlib import pyplot as p

x,y = zip(*instances)
p.scatter(x,y, 20, color="#0000FF")

for outlier in lof:
    value = outlier["lof"]
    instance = outlier["instance"]
    color = "#FF0000" if value > 1 else "#00FF00"
    p.scatter(instance[0], instance[1], color=color, s=(value-1)**2*10+20)

p.show()

输出的结果为:

2.20484969217 (3.3809644295064505, 6.749712135929268)
1.79484408482 (-4.27641527186509, 5.6551328734397766)
1.50121865848 (6.455149317295403, -0.45434966683144573)
1.47940253262 (6.361091573450284, -0.9905964824699189)
1.37216956549 (5.258693243996024, 0.032431285797532586)
1.29100195101 (4.603370800191209, 1.3375110154658127)
1.20274006333 (-4.844753224207498, -5.686953813290166)
1.18718018398 (-5.6249411288060385, -3.9251965527768755)
1.10898567816 (0.6846657252388478, 1.4374914487477481)
1.05728304007 (-4.667606202263555, 1.4925324371089148)
1.04216295935 (-5.140089782376224, -1.3359248994019064)
1.02801167935 (-0.5673059158944367, -5.585953296315335)

输出的结果为测试点集中的距离值以及离群点。
绘制Scatter图像为:
在这里插入图片描述
其中蓝点表示传递给LOF构造函数的实例,红点是异常值的实例(lof值> 1)。大小或红点代表lof值,这意味着更大的lof值会产生更大的点。

参考

[1]陈瑜. 离群点检测算法研究[D].兰州大学,2018.
[2]https://blog.youkuaiyun.com/wangyibo0201/article/details/51705966

LOF:一种强大的离群值检测算法 在开始讨论LOF算法之前,让我们先了解一下离群值的概念。离群值通常指的是与数据集中的大多数观测值明显不同的观测值。这些值可能是异常的、异常的,或者与正常观测值的分布方式不同。离群值可能由于错误、噪声、异常事件或其他原因而存在,它们的存在可能会影响数据分析和模型的性能。LOF(局部离群因子)是一种强大的离群值检测算法,它强调了局部异常性并能够捕捉到特定区域内的离群值。它在各种领域都有广泛的应用,包括金融、医疗、工业制造和网络安全等。 阅读详情

相关推荐

Python 离群点检测算法 -- LOF详解

我们可以采取更保守的方法,选择一个较高的阈值,这样离群值组中的离群值会更少,但期望更准确。局部邻域中数据点的密度是关键,而 LOF 将不同密度的局部邻域纳入了识别局部离群值的考虑范围。例如,在图(A)中,蓝色或绿色聚类中数据点的 LOF 值都接近 1,尽管这两个聚类的密度不同。一般来说,当 LOF> 1 时,被视为离群点,即数据点与邻居的距离比预期的要远。如果O点不是离群点,则邻近点的平均 LRD 与 O 点的 LRD 大致相等,此时 LOF 几乎等于 1。该数据点与相邻数据点的距离比预期的要远。

abackcab的博客 3475

异常检测算法之局部异常因子算法-Local Outlier Factor(LOF)

简介 局部异常因子算法-Local Outlier Factor(LOF) 在数据挖掘方面,经常需要在做特征工程和模型训练之前对数据进行清洗,剔除无效数据和异常数据。异常检测也是数据挖掘的一个方向,用于反作弊、伪基站、金融诈骗等领域。   异常检测方法,针对不同的数据形式,有不同的实现方法。常用的有基于分布的方法,在上、下α分位点之外的值认为是异常值(例如图1),对于属性值常用此类方法。基于距离的...

BigData_Mining的博客 1万+

局部异常因子算法 Local Outlier Factor(LOF)

每个样本的异常分数称为局部异常因子。异常分数是局部的,取决于相对于周围邻域的隔离程度。局部性由 k 近邻给出,并使用距离估计局部密度,通过将样本的局部密度与其邻居的局部密度进行比较,可以是被密度明显低于其邻居的样本,这些样本就被当作是异常样本点。 算法原理 & LOF 算法相关定义: d(p,o)d(p, o)d(p,o):点 p 和点 o 之间的距离 k-distance: 第 ...

liuyinglxl 3340

深入理解Local Outlier Factor(LOF)局部异常因子算法

局部异常因子算法

tinstone的博客 1万+

sklearn中的异常检测方法

本文是对sklearn 2.7. Novelty and Outlier Detection的一个简单总结。 简介 假设我们有一个数据集,这个数据集中只有两类:正常(又称inliner)和异常(又称outliner)。 怎么就叫正常: 占数据集的大多数 在各个维度上比较聚集 怎么就叫异常: 占少数 通常是比较分散 很多场景下我们需要识别正常和异常,即异常检测,特别常见于数据清洗。 ...

hustqb的博客 3万+

Local Outlier Factor(LOF算法matlab程序)

Local Outlier Factor(LOF算法matlab程序),常用于离群点检验,异常值剔除等应用中

离群点检测——局部离群因子(Local Outlier Factor,LOF)算法

1 离群点检测概述 离群点是观察的数据集中明显异常的数据点,或者说,离群点的数据分布与数据集的整体分布不同。离群点检测的目的是检测出那些与正常数据差别较大的数据点,然后根据具体的问题作进一步处理。 离群点检测算法主要有基于统计、聚类、分类、信息论、距离、密度等相关的方法,列表如下 检测方法 描述 优缺点 基于统计 根据数据的分布特点,选择一个概率分布模型对数据进行匹配,将不能匹...

归去来兮的博客 1万+

nbiot和2g_浅谈NBIOT

一、什么是NBIOT?1、概念窄带物联网(Narrow Band Internet of Things, NB-IoT),NB-IoT构建于蜂窝网络,只消耗大约180KHz的带宽,使用License频段,可采取带内、保护带或独立载波等三种部署方式,与现有网络共存。可直接部署于GSM网络、UMTS网络或LTE网络,以降低部署成本、实现平滑升级。2、NBIOT的特点和目标(1)超强覆盖:相对GPRS来...

weixin_39534100的博客 1705

#LOF算法

a.每个数据点,计算它与其他点的距离 b.找到它的K近邻,计算LOF得分 clf=LocalOutlierFactor(n_neighbors=20,algorithm='auto',contamination=0.1,n_jobs=-1,p=2) 参数含义 ●n_neighbors=20:即LOF算法中的k的值,检测的邻域点个数超过样本数则使用所有的样本进行检测 ●algorithm...

weixin_30932215的博客 5735

C/C++面试八股文汇总

以对象管理资源,利用的就是C++构造的对象最终会被对象的析构函数销毁的原则。上述的的申请、使用、释放资源的程序较为简单,但是如果程序很复杂的时候,需要为所有的new 分配的内存delete掉,导致极度臃肿,效率下降,更可怕的是,程序的可理解性和可维护性明显降低了,当操作增多时,处理资源释放的代码就会越来越多,越来越乱。栈在函数调用时,第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变量。

wzzrh的博客 1万+

汽车底盘技术解析:从悬架调校到智能化,如何评价国产车底盘实力

汽车底盘作为决定车辆驾驶质感、安全性和耐久性的核心系统,其技术内涵远不止于悬架结构。从行驶系、转向系到制动系的协同工作,底盘调校是一门融合机械原理与工程实践的艺术。在电动化与智能化浪潮下,底盘技术正经历从被动适应到主动响应的变革,CDC可变阻尼减震器和空气悬架等技术的应用,让底盘具备了通过OTA升级实现性能优化的可能。国产汽车品牌如奇瑞、吉利等,通过平台化架构研发与调校经验积累,正推动底盘技术从“能用”向“好用”乃至“塑造独特驾驶风格”迈进。理解底盘技术,需超越简单的结构对比,关注其在实际路况中的滤震性、支

weixin_34413103的博客 387

异常检测算法:LOF算法(Local Outlier Factor)的python代码实现

文章目录LOF算法算法介绍代码实现可视化 LOF算法 算法介绍 Local Outlier Factor(LOF)是基于密度的经典算法,也十分适用于anomaly detection的工作。 基于密度的离群点检测方法的关键步骤在于给每个数据点都分配一个离散度,其主要思想是:针对给定的数据集,对其中的任意一个数据点,如果在其局部邻域内的点都很密集,那么认为此数据点为正常数据点,而离群点则是距离正常数据点最近邻的点都比较远的数据点。通常有阈值进行界定距离的远近。 LOF 主要通过计算一个数值 score 来反映

qq_40177015的博客 6454

心电图机原理及电路超详细讲解

前置心电放大电路(虚线框:这是隔离电路的分界,在隔离电路分析中知道,完整隔离包括信号隔离(脉宽调制)、控制信号隔离(光电耦合)和电源隔离)后级放大电路。

fcxgfdjy的博客 2万+

基于密度的局部离群点检测(lof算法) (Java 实现)

算法:基于密度的局部离群点检测(lof算法) 输入:样本集合D,正整数K(用于计算第K距离) 输出:各样本点的局部离群点因子 过程: 1,    计算每个对象与其他对象的欧几里得距离 2,    对欧几里得距离进行排序,计算第k距离以及第K领域 3,    计算每个对象的可达密度 4,    计算每个对象的局部离群点因子 5,    对每个点的局部离群点因子进行排序,输出。

邹中凡 1万+

Power BI实战:从数据清洗到可视化报表的完整流程

本文详细介绍了使用Power BI进行数据分析的完整流程,从数据获取、清洗整理到建模与可视化。通过实战案例,重点讲解了连接MySQL数据库、使用Power Query进行数据清洗、利用DAX创建核心度量值以及设计交互式报表的关键步骤与技巧,帮助用户高效完成从原始数据到专业可视化报表的转化,实现数据驱动决策。

weixin_29070721的博客 399

RabbitMQ的使用(JAVA)

Java快速上手的MQ上线!

.............. 1万+

python离群点检测_L O F 离 群 点 检 测 算 法

异常检测算法--LOF【给力追-女生干货】【企鹅:⒈О1⒍.x.⒐5⒉б】1.主要思想针对给定的数据集,对其中的任意一个数据点,如果在其局部邻域内的点都很密集,那么认为此数据点为正常数据点,而离群点则是距离正常数据点最近邻的点都比较远的数据点。通常有阈值进行界定距离的远近。2. compare with及其他算法2.1孤立森林孤立森林不适用于特别高维的数据。由于每次切数据空间都是随机选取一个维度,...

weixin_39635130的博客 293

MOSFET关断尖峰电压的机理与抑制

MOSFET在电力电子系统中存在开关尖峰电压/电流问题,主要源于寄生电感、密勒电容及开关瞬态特性。尖峰会引发过压击穿、功率损耗和EMI干扰。抑制措施包括优化驱动电路、添加缓冲网络(RC/RCD)、降低寄生电感(改进PCB布线/封装)、使用快速二极管及远端负载特殊处理(电抗器/滤波器)。系统性的器件选型与电路设计是确保功率电子稳定运行的关键。

硬核科技 1826

异常检测-基于相似度的方法-datawhale-task4

异常检测-基于相似度的方法-datawhale-task4基于距离的度量基于单元的⽅法基于索引的⽅法基于密度的度量(以LOF为主)概念引入练习 基于相似度的方法可分为基于距离和密度的度量方法 基于距离的度量 基于单元的⽅法 在基于单元格的技术中,数据空间被划分为单元格,单元格的宽度是阈值D和数据维数的函数。具体地说,每个维度被划分成宽度最多为D2d\frac{D}{2\sqrt{d}}2d​D​单元格。在给定的单元以及相邻的单元中存在的数据点满⾜某些特性,这些特性可以让数据被更有效的处理。 注:d代表维度,

yo跟着新宇走 208

基于Simulink的无线充电系统LCC补偿网络建模与控制

本文详细介绍了基于Simulink的无线充电系统LCC补偿网络建模与控制方法。首先分析了LCC补偿网络的恒流输出、软开关实现和抗偏移能力等优势,并对比了不同补偿拓扑特性。随后分步骤讲解了Simulink建模流程,包括LCC主电路构建、关键参数设计、双闭环控制系统实现等核心环节。重点阐述了移相控制策略和软开关验证方法,提供了系统效率计算和抗偏移测试的调试技巧。最后展示了仿真结果,在耦合系数变化20%时,闭环系统仍能保持输出电压稳定在±2%波动范围内。文章还探讨了工程扩展方向,并针对常见问题给出了解决方案,为无

xiaoheshang_123的博客 540

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

2021-05-20

四、基于相似度的方法 1、概述 “异常”通常是一个主观的判断,什么样的数据被认为是“异常”的,需要结合业务背景和环境来具体分析确定。 实际上,数据通常嵌入在大量的噪声中,而我们所说的“异常值”通常指具有特定业务意义的那一类特殊的异常值。噪声可以视作特性较弱的异常值,没有被分析的价值。噪声和异常之间、正常数据和噪声之间的边界都是模糊的。异常值通常具有更高的离群程度分数值,同时也更具有可解释性。 在普通的数据处理中,我们常常需要保留正常数据,而对噪声和异常值的特性则基本忽略。但在异常检测中,我们弱化了

liuyupei的博客 882

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

机器学习算法(二十二):局部离群因子检测方法 (Local Outlier Factor, LOF)

1 离群点挖掘方法 2LOF 算法背景 基于密度的离群点检测方法的关键步骤在于给每个数据点都分配一个离散度,其主要思想是:针对给定的数据集,对其中的任意一个数据点,如果在其局部邻域内的点都很密集,那么认为此数据点为正常数据点;而离群点则是距离正常数据点最近邻的点都比较远的数据点。通常有阈值进行界定距离的远近。在基于密度的离群点检测方法中,最具有代表性的方法是局部离群因子检测方法 (Local Outlier Factor, LOF)。 3LOF算法简介 在众多...

weixin_39910711的博客 1万+

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

LOF(local outlier factor)算法的Matlab版本实现

LOF算法是一种基于密度的无监督离群点检测算法,其核心思想是:通过比较对象xi与其邻居密度的相似性程度,如果越不相似,即xi的LOF值越大于1,则其是离群点的可能性越高。 下面给出了LOF算法的Matlab版本实现,可直接粘贴复制,并将代码稍作修改即可运行。 function [outputArg1,outputArg2] = LOF(inputArg1,inputArg2) x=load ('Normalization_wbc.txt');%装载要检测的数据集 Label=load('Label_w

jinhualun911的博客 9020

【机器学习】 Local Outlier Factor(LOF)算法

1.Local Outlier Factor(局部离群因子)算法的原理;2.python-sklearn中的LOF算法

Zhang_Chen_的博客 8700

异常检测(三)——Local Outlier Factor(LOF)

在中等高维数据集上执行异常值检测的另一种有效方法是使用局部异常因子(Local Outlier Factor ,LOF)算法。1、算法思想LOF通过计算一个数值score来反映一个样本的异常程度。这个数值的大致意思是:一个样本点周围的样本点所处位置的平均密度比上该样本点所在位置的密度。比值越大于1,则该点所在位置的密度越小于其周围样本所在位置的密度,这个点就越有可能是异常点。关于密度等理论概念,详...

MinerYCC 2万+
上一篇: Logistic Regression算法
下一篇: Softmax Regression算法
ilike_program
博客等级 码龄10年 20粉丝 15原创
评论 6
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值