Das deutsche Python-Forum

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()

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()

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()

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])

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

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()

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)

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()

Code: Alles auswählen

mport os
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

#Wir möchten unser Modell auf einem Hardwarebeschleuniger
#wie der GPU oder MPS trainieren können, sofern verfügbar.
#Schauen wir mal, ob Torch.cuda oder Torch.backends.mps verfügbar sind,
#andernfalls nutzen wir die CPU.

device = (
    "cuda"
    if torch.cuda.is_available()
    else "mps"
    if torch.backends.mps.is_available()
    else "cpu"
)
print(f"Using {device} device")

#Wir definieren unser neuronales Netzwerk durch Unterklassenbildung
#nn.Module und initialisieren die neuronalen Netzwerkschichtenin __init__.
#Jede nn.ModuleUnterklasse implementiert die Operationen an Eingabedaten
#in der forwardMethode.

class NeuralNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

model = NeuralNetwork().to(device)
print(model)

# Der Aufruf des Modells für die Eingabe gibt einen zweidimensionalen Tensor zurück,
#wobei dim=0 jeder Ausgabe von 10 vorhergesagten Rohwerten
#für jede Klasse entspricht und dim=1 den einzelnen Werten jeder Ausgabe entspricht.
#Wir erhalten die Vorhersagewahrscheinlichkeiten,
#indem wir sie durch eine Instanz des nn.SoftmaxModuls leiten.

X = torch.rand(1, 28, 28, device=device)
logits = model(X)
pred_probab = nn.Softmax(dim=1)(logits)
y_pred = pred_probab.argmax(1)
print(f"Predicted class: {y_pred}")
#Lassen Sie uns die Schichten im FashionMNIST-Modell aufschlüsseln.

#Zur Veranschaulichung nehmen wir einen Beispiel-Minibatch
#'mit drei Bildern der Größe 28x28 und sehen, was damit passiert,
#wenn wir ihn durch das Netzwerk weiterleiten.

input_image = torch.rand(3,28,28)
print(input_image.size())

#Wir initialisieren die nn.Flatten- Ebene,
#um jedes 2D-28x28-Bild in ein zusammenhängendes Array von 784 Pixelwerten umzuwandeln
#(die Minibatch-Dimension (bei dim=0) bleibt erhalten).

flatten = nn.Flatten()
flat_image = flatten(input_image)
print(flat_image.size())

#Die lineare Ebene ist ein Modul, das mithilfe seiner gespeicherten Gewichtungen
#und Vorspannungen eine lineare Transformation auf die Eingabe anwendet.

layer1 = nn.Linear(in_features=28*28, out_features=20)
hidden1 = layer1(flat_image)
print(hidden1.size())

#nn.ReLU

#Nichtlineare Aktivierungen erzeugen die komplexen Zuordnungen zwischen den Eingaben und Ausgaben des Modells.
#Sie werden nach linearen Transformationen angewendet, um Nichtlinearität einzuführen
#und neuronalen Netzen dabei zu helfen, eine Vielzahl von Phänomenen zu lernen.

#In diesem Modell verwenden wir nn.ReLU zwischen unseren linearen Schichten,
#es gibt jedoch noch andere Aktivierungen, um Nichtlinearität in Ihr Modell einzuführen.

print(f"Before ReLU: {hidden1}\n\n")
hidden1 = nn.ReLU()(hidden1)
print(f"After ReLU: {hidden1}")

#nn.Sequentiell
#nn.Sequential ist ein geordneter Container von Modulen.
#Die Daten werden in der definierten Reihenfolge durch alle Module geleitet.
#Sie können sequentielle Container verwenden,
#um ein schnelles Netzwerk wie  ' seq_modules'   zu erstellen.

seq_modules = nn.Sequential(
    flatten,
    layer1,
    nn.ReLU(),
    nn.Linear(20, 10)
)

print(seq_modules)

input_image = torch.rand(3,28,28)
logits = seq_modules(input_image)
#nn.Softmax
#Die letzte lineare Schicht des neuronalen Netzwerks gibt Logits zurück
#– Rohwerte in [-infty, infty] – die an das nn.Softmax- Modul übergeben werden. Die Logits werden auf Werte [0, 1] skaliert, die die vorhergesagten Wahrscheinlichkeiten des Modells für jede Klasse darstellen. dimDer Parameter gibt die Dimension an, entlang derer die Werte 1 ergeben müssen.

softmax = nn.Softmax(dim=1)
pred_probab = softmax(logits)
print(pred_probab)

#In diesem Beispiel iterieren wir über jeden Parameter und drucken seine Größe und eine Vorschau seiner Werte aus.

print(f"Model structure: {model}\n\n")

for name, param in model.named_parameters():
    print(f"Layer: {name} | Size: {param.size()} | Values : {param[:2]} \n")

