Code für beste Passform gerader Linie von einem scatter-plot in python

Unten ist mein code für die scatter-Darstellung der Daten in meiner Textdatei. Die Datei, die ich öffnen, enthält zwei Spalten. Die linke Spalte ist die x-Koordinaten und die Rechte Spalte die y-Koordinaten. der code erstellt ein Streudiagramm von x gegen y. Ich brauche ein code, um overplot eine Linie der besten Anpassung an die Daten in der scatter plot, und keiner der eingebauten pylab Funktion haben für mich gearbeitet. 

from matplotlib import *
from pylab import *

with open('file.txt') as f:
   data = [line.split() for line in f.readlines()]
   out = [(float(x), float(y)) for x, y in data]
for i in out:
   scatter(i[0],i[1])
   xlabel('X')
   ylabel('Y')
   title('My Title')
show()
  • möglich, Duplikat der Einbau einer gekrümmten best-fit-Linie zu einem Daten-set in python
  • Ich brauche nicht eine gekrümmte best-fit-Linie, ich brauche eine gerade best-fit-Linie
  • dg99, habe ich mir angeschaut, der link vor dem zum erstellen dieser Frage und ich habe versucht, Techniken aus dem link-ohne Erfolg.
  • Können Sie zeigen Sie uns den code, den Sie versucht mit der polyfit Funktion und beschreiben Sie, wie es nicht funktioniert hätte? Denken Sie daran, die deg parameter 1 um einen linearen fit. (Siehe docs hier.)
InformationsquelleAutor Astronerd326 | 2014-03-07
  1. 77

    Einer Online-version von diese hervorragende Antwort, um den Verlauf der Linie der besten Passform ist:

    plt.plot(np.unique(x), np.poly1d(np.polyfit(x, y, 1))(np.unique(x)))

    Mit np.unique(x) statt x behandelt den Fall, wo x ist nicht sortiert oder über doppelte Werte verfügt.

    • Ich verstehe nicht, die (x) am Ende. Ich habe in der scipy-Dokumentation und nicht sehen, eine Erklärung gibt. Wie wussten Sie, dass Sie verwenden, die syntax mit poly1d?
    • gibt eine Funktion für die Linie der besten Passform, die Sie dann bewerten auf die Punkte x.
    • Gibt es eine Möglichkeit zu erweitern die best-fit-Linie über die ursprüngliche x-Achse?
    • Ja, ersetzen Sie die zweite np.unique(x) mit einem 1D-array mit den x-Punkte, die Sie möchten, um den Verlauf der Linie an.
    • ^ Huch, haben Sie zu ersetzen, sowohl von der np.unique(x), nicht nur die zweite, wie ich oben sagte.
    InformationsquelleAutor 1''
  2. 17

    Vorausgesetzt Linie der besten Passform, die für eine Reihe der Punkte ist:

    y = a + b * x

    wo: 

    b = ( sum(xi * yi) - n * xbar * ybar ) / sum((xi - xbar)^2)
a = ybar - b * xbar

    Code und Grundstück

    # sample points 
X = [0, 5, 10, 15, 20]
Y = [0, 7, 10, 13, 20]

# solve for a and b
def best_fit(X, Y):

    xbar = sum(X)/len(X)
    ybar = sum(Y)/len(Y)
    n = len(X) # or len(Y)

    numer = sum([xi*yi for xi,yi in zip(X, Y)]) - n * xbar * ybar
    denum = sum([xi**2 for xi in X]) - n * xbar**2

    b = numer / denum
    a = ybar - b * xbar

    print('best fit line:\ny = {:.2f} + {:.2f}x'.format(a, b))

    return a, b

# solution
a, b = best_fit(X, Y)
#best fit line:
#y = 0.80 + 0.92x

