kleine Mathe-Spielereien

mit matplotlib, NumPy, pandas, SciPy, SymPy und weiteren mathematischen Programmbibliotheken.
OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

5.4.2024
Wahrscheinlich gibt es für das obige Problem
keine Lösung mit den vorhandenen Mitteln.
KI(?)
Hier mein erweitertes 'MATHEASS'
OSWALD

Code: Alles auswählen


##########                                     MATHEASS     WERKSTATT
# 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,'Eingabe Fehler !') 
        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=3, 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="black",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="black", 
                command=lambda:self.squareroot()).grid(row=1, column=6) 

            Button(master,text="**",width=7,height=5,
                fg="white",bg="black", 
                command=lambda:self.square()).grid(row=2, column=6) 
 
            Button(master,text=" exp = e",width=7,height=5,
                fg="white",bg="red",        
                command =lambda :self.action('e')).grid(row=3, column=6) 
 
            Button(master,text=" pi",width=7,height=5,
                fg="white",bg="red",       
                command =lambda :self.action('pi')).grid(row=4, column=6) 

            Button(master,text="sin()",width=7,height=5,
                fg="white",bg="red",       
                command =lambda :self.action('sin')).grid(row=4, column=4)

            Button(master,text="cos()",width=7,height=5,
                fg="white",bg="red",       
                command =lambda :self.action('cos')).grid(row=4, column=5)

root = Tk() 
root.geometry("600x600+300+300")
obj=calc(root) # object instantiated 

root.mainloop()












OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

14.04.2024
in letzter Zeit habe ich mich mit dem
Thema 'Transponieren' von Arrys und Listen
beschäftigt. Dabei habe ch erfahren, dass es nicht nur um
Umformen von Arrays t geht, sondern dass man
mit dem T.Attribut auch die Übertragung von dataFrames(pandas)
nach tkinter durchführen kann.
Ob das auch mit der Transpose - Methode ist , habe ich noch
nicht ausprobiert. Diese Methgode muss ich erst ausprobieren.
Zunächst die 'Übertagung

'

Code: Alles auswählen


import numpy as np
import pandas   as pd 
from tkinter import * 
import sys
##########################   alternativ  1
#dates = pd.date_range('240414', periods=12)
#df = pd.DataFrame(np.random.randn(12,4 ),index=dates,columns=list('ABCD'))
#print(df)
##########################   alternativ  2
df = pd.DataFrame  ({"Club":[ "München", "Berlin","Frankfurt","Leipzig" ,"Dortmund ","Freiburg" ,"Augsburg" ,"Köln"] ,
                    "Zuschauer": [ 234566 , 240000, 250000, 188000,  220000,  236000,   177000, 210000] ,
                    "Tore": [ 197 ,  77,    80  ,   79,  80,   75, 45,  68   ]}) 
print(df)
##########################


root = Tk() 
root.title("PANDAS UND TKINTER :  SINNVOLL ?")
t1 = Text(root) 
t1.pack() 

class PrintToT1(object): 
 def write(self, s): 
     t1.insert(END, s) 

sys.stdout = PrintToT1() 

print ("TRANSPONIEREN    VON PANDAS NACH TKINTER") 
print (df)

mainloop()







OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

Ob diese Daten-Übertragung von
Pandas nach tkinter ü+berhaupt sinnvoll
oder irgendwie anwandbar ist , weiß ich allerdings nicht.
Gute Zeit OSWALD
Benutzeravatar
__blackjack__
User
Beiträge: 13123
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

Hat alles nichts mit „tansponieren“ zu tun und noch nicht einmal mit Numpy oder Pandas. Du hast halt ein `print()` über `sys.stdout` abegfangen und die Ausgabe in eine GUI umgeleitet. Und das mit Code der gruselig aussieht.

Sternchem-Importe waren sicher hier schon mal Thema, und warum man das gerade bei `tkinter` nicht machen sollte. Saubere Einrückung mit vier Leerzeichen pro Ebene. Namensgebung. `t1` ist kein guter Name. Der sagt nichts aus, und es ist eine sinnlose Nummer angehängt.

Dann haben wie eine Klasse die keine Klasse ist, und deren einzige ”Methode” magisch auf `t1` zugreift, was ja gar nicht geht, wenn das Hauptprogramm in einer Funktion steht um globale Variablen zu vermeiden.

Von `object` muss man nicht explizit erben.

Es gibt in der Standardbibliothek einen Kontextmanager zum Umleiten der Standardausgabe.

Code: Alles auswählen

#!/usr/bin/env python3
import tkinter as tk
from contextlib import redirect_stdout

