Python Datenanalyse Cheat Sheet (DRAFT) by moeregrind8645

for c_i in c:
	print(c_i)
for index, wert in enumerate(a):
    b[index] = wert**2

import matplotlib.pyplot as plt 

# Umrechnung von Zoll in cm (1 Zoll = 2.54 cm)
cm = 0.393701

# Definition von globalen Parametern, hier die Schriftgrösse
plt.rcParams.update({'font.size': 16})
plt.rcParams.update({'axes.labelsize': 16})

# Definition der Figur, mit Grössenangabe
fig = plt.figure(figsize=(20cm, 17cm))
ax1 = fig.add_subplot(1, 1, 1) (anzahl, (x,y))
# Definitiond er zu plottenden Daten mit Label
ax1.plot(x0, y0, 'bo', label='Data') #b = blue, o = Punkte
ax1.plot(x0, y0, 'r-', label=r'$y = x^2$') #Rote Striche
# Achsenbeschriftung, die Angegebene Schriftgrösse überschrebit die globale Schriftgrösse
ax1.set_xlabel('x (x unit)')
ax1.set_ylabel('y (y unit)')
ax1.set_title("Titel")
# Definition des Bereichs der geplottet werden soll
ax1.set_xlim(0, 2)
ax1.set_ylim(0, 4)
# Erzeugen einer Legende, hier werden die Label aus der Plotfunktion übernommen
ax1.legend(fontsize=20, frameon=False)


# Abspeichern der Figur
fig.savefig(r'Figur.png', dpi=400, transparent=True)

SPEICHERN
np.savetxt('DataOut.txt', (x0, y0), delimiter = ',') #Speichert Daten als ASCI (txt)
np.savetxt('DataOut.txt', (x,y,z), delimiter=',', header='Beispieldatei Datenanalyse, 14.2.2023. Format: x, y, z') #Für Metadaten


LADEN
(x2, y2) = np.loadtxt('DataOut.txt', delimiter = ',' , comments = '#') #lädt Daten, blendet # aus
data = np.loadtxt('DataOut.txt', delimiter = ',') #Daten von allg. Datenarray

print(data.shape) # a=np.array([[[0],[0]]]) hat shape (1,2,1) (3-dimensional)
x3 = data[0, :]
y3= data[1, :]
plt.plot(x3, y3)
zeilen, spalten = a.shape

LADEN
with open(file, 'r') as f:
    lines = f.readlines()
#lines ist ein String Array mit allen Daten

d = np.zeros((len(lines)-1, 2))
i = 0
for l in lines[1:]:
    d[i,:] = np.array([np.fromstring(l, dtype=float, sep=',')])
    i = i+1

SPEICHERN
with open('DataOut.txt', 'w') as f:
    f.writelines('x, y, z\n') #schreibe header 
    for i in range(0, len(x)):
        f.writelines('{:0.5f}, {:0.5f}, {:0.5f}\n'.format(x[i], y[i], z[i]))

IMPORTS
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score

# Daten in Trainingsset und Testset aufteilen
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Regressionsmodell trainieren, d.h. Koeffizienten optimieren.
linreg = LinearRegression()
linreg.fit(X_train, y_train)
#analog für logistische Regression
# Logistische Regression
lr = LogisticRegression()
lr.fit(X_train, y_train)


# Measure the quality of the regression in the test data.
y_pred = linreg.predict(X_test)
r2 = r2_score(y_test, y_pred)
print("R2 on test data: {:.3f}".format(r2))

Auf neuen Datensatz anwenden

X_final = pd.read_csv("Daten_Aufgabe2/X_final.csv")
y_final = linreg.predict(X_final)
print(y_final)


from sklearn.neural_network import MLPClassifier

# Neuronales Netzwerk
mlp = MLPClassifier(hidden_layer_sizes=(100,), max_iter=1000, random_state=42)
mlp.fit(X_train, y_train)

y_pred_mlp = mlp.predict(X_test)
accuracy_mlp = accuracy_score(y_test, y_pred_mlp)

IMPORTS
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.tree import plot_tree

# 1. Daten in Testdaten und Trainingsdaten aufteilen
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 2. Entscheidungsbaum erstellen und trainieren
tree = DecisionTreeClassifier(random_state=42, max_depth=4)
tree.fit(X_train, y_train)

# 3. Vorhersagen des Baumes überprüfen
y_pred_tree = tree.predict(X_test)
accuracy_tree = accuracy_score(y_test, y_pred_tree)
print("Accuracy of classification tree on test data: {:.3f}".format(accuracy_tree))

# Entscheidungsbaum plotten
plot_tree(tree, feature_names=X.columns)
plt.savefig('decision_tree.pdf')

IMPORTS
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from evaluate import *

# Lade Daten in ein pandas Dataframe
df = pd.read_csv('periodic_table.csv')

# Zeige die ersten fünf Zeilen des Dataframes
df.head()

#Bereich von Spalten auswählen und anzeigen
df[5:10]

#Spalte auswählen (Namen eingeben)
df['Atomic_Weight']
df[['Symbol', 'Melting_Point', 'Boiling_Point']]

# Spalten ausschliessen:
df.drop(['Name', 'Atomic_Number', 'Atomic_Radius'], axis=1)