Code: Alles auswählen

mport torch
import matplotlib.pyplot as plt
X = torch.arange(-40, 40, 1).view(-1, 1).type(torch.FloatTensor)
Y = torch.zeros(X.shape[0])
Y[(X[:, 0] <= -10)] = 1.0
Y[(X[:, 0] > -10) & (X[:, 0] < 10)] = 0.5
Y[(X[:, 0] > 10)] = 0
 
plt.title("Zuerst  'künstliche Daten'  erstellen  und anzeigen") 
plt.plot(X, Y)
plt.grid()
plt.show()

#   Mit dem  - nn. Modul - wird  jetztn   nutzerdefiniertes ,einschichtiges, neuronales Netzwerk erstellt

#   Dieses neuronale Netzwerk verfügt über  eine Eingabeschicht,
#   eine verborgene Schicht mit zwei Neuronen und eine Ausgabeschicht.

#   Nach jeder Schicht wird eine Sigmoid-Aktivierungsfunktion angewendet.
#   Andere Arten von Aktivierungsfunktionen sind in PyTorch verfügbar,
#   das klassische Design für dieses Netzwerk ist die Verwendung der Sigmoidfunktion.

#  So sieht Ihr einschichtiges neuronales Netzwerk im Code aus.

class one_layer_net(torch.nn.Module):    
    # Constructor
    def __init__(self, input_size, hidden_neurons, output_size):
        super(one_layer_net, self).__init__()
        # hidden layer 
        self.linear_one = torch.nn.Linear(input_size, hidden_neurons)
        self.linear_two = torch.nn.Linear(hidden_neurons, output_size) 
        # defining layers as attributes
        self.layer_in = None
        self.act = None
        self.layer_out = None
    # prediction function
    def forward(self, x):
        self.layer_in = self.linear_one(x)
        self.act = torch.sigmoid(self.layer_in)
        self.layer_out = self.linear_two(self.act)
        y_pred = torch.sigmoid(self.linear_two(self.act))
        return y_pred

#      Lassen Sie uns auch ein Modellobjekt instanziieren.
#      Das  Modell  ist ein Ein-Schcht-Netz und  zeigt   zwei Neuronen in einer verborgenen Schicht
model = one_layer_net(1, 2, 1)  #      
#      Trainieren Sie das Modell
#      Bevor wir mit der Trainingsschleife beginnen,
#      definieren wir die Verlustfunktion und den Optimierer für das Modell.
#      Sie schreiben eine Verlustfunktion für den  sog. Kreuzentropieverlust 
#      und verwenden den stochastischen Gradientenabstieg zur Parameteroptimierung.

def criterion(y_pred, y):
    out = -1 * torch.mean(y * torch.log(y_pred) + (1 - y) * torch.log(1 - y_pred))
    return out
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
#   Jetzt hat  man  alle Komponenten, um das Modell zu trainieren.
#    Es sollenLassen Sie uns das Modell für 5000 Epochen trainieren. Sie sehen eine Darstellung,
#    wie das neuronale Netzwerk die Funktion nach jeweils 1000 Epochen annähert.

#   Die Dainingsschleife 
epochs=5000
cost = []
total=0
for epoch in range(epochs):
    total=0
    epoch = epoch + 1
    for x, y in zip(X, Y):
        yhat = model(x)
        loss = criterion(yhat, y)
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()
        # get total loss 
        total+=loss.item() 
    cost.append(total)
    if epoch % 1000 == 0:
        print(str(epoch)+ " " + "Epochen  sind jetzt durchlaufen!")  # visualisiert  jeweils nach 1q000 Durchläufen
        # plot the result of function approximator
        plt.plot(X.numpy(), model(X).detach().numpy())
        plt.plot(X.numpy(), Y.numpy(), 'm')
        plt.xlabel('x')
        plt.title("Beachten : wie sich die Sigmoid-Funktion den Originaldaten nähert")
        plt.show()
#      Nach  jeweils 1000 Epochen näherte sich das Modell der Funktion wie folgt an:
#      Aber nach 5000 Epochen verbessert es sich ersichtlich.
#      Daraus können Sie ersehen, dass die Näherung in Blau näher an den Daten in Lila liegt.
#      Wie Sie sehen, nähert sich das neuronale Netzwerk den Funktionen recht gut an.
#      Wenn die Funktion komplexer ist, benötigt  man   mehr verborgene Schichten
#      oder mehr Neuronen in der verborgenen Schicht, also ein komplexeres Modell.
#      Geeignete Hardware ist hierfür Voraussetzung füä die 
#
#      Lassen Sie uns auch grafisch darstellen, wie sich der Verlust während des Trainings verringert hat.

# plot the cost
plt.plot(cost)
plt.xlabel('Duchläufe')
plt.title("Kreuzentropeverlust")
plt.show()