|
|
|
|
Glaube nicht, dass du da Chancen hast. Es kommt auf den generator an, aber selbst wenn der nicht gut ist kommst du mit Mathematik vermutlich weiter als mit neuronalen Netzen.
Diese deep learning chose ist nicht überall die beste Methode und wird im Moment viel zu sehr gehyped.
|
|
|
|
|
|
|
| Zitat von Oli
Glaube nicht, dass du da Chancen hast. Es kommt auf den generator an, aber selbst wenn der nicht gut ist kommst du mit Mathematik vermutlich weiter als mit neuronalen Netzen.
Diese deep learning chose ist nicht überall die beste Methode und wird im Moment viel zu sehr gehyped.
| |
Gerade noch fix editiert gehabt:
Wobei das glaube ich eher weniger Richtung neuronales Netzwerk gehen würde.
Würde die gesammelten Daten in Chunks speichern, den aktuellen "Zeitabschnitt" mit den gesammelten Chunks vergleichen. (Auf unterschiedliche Arten vergleichen, über mehrere Worker, die dann jeweils 1 oder 0 zurückgeben.)
Je nach dem welche Worker richtig liegen, denen, über Zeit, eine bessere Gewichtung zuteilen.
|
|
|
|
|
|
|
Kennst du den Zufallszahlen generator und hast du Einfluss auf den seed? Wenn ja, dann würde ich erstmal dessen Schwächen recherchieren und gezielt versuchen auszunutzen. Musst dich halt mit der Mathematik beschäftigen.
|
|
|
|
|
|
|
Ja, denke das kommt vollkommen darauf an, wie deine Daten erzeugt werden.
Ich hab ja keine Ahnung, aber ein naiver Schutz gegen deine Idee könnte sein einen weiteren, für dich unsichtbaren, RNG zu benutzen, der in (pseudo-)zufälligen Abständen das System (den Generator, den Seed,...) der Daten die du siehst ändert. Vielleicht das Ganze 1-2 Iterationen tief, glaube nicht, dass man da (schnell) drauf kommt. Müsste man dann wiederum Statistiken der Messdaten nehmen und auf Unterschiede untersuchen, das kann man natürlich auch verschleiern etc. Klingt interessant, aber eher aus theoretischer Perspektive.
|
|
|
|
|
|
|
Wenn dein Zufallszahlengenerator gut gewählt ist und "aktuellen" Anforderungen entspricht (oder genauer: es nicht bekannt ist, dass er das nicht tut), dann wirst du dich sehr schwer tun seine Ausgabe vorherzusagen, denn was du forderst ist gerade die Definition eines guten Zufallszahlengenerators zu brechen. Anders formuliert: Wenn du einen Algorithmus findest (und ich bin mir recht sicher, dass der nicht auf Methoden des maschinellen Lernens basieren wird), der einen gängigen guten Zufallszahlengenerator bricht, dann mach da lieber mal ein Paper draus und werd reich.
Wenn der Algorithmus schlecht ist, ist es wahrscheinlich zielführender den Algorithmus selbst zu analysieren, wenn bekannt.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von B0rG* am 03.07.2017 18:29]
|
|
|
|
|
|
Versuch es ansonsten doch mal mit nem schöönen Chart Pattern!
Scheint auch immer noch Leute zu motivieren, aber leider...
| The results for the proposed model were not perfect because many factors including but not limited to political events, general economic conditions, and investors’ expectations influence stock market. | |
|
|
|
|
|
|
|
Was ist der Weg des geringsten Widerstandes um folgendes zu erreichen:
|
Code: |
class bla {
public:
...
??? operator[](int i) const {
// return iterator for data[i * length] - data[(i+1) * length]
return ...
}
??? &operator[](int i) {
// return iterator for data[i * length] - data[(i+1) * length]
return ...
}
size_t length{1000};
std::vector<float> data;
};
int main(int argc, char const *argv[]) {
bla x;
...
for(float & d: x[10]) {
...
}
return 0;
} |
|
Ich will also über einen Slice des data members iterieren. Die range based for loop braucht ja eine begin() und eine end() Funktion in der Klasse, die vom [] Operator returned wird. Ideen?
//e: Habe beim ersten googeln wohl folgende Antwort übersehen: https://stackoverflow.com/questions/30540101/iterator-for-a-subset-of-a-vector
Erledigt, danke.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Oli am 06.07.2017 11:49]
|
|
|
|
|
|
Nochmal.
Wieso segfaulted das hier?
|
Code: |
#include <vector>
#include <algorithm>
int main(int argc, char const *argv[])
{
size_t N = 8000;
std::vector<char> f(sizeof(float) * N);
std::vector<float> ff(N);
std::vector<float> entry(N, 9999);
std::copy(entry.begin(), entry.end(), &f[0]);
std::copy(f.begin(), f.end(), &ff[0]);
return 0;
} |
|
Alle vektoren sind doch genau gleich groß, nicht?
|
|
|
|
|
|
|
Nope, scheinbar nicht:
|
Code: |
size_t N = 8000;
std::vector<char> f(sizeof(float) * N);
std::vector<float> ff(N);
std::vector<float> entry(N, 9999);
std::cout << f.size() << std::endl;
std::cout << ff.size() << std::endl;
std::cout << entry.size() << std::endl;
|
|
->
32000
8000
8000
Wieso das so ist seh ich gerade aber auch nicht.
/e: Ah. std::copy nutzt die Iteratoren des Vektors. Daher sollte der allokierte Speicherbereich zwar schon exakt gleich groß sein, da die Typen aber unterschiedliche sizes haben, schiebt std::copy aber 32000 Elemente in nen Vektor der nur 8000 Elemente halten kann. Also so erklär ich's mir gerade. Wenn du ff um Faktor 4 (sizeof(float)) vergrößerst, läufts ohne Knall.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von statixx am 07.07.2017 11:01]
|
|
|
|
|
|
Ja, ich habe angenommen, std::copy sei schlau genug für Type casts. Ist es nicht.
|
Code: |
#include <vector>
#include <algorithm>
int main(int argc, char const *argv[])
{
size_t N = 8000;
std::vector<char> buffer(sizeof(float) * N);
std::vector<float> out(N);
std::vector<float> in(N, 9999);
std::copy(in.begin(), in.end(), reinterpret_cast<float*>(buffer.data()));
std::copy(buffer.begin(), buffer.end(), reinterpret_cast<char*>(out.data()));
return 0;
} |
|
So geht's.
|
|
|
|
|
|
|
Naja, std::vector.size() gibt doch nur die Anzahl der Elemente zurueck. Ich koennte da ja auch sizeof(float) * N viele Instanzen einer richtig fetten Klasse reinstopfen.
|
|
|
|
|
|
|
Da hast du natürlich vollkommen recht, war mir wohl gerade entfallen.
|
|
|
|
|
|
|
Ich wuerds mir aber genauso erklaeren wie du. Wenn ich jetzt 4000 1 Byte grosse Elemente habe, ist das beim Rumspringen der Iteratoren wohl was anderes als 1000 4 Byte grosse Elemente. Glaub' ich.
/Ich versteh auch irgendwie den Anwendungsfall nicht so richtig. Oli, kannst du da ein bisschen mehr Kontext liefern?
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von MCignaz am 07.07.2017 11:16]
|
|
|
|
|
|
Ich dachte halt, der iteriert zwar durch das Eingangsarray (von begin() bis end()), schreibt aber einfach den Speicher kontinuierlich in das Ausgangsarray. Anscheinend wird das Ausgangsarray auch mittels + Operator advanced, deshalb braucht man den Cast.
Ich sag euch, Serialization und MPI sind ganz schön scheiße zu debuggen. Die Soße kompiliert nämlich ohne Warnung, und das Programm Crasht (wenn der char buffer groß genug ist) an den komischsten Stellen.
/e:
| Zitat von MCignaz
/Ich versteh auch irgendwie den Anwendungsfall nicht so richtig. Oli, kannst du da ein bisschen mehr Kontext liefern?
| |
Ich schicke Dinge per message passing zwischen Rechnern hin und her und dafür muss ich Objekte in char* buffer serializen. Will keine Library für die paar Zeilen code nutzen.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Oli am 07.07.2017 11:17]
|
|
|
|
|
|
|
|
|
|
Folgendes Problem:
Ich brauche einen Texteditor (OS X) für den ich ziemlich schnell ein simples, eigenes Synthax Highlighting bauen kann. Es geht im Prinzip nur um das einfärben einzelner Stichworte.
Er sollte kostenlos sein, da das ganze nicht nur für mich ist.
Ich hatte an Atom gedacht, das Erstellen eigener Syntax Highlightings scheint aber nicht wirklich dokumentiert zu sein.
Jemand einen schnellen Tip?
|
|
|
|
|
|
|
|
|
|
|
Yo beotches. Der ein oder andere von euch kann doch Python, und ein paar wenige sprechen sogar RegEx. Ich versuch hier gerade ein wild zusammengewürfeltes Literaturverzeichnis zu reparieren. Wie mach ich am klügsten automatisiert aus:
"A. Author, B. Author, C.D. Author (1999): Asdfxyz, 1(2), 3-4."
"Author, A., Author, B., Author C.D. (1999): Asdfxyz, 1(2), 3-4."
?
/e: Potentielles Problem: Mitunter kommen auch C. D. statt C.D. und CD, C-D, C.-D., C D vor. Aber da die meisten wie oben geschrieben sind, wäre mir ein Codenschnippsel dafür schon eine erhebliche Hilfe.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von nobody am 10.07.2017 14:59]
|
|
|
|
|
|
Habe mich entschlossenen den PhD in theoretischer Physik dranzuhängen. Leider hat mein Masterarbeitbereuer wahrscheinlich keine Kapazitäten und ich muss mich nach Alternativen umschauen.
Kennt jemand Anlaufstellen außer dem Üblichen (Betreuer fragen, Konferenzen, prof-homepages abklappern und direkt anschreiben)?
Falls jemand zufällig eine Stelle im Bereich condensed matter theory, speziell richtung: Non-equilibrium quantum Field theory&dynamics, functional RG, quantum information, machine learning, top. qu. field theory sieht, her damit, bin für jeden Tipp dankbar!
/e: Spezialisierungen angepasst/erweitert
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von R am 10.07.2017 20:46]
|
|
|
|
|
|
| Zitat von nobody
Yo beotches. Der ein oder andere von euch kann doch Python, und ein paar wenige sprechen sogar RegEx. Ich versuch hier gerade ein wild zusammengewürfeltes Literaturverzeichnis zu reparieren. Wie mach ich am klügsten automatisiert aus:
"A. Author, B. Author, C.D. Author (1999): Asdfxyz, 1(2), 3-4."
"Author, A., Author, B., Author C.D. (1999): Asdfxyz, 1(2), 3-4."
?
/e: Potentielles Problem: Mitunter kommen auch C. D. statt C.D. und CD, C-D, C.-D., C D vor. Aber da die meisten wie oben geschrieben sind, wäre mir ein Codenschnippsel dafür schon eine erhebliche Hilfe.
| |
|
Code: |
([A-Z\.-]+\s)|([A-Za-z]+)|:.* |
|
Mit Python hab ich keine Ahnung, aber mit dem Pattern und einem matching-array geht das auf jeden Fall.
https://regex101.com/r/kqTko1/3
In den Capture Groups hast du immer abwechselnd:
10 Kürzel von Person A
20 Name von Person A
30 Kürzel von Person B
40 Name von Person B
GOTO 10
Kannst du dann umsortieren, wie du willst.
// Hm, naja. Deine Spezialfälle muss ich noch checken.
// So!
|
[Dieser Beitrag wurde 4 mal editiert; zum letzten Mal von derSenner am 10.07.2017 19:58]
|
|
|
|
|
|
Wie kann ich den Code hier schlanker bzw. schneller machen? Ich habe ein Pandas-Dataframe mit den Spalten 'ARBPL [str]' und 'Masch.-Rep. BDE 15 [min]'. Im Endeffekt will ich z.B. einen cumcount auf ein groupby, der aber bei bestimmten Kriterien zurückgesetzt wird (wenn z.B. Masch-Rep... nicht 0 ist)
|
Code: |
for arbpl in df['ARBPL [str]'].unique():
rep_count = 0
for row in df_c.loc[df_c['ARBPL [str]'] == arbpl].index:
df_c.loc[row, 'Without_Rep'] = rep_count
if df_c.loc[row, 'Masch.-Rep. BDE 15 [min]'] == 0:
rep_count += 1
else:
rep_count = 0
count += 1 |
|
Danke!
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von homer is alive am 10.07.2017 19:59]
|
|
|
|
|
|
| Zitat von R
Habe mich entschlossenen den PhD in theoretischer Physik dranzuhängen. Leider hat mein Masterarbeitbereuer wahrscheinlich keine Kapazitäten und ich muss mich nach Alternativen umschauen.
Kennt jemand Anlaufstellen außer dem Üblichen (Betreuer fragen, Konferenzen, prof-homepages abklappern und direkt anschreiben)?
Falls jemand zufällig eine Stelle im Bereich condensed matter theory, speziell richtung: Non-equilibrium Field theory&dynamics, quantum information, machine learning, top. field theory sieht, her damit, bin für jeden Tipp dankbar!
| |
...ich nehme an, wenn ich dir Bianca Dittrich oder so jemanden für TQFT empfehle, liege ich falsch, oder?
¤DIT:
Woops, talks durcheinander geworfen.
No, murder is not the answer. You always suggest that.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Wraith of Seth am 10.07.2017 20:02]
|
|
|
|
|
|
| Zitat von homer is alive
Wie kann ich den Code hier schlanker bzw. schneller machen? Ich habe ein Pandas-Dataframe mit den Spalten 'ARBPL [str]' und 'Masch.-Rep. BDE 15 [min]'. Im Endeffekt will ich z.B. einen cumcount auf ein groupby, der aber bei bestimmten Kriterien zurückgesetzt wird (wenn z.B. Masch-Rep... nicht 0 ist)
|
Code: |
for arbpl in df['ARBPL [str]'].unique():
rep_count = 0
for row in df_c.loc[df_c['ARBPL [str]'] == arbpl].index:
df_c.loc[row, 'Without_Rep'] = rep_count
if df_c.loc[row, 'Masch.-Rep. BDE 15 [min]'] == 0:
rep_count += 1
else:
rep_count = 0
count += 1 |
|
Danke!
| |
Ich denke gerne über dein Problem nach, wenn du ein bisschen besser beschreibst, was du eigentlich willst. Könntest du ein einfaches Beispiel zeigen mit dem Ergebnis, das du dir vorstellst?
Generell ist die Antwort auf deine Frage sehr wahrscheinlich "ja".
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von B0rG* am 10.07.2017 21:22]
|
|
|
|
|
|
Seid ihr nicht so was wie Gedankenleser? Na gut!
Im Endeffekt soll in diesem einfacheren Fall (habe auch noch schwierigere, aber erhoffe mir, dass ich das einfach übertragen kann), dass ein Counter hochzählt (oder eine Summe), wenn ein Ereignis wahr ist. Einfacher Fall mit einem DF mit 2 Spalten:
|
Code: |
A B Counter
0 X 0 0
1 X 0 1
2 X 0 2
3 S 0 1
4 S 0 2
5 X 1 0
6 X 0 1
7 X 0 2
|
|
Der Counter für X (in Spalte A) zählt also solange hoch, wie in B eine 0 steht. Sobald etwas ungleich 0 steht, wird er zurückgesetzt und startet wieder von Neuem. Das gleiche soll dann für alle anderen Einträge aus A (also bspw. S, in meinem Codebeispiel geht er eben alle Uniques durch).
Ist das verständlicher?
|
|
|
|
|
|
|
|
Code: |
df = pd.DataFrame({'A': ['X', 'X', 'X', 'S', 'S', 'X', 'X', 'X', 'S'], 'B': [0, 0, 0, 0, 0, 1, 0, 0, 0]})
df['C'] = df.groupby(['A', df.groupby('A')['B'].cumsum()]).cumcount()
df
Out[29]:
A B C
0 X 0 0
1 X 0 1
2 X 0 2
3 S 0 0
4 S 0 1
5 X 1 0
6 X 0 1
7 X 0 2
8 S 0 2
|
|
So in etwa?
Ich glaube das ist noch nicht so effizient wie es sein könnte, eventuell kann man das auch in einer groupby-Operation lösen. Aber sollte schon schneller sein als die jetzige Lösung hoffe ich?
|
|
|
|
|
|
|
| Zitat von derSenner
| Zitat von nobody
Yo beotches. Der ein oder andere von euch kann doch Python, und ein paar wenige sprechen sogar RegEx. Ich versuch hier gerade ein wild zusammengewürfeltes Literaturverzeichnis zu reparieren. Wie mach ich am klügsten automatisiert aus:
"A. Author, B. Author, C.D. Author (1999): Asdfxyz, 1(2), 3-4."
"Author, A., Author, B., Author C.D. (1999): Asdfxyz, 1(2), 3-4."
?
/e: Potentielles Problem: Mitunter kommen auch C. D. statt C.D. und CD, C-D, C.-D., C D vor. Aber da die meisten wie oben geschrieben sind, wäre mir ein Codenschnippsel dafür schon eine erhebliche Hilfe.
| |
|
Code: |
([A-Z\.-]+\s)|([A-Za-z]+)|:.* |
|
Mit Python hab ich keine Ahnung, aber mit dem Pattern und einem matching-array geht das auf jeden Fall.
https://regex101.com/r/kqTko1/3
In den Capture Groups hast du immer abwechselnd:
10 Kürzel von Person A
20 Name von Person A
30 Kürzel von Person B
40 Name von Person B
GOTO 10
Kannst du dann umsortieren, wie du willst.
// Hm, naja. Deine Spezialfälle muss ich noch checken.
// So!
| |
Danke! Ich schau morgen mal, was ich daraus gebastelt kriege.
|
|
|
|
|
|
|
| Zitat von B0rG*
|
Code: |
df = pd.DataFrame({'A': ['X', 'X', 'X', 'S', 'S', 'X', 'X', 'X', 'S'], 'B': [0, 0, 0, 0, 0, 1, 0, 0, 0]})
df['C'] = df.groupby(['A', df.groupby('A')['B'].cumsum()]).cumcount()
df
Out[29]:
A B C
0 X 0 0
1 X 0 1
2 X 0 2
3 S 0 0
4 S 0 1
5 X 1 0
6 X 0 1
7 X 0 2
8 S 0 2
|
|
So in etwa?
Ich glaube das ist noch nicht so effizient wie es sein könnte, eventuell kann man das auch in einer groupby-Operation lösen. Aber sollte schon schneller sein als die jetzige Lösung hoffe ich?
| |
Das ist ziemlich gut. Danke!
Was mir auffällt, der cumcount beginnt leider eins zu früh, schau:
|
Code: |
A B b0rg homer
0 X 0 0 0.0
1 X 801 0 1.0
2 X 0 1 0.0
3 X 799 0 1.0
4 X 1 0 0.0
5 X 1 0 0.0
6 X 1 0 0.0
7 X 0 1 0.0
8 X 0 2 1.0 |
|
So müsste es sein (habe nur große Werte für B verwendet, weil es nicht nur binär ist, aber ist ja egal).
Mein Code:
|
Code: |
rep_count = 0
for row in df.index:
df.loc[row, 'homer'] = rep_count
if df.loc[row, 'B'] == 0:
rep_count += 1
else:
rep_count = 0 |
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von homer is alive am 11.07.2017 0:31]
|
|
|
|
|
|
Ich fürchte dann verstehe ich die Logik nicht - in deinem Beispiel ist in der Zeile mit der 1 in B eine 0 in C - wobei ich die Einträge für S für einen Fehler gehalten habe. Was würdest du dir genau wünschen?
e/ Falls du möchtest, dass die Zeile mit der 1 drin noch zur vorherigen Gruppe gehört, ist das schnellste was mir einfällt df['C'] = df.groupby(['A', df.groupby('A')['B'].shift(1).fillna(0).cumsum()]) - wobei das schon durchaus nicht hübsch ist .
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von B0rG* am 11.07.2017 0:44]
|
|
|
|
|
|
Sorry, ich hätte einfach ein Codebeispiel von mir nehmen sollen wie in meinem letzten Post. Im ursprünglichen tatsächlich ein Fehler von mir drin, da bei B>0 noch nicht direkt zurückgesetzt wird, sondern erst das nächste auf 0 gesetzt wird. Es steht also immer der Vorgängerwert drin sozusagen (es wird erst der alte Counter eingetragen, dann wird er aktualisiert). Im Endeffekt soll das passieren:
Solange eine Maschine (Spalte A) ohne Reparatur läuft (Spalte B = 0), soll ein Counter hochzählen, damit ich nachher das Feature "Tage ohne Reparatur" habe. X und S wären demnach unterschiedliche Maschinen.
Dies ist noch ein relativ einfaches Feature, da ich nur ein Groupby habe. Später muss ich aber 2 machen und mit 2 for-Schleifen dauert es ewig (bestimmt ne Minute), obwohl der Datensatz nur 10000 Examples hat.
Sorry
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von homer is alive am 11.07.2017 0:50]
|
|
|
|
|
|
kennt jemand einen Weg ein Gleichungssystem der Form
(x_m)^2 + \Sum n [ a_n * x_n ] = 0
analytisch zu lösen?
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von RichterSkala am 11.07.2017 13:20]
|
|
|
|
|
Thema: pOT-lnformatik, Mathematik, Physik XXI ( X-Ray-Edition ) |
|