import numpy as np
import pandas as pd


class FileToUI:
    def __init__(self, output_widget):
        self.output_widget = output_widget

    def write(self, text):
        self.output_widget.insert(tk.END, text)


def main():
    dates = pd.date_range("240414", periods=12)
    df = pd.DataFrame(
        np.random.randn(12, 4), index=dates, columns=list("ABCD")
    )
    print(df)

    df = pd.DataFrame(
        {
            "Club": [
                "München",
                "Berlin",
                "Frankfurt",
                "Leipzig",
                "Dortmund ",
                "Freiburg",
                "Augsburg",
                "Köln",
            ],
            "Zuschauer": [
                234_566,
                240_000,
                250_000,
                188_000,
                220_000,
                236_000,
                177_000,
                210_000,
            ],
            "Tore": [197, 77, 80, 79, 80, 75, 45, 68],
        }
    )
    print(df)

    root = tk.Tk()
    root.title("PANDAS UND TKINTER: SINNVOLL?")
    output_widget = tk.Text(root)
    output_widget.pack()

    with redirect_stdout(FileToUI(output_widget)):
        print("TRANSPONIEREN VON PANDAS NACH TKINTER")
        print(df)

        root.mainloop()


if __name__ == "__main__":
    main()
„All religions are the same: religion is basically guilt, with different holidays.” — Cathy Ladman
OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

14.4.2024
@__blackjack__ ich hbatte schon ein mulmiges Gefühl,
als ich meinen 'Code' hier einstellte.
Offenbar hatte ich etwas in irgend einemTtutorial völlig falsch verstanden.
Ich danke jedenfalls herzlich für die Auklärung und den korrigierten Code.
Gute Zeit OSWAL
OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

16.4.2024
Mit der Neuinstallation vonPython 3.12.3
werden sämtliche 'alten' Bibliotheken im System gelöscht.
Das ist ein großer Vorteil.
Jetzt konnte ich endlich mühelos alle gewünschten Bibliotheken
endlich mühelos installieren mit " pip install ......"
auf Windows EingabeAufforderung.
(ähnlich einer Garbage Collection ?)
Empfehlenswert)
Gute Zeir OSWALD
Benutzeravatar
Dennis89
User
Beiträge: 1158
Registriert: Freitag 11. Dezember 2020, 15:13

Hallo,

ich weis nicht, wieso du die erst jetzt mühelos installieren konntest, aber es macht Sinn, vorallem wenn man viel experimentiert, das man sich für die Projekte eigene Entwicklungsumgebungen einrichtet. Die Bibliotheken werden dann in der Umgebung installiert und sind vom System an sich unabhängig. Wenn man zum Beispiel Mist gebaut hat, einfach die Umgebung löschen und eine frische neue erstellen.
Infos dazu gibt es hier:
https://docs.python.org/3/library/venv.html

Grüße
Dennis
"When I got the music, I got a place to go" [Rancid, 1993]
OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

20.4.2024
Wo fange ich an, wenn ich 'Machine learn' näher
kennenlerenen will? Ich lese einige der unzähligen Definitionen, etwa

"Maschinelles Lernen kann automatisiert Wissen generieren, Algorithmen trainieren,
Zusammenhänge identifizieren und unbekannte Muster erkennen.
Diese identifizierten Muster und Zusammenhänge lassen sich auf einem neuen,
unbekannten Datensatz anwenden, um so Vorhersagen zu treffen und Prozesse zu optimieren.

Maschinelles Lernen kann folgende Aufgaben erledigen:
Vorhersage von Werten auf Basis der analysierten Daten treffen
(bspw. Stromverbrauch oder Umsatzforecast),
Berechnung von Wahrscheinlichkeiten für bestimmte Ereignisse
(bpsw. Kaufwahrscheinlichkeit oder Kündigungswahrscheinlichkeit),
Erkennen von Gruppen und Clustern in einem Datensatz,
Erkennen von Zusammenhängen in Sequenzen,
Reduktion von Dimensionen ohne großen Informationsverlust
Optimierung von Geschäftsprozessen."
Und um überhaupt eine erste Vorstellung zu gewinnen, suche ich den einfachsten
Code, den ich finden kann, um ihn zu analysieren.
Dann geht es in die Einzelheiten.Mal sehen, wie weit ich mit
meinen Kenntnissen kommen werde. Alles ohne Garantie.

Code: Alles auswählen


import numpy as np
import pandas as pd
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

#Datenaufbereitung
#Vor dem Training    die Daten aufbereiten,
#z. B. durch Normalisierung und Aufteilung in Trainings- und Testdaten.