def mode(data, resolution):
    # Berechnen der PMF
    x, px = PMF(data, resolution)
    # Der Wahrscheinlichste Wert ist derjenige, bei dem die PMF ein Maximum hat. 
    return x[np.argmax(px)]

------------------------------------------------------

def median(data):
    # Wir sortieren die Daten, der Median entspricht dem Datenpunkt in der Mitte.
    data_sorted = np.sort(data)
    if len(data) % 2 != 0:
        median = data_sorted[len(data)//2]
    # Bei ungerader Anzahl Datenpunkten mitteln wir über die beiden benachbarten Punkte.
    else:
        median = (data_sorted[len(data)//2] + data_sorted[len(data)//2 - 1]) / 2
    return median

def PMF(data, resolution):
    # Definieren der Bins und Berechnen des Histogramms
    # Wir addieren resolution / 1000 zur Obergrenze, um sicherzustellen, dass der letzte Wert auch im Array ist.
    bin_centers = np.arange(np.min(data), np.max(data) + resolution / 1000, resolution)
    bin_edges = np.linspace(bin_centers[0] - resolution / 2,
                            bin_centers[-1] + resolution / 2,
                            len(bin_centers) + 1)
    
    hist, _ = np.histogram(data, bin_edges)
    
    # Normieren
    px = hist / np.sum(hist)
    
    return bin_centers, px

def ffilter(t, A, fmin, fmax):
    N = len(t)
    dt = t[1] - t[0]
    f = np.fft.fftfreq(N, dt)
    
    spectrum = np.fft.fft(A)
    
    for i,freq in enumerate(f):
        if abs(freq) < fmin or abs(freq) > fmax:
            spectrum[i] = 0
    
    return np.fft.ifft(spectrum)

def binomial(n, k, p):
    return scipy.special.binom(n,k)pk(1-p)(n-k)

def LP_filter(x_sample, N_num):
    # N_num ist die Anzahl Werte vor und nach jedem originalen Wert, die gemittelt werden
    N_av = 2*N_num+1 # Filterlänge
    n_x = len(x_sample) # Anzahl des Messwerte in x
    x_filtered = x_sample.copy() # wir erstellen eine Kopie von x, um die neuen Werte hineinzuschreiben
    for n in range(N_num,n_x-N_num): # wir ignoriernen wir N_num ersten und letzte Werte
        x_filtered[n] = sum(x_sample[n-N_num:n+N_num+1])/N_av # Mittelwert
    return x_filtered

from scipy import signal

#f_samling = 1/sampling time

f,PSDx = scipy.signal.periodogram(U_mess,f_sampling,return_onesided=True,scaling='density')

alternative Berechnung

from numpy.fft import fftfreq, fft, ifft

data = np.loadtxt('autocorrelation_laser.txt')
t = data[:, 0] * 1e-12  # in ps abgespeichert. Wir konvertieren in s
signal = data[:, 1]

# Zeitauflösung und Länge des Signals berechnen
dt = t[1] - t[0]
N = len(t)

# Fouriertransformation
frequency = fftfreq(N, d=dt)
spectrum = fft(signal)

# Spektrale Leistungsdichte
psd = dt / N  np.abs(spectrum)*2

Fourier Rücktransformation: 
singal = np.fft.ifft(spectrum). 
np.real(signal)

Koeffizienten für eine Frequenz bestimmen


def CN(x,f):
    Xn = 0
    for n in range(N):
        Xn += x[n]  cmath.exp(-1j2np.pif*n)
    return Xn

fc = 0.022  #f_sig1

print(CN(x,fc))
#print(CN(U,-fc))

 C = np.stack((U1_mess,U3_mess), axis=0)
 np.cov(C) #Kovarianzmatirx
 np.corrcoef(C) #Koeffizienten

AUTOKOVARIANZFUNKTION
def Rxx(x, delta):
    xm = np.mean(x)
    dev_sum = 0
    for i in range(len(x) - delta):
        dev_sum += (x[i] - xm) * (x[i + delta] - xm)
    return dev_sum / (len(x) - delta)

V = Spannungswerte

#Wähle Bingrösse und erstelle einzelne bins
binsize = 0.01
bins = np.arange(np.min(V), np.max(V)+1, binsize)

hist, b = np.histogram(V, bins) #hist: häufigkeiten, b: array mit bin_edges

#plotte normal balken (breite kleiner als binsize)
fig = plt.figure(figsize=(30cm, 25.5cm))
ax1 = fig.add_subplot(2,2,1)
ax1.bar(bins[:-1], hist, width=0.8*binsize)
ax1.set_title('Binsize: {:.2f}V'.format(binsize))

def extract_resolution(measured_values):
    '''Extract smallest difference between two unique values in an array.
    Values are treated as unique if their absolute difference is greater than the tolerance.'''
    
    sorted_values = np.sort(measured_values)
    differences = np.diff(sorted_values)
    sorted_differences = np.sort(np.abs(differences))
    resolution = -1
    
    tolerance = np.max(np.abs(measured_values)) * 1e-10  # Gleitkommavergleich
    for diff in sorted_differences:
        if diff > tolerance:
            resolution = diff
            break  

    return resolution