Füllen einer Matrix mit NaN sinnvoll ?!

[TobiFrischling]

Hallo liebe Community,

bin selber ziemlich neu in Python und eigentlich eher ein R Programmierer , hab seit kurzem eine neue Tätigkeit als Student im Bereich Data Science.
Daher wird eine Umsetzung vieler meiner Codes in Python vorausgesetzt.

Code: Alles auswählen

X= matrix(NaN,length(int.x),length(l))

ist eine Zeile aus meinem Code, dies zu übersetzten fällt mir leider ein wenig schwer

Mein Ansatz->

Code: Alles auswählen

X=np.mat(np.nan,length(x),length(l)

leider bin ich bei der Zeile ziemlich am zweifeln ...vielleicht kann mir der eine oder andere mit einem neuen Ansatz helfen

[__deets__]

Warum nicht x = np.zeros((hoehe, breite))? Oder ist das NaN wirklich wichtig? Dann ein x.fill(np.nan) hinter dran. Was man uebrigens auch in wenigen Sekunden googeln findet.

https://www.google.de/search?q=numpy+ar ... e&ie=UTF-8

Es lohnt IMHO in seine google-Faehigkeiten zu investieren, denn hier ist ja nicht immer wer zeitnah dabei.

[TobiFrischling]

NaN wäre schon notwendig...
DANKEE

Noch eine blöde Frage hätte ich noch

Code: Alles auswählen

for(i in 1:length(l)) X[,i]= MF[[i]](x)

Mein Ansatz sehe so aus:

Code: Alles auswählen

for i in range(1,1+l.length()):
            X[:,i]= MF[i](x)

Mir macht die zweifache Klammerung bei R ein wenig Kopfschmerzen

[Sirius3]

@TobiFrischling: es wäre auf jeden Fall hilfreich, erst einmal das Numpy-Tutorial durchzuarbeiten. Ich weiß nicht, was die MF ist und was diese doppelten Klammern in R bedeuten, aber bei numpy macht man in 90% der Fälle etwas falsch, wenn man explizite Schleifen programmiert. Ein bißchen mehr Kontext und Erklärung, was Du versuchst zu machen, wäre gut.

[TobiFrischling]

Okay , hast recht
Tut mir leid
Hatte ich noch vor , die numpy library mir anzuschauen

Also

Code: Alles auswählen

me.pdf= function(MF,l) {
		pdf = function(x){
				for(i in 1:length(l)) X[,i]	= MF[[i]](x)
				exp(l%*%t(X))
			}
		pdf
	}

Mein Ansatz, bis zu jetzigem Zeitpunkt :

Code: Alles auswählen

def mepdf(MF,l):
    def pdf(x):
        for i in range(1,1+l.length()):
            X[:,i]= MF[i](x)
            np.exp(l * np.transpose(X))
        return pdf

[Sirius3]

@TobiFrischling: das, was Du hier zeigst, ist kein Python. Man kann nicht einfach ein Programm aus einer anderen Programmiersprache nehmen und hoffen, dass, wenn man ein paar Zeichen ändert, auf magische Weise ein funktionierendes Programm rauskommt. Fang mit einem Python-Tutorial an, mach mit dem numpy-Tutorial weiter und schreibe dann Deine Algorithmen neu, mit dem Wissen, wie man Python-Programme schreibt.

[MagBen]

Numpy ist 0-basiert, d.h. das erste Array-Element hat den Index 0.

Also nicht

Code: Alles auswählen

for i in range(1,1+l.length()):

sondern

Code: Alles auswählen

for i in range(0,l.size):

oder

Code: Alles auswählen

for i in range(l.size):

Das sieht hübscher aus

Code: Alles auswählen

np.exp(l * X.T)

als

Code: Alles auswählen

np.exp(np.transpose(X))

Und zum Titel "Füllen einer Matrix mit NaN sinnvoll ?! "
Mit NaN rechnen ist extrem nützlich.

[__deets__]

Ich glaube sofort, das man mit NaN nette Dinge anfangen kann. Nur sieht es doch so aus, als ob der TE eine Matrix alloziert, um sie dann spaltenweise mit irgendetwas zu fuellen. So zumindest interpretiere ich X[:,i]= MF(x) - das wird fuer alle Spalten i ausgefuehrt.

Insofern sollte es auch voellig wumpe sein, wie die Matrix initialisiert wurde :K Daher die Frage, ob er das ueberhaupt braucht.

[narpfel]

@TobiFrischling: Anscheinend bist du nicht der einzige mit dem Problem: Joey21 hat hier genau das selbe Problem.

[TobiFrischling]

Danke, für die nette Unterstützung
Eine kleine Frage hätte ich da noch.
In R gibt es die Schreibweise

Code: Alles auswählen

for(i in 1:length(l)) X[,i]= MF[[i]](x)

mit der zweifachen eckigen Klammer. Heißt ja nichts anderes als das i te Element von der Liste, Array..

Die Umsetzung für Python gelingt mir leider nicht .

Code: Alles auswählen

for i in range(0,l.size): X[:,i] = ....

[__deets__]

Was heisst geht nicht? Denn fuer mich geht genau das.

Code: Alles auswählen

>>> import numpy as np
>>> a = np.zeros((3, 6))
>>> a[:,1]
array([ 0.,  0.,  0.])

Bitte arbeite mal ein bisschen an deinem Frage-Stil: wenn du Fehlermeldungen hast, poste die. Wenn nicht das passiert, was du moechtest, das passiert, beschreibe auch das.

[TobiFrischling]

Klar, blöd von mir. Ihr könnt ja keine Gedanken lesen.
Meine Hauptaufgabe besteht darin eine csv Datei einzulesen , Integrationsgewichte definieren und sie mit einer Normalverteilung zu plotten und schauen ob sie konvergiert.

Die Gewichte habe ich ziemlich ineffizient gelöst. Eine kleine Kostprobe

Code: Alles auswählen

import csv
import pandas as pd
#data = np.loadtxt('xy.csv',skiprows=1, delimiter=';')
data =pd.read_csv('xy.csv', delimiter=';')
x =data[:1]
w = data[:2]

a = (x/2 + 0.5)* 0.1 
b= 0.1+(x/2+.5)*0.9
g = 1+(x/2+.5)*9
c= 10+(x/2+.5)*90
d= 100+(x/2+.5)*900
X=np.concatenate((a,b,g,c,d))

q= w* 0.1/2
e= w*0.9/2
r= w*9/2
m= w*90/2
n= w*900/2
W=np.concatenate((q,e,r,m,n))

plt.plot(W)

Daraufhin wollte ich die pdf definieren , welches wie folgt ausschaut

Code: Alles auswählen

def mepdf(MF,l):
    def pdf(X):
        for i in range(0,l.size):
            Y[:,i]= MF[i](X)
            np.exp(l * Y.T)
        return pdf
    return mepdf(MF,l)

Der Code ,welches in R Funktioniert schaut so aus

Code: Alles auswählen

me.pdf	= function(MF,l) {
		pdf = function(x){
				for(i in 1:length(l)) X[,i]	= MF[[i]](x)
				exp(l%*%t(X))
			}
		pdf
	}

Nur wenn ich in die Konsole bspw mepdf(1,2) eintrage
kommt die Meldung

Code: Alles auswählen

---------------------------------------------------------------------------
RecursionError                            Traceback (most recent call last)
<ipython-input-129-92a8d26d77f2> in <module>()
----> 1 mepdf(1,2)

<ipython-input-128-fe4a3881f4f8> in mepdf(MF, l)
      8             np.exp(l * Y.T)
      9         return pdf
---> 10     return mepdf(MF,l)

... last 1 frames repeated, from the frame below ...

<ipython-input-128-fe4a3881f4f8> in mepdf(MF, l)
      8             np.exp(l * Y.T)
      9         return pdf
---> 10     return mepdf(MF,l)

RecursionError: maximum recursion depth exceeded

[__deets__]

Das ist ja nun ein komplett anderes Problem. Was du da gemacht hast kann kuerzer so umschrieben werden:

Code: Alles auswählen

def mepdf(MF,l):
    return mepdf(MF,l)

Denn ob du da nun eine Funktion lokal definierst oder nicht - das spielt fuer's Ergebnis keine Rolle: du rufst einfach mepdf die ganze Zeit aus sich selbst auf. Eine Rekursion, und da keine Abbruchbedingung definiert ist, ist die endlos. Da endlose Dinge nur in der Mathematik funktionieren, aber weniger gut auf unseren beschraenkten endlichen Computern, bricht das ganze dann nach ein paar 1000 Selbst-Aufrufen ab.

Ich kann kein R, aber mein Eindruck ist, das du eigentlich statt "return mepdf" ein "return pdf" machen willst, weil du dann eine Funktion definiert hast, welche die Parameter MF und l fest angebunden hat. Kann man so machen, ist auch nicht boese oder so, wuerde man in Python aber eher anders machen: mit functools.partial.

Code: Alles auswählen

def pdf(MF, l, X):
      ...

bound_pdf = functools.partial(pdf, ein_mf, ein_l) # ergibt eine Funktion, die nur noch X nimmt.

[TobiFrischling]

Sau die gute Erklärung ,danke:D

Ich muss gestehen , hab es mir mal eben ein wenig angeschaut mit den functools partial
nicht so einfach die Logik dahinter zu verstehen

Ausserdem wäre mein nächstes Problem dass mit der zweifachen eckigen Klammer von R , dies in Python umzusetzen ist nicht so einfach

Aber der Tag hat ja noch paar Stündchen