# Iris-Datensatz laden
iris = datasets.load_iris()
X = iris.data
y = iris.target

# Aufteilung der Daten in Trainings- und Testdaten
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.8, random_state= 60)

# Normalisierung der Daten
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

#Modellauswahl und Training
#Scikit-Learn bietet eine Vielzahl von Algorithmen zur Auswahl.
#Hier ein Beispiel für die Verwendung von K-Nearest Neighbors (KNN) zur Klassifikation:

from sklearn.neighbors import KNeighborsClassifier

# KNN-Modell erstellen
knn = KNeighborsClassifier(n_neighbors=3)             ######

# Modell trainieren

knn.fit(X_train, y_train)
#Modellbewertung
#Um die Leistung des Modells zu bewerten,
#kannst Du die Genauigkeit auf den Testdaten berechnen:

# Genauigkeit berechnen
accuracy = knn.score(X_test, y_test)
print("Genauigkeit:", accuracy)

#Modellanwendung
#nun as trainierte Modell verwenden, um Vorhersagen für neue Daten zu treffen:

# Neue Daten vorbereiten  zwei Dortenarten   vorhanden
#new_data = np.array([[ 1.1,  8.5, 6.4, 0.8]])    #    virginia 
new_data = np.array([[ 0.3,  18.5, 2.4, 0.3]])    #    setosa 

# Vorhersage treffen
prediction = knn.predict(new_data)
print("Vorhersage:", iris.target_names[prediction])


OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

20.4.2024
Mit welchen Mitteln will ch arbeiten ?
1. Python: eine high-level Programmiersprache, besonders bekannt für ihre einfache Lesbarkeit.
Die weltweit am häufigsten eingesetzte Programmiersprache für Machine Learning.
2.Pandas: eine Python-Bibliothek, die Spreadsheet-ähnliche Funktionen in Python ermöglicht.
3Seaborn: Eine Bibliothek zum Erstellen von Diagrammen und anderen Grafiken.
4Scikit learn: Eine Machine Learning-Bibliothek für Python, die einfache Werkzeuge fürs Training
und Evaluieren verschiedener Algorithmen bereitstellt.

Um welche Themen will ich mich zunächst kümmern? (eine ganze menge)
Klassifikation : heißt Muster in Daten zu erkennen, z.B. negative u. positive
Die Klassifizierung ist eine überwachte Methode des maschinellen Lernens,
bei der das Modell versucht, die korrekte Bezeichnung bestimmter Eingabedaten vorherzusagen

Bei der Klassifizierung wird das Modell mithilfe der Trainingsdaten vollständig trainiert
und anschließend anhand von Testdaten ausgewertet,
bevor es zur Vorhersage neuer, noch nicht sichtbarer Daten verwendet wird.

Arten von Machine Learning Algorithmen :
überwachtes Lernen (Supervised Learning)
unüberwachtes Lernen (Unsupervised Learning)
teilüberwachtes Lernen (Semi-Supervised Learning)
verstärkendes Lernen (Reinforcement Learning)
Gute Zeit OSWALD
OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

22.4.2024
Inzwischen habe ich mich ausführlich mit machine learn
befasst. Zunächst musste ich mich die für mich
optimale Bibliothek entscheiden. Ich habe geladen
sklearn , TensorFlow , torch und torchvision
und probiert , entschieden für sklearn .
Bei TensorFlow konnte ich einen schon länger
im web bekannten Fehler nicht beseitigen, bei
tochvision ein Bild nicht laden. Sonst wäre ich auch hier
weiterjekommen.
Beisklearn gbit es keine Probleme, um die zahllosen tools
nachzuvollziehen. Davon werde ich umgehend einige
hirzeigen.
Das Problem sind die richtige Wahl von Modellen und
gitre Daten für die Auswertung.
Insgesamt für Hobb-y Pprogrammierer interessant aber etwas zu viel.
Gute Zeit OSWALD
OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

22.4.2024
Ich schicke einfach mal den besprocenen
TensorFlow-Code.
Vielleicht kennt ein Fachmann hier den Fehler
Gute Zeit OSWALD

Code: Alles auswählen

mport tensorflow as tf
import numpy as np

import pandas as pd
import matplotlib
from matplotlib import pyplot as plt
import tensorflow__datasets as tfds



# Set a random seed for reproducible results 
tf.random.set_seed(22)

url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data'
column_names = ['MPG', 'Cylinders', 'Displacement', 'Horsepower', 'Weight',
                'Acceleration', 'Model Year', 'Origin']

