Comment ajouter une ligne basée sur la pente et l'intercept dans Matplotlib ?

Question

En R, il existe une fonction appelée abline dans lequel une ligne peut être tracée sur un graphique en fonction de la spécification de l'ordonnée à l'origine (premier argument) et de la pente (deuxième argument). Par exemple,

plot(1:10, 1:10)
abline(0, 1)

où la ligne dont l'ordonnée à l'origine est 0 et la pente 1 s'étend sur toute la plage du graphique. Existe-t-il une telle fonction dans Matplotlib ?

Answer 1

Beaucoup de ces solutions se concentrent sur l'ajout d'une ligne au graphique qui correspond aux données. Voici une solution simple pour ajouter une ligne arbitraire au graphique à partir d'une pente et d'une ordonnée à l'origine.

import matplotlib.pyplot as plt 
import numpy as np    

def abline(slope, intercept):
    """Plot a line from slope and intercept"""
    axes = plt.gca()
    x_vals = np.array(axes.get_xlim())
    y_vals = intercept + slope * x_vals
    plt.plot(x_vals, y_vals, '--')

Answer 2

Je sais que cette question date de quelques années, mais comme il n'y a pas de réponse reconnue, je vais ajouter ce qui fonctionne pour moi.

Vous pouvez simplement reporter les valeurs dans votre graphique, puis générer un autre ensemble de valeurs pour les coordonnées de la ligne de meilleur ajustement et les reporter sur votre graphique original. Par exemple, voyez le code suivant :

import matplotlib.pyplot as plt
import numpy as np

# Some dummy data
x = [1, 2, 3, 4, 5, 6, 7]
y = [1, 3, 3, 2, 5, 7, 9]

# Find the slope and intercept of the best fit line
slope, intercept = np.polyfit(x, y, 1)

# Create a list of values in the best fit line
abline_values = [slope * i + intercept for i in x]

# Plot the best fit line over the actual values
plt.plot(x, y, '--')
plt.plot(x, abline_values, 'b')
plt.title(slope)
plt.show()

Answer 3

X = np.array([1, 2, 3, 4, 5, 6, 7])
Y = np.array([1.1,1.9,3.0,4.1,5.2,5.8,7])

scatter (X,Y)
slope, intercept = np.polyfit(X, Y, 1)
plot(X, X*slope + intercept, 'r')

Answer 4

Il semble que cette fonctionnalité fera partie de la version 3.3.0 :

matplotlib.axes.Axes.axline

Vous serez, par exemple, en mesure de tracer une ligne rouge à travers des points (0, 0) y (1, 1) en utilisant

axline((0, 0), (1, 1), linewidth=4, color='r')

Answer 5

Je n'ai pas réussi à trouver un moyen de le faire sans recourir à des rappels, mais cela semble fonctionner assez bien.

import numpy as np
from matplotlib import pyplot as plt

class ABLine2D(plt.Line2D):

    """
    Draw a line based on its slope and y-intercept. Additional arguments are
    passed to the <matplotlib.lines.Line2D> constructor.
    """

    def __init__(self, slope, intercept, *args, **kwargs):

        # get current axes if user has not specified them
        if not 'axes' in kwargs:
            kwargs.update({'axes':plt.gca()})
        ax = kwargs['axes']

        # if unspecified, get the current line color from the axes
        if not ('color' in kwargs or 'c' in kwargs):
            kwargs.update({'color':ax._get_lines.color_cycle.next()})

        # init the line, add it to the axes
        super(ABLine2D, self).__init__([], [], *args, **kwargs)
        self._slope = slope
        self._intercept = intercept
        ax.add_line(self)

        # cache the renderer, draw the line for the first time
        ax.figure.canvas.draw()
        self._update_lim(None)

        # connect to axis callbacks
        self.axes.callbacks.connect('xlim_changed', self._update_lim)
        self.axes.callbacks.connect('ylim_changed', self._update_lim)

    def _update_lim(self, event):
        """ called whenever axis x/y limits change """
        x = np.array(self.axes.get_xbound())
        y = (self._slope * x) + self._intercept
        self.set_data(x, y)
        self.axes.draw_artist(self)