aggiungi la linea in base alla pendenza e intercetta in matplotlib?

Question

In R, esiste una funzione denominata abline in cui è possibile tracciare una linea su un grafico basato sulla specifica della pendenza di intercettazione (primo argomento) (secondo argomento). Ad esempio,

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

dove la linea con intercetta 0 e pendenza 1 copre l'intera gamma di trama. Esiste una tale funzione in matplotlib.pyplot?

Answer 1

I supporti per il caso di (intercept, slope) della (0, 1) seguente funzione potrebbe essere utilizzata ed esteso per accogliere altre piste e intercetta, ma non si riaggiustare se limiti assi vengono modificati o autoscale viene riattivata.

def abline(): 
    gca = plt.gca() 
    gca.set_autoscale_on(False) 
    gca.plot(gca.get_xlim(),gca.get_ylim()) 

import matplotlib.pyplot as plt 
plt.scatter(range(10),range(10)) 
abline() 
plt.draw() 

Answer 2

Non riuscivo a immaginare un modo per farlo senza ricorrere a callback, ma questo sembra funzionare abbastanza bene.

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) 

Answer 3

So che questa domanda è un paio di anni, ma dal momento che non v'è alcuna risposta accettata, io aggiungo quello che funziona per me.

È possibile solo tracciare i valori nel grafico e quindi generare un altro insieme di valori per le coordinate della linea di adattamento ottimale e tracciare il grafico originale. Ad esempio, vedere il codice seguente:

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 4

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 5

Un sacco di queste soluzioni si stanno concentrando su come aggiungere una linea per la trama che si adatta ai dati. Ecco una soluzione semplice per aggiungere una linea arbitraria alla trama basata su una pendenza e un'intercettazione.

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, '--')