|
|
|
|
Richtig. Einfach immer das ganze File analysieren, dann hast du garantiert auch bei jedem Timestamp den richtigen State. Wie gross sind die Files und hast du irgendwelche Performanceziele?
¤: Und das Fühl für Java6, durfte ich bis letztes Jahr auch noch ganz viel in Produktion schieben weil IBM.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von SwissBushIndian am 18.07.2017 10:03]
|
|
|
|
|
|
Bau dir nen "Parser", der den Inhalt in ein ordentliches Format übersetzt.
Dafür würde ich das File Zeile für Zeile durchgehen, nach den Timecodes suchen, und diese und die bis dahin aufgetretenen Befehle in eine HashMap speichern.
Willst du dann z.B. einen bestimmten Timecode, kannst du den direkt aus der HashMap auslesen.
Fakeedit: Ich wollte gerade ein Testbeispiel erstellen, und bin darauf gekommen, dass es in 1.6 den Diamond-Operator nicht gibt .
// Und viel zu langsam :| .
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von derSenner am 18.07.2017 19:50]
|
|
|
|
|
|
Es hängt viel von der Filegröße ab, wenn sie groß sind, könntest du auch cachen, z.b. der erste Run liest das File von oben bis unten und merkt sich in Abständen einen Index
Timestamp -> Byte Offset im File (beliebige Granularität)
der zweite Request kann dann über den Index mit Hilfe eines Seeks schon grob an die richtige Stelle springen und ggf den Index weiterpflegen
|
|
|
|
|
|
|
Gibt es eigentlich irgendeine Konvention, wie man selbst erstellte Features (in Python/pandas) benennt?
|
|
|
|
|
|
|
Sprichst du von patches für die Bibliothek oder von Dimensionen in einem Datensatz? Für ersteres würde ich in sie Richtlinien der Bibliothek schauen, für zweiteres nicht, dass ich wüsste. Wähle etwas, was zum Rest des Datensatzes passt. MultiIndizes sind eine coole Erfindung in dem Zusammenhang
|
|
|
|
|
|
|
Ich meine eher, dass es sowas wie CamelCase under_score zur Kennzeichnung von Features in einem Datensatz gibt, die man selbst erstellt hat. Irgendein Suffix oder so, damit man weiß, dass es selbst erstellt wurde, wenn sich jemand den Datensatz anschauen will oder man die alle über eine kleine list comprehension finden möchte. Ich benenne einfach mein Feature und hänge hintendran ein "_new", aber bin damit ehrlich gesagt nicht so zufrieden.
Übrigens: Die Groupby-Operation von letztem Mal hat mir sehr geholfen. Danke nochmal
Edit: Und gibt es eine Möglichkeit, dass ich polynomiale Features gut benennen kann?
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von homer is alive am 19.07.2017 15:24]
|
|
|
|
|
|
Hm, ich fürchte bisher waren alle Datensätze mit denen ich so gearbeitet habe von Haus aus schon nicht sonderlich sauber, sodass man da gar nicht mehr viel kaputt machen konnte . Die Daten mit denen man in meinem Kontext am Ende lernt sind ohnehin quasi alle schon "berechnet", sodass diese Unterscheidung nicht wirklich sinnvoll wäre, wobei schon wahr ist, dass abgeleitete Features (im schlimmsten Fall Linearkombinationen) schon irgendwie als solche erkennbar sein sollten. Ich würde sagen am üblichsten sind von dem was ich so gesehen habe Präfixe und Suffixe durch Unterstriche getrennt, zum Beispiel wird aus "alpha" dann "sin_alpha" und "cos_alpha".
Wenn ich viele Aggregationen oder so rechne, finde ich MultiInidzes sehr praktisch, deswegen habe ich das vorhin auch erwähnt. Ein Level könnte dabei das "Ausgangsfeature" sein und ein anderes Level die Aggregationsfunktion oder irgendein beschreibender String. Das hilft dann auch dabei, nach einzelnen Features oder Verfahren zu filtern ohne irgendwelche Stringoperationen machen zu müssen, die ohnehin immer schief gehen früher oder später. Was meinst du denn mit polynomialen Features?
| Zitat von homer is alive
Übrigens: Die Groupby-Operation von letztem Mal hat mir sehr geholfen. Danke nochmal
| |
|
|
|
|
|
|
|
Ich weiß, es ist ein long shot, aber arbeitet hier zufällig jemand bei Swisscom? Bitte PM.
|
|
|
|
|
|
|
Hier im Thread oder im pOT? UCB ist da, glaube ich.
|
|
|
|
|
|
|
|
|
|
|
| Zitat von B0rG*
...
Was meinst du denn mit polynomialen Features?
| |
Okay, danke zu der ersten Frage. Mit polynomialen Features meine ich, dass ich zusätzlich zu F1 und F2 auch F1^2, F2^2 und F1*F2 (also eine als Features habe, damit ich eine polynomiale Regression durchführen kann.
Wenn ich aber PolynomialFeatures() anwende, habe ich nicht mehr meine alten Spaltennamen mit schönen Strings, sondern nur noch x1, x2, x3, ... Ich habe einfach eine Tabelle gemacht, wo man das ablesen kann, für was welches x steht. Ich kann mir kaum vorstellen, dass ich das über einen RegEx oder so machen muss, da sowas, wie du schon beschrieben hast, öfter mal schiefgeht.
|
|
|
|
|
|
|
| Zitat von derSenner
Bau dir nen "Parser", der den Inhalt in ein ordentliches Format übersetzt.
Dafür würde ich das File Zeile für Zeile durchgehen, nach den Timecodes suchen, und diese und die bis dahin aufgetretenen Befehle in eine HashMap speichern.
Willst du dann z.B. einen bestimmten Timecode, kannst du den direkt aus der HashMap auslesen.
Fakeedit: Ich wollte gerade ein Testbeispiel erstellen, und bin darauf gekommen, dass es in 1.6 den Diamond-Operator nicht gibt http://imgur.com/HL782bN.png.
// Und viel zu langsam :| .
| |
Hmm ich müsste dann hinter jeden Hashmap Timecode Key mehrere ArrayLists o.ä. hängen ,für jeden Parameter + Werte eine. Ein Parameter kann auch aus einer Liste von Werten bestehen. So ganz kann ich gerade nicht voraussehen wie kompliziert das ist aber ich versuche mich da mal reinzuarbeiten.
Danke für die vielen Hinweise. I'll be back...
|
|
|
|
|
|
|
Wenn du faul sein willst und / oder dich nicht so sehr auf die Datenstrukturen konzentrieren möchest: Guava hat eine Multimap.
¤: Das klingt jetzt irgendwie negativ, aber so meine ich das überhaupt nicht. Guava ist gutes Zeug.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von SwissBushIndian am 20.07.2017 10:20]
|
|
|
|
|
|
Ich hätte tatsächlich Lust mich da reinzuarbeiten und die Datenstrukturen zu bauen, allerdings habe ich leichte Hemmungen.
Ich will den Java Teil des Projekts nicht zu kompliziert werden lassen, weil mir da einfach die Erfahrung fehlt und mir das sonst vielleicht über den Kopf wächst. Am Ende muss das Teil mehrere Proben und Konzert fehlerfrei überstehen, wahrscheinlich sogar ohne meine Anwesenheit. Ich will da nichts erschaffen, was ich nicht 100% im Griff habe...
|
|
|
|
|
|
|
Du kannst ja jederzeit ein solides Fundament mit einer Library legen und wenn du dann noch Zeit und Lust hast das durch deine eigene Datenstruktur ersetzen. Was einfach ein grosses Problem dabei ist, gerade wenn man wenig Erfahrung hat: man abstrahiert zu wenig und spiegelt viel zu viel der eigentlichen "Businesslogik" darin nieder wie die Daten organisiert sind. Da kann es helfen in einer ersten Iteration das ganze erstmal funktionierend zu haben, dann kann man immernoch selber Hand anlegen in einem zweiten Anlauf.
|
|
|
|
|
|
|
| Zitat von homer is alive
| Zitat von B0rG*
...
Was meinst du denn mit polynomialen Features?
| |
Okay, danke zu der ersten Frage. Mit polynomialen Features meine ich, dass ich zusätzlich zu F1 und F2 auch F1^2, F2^2 und F1*F2 (also eine als Features habe, damit ich eine polynomiale Regression durchführen kann.
Wenn ich aber PolynomialFeatures() anwende, habe ich nicht mehr meine alten Spaltennamen mit schönen Strings, sondern nur noch x1, x2, x3, ... Ich habe einfach eine Tabelle gemacht, wo man das ablesen kann, für was welches x steht. Ich kann mir kaum vorstellen, dass ich das über einen RegEx oder so machen muss, da sowas, wie du schon beschrieben hast, öfter mal schiefgeht.
| |
Hm, das ist in der Tat ziemlich doof was die Benennung angeht. Bei StackOverflow wurde mal eine Lösung dafür besprochen - der Code ist zwar recht grausig, aber die Idee kommt ja rüber. Statt die Python-Datenstrukturen irgendwie zu einem String zu verwursten kannst du auch Tupel oder so draus machen, der Name einer Spalte muss kein String sein (wsl aber hashbar). Vielleicht bekommst du damit ja was hin, womit du leben kannst.
|
|
|
|
|
|
|
| Zitat von Dumenikl
| Zitat von derSenner
Bau dir nen "Parser", der den Inhalt in ein ordentliches Format übersetzt.
Dafür würde ich das File Zeile für Zeile durchgehen, nach den Timecodes suchen, und diese und die bis dahin aufgetretenen Befehle in eine HashMap speichern.
Willst du dann z.B. einen bestimmten Timecode, kannst du den direkt aus der HashMap auslesen.
Fakeedit: Ich wollte gerade ein Testbeispiel erstellen, und bin darauf gekommen, dass es in 1.6 den Diamond-Operator nicht gibt http://imgur.com/HL782bN.png.
// Und viel zu langsam :| .
| |
Hmm ich müsste dann hinter jeden Hashmap Timecode Key mehrere ArrayLists o.ä. hängen ,für jeden Parameter + Werte eine. Ein Parameter kann auch aus einer Liste von Werten bestehen. So ganz kann ich gerade nicht voraussehen wie kompliziert das ist aber ich versuche mich da mal reinzuarbeiten.
Danke für die vielen Hinweise. I'll be back...
| |
Eine HashMap die den Timecode als Key hat, und eine Liste an Commands. Funktioniert auf jeden Fall. Wenn das wirklich irrsinnig viele Daten sind, müsste man die Performance testen.
Achtung: Das folgende Snippet ist in Java 1.8, funktioniert aber auch auf 1.6, wenn du den Diamond-Operator weg lässt. Aber ich bin halt 1.8 gewohnt, deshalb.
|
Code: |
package pot_20170718;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
class Main {
private static final String file = "0:0:1:40\n" +
"param1 bla\n" +
"param2 bla\n" +
"param3 blub\n" +
"0:0:2:30\n" +
"param4 hip\n" +
"param5 hop\n" +
"0:0:3:55\n" +
"param3 la\n" +
"param2 la";
public static void main (String[] args) throws java.lang.Exception {
// Map for timecodes and commands
Map<String, List<String>> commands = new HashMap<String, List<String>>();
// Parse file
List<String> currentCommands = null;
for (String line: Main.file.split("\n")) {
// Time
// Adjust method to detect timecode as you wish
if (line.indexOf(':') != -1) {
currentCommands = new ArrayList<String>();
commands.put(line, currentCommands);
continue;
}
// Command
// As long, as no timecode was found, ignore commands
if (currentCommands != null) {
currentCommands.add(line);
}
}
// Read created command-map
for (Map.Entry<String, List<String>> command: commands.entrySet()) {
String time = command.getKey();
System.out.println("Commands for: " + time);
for (String value: command.getValue()) {
System.out.println(value);
}
}
// Get specific command
System.out.println();
System.out.println("Commands for 0:0:2:30:");
for (String value: commands.get("0:0:2:30")) {
System.out.println(value);
}
System.out.println();
System.out.println("Commands for 0:0:3:55:");
for (String value: commands.get("0:0:3:55")) {
System.out.println(value);
}
System.out.println();
System.out.println("Commands for 0:0:1:40:");
for (String value: commands.get("0:0:1:40")) {
System.out.println(value);
}
}
} |
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von derSenner am 20.07.2017 19:33]
|
|
|
|
|
|
//nvm.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von csde_rats am 20.07.2017 19:33]
|
|
|
|
|
|
Ohne den Code jetzt auf Anhieb komplett zu verstehen, sieht das schon sehr interessant aus.
Ich merke, dass ich so umbauen muss, dass für jeden eingehenden timecode nicht jedesmal das ganze file durchsucht wird. Ich weiß nicht genau wieviel da kommt, ein paar hundert Zeilen werden da aber schon zusammen kommen.
|
|
|
|
|
|
|
Ein paar hundert Einträge ist ja quasi nix. Da kannst du auch jedesmal das ganze File durchgehen. Höchstens wenn die einzelnen Zeilen ein komplexeres Format zum parsen hätten, kann das langsamer werden. Aber das sieht ja nicht wirklich so aus.
Ansonsten, wenn das File quasi immer weiterwächst, kannst du dir ja die Größe des Files beim letzten parsen merken, und beim erneuten parsen dort, und nicht von vorne anfangen. Oder halt beim letzten Timestamp fortsetzen. Kommt halt drauf an, wie deine Daten reinkommen.
Der Code oben macht aber genau das, was du ungefähr beschrieben hast:
Eine Liste von Listen, wobei der Timecode als Schlüssel zu einer Liste verwendet wird.
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von derSenner am 23.07.2017 17:07]
|
|
|
|
|
|
Moin.
Gnuplot-Frage: Kriegt man diese Funktionalität mit Gnuplot-Bordmitteln irgendwie schöner/kompakter?
|
Code: |
set ytics nomirror
set y2tics
set terminal png size 1280,1024
set xtics rotate by 45 right
set title "day"
set ylabel "Temp"
set y2label "Hum"
stats "day.txt" using 1:(($3+$5)/2.)
tmin= STATS_min_y
tmax = STATS_max_y
stats "day.txt" using 1:(($4+$6)/2.)
hmin = STATS_min_y
hmax = STATS_max_y
set yrange [19:22]
if(tmin < 19.) {
set yrange [*:]
}
if(tmax > 22.) {
set yrange [:*]
}
set y2range [55:65]
if(hmin < 55.) {
set y2range [*:]
}
if(hmax > 65.) {
set y2range [:*]
}
set xdata time
set timefmt "%Y-%m-%d %H:%M:%S"
set format x "%H:%M"
set output "day.png"
plot "day.txt" using 1:(($3+$5)/2.) w l axes x1y1 title "T", "day.txt" using 1:(($4+$6)/2.) w l axes x1y2 title "H"
reset
<nochmal das gleiche mit "week" anstelle von "day">
|
|
stats() ist total nervig, da es sensitiv auf xrange, yrange und scheinbar andere Variablen reagiert, daher der Umweg mit tmin, tmax usw.
Und auch das reset in der Mitte ist stats geschuldet, da es sonst beim vierten(!) Aufruf zu
| line 53: All points out of range | |
führt.
Ich könnte mir die Datums-Option ganeuer angucken und den day-Plot auch aus week.txt erstellen, ja, aber der Teil mit "stats()" ist der, der mich stört.
set yrange [min(tmin,19):max(tmax,auto)] wäre ja z.B: kürzer, aber das scheint Gnuplot nicht zu können. Ich könnte versuchen die ifs als ?: in die Klammern zu ziehen, aber schön ist das ja auch nicht.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Rootsquash am 24.07.2017 15:03]
|
|
|
|
|
|
Ich würde gern in VS 2017 ein paar Node Module auf Solution Ebene laufen lassen, in 2015 ging das noch, wie schaffe ich das in 2017?
|
|
|
|
|
|
|
Man stelle sich vor ein Molekül mit Symmetrie () ist zufällig im Raum orientiert. Ihr kennt den Erwartungswert einer Größe für die Karthesischen Koordinaten des Moleküls - wie ist nun der gemittelte Wert für alle zufälligen Orientierungen?
|
|
|
|
|
|
|
Über alle Orientierungen mitteln?
|
|
|
|
|
|
|
Dachte ich auch erst, aber angeblich muss man da die Symmetrie mitbeachten hatmanmirgesagt.
|
|
|
|
|
|
|
baja gut, bei ner 3-fach Symmetrie musst du halt nur 120° mitteln, dann wiederholt es sich ja. Oder so.
|
|
|
|
|
|
|
Ihr immer mit eurer esoterischen Physik, die kein Schwein (ich) versteht...
|
|
|
|
|
|
|
| Zitat von Xerxes-3.0
baja gut, bei ner 3-fach Symmetrie musst du halt nur 120° mitteln, dann wiederholt es sich ja. Oder so.
| |
Über alle Orientierungen zu mitteln macht vielleicht mehr Arbeit, aber das Ergebnis sollte trotzdem stimmen, oder?
|
|
|
|
|
|
|
| Zitat von Rootsquash
| Zitat von Xerxes-3.0
baja gut, bei ner 3-fach Symmetrie musst du halt nur 120° mitteln, dann wiederholt es sich ja. Oder so.
| |
Über alle Orientierungen zu mitteln macht vielleicht mehr Arbeit, aber das Ergebnis sollte trotzdem stimmen, oder?
| |
Es ist mehr Rechenaufwand, aber ja. Sprich, je nachdem, wie gut du darin bist, die Symmetrien zu implementieren, kannst du vielleicht auch schneller über alles mitteln.
|
|
|
|
|
|
|
Scheinbar ist das doch alles etwas komplexer, als ich dachte... Also die Situation ist folgende: Ich habe ein Molekül, für dessen Koordinatensystem ich das Übergangsdipolmoment in X-, Y- und Z-Achse kenne. Das ganze interagiert mit Laserpulsen im Lab-System Entlang einer Achse A polarisiert. Bisher nahm ich an, ich könnte jetzt die Dynamiken ausrechnen, wenn ich das Molekül im Lab-System entlang einer Achse fixiere und hinterher aus den drei Möglichkeiten ein Mittel ausrechne, dass die zufällige Orientierung des Molekül relativ zum Lab-System repräsentiert.
Allerdings hab ich jetzt ein PRA vom letzten Jahr gefunden, das suggeriert, dass diese sehr pathologische Wahl der Koordinaten nicht ausreichen um koheränte Mischungen aus Anregungen entlang der Achsen zu repräsentieren... Daher fangen die dann an tatsächlich über verschiedene Winkel zu integrieren - was aber natürlich den computational Aufwand in die Höhe treibt. Naja mal schauen, vielleicht geht da ja was mit nem magic angle
|
|
|
|
|
|
Thema: pOT-lnformatik, Mathematik, Physik XXI ( X-Ray-Edition ) |