Hintergrundinformationen zum Stan Playground ist hier.

Und jetzt Brian Ward Berichte:

Es gibt jetzt eine neue Registerkarte im Abschnitt zur Datengenerierung, auf der Sie Dateien wie CSVs hinzufügen können, auf die die Datenskripte zugreifen können

Bild1719×773 47,4 KB

 

Generieren von Stan-Daten und Code mit brms

Sie können jetzt BRMS verwenden, um den Stan-Code und die Daten für die Verwendung in Stan Playground zu generieren

 

Bild1228×377 26,5 KB

 

Choice zum schnellen Teilen

Das Exportfenster bietet jetzt die Möglichkeit, einen gemeinsam nutzbaren Hyperlink zu erstellen, bei dem alle Daten für das Projekt in der URL kodiert sind. Dies kann zu einigen führen sehr lange URLsaber es ist eine sehr schnelle Möglichkeit, Ihre Modelle zu teilen, ohne sich für Github Gists authentifizieren zu müssen.

JOSS-Papier

Unser Artikel über Stan Playground wurde heute Morgen in JOSS veröffentlicht! Journal of Open Supply Software program: stan-playground: Führen Sie Stan-Modelle direkt in Ihrem Browser aus

Wie cool ist das??

[ad_2]

Schauen Sie, wie hart wir mussten arbeiten:

Okay, es struggle gar nicht so schlimm. Wir haben es schließlich geschafft. Trotzdem struggle es eine Menge Arbeit. Auf der nächsten Seite des Artikels wird beschrieben, wie wir ein Polynom dritten Grades verwendet haben, um die Erwartungen mit der Logit-Transformation näherungsweise zu berechnen.

Der eigentliche Punkt ist nicht, dass wir dieses spezielle Modell jetzt viel einfacher anpassen können, sondern dass wir mit Stan und ähnlichen Instruments kompliziertere Modelle an größere Datensätze anpassen und anspruchsvollere Fragen beantworten können. Tatsächlich spricht niemand mehr über die Sitze-Stimmen-Kurve!

[ad_2]

Beim Erstellen von Modellen ist es hilfreich, unser Verständnis zu überprüfen, indem wir gefälschte Daten simulieren und prüfen, ob das angepasste Modell die wahren zugrunde liegenden Parameter wiederherstellen kann. Und das geht in Stan so einfach!

Siehe oben – ich habe gerade ein einfaches Beispiel gemacht Stan-Spielplatz. (Danke, Brian!) Der Code ist irgendwie hässlich, weil ich die wahren Parameterwerte im Stan-Code des transformierten Datenblocks angegeben habe, anstatt sie als Daten aufzurufen; Auf der anderen Seite ist das Ganze dann in einem Programm.

Das ist nicht dasselbe wie voll Simulationsbasierte Kalibrierungsprüfung (SBC). In SBC ziehen Sie die wahren Parameterwerte aus dem Prior, wiederholen den gesamten Prozess viele Male parallel und überprüfen dann die durchschnittliche Abdeckung der Posterior-Inferenzen in Bezug auf die wahren Parameterwerte, indem Sie über den Prior mitteln. Hier führe ich nur eine Simulation durch und stelle die wahren Parameterwerte nur einmal ein. Es ist eine Artwork schnell und schmutzig SBC, das immer noch nützlich sein kann, um Probleme wie nicht identifizierte Modelle oder schlechte Mischung zu erkennen.

Und es ist so einfach! Wann immer Sie ein Modell anpassen, sollten Sie es anhand gefälschter Daten überprüfen.

Ich habe das obige Beispiel gemacht, weil ich schnell nach einer der Übungen suchen wollte, die ich für das kommende Buch „Bayesian Workflow“ schreibe.

PS Hier ist der Code für das obige Beispiel, falls Sie es selbst ausprobieren möchten:

reworked knowledge {
  int N = 100;
  actual a_true = 0.2;
  actual b_true = 0.3;
  actual sigma_true = 0.2;
  vector(N) x;
  vector(N) y;
   for (n in 1:N) {
    x(n) = uniform_rng(0, 10);
    y(n) = normal_rng(1 / (a_true + b_true * x(n)), sigma_true);
  }
}
parameters {
  actual<decrease=0> a, b, sigma;
}
mannequin {
  a ~ regular(0, 1);
  b ~ regular(0, 1);
  for (n in 1:N) {
    y(n) ~ regular(1 / (a + b * x(n)), sigma);
  }
}

