Code: Alles auswählen
import numpy as np
from scipy.linalg import logm, expm
a = np.array([[1.0, 3.0], [1.0, 4.0]])
print("Array a :" ,a )
print()
a= logm(a)
print(" Logarithmus von lArray a ",a)
print()
c=expm(a)
print("c = delogarithmieren :", c)
#############################
print()
b = logm(a)
print("Logarithmus von b :", b)
Code: Alles auswählen
import numpy as np
from numpy import *
import matplotlib.pyplot as plt
in_array = [[0. , 0.69314718, 1.09861229, 0.69314718, 1.09861229 ,1.38629436,
1.60943791, 1.79175947, 1.94591015 ,2.07944154 ,2.19722458 ,2.30258509,
2.39789527, 2.48490665, 2.56494936 ,2.63905733],
[2.83321334, 2.89037176 ,2.94443898 ,2.99573227 , 3.04452244 ,3.09104245,
3.13549422 ,3.17805383 ,3.21887582 ,3.25809654 ,3.29583687 ,3.33220451,
3.36729583 ,3.40119738 ,3.4339872 , 3.4657359 ],
[3.49650756, 3.52636052 ,3.55534806,3.58351894, 3.61091791 ,3.63758616,
3.66356165, 3.68887945 ,3.71357207, 3.73766962, 3.76120012 ,3.78418963,
3.80666249, 3.8286414 ,3.8501476 , 3.87120101],
[3.8918203 , 3.91202301 ,3.93182563 ,3.95124372, 3.97029191, 3.98898405,
4.00733319, 4.02535169, 4.04305127 ,4.06044301 ,4.07753744 ,4.09434456,
4.11087386 ,4.12713439 ,4.14313473, 4.15888308],
[4.17438727 ,4.18965474, 4.20469262, 4.21950771, 4.2341065 , 4.24849524,
4.26267988, 4.27666612 ,4.29045944 ,4.30406509 ,4.31748811, 4.33073334,
4.34380542 ,4.35670883, 4.36944785, 4.38202663],
[4.39444915 ,4.40671925, 4.41884061, 4.4308168 , 4.44265126 ,4.4543473,
4.46590812, 4.47733681, 4.48863637 ,4.49980967 ,4.51085951, 4.52178858,
4.53259949, 4.54329478 ,4.55387689, 4.56434819]]
# Figure und Axes erstellen
leinwand ,diagramm = plt.subplots()
diagramm.imshow(in_array)
plt.show()
Code: Alles auswählen
import math
from math import log10 , log
Ergebnis =0
#gewählte Wurzel
def W10(Rad,Wp):
mantisse =(1/Wp)*log10(Rad)
Ergebnis =round(10** mantisse,4)
print(Ergebnis)
W10(64 ,2)
###################
import math
from math import log, e
Ergebnis =0.
def Wnat(R ,W ):
mantisse = (1/W)*log(R)
Ergebnis =2.7183** mantisse
print(Ergebnis)
Wnat(100 , 3 )
############################
Code: Alles auswählen
Exponentialgleichungen und Logarithmen
print(" Basis ** Exponent = Ergebnis | z.B. 2**3 =8 ")
print(" Basis ** x = Ergebnis |Exponentialgleichung ")
import numpy as np
from numpy import log # log.nat
#Aufgabe : 3 **x = 2187
#log(3**x)=log(2187)
#x * log(3) =log(2187)
#print(log(3)) 1.0986122886681098
#print(log(2187) ) 7.690286020676768
print(log(2187)/(log(3)))
x =(log(2187)/(log(3)))
print("Ergebnis (mantisse) ", x)
print("Test :",3**7)
print()
############################################
# Exponentialgleichungen und Logarithmen
print(" Basis ** Exponent = Ergebnis | z.B. 2**3 =8 ")
print(" Basis ** x = Ergebnis |Exponentialgleichung ")
#Aufgabe : 4 **x = 21
import numpy as np
from numpy import log10
print(log10(4))
print(log10(21))
x= log10(21)/ log10(4)
print(x)
print("Ergebnis ((mantisse) ", x)
print("Test :",4**2.1961587113893803)
Code: Alles auswählen
######################################
import numpy as np
from numpy import *
def EXPO(ergebnis,basis):
mantisse = log(ergebnis) / log(basis)
print(mantisse )
EXPO(2187,3)
EXPO(100,3)
EXPO(2.5,0.5 )
EXPO((20),e)
#######################################
Code: Alles auswählen
#######################################
import numpy as np
from numpy import log10
def EXPO(ergebnis,basis):
#
#######################################
mantisse = log10(ergebnis) / log10(basis)
print(mantisse )
EXPO(2.718544 ,e)
Code: Alles auswählen
import numpy as np
from numpy import log10
def EXPO(ergebnis,basis):
# Aufgabe : 3**2*x = 4 * 5**x
# Umrechnung:
# #3**2*x =5**x*4
# (3**2)**x = 4*5**x
# 9**x / 5**x =4
# 1.8**x =4
#x*log(1,8) = log(4)
#x=log(4)/log(1.8)
#######################################
mantisse = log10(ergebnis) / log10(basis)
print(mantisse )
EXPO(4,1.8)
Code: Alles auswählen
# importing Tkinter and math
import math
from math import *
import numpy as np
import tkinter
from tkinter import *
class calc:
def getandreplace(self):
self.expression = self.e.get()
self.newtext=self.expression.replace('/','/')
self.newtext=self.newtext.replace('x','*')
def equals(self):
"""when the equal button is pressed"""
self.getandreplace()
try:
# evaluate the expression using the eval function
self.value= eval(self.newtext)
except SyntaxError or NameError:
self.e.delete(0,END)
self.e.insert(0,'Eingabe falsch')
else:
self.e.delete(0,END)
self.e.insert(0,self.value)
def squareroot(self):
"""squareroot method"""
self.getandreplace()
try:
# evaluate the expression using the eval function
self.value= eval(self.newtext)
except SyntaxError or NameError:
self.e.delete(0,END)
self.e.insert(0,'Invalid Input!')
else:
self.sqrtval=math.sqrt(self.value)
self.e.delete(0,END)
self.e.insert(0,self.sqrtval)
def square(self):
"""square method"""
self.getandreplace()
try:
#evaluate the expression using the eval function
self.value= eval(self.newtext)
except SyntaxError or NameError:
self.e.delete(0,END)
self.e.insert(0,'Falsche Eingabe')
else:
self.sqval=math.pow(self.value,2)
self.e.delete(0,END)
self.e.insert(0,self.sqval)
def clearall(self):
"""when clear button is pressed,clears the text input area"""
self.e.delete(0,END)
def clear1(self):
self.txt=self.e.get()[:-1]
self.e.delete(0,END)
self.e.insert(0,self.txt)
def action(self,arge):
"""pressed button's value is inserted into the end of the text area"""
self.e.insert(END,arge)
def __init__(self,master):
"""Constructor method"""
master.title(" M A T H E A S S ")
self.e = Entry(master)
self.e.grid(row=0,column=0,columnspan=6,pady=6)
self.e.focus_set() #Sets focus on the input text area
# Generating Buttons
Button(master,text="=",width=15,height=5 ,fg="white",
bg="blue",command=lambda:self.equals()).grid(
row=4, column=4,columnspan=2)
Button(master,text='CLEARALL',width=7,height=5,
fg="red", bg="light blue", ###########
command=lambda:self.clearall()).grid(row=1, column=4)
Button(master,text='Clear',width=7,height=5,
fg="white",bg="green", ############ light green
command=lambda:self.clear1()).grid(row=1, column=5)
Button(master,text="+",width=7,height=5,
fg="white",bg="green",
command=lambda:self.action('+')).grid(row=4, column=3)
Button(master,text="X",width=7,height=5,
fg="blue",bg="orange",
command=lambda:self.action('x')).grid(row=2, column=3)
Button(master,text="minus",width=7,height=5,
fg="red",bg="light green",
command=lambda:self.action('-')).grid(row=3, column=3)
Button(master,text="Divide",width=7,height=5,
fg="blue",bg="orange",
command=lambda:self.action('/')).grid(row=1, column=3)
Button(master,text="%",width=7,height=5,
fg="red",bg="light green",
command=lambda:self.action('%')).grid(row=4, column=2)
Button(master,text="7",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.action('7')).grid(row=1, column=0)
Button(master,text="8",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.action(8)).grid(row=1, column=1)
Button(master,text="9",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.action(9)).grid(row=1, column=2)
Button(master,text="4",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.action(4)).grid(row=2, column=0)
Button(master,text="5",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.action(5)).grid(row=2, column=1)
Button(master,text="6",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.action(6)).grid(row=2, column=2)
Button(master,text="1",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.action(1)).grid(row=3, column=0)
Button(master,text="2",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.action(2)).grid(row=3, column=1)
Button(master,text="3",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.action(3)).grid(row=3, column=2)
Button(master,text="0",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.action(0)).grid(row=4, column=0)
Button(master,text="Point",width=7,height=5,
fg="black",bg="white",
command=lambda:self.action('.')).grid(row=4, column=1)
Button(master,text="(",width=7,height=5,
fg="blue",bg="orange",
command=lambda:self.action('(')).grid(row=2, column=4)
Button(master,text=")",width=7,height=5,
fg="blue",bg="orange",
command=lambda:self.action(')')).grid(row=2, column=5)
Button(master,text="1/**",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.squareroot()).grid(row=3, column=4)
Button(master,text="**",width=7,height=5,
fg="white",bg="black",
command=lambda:self.square()).grid(row=3, column=5)
Button(master,text="log10",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.action("log10")).grid(row=1, column=6)
Button(master,text="log.nat",width=7,height=5,
fg="white",bg="blue",
command=lambda:self.action("log")).grid(row=2, column=6)
root=Tk()
obj=calc(root)
root.mainloop()
Code: Alles auswählen
original_string =''' -2.30258509 -1.60943791 -1.2039728 -0.91629073 -0.69314718 -0.5108256
-0.35667494 -0.22314355 -0.10536052 0.0.09531018 0.18232156
0.26236426 0.33647224 0.40546511 0.47000363 0.53062825 0.58778666
0.64185389 0.69314718 0.74193734 0.78845736 0.83290912 0.87546874
0.91629073 0.95551145 0.99325177 1.02961942 1.06471074 1.09861229
1.13140211 1.16315081 1.19392247 1.22377543 1.25276297 1.28093385
1.30833282 1.33500107 1.36097655 1.38629436 1.41098697 1.43508453
1.45861502 1.48160454 1.5040774 1.5260563 1.54756251 1.56861592
1.58923521 1.60943791 1.62924054 1.64865863 1.66770682 1.68639895
1.70474809 1.7227666 1.74046617 1.75785792 1.77495235 1.79175947
1.80828877 1.82454929 1.84054963 1.85629799 1.87180218 1.88706965
1.90210753 1.91692261 1.93152141 1.94591015 1.96009478 1.97408103
1.98787435 2.00148456 2.01490302 2.02814825 2.04122033 2.05412373
2.06686276 2.07944154 2.09186406 2.10413415 2.11625551 2.12823171
2.14006616 2.1517622 2.16332303 2.17475172 2.18605128 2.19722458
2.20827441 2.21920348 2.2300144 2.24070969 2.2512918 2.2617631
2.27212589 2.28238239 2.29253476 2.30258509 2.31253542 2.32238772
2.3321439 2.34180581 2.35137526 2.360854 2.37024374 2.37954613
2.38876279 2.39789527 2.40694511 2.41591378 2.42480273 2.43361336
2.44234704 2.4510051 2.45958884 2.46809953 2.4765384 2.48490665
2.49320545 2.50143595 2.50959926 2.51769647 2.52572864 2.53369681
2.54160199 2.54944517 2.55722731 2.56494936 2.57261223 2.58021683
2.58776404 2.59525471 2.60268969 2.61006979 2.61739583 2.62466859
2.63188884 2.63905733 2.6461748 2.65324196 2.66025954 2.66722821
2.67414865 2.68102153 2.68784749 2.69462718 2.70136121 2.7080502
2.71469474 2.72129543 2.72785283 2.73436751 2.74084002 2.74727091
2.75366071 2.76000994 2.76631911 2.77258872 2.77881927 2.78501124
2.79116511 2.79728133 2.80336038 2.8094027 2.81540872 2.82137889
2.82731362 2.83321334 2.83907846 2.84490938 2.8507065 2.85647021
2.86220088 2.8678989 2.87356464 2.87919846 2.88480071 2.89037176
2.89591194 2.90142159 2.90690106 2.91235066 2.91777073 2.92316158
2.92852352 2.93385687 2.93916192 2.94443898 2.94968834 2.95491028
2.9601051 2.96527307 2.97041447 2.97552957 2.98061864 2.98568194
2.99071973 2.99573227 3.00071982 3.0056826 3.01062089 3.0155349
3.02042489 3.02529108 3.0301337 3.03495299 3.03974916 3.04452244
3.04927304 3.05400118 3.05870707 3.06339092 3.06805294 3.07269331
3.07731226 3.08190997 3.08648664 3.09104245 3.09557761 3.10009229
3.10458668 3.10906096 3.11351531 3.11794991 3.12236492 3.12676054
3.13113691 3.13549422 3.13983262 3.14415228 3.14845336 3.15273602
3.15700042 3.16124671 3.16547505 3.16968558 3.17387846 3.17805383
3.18221184 3.18635263 3.19047635 3.19458313 3.19867312 3.20274644
3.20680324 3.21084365 3.2148678 3.21887582 3.22286785 3.22684399
3.2308044 3.23474917 3.23867845 3.24259235 3.24649099 3.25037449
3.25424297 3.25809654 3.26193531 3.26575941 3.26956894 3.27336401
3.27714473 3.28091122 3.28466357 3.28840189 3.29212629 3.29583687
3.29953373 3.30321697 3.3068867 3.31054301 3.314186 3.31781577
3.32143241 3.32503602 3.32862669 3.33220451 3.33576958 3.33932198
3.3428618 3.34638915 3.34990409 3.35340672 3.35689712 3.36037539
3.3638416 3.36729583 3.37073817 3.37416871 3.37758752 3.38099467
3.38439026 3.38777436 3.39114705 3.39450839 3.39785848 3.40119738
3.40452517 3.40784192 3.41114771 3.41444261 3.41772668 3.42100001
3.42426265 3.42751469 3.43075618 3.4339872 3.43720782 3.44041809
3.4436181 3.44680789 3.44998755 3.45315712 3.45631668 3.45946629
3.46260601 3.4657359 3.46885603 3.47196645 3.47506723 3.47815842
3.48124009 3.48431229 3.48737508 3.49042852 3.49347266 3.49650756
3.49953328 3.50254988 3.5055574 3.5085559 3.51154544 3.51452607
3.51749784 3.5204608 3.52341501 3.52636052 3.52929738 3.53222564
3.53514535 3.53805656 3.54095932 3.54385368 3.54673969 3.54961739
30271283 4.30406509 4.30541553 4.30676415 4.30811095 4.30945594
.48751214 4.48863637 4.48975933 4.49088104 4.49200149 4.49312068
.56538932 4.56642936 4.56746832 4.5685062 4.56954301 4.57057874
4.5716134 4.57264699 4.57367952 4.57471098 4.57574138 4.57677071
4.57779899 4.57882621 4.57985238 4.58087749 4.58190156 4.58292458
4.58394655 4.58496748 4.58598737 4.58700622 4.58802403 4.5890408
4.59005655 4.59107126 4.59208495 4.5930976 4.59410924 4.59511985
4.59612944 4.59713801 4.59814557 4.59915211 4.60015764 4.60116216
4.60216568 4.60316818 4.60416969'''
# Vor der Auaführung des Codes, zuächst immer Originalzustand herstellen.
# Dann Komma einsetzen u, print(modified_string) aktivieren
modified_string = original_string.replace(" " , " ") # ((" " , ", ")
#print(original_string )
print(modified_string)
Code: Alles auswählen
# Einfache Logarithmische Gleichungen lösen
# ipy import *
import numpy as np
from numpy import *
# Allgemeine Formel : log(Basis) = Numerus
# Beispiele mit unterschiedlicher Basis
########## log(x) = 2
x=e**1
print(x)
x=e**2
print(x)
x=e**2.718
print(x)
x=e**exp(-2)
print(x)
print()
########## log10(x) = 3
x= log10(1)
print(x)
x= log10(10)
print(x)
x= log10(3.4)
print(x)
x= log10(log(10))
print(x)
print()
########## log2(x) =2
x= log2(1)
print(x)
x=log2(10)
print(x)
x=log2(10)
print(x)
x=log2(sin(3))
print(x)
print()
########## log5(x) =2
x= log((1,5) )
print(x)
x= log((3.27,5))
print(x)
x=log((0.4,5))
print(x)
x=log((log10(19),5))
print(x)
x=log((exp(3),5))
print(x)
Code: Alles auswählen
#Logarithmische Gleichungen :Bestimmung des Logarithmanden als " Basis " ipy import *
import numpy as np
from numpy import *
#:formal : logarithmand * x = numerus
#log3 *x =100
print(3**10)
#####################################
# beispiel
# log(.e**1/2 * x = 7
x= e**1/2 ** 7
print(e **7)
#log4*x**2 =6
#x**2 = 4**6
x= 4**6 *1/2
print(4**6 *1/2)
#log3*x - log3*5*x = 5
# log3*4*x =12
x= 4**5**1/4
print(4**5**1/4)
#log2*x = 2.7184
x= 2**2.718
print(e**2.7184)
#log1.7 *x = 10
x=1.7
1.7**5
print(x)
#loge *x =100
x= e**100
print(e**10)
#log(pi/e) x = 35
x=pi/e**35
Code: Alles auswählen
#Logarithmus mit sehr kleiner Basis
import numpy as np
from numpy import *
# log0.5(*x) = 25 gilt formal für weitere Ergebnisse)
print(0.5 **pi)
print(0.1 **e)
print(0.03**e )
print(0.1 ** pi)
print(log(pi)** 0.0000000001)
print(log(e)**e)
Code: Alles auswählen
# Handschriftliche Ziffern erkennen mit dem ZIFFERN-DATENSATZ
# Dieses Beispiel zeigt, wie scikit-learn verwendet werden kann, um Bilder handgeschriebener Ziffern von 0 bis 9 zu erkennen.
# Standard scientific Python imports
import matplotlib.pyplot as plt
import image
# Import datasets, classifiers and performance metrics
from sklearn import datasets, metrics, svm
from sklearn.model_selection import train_test_split
digits = datasets.load_digits()
_, axes = plt.subplots(nrows=1, ncols=4, figsize=(10, 6))
for ax, image, label in zip(axes, digits.images, digits.target):
ax.set_axis_off()
ax.imshow(image, cmap=plt.cm.gray_r, interpolation="nearest")
ax.set_title("Training: %i" % label)
# flatten the images
n_samples = len(digits.images)
data = digits.images.reshape((n_samples, -1))
print( " Der Datensatz ", data)
# Create a classifier: a support vector classifier
clf = svm.SVC(gamma=0.001)
# Split data into 50% train and 50% test subsets
X_train, X_test, y_train, y_test = train_test_split(
data, digits.target, test_size=0.5, shuffle=False
)
# Learn the digits on the train subset
clf.fit(X_train, y_train)
# Predict the value of the digit on the test subset
predicted = clf.predict(X_test)
#Nachfolgend visualisieren wir die ersten 4 Testbeispiele und zeigen ihren vorhergesagten
#Ziffernwert im Titel.
_, axes = plt.subplots(nrows=1, ncols=4, figsize=(10, 3))
for ax, image, prediction in zip(axes, X_test, predicted):
ax.set_axis_off()
image = image.reshape(8, 8)
print(image)
ax.imshow(image, cmap=plt.cm.gray_r, interpolation="nearest")
ax.set_title(f"Prediction: {prediction}")
#'Vorhersage: 8, Vorhersage: 8, Vorhersage: 4, Vorhersage: 9
#classification_reporterstellt einen Textbericht, der die wichtigsten Klassifizierungsmetriken zeigt.
print(
f"Classification report for classifier {clf}:\n"
f"{metrics.classification_report(y_test, predicted)}\n"
)
#Classification report for classifier SVC(gamma=0.001):
# precision recall f1-score support
# 0 1.00 0.99 0.99 88
# 1 0.99 0.97 0.98 91
# 2 0.99 0.99 0.99 86
# 3 0.98 0.87 0.92 91
# 4 0.99 0.96 0.97 92
## 5 0.95 0.97 0.96 91
# 6 0.99 0.99 0.99 91
# 7 0.96 0.99 0.97 89
# 8 0.94 1.00 0.97 88
# 9 0.93 0.98 0.95 92
#accuracy 0.97 899
#macro avg 0.97 0.97 0.97 899
#weighted avg 0.97 0.97 0.97 899
#Wir können auch eine Konfusionsmatrix der wahren Ziffernwerte und der
#vorhergesagten Ziffernwerte darstellen.
disp = metrics.ConfusionMatrixDisplay.from_predictions(y_test, predicted)
disp.figure_.suptitle("Confusion Matrix")
print(f"Confusion matrix:\n{disp.confusion_matrix}")
plt.show()
Code: Alles auswählen
# Isolations Forest zum Austesten von 2D - Arrays
# die Länge von X und y muss stets übereinstimmen, ist aber beliebig.
import matplotlib.pyplot as plt
import numpy as np
from numpy import *
#x = np.array
X = np.array( [ [1.4, 0.7],
[-2.5, -1.0],
[-1.3, -1.2],
[-1.2, -0.4],
[0.5, 5.2],
[-3.0, 0.40],
[2.5, 3.4],
[ 5,1.55],
[1.0, 1.0],
[1.3, 0.8],
[1.2, 0.5],
[0.2, -2.0],
[3.5, -2.4],
[0.8, -4.3],
[5.0, -2.7],
[1.8, 5.1]] )
y = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1,1]] )
fig, ax = plt.subplots(figsize=(10, 10))
x_min, x_max, y_min, y_max = - 10 ,10, -10, 10
ax.set(xlim=(x_min, x_max), ylim=(y_min, y_max))
# Plot samples by color and add legend
scatter = ax.scatter(X[:,1], X[:,0], s=150, c=y, label=y, edgecolors="k")
ax.legend(*scatter.legend_elements(), loc="upper right", title="Classes")
ax.set_title("TOOL für Isolated Forest 2D")
plt.grid()
plt.show()
X = np.array( [ [5.4, 0.7],
[-1.5, -1.0],
[-1.3, -1.2],
[-1.2, -0.4],
[1.5, 5.2],
[7.4, 4.0],
[2.5, 3.4],
[ 3,1.5],
[-1.0, 1.0],
[6.3, 0.8],
[1.2, 0.5],
[3.2, -1.0],
[2.5, -2.4],
[0.8, -4.3],
[5.0, -2.7],
[1.8,- 1.1]] )
y = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1]] )
# Plotting settings
fig, ax = plt.subplots(figsize=(10, 10))
x_min, x_max, y_min, y_max = - 10 ,10, -10, 10
ax.set(xlim=(x_min, x_max), ylim=(y_min, y_max))
# Plot samples by color and add legend
scatter = ax.scatter(X[:,1], X[:,1], s=150, c=y, label=y, edgecolors="k")
ax.legend(*scatter.legend_elements(), loc="upper right", title="Classes")
ax.set_title("TOOL für Isolated Forest 2D")
plt.grid()
plt.show()
Code: Alles auswählen
import numpy as np
from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
X, y = fetch_openml(data_id=41082, as_frame=False, return_X_y=True)
X = MinMaxScaler().fit_transform(X)
##Die Idee besteht darin, eine PCA-Basis (mit und ohne Kernel) anhand verrauschter Bilder zu erlernen und diese Modelle dann zum Rekonstruieren und Entrauschen dieser Bilder zu verwenden.
#Daher teilen wir unseren Datensatz in einen Trainings- und einen Testdatensatz auf, bestehend aus 1.000 Beispielen für das Training und 100 Beispielen für den Test. Diese Bilder sind rauschfrei und werden von uns verwendet, um die Effizienz der Denoising-Ansätze zu bewerten. Zusätzlich erstellen wir eine Kopie des Originaldatensatzes und fügen ein Gaußsches Rauschen hinzu.
#Die Idee dieser Anwendung besteht darin, zu zeigen, dass wir beschädigte Bilder durch das Erlernen einer PCA-Basis anhand einiger unbeschädigter Bilder entrauschen können. Wir werden sowohl eine PCA als auch eine kernelbasierte PCA verwenden, um dieses Problem zu lösen.
X_train, X_test, y_train, y_test = train_test_split(
X, y, stratify=y, random_state=0, train_size=1_000, test_size=100
)
rng = np.random.RandomState(0)
noise = rng.normal(scale=0.25, size=X_test.shape)
X_test_noisy = X_test + noise
noise = rng.normal(scale=0.25, size=X_train.shape)
X_train_noisy = X_train + noise
#Darüber hinaus erstellen wir eine Hilfsfunktion zur qualitativen Beurteilung der Bildrekonstruktion durch Plotten der Testbilder.
import matplotlib.pyplot as plt
def plot_digits(X, title):
"""Small helper function to plot 100 digits."""
fig, axs = plt.subplots(nrows=10, ncols=10, figsize=(8, 8))
for img, ax in zip(X, axs.ravel()):
ax.imshow(img.reshape((16, 16)), cmap="Greys")
ax.axis("off")
fig.suptitle(title, fontsize=24)
#Darüber hinaus verwenden wir den mittleren quadratischen Fehler (MSE), um die Bildrekonstruktion quantitativ zu bewerten.
#Schauen wir uns zunächst den Unterschied zwischen rauschfreien und verrauschten Bildern an. Dazu überprüfen wir das Testset.
plot_digits(X_test, "Uncorrupted test images")
plot_digits(
X_test_noisy, f"Noisy test images\nMSE: {np.mean((X_test - X_test_noisy) ** 2):.2f}"
)
#Unverfälschte Testbilder Verrauschte Testbilder MSE: 0,06
#Lernen Sie die PCAGrundlagen
#Wir können jetzt unsere PCA-Basis sowohl mithilfe einer linearen PCA als auch einer Kernel-PCA lernen, die einen Kernel mit radialer Basisfunktion (RBF) verwendet.
from sklearn.decomposition import PCA, KernelPCA
pca = PCA(n_components=32, random_state=42)
kernel_pca = KernelPCA(
n_components=400,
kernel="rbf",
gamma=1e-3,
fit_inverse_transform=True,
alpha=5e-3,
random_state=42,
)
pca.fit(X_train_noisy)
_ = kernel_pca.fit(X_train_noisy)
X_reconstructed_kernel_pca = kernel_pca.inverse_transform(
kernel_pca.transform(X_test_noisy)
)
X_reconstructed_pca = pca.inverse_transform(pca.transform(X_test_noisy))
plot_digits(X_test, "Uncorrupted test images")
plot_digits(
X_reconstructed_pca,
f"PCA reconstruction\nMSE: {np.mean((X_test - X_reconstructed_pca) ** 2):.2f}",
)
plot_digits(
X_reconstructed_kernel_pca,
(
"Kernel PCA reconstruction\n"
f"MSE: {np.mean((X_test - X_reconstructed_kernel_pca) ** 2):.2f}"
),
)
#Unverfälschte Testbilder PCA-Rekonstruktion MSE: 0,01 Kernel-PCA-Rekonstruktion MSE: 0,03
plt.show()
Erkennen und Filtern von Ausreißern
import numpy as np
import pandas as pd
df = pd.DataFrame(np.random.randn(5, 4))
print(df)
df.describe()
print(df.describe())
# Angenommen, ihr wollt in einer der Spalten Werte finden, deren absoluter Wert größer als 3 oder kleiner als -3 ist:
###########################
#Für jede Spalte kann die Kontrolle auf Ausreisser kontrolliert werden
# Beispiel : Untersuchung der 4 Spalten auf beliebige Intervalle , hier -3 bis +3
col = df[0]
print("Spalte 1 :",col)
col[col.abs() > 3]
col = df[1]
print("Spalte 1 :",col)
col[col.abs() > 3]
col = df[2]
print("Spalte 2 :",col)
col[col.abs() > 3]
col = df[3]
print("Spalte 3 : ",col)
col[col.abs() > 4]
#Name: 1, dtype: float64
#Um alle Zeilen auszuwählen, in denen Wert größer 3 oder kleiner -3 in einer der Spalten ist, könnt ihr pandas.DataFrame.any auf einen booleschen DataFrame anwenden, wobei mit any(axis=1) üüberprüft wird, ob ein Wert in einer Zeile wahr ist:
df[(df.abs() > 3).any(axis=1)]
print(df[(df.abs() > 3).any(axis=1)])
#Auf dieser Grundlage können die Werte begrenzt werden auf ein Intervall zwischen -3 und 3.
#Hierfür verwenden wir die Anweisung np.sign(df), die Werte 1 und -1 erzeugt, je nachdem,
#ob die Werte in df positiv oder negativ sind:
df[df.abs() > 3] = np.sign(df) * 3
print(df.describe())
Code: Alles auswählen
#Comprehensive - Tool Listen zu Matrizen transformieren
# Code 1
def generate_row(i):
return [x + i if x + i > 25. else x + i - 13 for x in range(10)]
matrix = [generate_row(i) for i in range(1,11)]
print(matrix)
######################################################
mport numpy as np
import matplotlib.pyplot as plt
#import matplotlib.cm as cm
# Code 2
matrix = [[-12, -11, -10, -9, -8, -7, -6, -5, -4, -3],
[-11, -10, -9, -8, -7, -6, -5, -4, -3, -2],
[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1],
[-9, -8, -7, -6, -5, -4, -3, -2, -1, 0],
[-8, -7, -6, -5, -4, -3, -2, -1, 0, 1],
[-7, -6, -5, -4, -3, -2, -1, 0, 1, 2],
[-6, -5, -4, -3, -2, -1, 0, 1, 2, 3],
[ 5, -4, -3, -2, -1, 0, 1, 2, 3, 4],
[-4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-3, -2, -1, 0, 1, 2, 3, 4, 5, 6]]
fig = plt.figure()
ax1 = fig.add_subplot(121)
# Bilinear interpolation - this will look blurry
ax1.imshow(matrix,cmap=('Purples_r' ) ) # "RdYlGn"))
ax2 = fig.add_subplot(122)
# 'nearest' interpolation - faithful but blocky
ax2.imshow(matrix, interpolation='nearest', cmap=("RdGy") )
plt.show()
Code: Alles auswählen
##########Define a function to perform matrix multiplication of matrices B and A
def matrix_multiplication(B,A):
"""
Perform matrix multiplication of matrices B and A.
Args:
B: First matrix (list of lists).
A: Second matrix (list of lists).
Returns:
Result of matrix multiplication (list of lists).
"""
if len(B[0]) != len(A):
raise ValueError("Number of columns in A must equal number of rows in B")
# Number of rows and columns in resulting matrix
num_rows_A = len(B)
num_cols_B = len(A[0])
# Perform matrix multiplication using list comprehension
result = [[sum(B[i][k] * A[k][j] for k in range(len(B))) for j in range(num_cols_B)] for i in range(num_rows_A)]
return result
# Example usage:
if __name__ == "__main__":
# Example matrices A and B
A = [[7, 8],
[9, 10],
[11, 12]]
B = [[1, 2, 3],
[4, 5, 6]]
# Print the result of matrix multiplication
print(matrix_multiplication(B, A))
Code: Alles auswählen
# Multiplikation von zwei 7 x 9 Matritzen
#
X = [[ 1,3,2,7,9,7], # 7 Zeilen
[ 2,1,3,5,5,-10],
[ 3,1,1,2,-6,4],
[ 1,0,3,1,2,5],
[4,1,4,1,1,6],
[-10,-10,2,-4,2,4],
[-
2,4,1,2,4,2]]
Y = [[1,3,0,7,-9,1], # 9 Spalten
[ 2,1,3,5,5,2],
[ 3,1,1,2,6,2],
[ 1,0,3,1,2,5],
[4,1,4,1,1,6],
[2,4,1,2,4,29],
[ 3,1,1,2,6,4],
[ 1,0,3,1,2,5],
[-4,1,4,1,1,0]]
resultant = [[sum(a * b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]
# printing matrix.
for x in resultant:
print(" " ,x)
# Zur Weiterverarbeirung das Produkt in den Code 2 eintragen