# plot points and fit line
import matplotlib.pyplot as plt
plt.scatter(X, Y)
yfit = [a + b * xi for xi in X]
plt.plot(X, yfit)

    Code für beste Passform gerader Linie von einem scatter-plot in python

    UPDATE:

    notebook-version

    • Genau das, was ich suchte. Nützlich, dass die matplot lib ist nicht vermischt mit dem eigentlichen LOB-Algorithmus. Danke Aziz.
    • Froh, dass u finden, ist es nützlich 🙂
    • Ich hatte zu konvertieren numer und denum zu Wagen. Sonst bekomme ich das falsche Ergebnis.
    • Zahl = float(sum([xi*yi xi,yi in zip(X, Y)]) - n * xbar * ybar) denum = float(sum([xi2 for xi in X]) - n * xbar2)
    • Tolle Arbeit!!. Möchte nur wissen, wie um das Ende zu finden (x,y) - Koordinaten dieser best-fit-line ?
    • danke, meinst du die letzten X-und yfit Punkte? wenn ja, wäre Sie, wie X[-1] und yfit[-1]

    InformationsquelleAutor Aziz Alto
  3. 16

    Können Sie numpy ist polyfit. Ich benutze die folgenden (Sie können sicher entfernen das bit über das Bestimmtheitsmaß und fehlerabschätzungen, ich denke, es sieht nett aus):

    #!/usr/bin/python3

import numpy as np
import matplotlib.pyplot as plt
import csv

with open("example.csv", "r") as f:
    data = [row for row in csv.reader(f)]
    xd = [float(row[0]) for row in data]
    yd = [float(row[1]) for row in data]

# sort the data
reorder = sorted(range(len(xd)), key = lambda ii: xd[ii])
xd = [xd[ii] for ii in reorder]
yd = [yd[ii] for ii in reorder]

# make the scatter plot
plt.scatter(xd, yd, s=30, alpha=0.15, marker='o')

# determine best fit line
par = np.polyfit(xd, yd, 1, full=True)

slope=par[0][0]
intercept=par[0][1]
xl = [min(xd), max(xd)]
yl = [slope*xx + intercept  for xx in xl]

# coefficient of determination, plot text
variance = np.var(yd)
residuals = np.var([(slope*xx + intercept - yy)  for xx,yy in zip(xd,yd)])
Rsqr = np.round(1-residuals/variance, decimals=2)
plt.text(.9*max(xd)+.1*min(xd),.9*max(yd)+.1*min(yd),'$R^2 = %0.2f$'% Rsqr, fontsize=30)

plt.xlabel("X Description")
plt.ylabel("Y Description")

# error bounds
yerr = [abs(slope*xx + intercept - yy)  for xx,yy in zip(xd,yd)]
par = np.polyfit(xd, yerr, 2, full=True)

yerrUpper = [(xx*slope+intercept)+(par[0][0]*xx**2 + par[0][1]*xx + par[0][2]) for xx,yy in zip(xd,yd)]
yerrLower = [(xx*slope+intercept)-(par[0][0]*xx**2 + par[0][1]*xx + par[0][2]) for xx,yy in zip(xd,yd)]

plt.plot(xl, yl, '-r')
plt.plot(xd, yerrLower, '--r')
plt.plot(xd, yerrUpper, '--r')
plt.show()
    InformationsquelleAutor Micah
  4. 6

    Umgesetzt haben @Micha 's-Lösung zu generieren, die ein trendline mit ein paar änderungen und dachte, ich würde Aktie:

    • Kodiert als Funktion
    • Option für eine Polynomische Trendlinie (Eingang order=2)
    • - Funktion kann auch nur wieder das Bestimmtheitsmaß (R^2, Eingang Rval=True)
    • Mehr Numpy-array-Optimierungen

    Code:

    def trendline(xd, yd, order=1, c='r', alpha=1, Rval=False):
    """Make a line of best fit"""

    #Calculate trendline
    coeffs = np.polyfit(xd, yd, order)

    intercept = coeffs[-1]
    slope = coeffs[-2]
    power = coeffs[0] if order == 2 else 0

    minxd = np.min(xd)
    maxxd = np.max(xd)

    xl = np.array([minxd, maxxd])
    yl = power * xl ** 2 + slope * xl + intercept

    #Plot trendline
    plt.plot(xl, yl, c, alpha=alpha)

    #Calculate R Squared
    p = np.poly1d(coeffs)

    ybar = np.sum(yd) / len(yd)
    ssreg = np.sum((p(xd) - ybar) ** 2)
    sstot = np.sum((yd - ybar) ** 2)
    Rsqr = ssreg / sstot

    if not Rval:
        #Plot R^2 value
        plt.text(0.8 * maxxd + 0.2 * minxd, 0.8 * np.max(yd) + 0.2 * np.min(yd),
                 '$R^2 = %0.2f$' % Rsqr)
    else:
        #Return the R^2 value:
        return Rsqr
    InformationsquelleAutor Siyh
Schreibe einen Kommentar