dataset = pd.read_csv(url, names=column_names, na_values='?', comment='\t',
                          sep=' ', skipinitialspace=True)

dataset = dataset.dropna()
dataset_tf = tf.convert_to_tensor(dataset, dtype=tf.float32)
dataset.tail()

dataset_shuffled = tf.random.shuffle(dataset_tf, seed=22)
train_data, test_data = dataset_shuffled[100:], dataset_shuffled[:100]
x_train, y_train = train_data[:, 1:], train_data[:, 0]
x_test, y_test = test_data[:, 1:], test_data[:, 0]
import tensorflow_datasets as tfds

# Fetch the dataset directly
mnist = tfds.image.MNIST()
# or by string name
mnist = tfds.builder('mnist')

# Describe the dataset with DatasetInfo
assert mnist.info.features['image'].shape == (28, 28, 1)
assert mnist.info.features['label'].num_classes == 10
assert mnist.info.splits['train'].num_examples == 60000

# Download the data, prepare it, and write it to disk
mnist.download_and_prepare()

# Load data from disk as tf.data.Datasets
datasets = mnist.as_dataset()
train_dataset, test_dataset = datasets['train'], datasets['test']
assert isinstance(train_dataset, tf.data.Dataset)

# And convert the Dataset to NumPy arrays if you'd like
for example in tfds.as_numpy(train_dataset):
  image, label = example['image'], example['label']
  assert isinstance(image, np.array)
#as_dataset() accepts a batch_size argument which will give you batches of examples
#instead of one example at a time. For small datasets that fit in memory, you can pass
#batch_size=-1 to get the entire dataset at once as a tf.Tensor.
#All tf.data.Datasets can easily be converted to iterables of NumPy arrays using tfds.as_numpy().
#As a convenience, you can do all the above with tfds.load, which fetches the DatasetBuilder by name,
#calls download_and_prepare(), and calls as_dataset().

import tensorflow_datasets as tfds

datasets = tfds.load("mnist")
train_dataset, test_dataset = datasets["train"], datasets["test"]
assert isinstance(train_dataset, tf.data.Dataset)
 # See the built-in configs
configs = tfds.text.IMDBReviews.builder_configs
assert "bytes" in configs

# Address a built-in config with tfds.builder
imdb = tfds.builder("imdb_reviews/bytes")
# or when constructing the builder directly
imdb = tfds.text.IMDBReviews(config="bytes")
# or use your own custom configuration
my_encoder = tfds.features.text.ByteTextEncoder(additional_tokens=['hello'])
my_config = tfds.text.IMDBReviewsConfig(
    name="my_config",
    version="1.0.0",
    text_encoder_config=tfds.features.text.TextEncoderConfig(encoder=my_encoder),
)
imdb = tfds.text.IMDBReviews(config=my_config)
 
imdb = tfds.builder("imdb_reviews/subwords8k")

# Get the TextEncoder from DatasetInfo
encoder = imdb.info.features["text"].encoder
assert isinstance(encoder, tfds.features.text.SubwordTextEncoder)

# Encode, decode
ids = encoder.encode("Hello world")
assert encoder.decode(ids) == "Hello world"

# Get the vocabulary size
vocab_size = encoder.vocab_size


OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

23..4.2024
So wie hier gezeigt könnte ein Mdell, allerdings mit synthetischen Daten
und mit bestimmten Algorithmen aussehen.
Ausschlaggebend sind in der Praxis immer die vorhandenen Daten
und das Ziel der Auswertung.
Gute Zeit OSWALD

Code: Alles auswählen

# Generieren synthetischer Daten 
#Lineare und quadratische Diskriminanzanalyse mit Kovarianzellipsoid
 
#Plotfunktionen
#Vergleich von LDA und QDA (Schätzer)
#und quadratische Diskriminanzanalyse mit Kovarianzellipsoid 
#LinearDiscriminantAnalysis In diesem Beispiel werden die Kovarianzellipsoide jeder Klasse
#und die von (LDA) und QuadraticDiscriminantAnalysis(QDA)
#gelernte Entscheidungsgrenze dargestellt .
#Die Ellipsoide zeigen die doppelte Standardabweichung für jede Klasse.
 
import numpy as np


def make_data(n_samples, n_features, cov_class_1, cov_class_2, seed=0):
    rng = np.random.RandomState(seed)
    X = np.concatenate(
        [
            rng.randn(n_samples, n_features) @ cov_class_1,
            rng.randn(n_samples, n_features) @ cov_class_2 + np.array([1, 1]),
        ]
    )
    y = np.concatenate([np.zeros(n_samples), np.ones(n_samples)])
    return X, y
