matplotlib中累积分布函数的对数图

问题描述

我有一个包含已记录事件的文件.每个条目都有时间和延迟.我对绘制延迟的累积分布函数感兴趣.我对尾巴延迟最感兴趣，因此我希望该图具有对数y轴.我对以下百分位的延迟感兴趣:第90、99、99.9、99.99和99.999.到目前为止，这是我的代码，可以生成常规的CDF图:

I have a file containing logged events. Each entry has a time and latency. I'm interested in plotting the cumulative distribution function of the latencies. I'm most interested in tail latencies so I want the plot to have a logarithmic y-axis. I'm interested in the latencies at the following percentiles: 90th, 99th, 99.9th, 99.99th, and 99.999th. Here is my code so far that generates a regular CDF plot:

# retrieve event times and latencies from the file
times, latencies = read_in_data_from_file('myfile.csv')
# compute the CDF
cdfx = numpy.sort(latencies)
cdfy = numpy.linspace(1 / len(latencies), 1.0, len(latencies))
# plot the CDF
plt.plot(cdfx, cdfy)
plt.show()

我知道我想让情节看起来像什么，但我一直在努力争取.我希望它看起来像这样(我没有生成该图):

I know what I want the plot to look like, but I've struggled to get it. I want it to look like this (I did not generate this plot):

使x轴对数很简单. y轴是给我麻烦的那个.使用set_yscale('log')不起作用，因为它想使用10的幂.我真的希望y轴具有与此图相同的刻度标签.

Making the x-axis logarithmic is simple. The y-axis is the one giving me problems. Using set_yscale('log') doesn't work because it wants to use powers of 10. I really want the y-axis to have the same ticklabels as this plot.

如何将我的数据放入这样的对数图中?

How can I get my data into a logarithmic plot like this one?

如果将yscale设置为'log'，将ylim设置为[0.1，1]，则会得到以下图:

If I set the yscale to 'log', and ylim to [0.1, 1], I get the following plot:

问题在于，从0到1的数据集上的典型对数刻度图将集中在接近零的值上.相反，我想关注于接近1的值.

The problem is that a typical log scale plot on a data set ranging from 0 to 1 will focus on values close to zero. Instead, I want to focus on the values close to 1.

推荐答案

本质上，您需要将以下转换应用于Y值:-log10(1-y).这对y < 1施加了唯一的限制，因此您应该能够在变换后的图形上使用负值.

Essentially you need to apply the following transformation to your Y values: -log10(1-y). This imposes the only limitation that y < 1, so you should be able to have negative values on the transformed plot.

这是matplotlib文档中修改后的示例，其中显示了如何合并自定义转换变成比例":

Here's a modified example from matplotlib documentation that shows how to incorporate custom transformations into "scales":

import numpy as np
from numpy import ma
from matplotlib import scale as mscale
from matplotlib import transforms as mtransforms
from matplotlib.ticker import FixedFormatter, FixedLocator


class CloseToOne(mscale.ScaleBase):
    name = 'close_to_one'

    def __init__(self, axis, **kwargs):
        mscale.ScaleBase.__init__(self)
        self.nines = kwargs.get('nines', 5)

    def get_transform(self):
        return self.Transform(self.nines)

    def set_default_locators_and_formatters(self, axis):
        axis.set_major_locator(FixedLocator(
                np.array([1-10**(-k) for k in range(1+self.nines)])))
        axis.set_major_formatter(FixedFormatter(
                [str(1-10**(-k)) for k in range(1+self.nines)]))


    def limit_range_for_scale(self, vmin, vmax, minpos):
        return vmin, min(1 - 10**(-self.nines), vmax)

    class Transform(mtransforms.Transform):
        input_dims = 1
        output_dims = 1
        is_separable = True

        def __init__(self, nines):
            mtransforms.Transform.__init__(self)
            self.nines = nines

        def transform_non_affine(self, a):
            masked = ma.masked_where(a > 1-10**(-1-self.nines), a)
            if masked.mask.any():
                return -ma.log10(1-a)
            else:
                return -np.log10(1-a)

        def inverted(self):
            return CloseToOne.InvertedTransform(self.nines)

    class InvertedTransform(mtransforms.Transform):
        input_dims = 1
        output_dims = 1
        is_separable = True

        def __init__(self, nines):
            mtransforms.Transform.__init__(self)
            self.nines = nines

        def transform_non_affine(self, a):
            return 1. - 10**(-a)

        def inverted(self):
            return CloseToOne.Transform(self.nines)

mscale.register_scale(CloseToOne)

if __name__ == '__main__':
    import pylab
    pylab.figure(figsize=(20, 9))
    t = np.arange(-0.5, 1, 0.00001)
    pylab.subplot(121)
    pylab.plot(t)
    pylab.subplot(122)
    pylab.plot(t)
    pylab.yscale('close_to_one')

    pylab.grid(True)
    pylab.show()

请注意，您可以通过关键字参数来控制9的数量:

Note that you can control the number of 9's via a keyword argument:

pylab.figure()
pylab.plot(t)
pylab.yscale('close_to_one', nines=3)
pylab.grid(True)

这篇关于matplotlib中累积分布函数的对数图的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！