[ad_2]

Dieser Beitrag stammt von Bob

Obwohl der Beitrag von mir stammt, geht es in der Geschichte teilweise um Andrew, aber hauptsächlich darum, wie LLMs in Mathe besser werden. Anstatt allen von LLMs zu erzählen und eine theoretische Diskussion zu führen, dachte ich, es wäre nützlich, Ihnen ein weiteres Beispiel für die Artwork der Interaktion mit LLMs zu zeigen, die ich sehr nützlich finde.

Die Hintergrundgeschichte

Andrew erwähnt häufig, dass er mit Stans Commonplace -Stichprobenzeiten ungeduldig ist und möchte, dass ihm etwas schneller eine grobe Antwort gibt. Ich und mehrere Kollegen haben additionally daran gearbeitet, eine schnellere Anpassung zu finden Nutpie Sampler, der bereits mit Modellen ausgeführt werden kann, die in Stan oder PYMC kodiert werden). Das bedeutet Bewertung. Additionally fragte ich Andrew endlich um ein Beispiel.

Gelman’s Messfehlermodell

Hier ist das Messfehlermodell, das Andrew mir gegeben hat:

knowledge {
  int N;
  vector(N) y;
  vector(N) x_star;
  actual sigma_x_star;
}
parameters {
  actual a, b, mu_x;
  actual sigma, sigma_x;
  vector(N) x;
}
mannequin {
  x ~ regular(mu_x, sigma_x);
  y ~ regular(a + b*x, sigma);
  x_star ~ regular(x, sigma_x_star);
}

Abgesehen davon liebe ich, dass es eine angemessene Untergrenze gibt N.

Dies ist ein klassisches Messfehlermodell – wenn Sie nicht bekannt sind Stan -Benutzerhandbuch Einführung in Messfehlermodelle.

Bobs überarbeitetes Modell

Das sieht aus wie ein BDA Typmodell – Es gibt unsachgemäße flache Priors. Und die latenten wahren Werte der Kovariaten x eine zentrierte Parametrisierung haben. Beide können zu Problemen zur Anpassung führen. Daher habe ich unter Verwendung von Offset und Multiplern zu einer nicht zentrierten Parametrisierung geschwungen und dann einige schwach informative Priors für alle Parameter hinzugefügt.

knowledge {
  int N;
  vector(N) y;
  vector(N) x_star;
  actual sigma_x_star;
}
parameters {
  actual a, b, mu_x;
  actual sigma, sigma_x;
  vector(N) x;
}
mannequin {
  a ~ regular(0, 1);
  b ~ regular(0, 1);
  mu_x ~ regular(0, 1);
  sigma ~ lognormal(0, 0.5);
  sigma_x ~ lognormal(0, 0.5);
  
  x ~ regular(mu_x, sigma_x);
  y ~ regular(a + b * x, sigma);
  x_star ~ regular(x, sigma_x_star);
}

Es passt besser als Andrew, aber immer noch nicht intestine. Mit dem Commonplace-1000-Warmup- und 1000-Stichproben-Iterationen auf vier Ketten gab es immer noch R-Hass-Werte über 1,2. Wenn wir das bis zu einer Größenordnung mehr Iterationen ankurbeln, sieht alles in Ordnung aus, aber es hat immer noch eine integrierte Autokorrelationszeit von rund 100 (was bedeutet, dass ES das 1/100 -fache der Stichprobengröße beträgt).

Überarbeitete Modell von GPT 5

Als ich mir das Modell ansah, dachte ich, dass es wie ein Hauptkandidat aussah, um das auszumarschieren x Parameter – Es hat einen normalen Prior und es wird zu einer normalen Wahrscheinlichkeit verwendet. Aber ich bin schrecklich in dieser Artwork von Mathematik und es gab keine Mathematikstatistik wie Philip Greengard, additionally wandte ich mich an GPT 5, was bereits etwas Mathe für mich gemacht hatte, das ich selbst nicht tun konnte (Berechnung der zweiten und vierten Momente von Neals Trichter). Hier ist meine Interaktion mit GPT 5.0 auf „Auto“. GPT 3.5 konnte kaum ein syntaktisch korrektes Stan -Programm für eine lineare Regression schreiben. Lassen Sie mich additionally nur sagen, dass es seitdem einen langen Weg zurückgelegt hat.