#Wir generieren drei Datensätze. Im ersten Datensatz teilen sich die beiden Klassen dieselbe Kovarianzmatrix, und diese Kovarianzmatrix hat die Besonderheit, dass sie sphärisch (isotrop) ist. Der zweite Datensatz ähnelt dem ersten, erzwingt jedoch nicht, dass die Kovarianz sphärisch ist. Schließlich verfügt der dritte Datensatz über eine nicht-sphärische Kovarianzmatrix für jede Klasse.

covariance = np.array([[1, 0], [0, 1]])
X_isotropic_covariance, y_isotropic_covariance = make_data(
    n_samples=1_000,
    n_features=2,
    cov_class_1=covariance,
    cov_class_2=covariance,
    seed=0,
)
covariance = np.array([[0.0, -0.23], [0.83, 0.23]])
X_shared_covariance, y_shared_covariance = make_data(
    n_samples=300,
    n_features=2,
    cov_class_1=covariance,
    cov_class_2=covariance,
    seed=0,
)
cov_class_1 = np.array([[0.0, -1.0], [2.5, 0.7]]) * 2.0
cov_class_2 = cov_class_1.T
X_different_covariance, y_different_covariance = make_data(
    n_samples=300,
    n_features=2,
    cov_class_1=cov_class_1,
    cov_class_2=cov_class_2,
    seed=0,
)
#Plotfunktionen 
#Der folgende Code wird verwendet, um mehrere Informationen aus den verwendeten Schätzern
#die Entscheidungsgrenze basierend auf der Wahrscheinlichkeitsschätzung des Schätzers;

#ein Streudiagramm mit Kreuzen, die die falsch klassifizierten Proben darstellen;

#die geschätzte Kovarianz, dargestellt durch eine Ellipse bei 2 Standardabweichungen
#
import matplotlib as mpl
from matplotlib import colors

from sklearn.inspection import DecisionBoundaryDisplay


def plot_ellipse(mean, cov, color, ax):
    v, w = np.linalg.eigh(cov)
    u = w[0] / np.linalg.norm(w[0])
    angle = np.arctan(u[1] / u[0])
    angle = 180 * angle / np.pi  # convert to degrees
    # filled Gaussian at 2 standard deviation
    ell = mpl.patches.Ellipse(
        mean,
        2 * v[0] ** 0.5,
        2 * v[1] ** 0.5,
        angle=180 + angle,
        facecolor=color,
        edgecolor="black",
        linewidth=2,
    )
    ell.set_clip_box(ax.bbox)
    ell.set_alpha(0.4)
    ax.add_artist(ell)


def plot_result(estimator, X, y, ax):
    cmap = colors.ListedColormap(["tab:red", "tab:blue"])
    DecisionBoundaryDisplay.from_estimator(
        estimator,
        X,
        response_method="predict_proba",
        plot_method="pcolormesh",
        ax=ax,
        cmap="RdBu",
        alpha=0.3,
    )
    DecisionBoundaryDisplay.from_estimator(
        estimator,
        X,
        response_method="predict_proba",
        plot_method="contour",
        ax=ax,
        alpha=1.0,
        levels=[0.5],
    )
    y_pred = estimator.predict(X)
    X_right, y_right = X[y == y_pred], y[y == y_pred]
    X_wrong, y_wrong = X[y != y_pred], y[y != y_pred]
    ax.scatter(X_right[:, 0], X_right[:, 1], c=y_right, s=20, cmap=cmap, alpha=0.5)
    ax.scatter(
        X_wrong[:, 0],
        X_wrong[:, 1],
        c=y_wrong,
        s=30,
        cmap=cmap,
        alpha=0.9,
        marker="x",
    )
    ax.scatter(
        estimator.means_[:, 0],
        estimator.means_[:, 1],
        c="yellow",
        s=200,
        marker="*",
        edgecolor="black",
    )

    if isinstance(estimator, LinearDiscriminantAnalysis):
        covariance = [estimator.covariance_] * 2
    else:
        covariance = estimator.covariance_
    plot_ellipse(estimator.means_[0], covariance[0], "tab:red", ax)
    plot_ellipse(estimator.means_[1], covariance[1], "tab:blue", ax)

    ax.set_box_aspect(1)
    ax.spines["top"].set_visible(False)
    ax.spines["bottom"].set_visible(False)
    ax.spines["left"].set_visible(False)
    ax.spines["right"].set_visible(False)
    ax.set(xticks=[], yticks=[])
#Vergleich von LDA und QDA 
#Wir vergleichen die beiden Schätzer LDA und QDA für alle drei Datensätze.