(Bob) Ich habe das folgende STAN -Programm für Messfehler in X und ich frage mich, ob es eine Möglichkeit gibt, einige der Variablen herauszufinden, um diese Probe effizienter zu gestalten. Ich dachte, da alles regular ist, würde es eine Probability geben. Insbesondere möchte ich das X out, wenn möglich, marginalisieren.

```stan
(code from above)
```

Ich wäre in Ordnung, die Priors auf dem Sigma leicht zu modifizieren, um inverse Gammas auf Sigma^2 zu sein, wenn dies dazu beitragen würde, die Räder der Marginalisierung zu fetten.

Und siehe da, der Genie hat ein korrekt marginalisiertes Stan -Programm zurückgegeben:

knowledge {
  int N;
  vector(N) y;
  vector(N) x_star;
  actual sigma_x_star;
}
parameters {
  actual a, b, mu_x;
  actual sigma, sigma_x;
}
remodeled parameters  x*)
  actual sd_xstar = sqrt(sq.(sigma_x) + sq.(sigma_x_star));
  actual sd_y_cond = sqrt(sq.(sigma) + sq.(b) * tilde_v);
  vector(N) tilde_mu = tilde_v * ( inv_var_x * rep_vector(mu_x, N)
                                 + inv_var_xs * x_star );

mannequin  x*)

Gefolgt von diesem Rat:

• (GPT5) Integration von μX ist auch mit einem normalen Prior möglich, induziert jedoch eine dichte Kreuzbeobachtungskovarianz (Rang-1-Replace) und ist in der Regel für HMC/Nuts schlechter. ΜX als Parameter zu halten ist normalerweise besser.

Hat es funktioniert?

Ja! Es hat nicht nur funktioniert, es hat auch beim ersten Versuch funktioniert. Und die Ergebnisse stimmten zu dem überein, was ich von einem viel längeren Lauf des vollständigen Modells bekam, aber mit einem großartigen ESS.

GPT, können Sie unseren Benutzern zu Hause erklären, wie Sie das gemacht haben?

Ich dachte Stan -Benutzerhandbuch. Additionally bat ich den Genie, sich selbst zu erklären.

. Jetzt möchte ich dies als Beispiel für unsere Benutzer im Effizienzkapitel des (*Stan -Benutzerhandbuchs*) (*Stan -Benutzerhandbuch*) aufschreiben (https://mc-stan.org/docs/stan-users-guide/efficien-tuning.html). Ich möchte additionally eine Erklärung für ein ähnliches Publikum. Angesichts der Tatsache, dass wir uns mit der faktorisierten bedingten Kind befassen, können Sie ein bisschen detaillierter darüber eingehen, wie Sie die Formulare der vier Variablen abgeleitet haben, die Konstanten $ tilde {v} $ und $ mu_i $ und die Ausschüttungen für $ x_i^ star $ und y_i mid x_i^ star $ $? Sie können es in bekannte Eigenschaften von Normalen unterteilen, erinnern Sie mich jedoch daran, was diese sind, weil ich nicht sehr intestine mit klassischen Mathematikstatistiken von Exponentialfamilien bin, noch viele unserer Benutzer.

Und natürlich mit einem LLM, Bob ist dein Onkel (aus der französischen Redewendung et voilà):

Natürlich muss ich die gesamte Mathematik überprüfen, bis ich sie gründlich verstehe, und dann in dann zu konvertieren
Die Stan -Benutzerhandbuch Stil.

[ad_2]

Dieser Beitrag stammt von Bob

Ich habe in letzter Zeit über die Bewertung nachgedacht, weil ich mit Kollegen daran gearbeitet habe neu Samplerwas bedeutet, zu bewerten, wie intestine sie funktionieren (mehr dazu bald). Dies wiederum bedeutet, Zieldichten zu finden, auf denen sie bewertet werden können.

Ein kombinatorischer multimodaler Testfall

Ich wollte etwas klar multimodal und daher nicht konkav log. Ich erinnere mich, dass jemandes Papier (Hilfe beim Zitat?) Eine Mischung aus vier zweidimensionalen isotropen Normalen verwendet hat, die genug getrennt sind, um den Übergang möglich zu machen, aber immer noch ein bisschen schwierig. Nicht um das Spiel zu verschenken, aber hier ist eine hintere Handlung einer Probe, die aus Stan gezogen wurde – das Ungleichgewicht in Komponentengewichten ist beabsichtigt, wie ich unten beschreiben werde.

Ich arbeite immer noch daran posteriordb mit der Stan Gang (siehe die Autoren des verknüpften Papiers) und Inferenz -Fitnessstudio mit Reuben Cohn-Gordon (Ein weiterer Linguist, der von Coaching und Programmiersprache Geek zu MCMC gewandt hat) und dachte, es wäre schön, etwas allgemeineres als nur das 2D -Beispiel zu haben. Additionally habe ich mein Notizbuch herausgeholt und die Verallgemeinerung auf D-Abmessungen festgestellt, die 2^D-Mischkomponenten umfasst, die regular sind, wobei die Einheit-Kovarianz an den Punkten in {-r, r}^d liegt.

p(y | r) = SUM_{mu in {-r, r}^D} 1/2^D regular(y | mu, I).

Ich habe dann verallgemeinert, damit die Wahrscheinlichkeit festgelegt wird, dass y (d)> 0 p in (0, 1) eine ungleichmäßige Mischung erhalten kann. Dies führt aufgrund der Ungleichmäßigkeit zu einer etwas komplexeren Dichte.

p(y | r) = SUM_{mu in {-r, r}^D} binomial(sum(mu == r) | D, p) * regular(y | mu, I).

Codierung in Stan mit Fortsetzung des Passing-Stils

Wie codieren wir das in Stan? Offensichtlich muss es rekursiv oder zumindest iterativ sein, damit das D zur Zusammenstellung unbekannt ist. Wann immer ich eine Rekursion sehe, denke ich sofort daran Fortsetzung des Passstils (CPS). Additionally habe ich dieses STAN -Programm entwickelt, um eine Verallgemeinerung in D -Dimensionen zu codieren.

features {
  actual mm(vector y, actual r, actual p, int d, actual lp) {
    if (d == 0) {
      return lp;
    }
    actual lp1 = mm(y, r, p, d - 1, lp + normal_lpdf(y(d) | r, 1));
    actual lp2 = mm(y, r, p, d - 1, lp + normal_lpdf(y(d) | -r, 1));
    return log_mix(p, lp1, lp2);
  }

  actual mm_lpdf(vector y, actual r, actual p, int D) {
    return mm(y, r, p, D, 0);
  }
}
information {
  int D;   // variety of dimensions
  actual r;  // modes in {-r, r}^D
  actual p;  // p = Pr(Y(d) > 0)
}
parameters {
  vector(D) y;
}
mannequin {
  y ~ mm(r, p, D);
}

Die Funktion log_mix ist wie folgt definiert, aber stabiler implementiert.

log_mix(p, lp1, lp2)
    = log_sum_exp(log(p) + lp1, log(1 - p) + lp2)
    = log(exp(log(p) + lp1) + exp(log(1 - p) + lp2))
    = log(p * exp(lp1) + (1 - p) * exp(lp2)).

Wenn Sie die Rekursion manuell entfalten, sind die Blätter die Holzdichten und die Gewichte landen wie in der Definition beschrieben. Wenn Sie Schwierigkeiten haben, dies zu sehen, hilft die manuelle Erweiterung der d = 1 und dann d = 2. Es ist kompakt, aber es ist immer noch exponentiell, eine Protokolldichte und einen Gradienten zu bewerten (dh O (2^d)). Obwohl es in höheren Dimensionen langsam ist, funktioniert es.

Python -Skripte

Das obige Diagramm stammt aus dem folgenden Python -Code, der festgelegt wird

D = 2, r = 2,5 und p = 2,0/3,0.

Für diejenigen unter Ihnen, die einen Umzug nach Python in Betracht ziehen, ist es ein Glücksfall, einen Klon von Datenrahmen (Pandas) und GGPlot2 (Plotnine) zu haben. Und ja, natürlich wissen die LLMs, wie man Pandas und Plotnine codiert.

import cmdstanpy as csp
import pandas as pd
import plotnine as pn

mannequin = csp.CmdStanModel(stan_file="mm.stan")
D = 2
r = 2.5
p = 2.0 / 3.0
information = {'D': D, 'r': r, 'p': p}
match = mannequin.pattern(information = information, iter_sampling=5_000)
print(match.abstract(sig_figs=2))

y = match.stan_variable('y')
df = pd.DataFrame({'y1': y(:, 0), 'y2': y(:, 1)})
plot = (
    pn.ggplot(df, pn.aes(x='y1', y='y2'))
    + pn.geom_vline(xintercept=(-r, r), coloration="purple", linetype="dashed")
    + pn.geom_hline(yintercept=(-r, r), coloration="purple", linetype="dashed")
    + pn.geom_point(alpha=0.1)
    + pn.scale_x_continuous(breaks=(-r, 0, r))
    + pn.scale_y_continuous(breaks=(-r, 0, r))
    + pn.coord_fixed()
    + pn.theme_minimal()
)
plot.save('mm.jpg', dpi=300)

Der Abschlag von Datenrahmen in Pandas und GGPLOT2 in Plotnine ist ein Glücksfall, wenn Sie von R nach Python wechseln (was ich sehr empfehlen würde).

Dynamische Programmierung zur Rettung

Weil es CPS beteiligte, habe ich es verschickt Brian Ward Gegen Mitternacht letzte Nacht. Ich bin ein anständiger Programmierer, aber Brians nächstes Degree. Als ich heute um 10 Uhr ankam, hatte er die Zieldichte wie folgt neu geschrieben.

  actual mm_lpdf(vector y, actual r, actual p, int d) {
    if (d == 0) {
      return 0;
    }
    actual lower_mixture = mm_lpdf(y | r, p, d - 1);
    actual lp1 = lower_mixture + normal_lpdf(y(d) | r, 1);
    actual lp2 = lower_mixture + normal_lpdf(y(d) | -r, 1);
    return log_mix(p, lp1, lp2);
  }

(Bearbeiten: Durch eine Mischung aus LPDF und LUPDF.

Er sah, dass die Rekursionen in jedem Zweig dasselbe machten und geteilt werden konnten. Da es nur einen rekursiven Anruf gibt, ist Brians Code linear (dh O (d)). Es erreicht diese Beschleunigung mithilfe der dynamischen Programmierung (DP). DP berechnet Teillösungen, die zu größeren Lösungen kombiniert werden können, anstatt sie neu zu berechnen. DP ist die Technik, die Sie benötigen, um die härteren L33T-Code-Checks zu lösen, die Sie heutzutage während technischer Interviews erhalten. Weitere Beispiele, bei denen DP für statistische Modelle hilfreich sein kann, umfassen die Quick Fourier-Transformation (FFT), den Vorwärtsalgorithmus für versteckte Markov-Modelle (HMMs) und die Poisson-Binomial-Verteilung. Die ersten beiden werden in Stan und letzterem effizient codiert, wie ich in a codieren kann Stan Discussion board Submit auf Poisson-Binomial.

Probieren Sie es selbst auf dem Stan -Spielplatz aus

Wenn Sie selbst damit spielen möchten, baute Brian eine Model mit dem Stan -Spielplatz, auf dem Sie im Browser laufen können.

• Stan -Spielplatz: Kombinatorische normale Gemische

So sieht es nach dem Einstellen von D = 3 aus, ausführte Stichproben und dann ein Histogramm mit allen drei ausgewählten Dimensionen anzusehen.

Es ist eine Stay -Demo, sodass Sie die Daten auf R, D und p bearbeiten können. Und es ist sehr schnell aufgrund des DP. Genau wie in Shinystan und vor allem seine generische Model im Browser McMcMonitor (Von vielen der gleichen Entwickler wie Stan-Spielplatz) können Sie 3D-Projektionen der höherdimensionalen Zeichnen anzeigen und sie drehen, um zu sehen, dass 8 Bälle in 3D hergestellt werden, von denen 7 im Bildschirmgreifer sichtbar sind. Oder Sie können zu höheren Dimensionen gehen und Projektionen auf zwei oder drei Dimensionen anzeigen. Möglicherweise möchten Sie die Anzahl der Ziehungen professional Kette erhöhen, um die posterioren Dichten in den Visualisierungen sauberer abzugrenzen.

[ad_2]

Pünktlich zu Halloween haben wir eine schaurig-effektive Umsetzung von Stan im Netz, vollgestopft mit einem wahren Spukhaus voller köstlicher Leckereien.

Brian Ward, Jeff Soules und Jeremy Magland schreiben:

Stan-Spielplatz ist ein neuer browserbasierter Open-Supply-Editor und eine Laufzeitumgebung für Stan-Modelle. Benutzer können Modelle bearbeiten, kompilieren und ausführen sowie die Ergebnisse mithilfe integrierter Diagramme und Statistiken oder benutzerdefinierten Analysecodes in Python oder R analysieren, ohne dass eine lokale Set up erforderlich ist. . . .

Egal, ob Sie ein neuer Benutzer sind, ein Pädagoge, der Stan etwas beibringen möchte, oder ein erfahrener Benutzer, der seinen neuen Laptop computer einfach noch nicht konfiguriert hat, wir hoffen, Ihnen das Leben ein wenig einfacher zu machen.

Die Dwell-Web site können Sie hier besuchen: https://stan-playground.flatironinstitute.org

Funktionsübersicht

Für Benutzer, die mit Instruments wie dem Compiler Explorer 1, repl.it oder JSFiddle vertraut sind, hofft Stan Playground, ein ähnliches Erlebnis für Stan-Modelle bieten zu können.

Stan-Herausgeber

Die Web site verfügt über einen Editor für Stan-Code mit Syntaxhervorhebung und stellt Warnungen und Fehler vom Stan-Compiler für sofortiges Suggestions bereit.

Kompilieren von Modellen

Die Zusammenstellung der Modelle ist der einzige Teil von Stan Playground, der nicht lokal betrieben wird. Der Einfachheit halber stellen wir einen öffentlichen Server zur Verfügung, Sie können aber auch Ihren eigenen hosten.

Daten vorbereiten

Daten können im JSON-Format in einem eigenen Editor bereitgestellt oder aus Code generiert werden, der in R (mit webR) oder Python (mit Pyodide) geschrieben wurde, einschließlich Code, der veröffentlichte Datensätze importiert.

Probenahme

Nachdem ein Modell kompiliert wurde, kann die Probenahme vollständig in Ihrem lokalen Browser ausgeführt werden.

Ergebnisse anzeigen und analysieren

Stan Playground verfügt über mehrere integrierte Möglichkeiten zum Anzeigen der Beispiele, unterstützt aber auch die Durchführung Ihrer eigenen Analyse, wiederum in R oder Python.

Teilen

Stan Playground verfügt über integrierte Freigabefunktionen, mit denen Sie eine Kopie Ihres Projekts herunterladen, ein vorhandenes Projekt hochladen oder über einen Github Gist teilen können. . . Sie können auch benutzerdefinierte Hyperlinks vorbereiten. . . Über diesen Hyperlink wird beispielsweise die Fallstudie „Golf“ aus dem Beispielmodell-Repository geladen: https://stan-playground.flatironinstitute.org/?title=Knitrpercent20-%20Golfpercent20-%20Golfpercent20Angle&stan=https://uncooked.githubusercontent.com/stan-dev/example-models/grasp/knitr /golf/golf_angle.stan&information=https://uncooked.githubusercontent.com/stan-dev/example-models/grasp/knitr/golf/golf1.information.json

ICH habe es ausprobiert und es hat wirklich funktioniert!

Ich habe ein einfaches Beispiel geschrieben, das gefälschte Daten aus einer linearen Regression mit bekannten Parametern (im transformierten Datenblock) simuliert und dann die Log-Posteriori-Dichte (im Modellblock) ausdrückt:

information {
  int N;             // pattern dimension
  actual a_, b_;   // true values of parameters
  actual<decrease=0> s_;  //   for the simulation
}
reworked information {
  vector(N) x = linspaced_vector(N, 0, 1);
  vector(N) y;
  for (n in 1:N) y(n) = normal_rng(a_ + b_*x(n), s_);
}
parameters {
  actual a, b;
  actual<decrease=0> s;
}
mannequin {
  y ~ regular(a + b*x, s);
}

Mit Daten:

{
  "N": 1000,
  "a_": 0.2,
  "b_": 0.3,
  "s_": 0.5
}

Es ist so einfach

Dies einzurichten und in Stan Playground zu betreiben, ist die einfachste Sache der Welt:

1. Fügen Sie das Stan-Programm in das Stan-Programmfenster ein.
2. Geben Sie die Daten (in diesem Fall die Stichprobengröße der Regression und die wahren Parameterwerte) als .json in das Datenfenster ein und klicken Sie zum Speichern.
3. Klicken Sie im Befehlsfenster einmal zum Kompilieren und erneut zum Ausführen.
4. Die Ausgabe (in tabellarischer und grafischer Type) erscheint im Ausgabefenster.

Das ist es! Das Bild oben in diesem Beitrag zeigt die Ergebnisse.

Außerdem werden viele Fehler in der Kompilierungs- und Sampling-Part entdeckt.

[ad_2]