import matplotlib.pyplot as plt

from sklearn.discriminant_analysis import (
    LinearDiscriminantAnalysis,
    QuadraticDiscriminantAnalysis,
)

fig, axs = plt.subplots(nrows=3, ncols=2, sharex="row", sharey="row", figsize=(8, 12))

lda = LinearDiscriminantAnalysis(solver="svd", store_covariance=True)
qda = QuadraticDiscriminantAnalysis(store_covariance=True)

for ax_row, X, y in zip(
    axs,
    (X_isotropic_covariance, X_shared_covariance, X_different_covariance),
    (y_isotropic_covariance, y_shared_covariance, y_different_covariance),
):
    lda.fit(X, y)
    plot_result(lda, X, y, ax_row[0])
    qda.fit(X, y)
    plot_result(qda, X, y, ax_row[1])

axs[0, 0].set_title("Linear Discriminant Analysis")
axs[0, 0].set_ylabel("Data with fixed and spherical covariance")
axs[1, 0].set_ylabel("Data with fixed covariance")
axs[0, 1].set_title("Quadratic Discriminant Analysis")
axs[2, 0].set_ylabel("Data with varying covariances")
fig.suptitle(
    "Linear Discriminant Analysis vs Quadratic Discriminant Analysis",
    y=0.94,
    fontsize=15,
)
plt.show()










OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

23.4.2024
Nachdem ich das Thema ML in etwa verstanden habe,
kann ich jetzt auch das Thema "TensorFlow" angehen.
Zur Einführung habe ich einen Teil eines großen Datensatzes
bearbeitet, den ich hier zeige. Die Bibliothek TF ist so groß,
dass ich mich längere Zeit damit befassen muss.
Hier deer Code.
Gute Zeit OSWALD

Code: Alles auswählen


import tensorflow as tf
import pandas as pd
import matplotlib
from matplotlib import pyplot as plt
import seaborn as sns
import sklearn.metrics as sk_metrics
import tempfile
import os

# Preset matplotlib figure sizes.
matplotlib.rcParams['figure.figsize'] = [9, 8]

print(tf.__version__)
# To make the results reproducible, set the random seed value.
tf.random.set_seed(52)
#Laden Sie die Daten
#Laden Sie als Nächstes den Wisconsin-Brustkrebsdatensatz aus dem UCI Machine Learning Repository .

#Dieser Datensatz enthält verschiedene Merkmale wie den Radius, die Textur und die Konkavität eines Tumors.
url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data'
features = ['radius', 'texture', 'perimeter', 'area', 'smoothness', 'compactness',
            'concavity', 'concave_poinits', 'symmetry', 'fractal_dimension']
column_names = ['id', 'diagnosis']

for attr in ['mean', 'ste', 'largest']:
  for feature in features:
    column_names.append(feature + "_" + attr)
#Lesen Sie den Datensatz in einen Pandas- DataFrame ein, indem Sie Folgendes verwenden pandas.read_csv:
dataset = pd.read_csv(url, names=column_names)
dataset.info()
#Zeigen Sie die ersten fünf Zeilen an:
dataset.head()
#pandas.DataFrame.sampleTeilen Sie den Datensatz mit , pandas.DataFrame.dropund in Trainings-
#und Testsätze auf pandas.DataFrame.iloc. Stellen Sie sicher, dass Sie die Features von den Zielbeschriftungen trennen.
#Der Testsatz wird verwendet, um die Generalisierbarkeit Ihres Modells auf unbekannte Daten zu bewerten.
train_dataset = dataset.sample(frac=0.75, random_state=1)
print("Grösse des Trainingssatzes", len(train_dataset))
print(train_dataset)
test_dataset = dataset.drop(train_dataset.index)
print(test_dataset)
len(test_dataset)
print("Grösse  des Datensatzes", len(test_dataset))
# The `id` column can be dropped since each row is unique
x_train, y_train = train_dataset.iloc[:, 2:], train_dataset.iloc[:, 1]
x_test, y_test = test_dataset.iloc[:, 2:], test_dataset.iloc[:, 1]

#Verarbeiten Sie die Daten vor

#Dieser Datensatz enthält den Mittelwert, den Standardfehler und die größten Werte für jede der 10 pro Beispiel erfassten Tumormessungen. Die "diagnosis"Zielspalte ist eine kategoriale Variable, die 'M'einen bösartigen Tumor und 'B'eine gutartige Tumordiagnose anzeigt. Diese Spalte muss für das Modelltraining in ein numerisches Binärformat konvertiert werden.

#Die pandas.Series.mapFunktion ist nützlich, um Binärwerte den Kategorien zuzuordnen.

#tf.convert_to_tensorNach Abschluss der Vorverarbeitung sollte der Datensatz mit der Funktion auch in einen Tensor umgewandelt werden .


y_train, y_test = y_train.map({'B': 0, 'M': 1}), y_test.map({'B': 0, 'M': 1})
x_train, y_train = tf.convert_to_tensor(x_train, dtype=tf.float32), tf.convert_to_tensor(y_train, dtype=tf.float32)
x_test, y_test = tf.convert_to_tensor(x_test, dtype=tf.float32), tf.convert_to_tensor(y_test, dtype=tf.float32)
#Verwenden Sie diese Option seaborn.pairplot, um die gemeinsame Verteilung einiger Paare mittelwertbasierter Merkmale aus dem Trainingssatz zu überprüfen und zu beobachten, wie sie sich auf das Ziel beziehen:


sns.pairplot(train_dataset.iloc[:, 1:6], hue = 'diagnosis', diag_kind='kde');
#Dieses Paardiagramm zeigt, dass bestimmte Merkmale wie Radius, Umfang und Fläche stark korrelieren. Dies ist zu erwarten, da der Tumorradius direkt in die Berechnung von Umfang und Fläche einfließt. Beachten Sie außerdem, dass bösartige Diagnosen bei vielen Merkmalen offenbar stärker rechtsschief sind.

#Überprüfen Sie unbedingt auch die Gesamtstatistik. Beachten Sie, dass jede Funktion einen sehr unterschiedlichen Wertebereich abdeckt.


train_dataset.describe().transpose()[:10]
#Angesichts der inkonsistenten Bereiche ist es vorteilhaft, die Daten so zu standardisieren, dass jedes Merkmal einen Mittelwert von Null und eine Einheitsvarianz aufweist. Dieser Vorgang wird als Normalisierung bezeichnet .


class Normalize(tf.Module):
  def __init__(self, x):
    # Initialize the mean and standard deviation for normalization
    self.mean = tf.Variable(tf.math.reduce_mean(x, axis=0))
    self.std = tf.Variable(tf.math.reduce_std(x, axis=0))

  def norm(self, x):
    # Normalize the input
    return (x - self.mean)/self.std

  def unnorm(self, x):
    # Unnormalize the input
    return (x * self.std) + self.mean

norm_x = Normalize(x_train)
x_train_norm, x_test_norm = norm_x.norm(x_train), norm_x.norm(x_test)

OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

24.4.2024
TensorFlow ist gewöhnungsbedürftig.
Meine Methode: Übung am fertigen Objekt.
Also learning by doing.
Hier ein Beispiel, selbsterklärend.
Gute Zeit OSWALD

Code: Alles auswählen

import tensorflow as tf
import pandas as pd
import matplotlib
from matplotlib import pyplot as plt
print("TensorFlow version:", tf.__version__)
# Set a random seed for reproducible results 
tf.random.set_seed(45)
url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data'
column_names = ['MPG', 'Cylinders', 'Displacement', 'Horsepower', 'Weight',
                'Acceleration', 'Model Year', 'Origin']

dataset = pd.read_csv(url, names=column_names, na_values='?', comment='\t',
                          sep=' ', skipinitialspace=True)

dataset = dataset.dropna()
dataset_tf = tf.convert_to_tensor(dataset, dtype=tf.float32)
dataset.tail()
dataset_shuffled = tf.random.shuffle(dataset_tf, seed=22)
train_data, test_data = dataset_shuffled[100:], dataset_shuffled[:100]
x_train, y_train = train_data[:, 1:], train_data[:, 0]
x_test, y_test = test_data[:, 1:], test_data[:, 0]

def onehot_origin(x):
  origin = tf.cast(x[:, -1], tf.int32)
  # Use `origin - 1` to account for 1-indexed feature
  origin_oh = tf.one_hot(origin - 1, 3)
  x_ohe = tf.concat([x[:, :-1], origin_oh], axis = 1)
  return x_ohe

x_train_ohe, x_test_ohe = onehot_origin(x_train), onehot_origin(x_test)
x_train_ohe.numpy()

class Normalize(tf.Module):
  def __init__(self, x):
    # Initialize the mean and standard deviation for normalization
    self.mean = tf.math.reduce_mean(x, axis=0)
    self.std = tf.math.reduce_std(x, axis=0)

  def norm(self, x):
    # Normalize the input
    return (x - self.mean)/self.std

  def unnorm(self, x):
    # Unnormalize the input
    return (x * self.std) + self.mean


norm_x = Normalize(x_train_ohe)
norm_y = Normalize(y_train)
x_train_norm, y_train_norm = norm_x.norm(x_train_ohe), norm_y.norm(y_train)
x_test_norm, y_test_norm = norm_x.norm(x_test_ohe), norm_y.norm(y_test)

class LinearRegression(tf.Module):

  def __init__(self):
    self.built = False

  @tf.function
  def __call__(self, x):
    # Initialize the model parameters on the first call
    if not self.built:
      # Randomly generate the weight vector and bias term
      rand_w = tf.random.uniform(shape=[x.shape[-1], 1])
      rand_b = tf.random.uniform(shape=[])
      self.w = tf.Variable(rand_w)
      self.b = tf.Variable(rand_b)
      self.built = True
    y = tf.add(tf.matmul(x, self.w), self.b)
    return tf.squeeze(y, axis=1)

lin_reg = LinearRegression()
prediction = lin_reg(x_train_norm[:1])
prediction_unnorm = norm_y.unnorm(prediction)
prediction_unnorm.numpy()

def mse_loss(y_pred, y):
  return tf.reduce_mean(tf.square(y_pred - y))

batch_size = 64
train_dataset = tf.data.Dataset.from_tensor_slices((x_train_norm, y_train_norm))
train_dataset = train_dataset.shuffle(buffer_size=x_train.shape[0]).batch(batch_size)
test_dataset = tf.data.Dataset.from_tensor_slices((x_test_norm, y_test_norm))
test_dataset = test_dataset.shuffle(buffer_size=x_test.shape[0]).batch(batch_size)

# Set training parameters
epochs = 100
learning_rate = 0.01
train_losses, test_losses = [], []
 
# Format training loop
for epoch in range(epochs):
  batch_losses_train, batch_losses_test = [], []

  # Iterate through the training data
  for x_batch, y_batch in train_dataset:
    with tf.GradientTape() as tape:
      y_pred_batch = lin_reg(x_batch)
      batch_loss = mse_loss(y_pred_batch, y_batch)
    # Update parameters with respect to the gradient calculations
    grads = tape.gradient(batch_loss, lin_reg.variables)
    for g,v in zip(grads, lin_reg.variables):
      v.assign_sub(learning_rate * g)


    batch_losses_train.append(batch_loss)

  # Iterate through the testing data
  for x_batch, y_batch in test_dataset:
    y_pred_batch = lin_reg(x_batch)
    batch_loss = mse_loss(y_pred_batch, y_batch)
    # Keep track of batch-level testing performance 
    batch_losses_test.append(batch_loss)

  # Keep track of epoch-level model performance
  train_loss = tf.reduce_mean(batch_losses_train)
  test_loss = tf.reduce_mean(batch_losses_test)
  train_losses.append(train_loss)
  test_losses.append(test_loss)

  if epoch % 10 == 0:
    print(f'Mean squared error for step {epoch}: {train_loss.numpy():0.3f}')

# Output final losses
print(f"\nFinal train loss: {train_loss:0.3f}")
print(f"Final test loss: {test_loss:0.3f}")

matplotlib.rcParams['figure.figsize'] = [9, 6]

plt.plot(range(epochs), train_losses, label = "Training loss")
plt.plot(range(epochs), test_losses, label = "Testing loss")
plt.xlabel("Epoch")
plt.ylabel("Mean squared error loss")
plt.legend()
plt.title("MSE loss vs training iterations");
plt.show()

OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

24.4.2024
Bevor ich richtig mit tensorflow beginnen kann, muss ich die " Datenbank Mnist"
importieren.

-- from tensorflow.keras import datasets. ---
Gute Zeit OSWALD
OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

28.4.2024
Es ist mir nicht gelungen
mit Tensor Flow 2.16.1 aus der ' Datenbank mnist'
eine Graphik zu erstellen. Es entsehen ikmmer nur
Unmengen von 'Daten' , die nur mit 'Programm löschen
beseitigt werden können.
Nach langem Suchen muss ich leider feststellen,
dass meine Grafikkarte dazu nicht in der Lage ist.
Es handelt sich um AMD Radeon (TM) Graphics.
Gute Zeit OSWALD
OSWALD
User
Beiträge: 361
Registriert: Freitag 18. März 2022, 17:32

29....4.2024
Ich habe bei PYTORCH nachgeprüft
und die gleichen Probleme
speziell bei MNIST & Co-Datenbanken
festgestellt,ansonsten alles normalwie bei TensorFlow.
Gute Zeit OSWALD
Antworten