kleine Mathe-Spielereien

[OSWALD]

27,1,2025
Die wahre Herausforderung bei der Entwicklung der KI liegt
letzten Endes im Bereich von - geeigneten - Daten,
etwa die Erkennung von Anomalien.
Damit beschäftige ich mich derzeit.
Besondes geeignet schedint mir Isolation Forest ,
ein Algorithmus zur Datenanomalieerkennung
mithilfe von Binärbäumen .
Dazu ein erstes Beispiel:
Gute Zeit OSWALD

Code: Alles auswählen

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import IsolationForest
from sklearn.datasets import make_blobs
# Generiere Beispieldaten
X, _ = make_blobs(n_samples=300, centers=1, random_state=42)
# Füge einige Ausreißer hinzu
outliers = np.random.RandomState(42).uniform(low=-6, high=6, size=(20, 2))
X = np.r_[X, outliers]
# Passe das Isolation Forest-Modell an
clf = IsolationForest(contamination=0.1, random_state=42)
clf.fit(X)
# Vorhersage von Anomalien
y_pred = clf.predict(X)
# Visualisiere die Ergebnisse
plt.scatter(X[:, 0], X[:, 1], c=y_pred, s=50, edgecolors='k', cmap='viridis')
plt.title('Anomalieerkennung mit Isolation Forest')
plt.xlabel('Merkmal 1')
plt.ylabel('Merkmal 2')
plt.show()

[OSWALD]

27.1.2025
hier ein umfangreicheres Progamm.
mit Isolation Forestselbsterklärend.
Die besten Ergebnise lassen sich mit großen
Datenmengen erzielen und umgekehrt-
Gute Zeit OSWALD

Code: Alles auswählen

#Bedeutungen

#Datum: Wann die Daten aufgezeichnet wurden.
#Zeit: Tageszeit für die Daten.
#CO(GT): Kohlenmonoxidgehalt.
#PT08.S1(CO): Sensorreaktion für CO.
#NMHC(GT): Nicht-Methan-Kohlenwasserstoffgehalt.
#C6H6(GT): Benzolgehalt.
#PT08.S2(NMHC): Sensorantwort für NMHC.
#NOx(GT): Stickoxidgehalt.
##PT08.S3(NOx): Sensorreaktion für NOx.
#NO2(GT): Stickstoffdioxidgehalt.
#PT08.S4(NO2): Sensorantwort für NO2.
#PT08.S5(O3): Sensorreaktion für Ozon.
#T: Temperatur.
#RH: Relative Luftfeuchtigkeit.
#AH: Absolute Luftfeuchtigkeit.




import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import IsolationForest
from ucimlrepo import fetch_ucirepo

# Fetch dataset from UCI repository
air_quality = fetch_ucirepo(id=360)

# Convert to DataFrame
data = air_quality.data.features
print(data)# Select features
#Gehaltsangaben Koihlenmooxid,Benzol,Stickmonoxid,Stickdioxid
#
 
features = data[['CO(GT)', 'C6H6(GT)', 'NOx(GT)', 'NO2(GT)']]
# Drop rows with missing values (-200)
features = features.replace(-200, np.nan)
features = features.dropna()

print(features.shape)
features.head()

 
   
  
# Parameters
n_estimators = 360                     # Anzahl der Bäume
contamination = 0.01                  # erwarteter Anteil von Anomalien
sample_size = 150                        # Anzahl der Knoten, die  jeden Baum trainieren
# Train Isolation Forest
iso_forest = IsolationForest(n_estimators=n_estimators,
                            contamination=contamination,
                            max_samples=sample_size,
                            random_state=242)                          #42
iso_forest.fit(features)

# Abomalie-Scores berechnen ,klassifizieren
data = data.loc[features.index].copy()
data['anomal_score'] = iso_forest.decision_function(features)
data['anomal'] = iso_forest.predict(features)

data['anomal'].value_counts()
 
# Visualisierung
plt.figure(figsize=(10, 6))

# Plot normale Transaktionen
normal = data[data['anomal'] == 1]
plt.scatter(normal.index, normal['anomal_score'], label='normal')

# Plot Anomalien
anomalies = data[data['anomal'] == -1]
plt.scatter(anomalies.index, anomalies['anomal_score'], label='anomal')
plt.xlabel("Transaktionen")
plt.ylabel("anomal Score")
plt.legend()
plt.title("Isolation Forest für große Datenmengen  geeignet")
plt.grid()
plt.show()
plt.figure(figsize=(5, 5))

# Plot non-anomalies then anomalies
plt.scatter(normal['CO(GT)'], normal['NO2(GT)'], label='Normal')
plt.scatter(anomalies['CO(GT)'], anomalies['NO2(GT)'], label='Anomal')
plt.xlabel("CO(GT)")
plt.ylabel("NO2(GT)")
plt.legend()
plt.grid()
plt.show()

[OSWALD]

29.1.2025
hier zeige ich 2 weitere Programme , von denen
ich mir tiefefe Einblicke in das Thema LKI zu erhalten.
Ich würde gerne wissen , wo genau die Unterschiede
zwischen ' KI CH' und ' KI USA' liegen.
Meine Vermutung.(als Laie)
Hier USA: Mehr Datengewinnung aus Bildern(zB.MNIST) Ergebnisse sehr genau ,aber sehr aufwendig
China Mehr Daten aus Zahlenmaterial ( z.B. Isolation Forest) Ergebnisse weniger genau , dafür weniger aufwendig
Aus den vielen Fachartikeln ist jedenfalls kaum Konkretes zu erfehren.
Gute Zeit OSWALD

Code: Alles auswählen

import numpy as np
import math
import pandas as pd
import matplotlib.pyplot as plt
from pyod.utils.data import generate_data, get_outliers_inliers
import seaborn as sns
from sklearn.ensemble import IsolationForest

plt.rcParams["figure.figsize"] = (9,7)
np.random.seed(12335)

data, is_anomaly = generate_data(
    n_features=2,
    train_only=True,
    random_state=42    )

data = pd.DataFrame(data, columns = ['x','y'])
print(data) 
data['is_really_anomaly'] = is_anomaly
print(data) 
sns.scatterplot(
    data = data, 
    x = 'x', 
    y = 'y', 
    hue =  'is_really_anomaly'                                      
    )

plt.grid()
plt.title("Synthetisch erzeugte zufällige Daten")
plt.show()

###################
Nummer 2
####################

rom sklearn.model_selection import train_test_split

# Example of dummy data for X (features) and y (labels)
X = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(X)
y = [0, 1, 0]
print(y)
# Use train_test_split to split the data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Display training and testing data
print("1. Training data X:", X_train)
print()
print("2. Training labels y:", y_train)
print()
print("3.Testing data X:", X_test)
print()
print("4. Testing data y:", y_test)
print()

#                                      Was ist random_state?
#random_state ist ein Parameter - train_test_split- , der den Zufallszahlengenerator steuert, 
#der zum Mischen der Daten vor dem Aufteilen verwendet wird.
# Mit anderen Worten stellt er sicher, dass bei jeder Ausführung des Codes dieselbe Zufallsverteilung verwendet wird,
#was zu denselben Aufteilungen der Daten führt.
#Schauen wir uns ein Beispiel an, um dies zu demonstrieren. Angenommen, Sie haben einen Datensatz mit 1000 Proben und möchten ihn in einen Trainingssatz mit 700 Proben und einen Testsatz mit 300 Proben aufteilen. So geht's:

from sklearn.model_selection import train_test_split
import numpy as np
# Generate data for the example (values from 0 to 99)
data = np.arange(100)

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(data, data, test_size=0.3, random_state=42)

# Display the training and testing sets
print("Training set X:", X_train)
print()
print("Testing set X:", X_test)
print()
print("Training labels y:", y_train)
print()
print("Testing labels y:", y_test)
print() 

[__blackjack__]

wäre CN oder CHN. CH ist die .

[grubenfox]

ach, stimmt schon irgendwie... die Schweiz bekommt offenbar auch keine AI-Chips mehr

https://www.swissinfo.ch/eng/multinatio ... s/88781270

[OSWALD]

30.1.2025
Hier ein ?rogramm, das demonstriert,
wie man sythetische Daten praxisnah erzeugen kann.
Dazu bekannte Statitiken auswerten und aus scipy mittels
Verteilungen die besten Modelle ausprobieren, trainieren ujsw


Gute Zeit OSWALD

Code: Alles auswählen

#  Beispiel          1000      Synthetische Daten , normalverteilt
#                                      Gewicht  und Körpergrösse  für  m/w

import pandas as pd
import numpy as np

# Generate 1,000 samples from a normal distribution
heights = np.random.normal(loc=170, scale=10, size=1000)
#print( heights)
weights = np.random.normal(loc=70, scale=15, size=1000)
#print(weights)


# Create a correlation between height and weight
weights += (heights - 170) * 0.5
df = pd.DataFrame({'Height': heights, 'Weight': weights})
print(df)
# Add categorical data
genders = np.random.choice(['Male', 'Female'], size=1000)
#print(genders)
df['Gender'] = genders
df.head()
#print(df.head())
df.describe()
print(df)

[OSWALD]

1.2.2025
Ich habe jetzt nmal ein kleines Programm im Ansatz
zur Erzeugung von synthetischen Daten zusammen zu schreiben,
etwa so wie ich mir als Anfänger so vorstelle könnte.
(Fehler nicht ausgechlossen, bitte melden)
Gleiches kann man natrlich mit anderen Verteilungen auch machen.
Gute Zeit OSWALD

Code: Alles auswählen

#Bernullie BAYESTest
from sklearn.datasets import make_classification
import numpy as np

# Model evaluation by using Bernoulli Naïve Bayes algorithm.

# Import Bernoulli Naive bayes from sklearn
from sklearn.naive_bayes import BernoulliNB

# Organizing dataset into training and testing set
# by using train_test_split() function
from sklearn.model_selection import train_test_split

# Creating the classification dataset with one informative feature and one cluster per class
nb_samples = 300

X, Y = make_classification(n_samples  =  nb_samples, n_features=2, n_informative=2, n_redundant=0)
X_train, X_test, Y_train, Y_test   =   train_test_split(X, Y, test_size=0.01)
print("               X_train "  ,X_train  )
print("                X_test"  , X_test )
print("                Y_train"  , Y_train )
print("                Y_test"  , Y_test  )       

# Let's initializing the model
B_NaiveBayes = BernoulliNB(binarize=0.0)
# Train the model
B_NaiveBayes.fit(X_train, Y_train)

# Making predictions by using pred() function
data = np.array([[1., 1.],
                 [1., 1.],
                 [1., 0.],
                 [2., 1.]])
 
Preds=B_NaiveBayes.predict(data)
print(Preds)
                        #               uswusw 

[OSWALD]

4.2.25
Auf der Suche nach brauchbaren sythetischen Daten
kann man nicht nur bei Isolation Forest, sondern auch
bei Clustern beliebig viele Daten abschöpfen. Hier ist sogar
eine 'Vorauswahl' aus mehreren Bereichen möglich.
Hier zwei Beispiele
Gute Zeit OSWALD

[code
mport numpy as np
from sklearn.model_selection import train_test_split

n_samples, n_outliers = 120, 40
rng = np.random.RandomState(0)
covariance = np.array([[0.5, -0.1], [0.7, 0.4]])

cluster_1 = 0.4 * rng.randn(n_samples, 2) @ covariance + np.array([2, 2]) # general
print(cluster_1)

cluster_2 = 0.3 * rng.randn(n_samples, 2) + np.array([-2, -2]) # spherical
print(cluster_2)

outliers = rng.uniform(low=-4, high=4, size=(n_outliers, 2))
print(" OUTRLIERS :" ,outliers)

X = np.concatenate([cluster_1, cluster_2, outliers])
y = np.concatenate(
[np.ones((2 * n_samples), dtype=int), -np.ones((n_outliers), dtype=int)]
)

X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)
#Wir können die resultierenden Cluster visualisieren:
print(" X_Train : " ,X_train)
print(" X_Test : " ,X_test)
print(" y_Train : " ,y_train)
print(" y_Test : " , y_test)




import matplotlib.pyplot as plt

scatter = plt.scatter(X[:, 0], X[:, 1], c=y, s=50, edgecolor="k")
handles, labels = scatter.legend_elements()
plt.axis("square")
plt.legend(handles=handles, labels=["outliers", "inliers"], title="true class")
plt.title("Gaussian inliers with \nuniformly distributed outliers")
plt.show()
#################
#Gaußsche Inlier mit gleichmäßig verteilten Ausreißern
#Training des Modells

from sklearn.ensemble import IsolationForest
clf = IsolationForest(max_samples=20, random_state=0)
print(clf)
clf.fit(X_train)

IsolationForest(max_samples=20, random_state=0)
from sklearn.inspection import DecisionBoundaryDisplay
disp = DecisionBoundaryDisplay.from_estimator(
clf,
X,
response_method="predict",
alpha=0.5,
)
disp.ax_.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor="k")
disp.ax_.set_title("Binary decision boundary \nof IsolationForest")
plt.axis("square")
plt.legend(handles=handles, labels=["outliers", "inliers"], title="true class")

plt.show()
#####################


disp = DecisionBoundaryDisplay.from_estimator(
clf,
X,
response_method="decision_function",
alpha=0.5,
)


disp.ax_.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor="k")
disp.ax_.set_title("Path length decision boundary \nof IsolationForest")
plt.axis("square")
plt.legend(handles=handles, labels=["outliers", "inliers"], title="true class")
plt.colorbar(disp.ax_.collections[1])
plt.show()

][/code]

[OSWALD]

5.2.2025
Das Beispiel eines Clusters zeigt , wie manipulativ
die hieraus gewinnbaren Daten sind.
Das ist ein Problem mit beliebig vielen Parametern.
Gibt es eine ID-KI ?.
Wieviel Wahrscheinlicheit steckt in der KI ?
Gut oder böse ?
Oder per se nur eine Geschäftsidee?
Scio nescio
Ich warte gespannt auf kommende Erfolgsmeldungen.
Es ist Fasching
OSWALD

Code: Alles auswählen

rom sklearn.cluster import MeanShift, estimate_bandwidth
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

 
#Datensatz mit 500 Stichproben,

# Datensatz hat fünf Zentren,mit einer Standardabweichung von 0,7 Clustern.
# Beispieldatensatz 
X, _ = make_blobs(n_samples=500, centers= 5 ,cluster_std=0.3, random_state=42)
print(X) 
print(_)
#Schätzen wir die Bandbreite mithilfe der Funktion estimate_bandwidth().


# Bandbreite schätzen
bandwidth = estimate_bandwidth(X, quantile=0.1, n_samples=500)
print(bandwidth) 


# Modell durchführen
ms_model = MeanShift(bandwidth=bandwidth, bin_seeding=True)
ms_model.fit(X)
labels = ms_model.labels_
mean_shift_centers = ms_model.cluster_centers_

 # Ergebvnisse plotten
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='plasma', marker='p')
plt.scatter(mean_shift_centers[:, 0], mean_shift_centers[:, 1], s=25, c='blue', marker='X')
plt.title('mean shift clustering')
plt.xlabel('Attribute 1')
plt.ylabel('Attribute 2')
plt.grid()
plt.show()

[OSWALD]

6.2.2025
Mein Veertrauen in die 'omnipotente KI ' ist inzwischen 'leicht angezählt'
Warum?
Ki iist definitiv nicht in der Lage, sehr viele alte bekannte
Probleme aus der Mathematik oder aus der Logik zu lösen.
Hingegen tauchen immer neue Probleeme auf, etwa Datenmangel, oder mehr
Energie (Atomkraft) und Kosten .Das alles mmutet mich an wie in Zeiten der Alchemie.

Hier stelle ich als Beispiel den einfachen Algorithmus des Collatz - Problemes ein.

Kann oder darf man demnach KI eher in der Stochastik oder gar der Philosophie
ansiedeln ? Bisher habe ich noch keine Antwort aus der
Wissenschaft gefunden.

Ein ähnliches Problem könnte immer mehr in der Quantenphysik
oder der Kernfusion erkennbar werden.
PYTHON ist Open Source.

Gute Zeit OSWALD

Code: Alles auswählen

def collatz(n):

    while n > 1:
                                #Anderung : print(n)                        eingesetzt  
        print(n, end=' ')                    #Änderung : print(n,end= ' ')                  "
        if (n % 2):
            # n is odd
            n = 3*n + 1.
            
        else:
            # n is even
            n = n//2
               
    print(1, end=' ')                           #Änderung:print(n,end= ' ')
 
 
n = int(input('Enter n: '))
print('Sequence: ', end='')
collatz(n)

[OSWALD]

10.2.2025
Derzeit beschäftige ich mich mit dem Chiquadrat-Test
und der Frage , ob auch damit synthetische Daten gewonnen können,
die sich fürKI eignen könnten.
Ich habe hierzu ein kleines Programm zusammengestellt mit zwei
zwei Möglichkeiten : Hypothese und Antihyperthese.


Der Chi-Quadrat-Test auf Unabhängigkeit
sucht nach einem Zusammenhang zwischen zwei kategorialen Variablen
innerhalb derselben Grundgesamtheit.
im Gegensatz zum Goodness-of-Fit-Test wird beim Unabhängigkeitstest
nicht eine einzelne beobachtete Variable
mit einer theoretischen Grundgesamtheit verglichen,
sondern zwei Variablen innerhalb einer Reihe von Stichproben miteinander.

Gute Zeit OSWALD

Code: Alles auswählen

from scipy.stats import chi2_contingency

#  Synthetische Daten   mit  CHIQuadrat  erzeugen    sinnvoll ??
#data = [[(257, 219, 230)  * 17] , [(234, 224, 230)*17]]           #   Nullhypothese
data = [[(1278, 255, 234) *20] , [ (245, 222, 213)*20]]            #   Antihypothese
stat, p, dof, expected = chi2_contingency(data)
print(" Das sind die Originaldaten     ;"  ,data)
print()
print("                         Die p-Werte   :",p)
print()
print("Das sind die erwarteten Daten :", expected)

## interpret p-value
alpha = 0.05              # Relevanzniveau   

#alpha < 0,01 : hoch signifikant
#alpha < 0,05 : signifikant
#alpha ≥ 0,05 : nicht signifikant


print("p value is " + str(p))
if p <= alpha:
    print(" Kategorale Variablen  sind 'abhängig       :  Nullhypothese zurückgewiesen")
else:
    print(" Kategorale Variablen  sind unabhänig                :  Nullhypothese hält")

[OSWALD]

10.2.2025
Statistik-Tests sind in der KI auch von einer gewissen
Bedeutung.
Hier noch ein Wilcoxon-Test , der immer dann
an Stelle vom t-Test anzuwenden ist, wenn nicht
genügend Datenmaterial vorhanden ist.
(Es handelt sich hier nicht um den
Wilcoxon-Rang-Summen-Test)
Die Auswahl solcher Tests ist riesig und mit
teils mächtigen Funktionen.
Gure Zeit OSWALD

Code: Alles auswählen

# Beispiel für die Anwendung des Wilcoxon-Tests in Python
from scipy.stats import wilcoxon
                      
# Daten
#data1 = [1, 2, 3, 4, 5]      #gleiche Verteilung
#data2 = [2, 3, 4, 5, 6]


data1 = [1, 2, 3, 4, 5 ,24]    #unterschiedliche Verteilung
data2 = [2, 3, 4, 5, 6, 458]

# Durchführung des Wilcoxon-Tests
stat, p = wilcoxon(data1, data2)

print(" stat, p",  p)
if p > 0.05:
  print('    Die gleiche Verteilung', p , 'mit  % Wahrscheinlichkeit')
else:
  print('   Uunterschiedliche Verteilungen' , p , 'mit  % Wahrscheinlichkeit', ) 

[OSWALD]

10.2.2025
Hier noch der Wilcoxon-Rangsummen-Test,
der sehr viele synth. Daten liefert.
Gute Zeit OSWALD

Code: Alles auswählen

#Wilkinson-Rangsummen-Test
import numpy as np
from scipy.stats import ranksums
rng = np.random.default_rng()
print(rng)
sample1 = rng.uniform(-1, 1, 200)
print(sample1)

sample2 = rng.uniform(-0.5, 1.5, 300) 
# a shifted distribution
print(sample2)

[OSWALD]

13.2.2025
Ich bin schon lange nach der Suche von konstistenten
unabhänigen synthetischen Daten und stelle jetzt
ein Experiment vor, von dem ich nicht weiß
,wie sinnvoll oder oder zielführend es sein könnte.
Ich erstelle ein Programm,
das Konfusionsmatrizen visuell erzeugt.
Die erstellten Daten (aktuell, predicted und trained ) werden dargestellt,
und zum Schluss auch eeine randomisierte neue Konfusionsmatrix.
Diese setze ich wieder , beliebig oft in den Originalcode ein und erzeuge
immer wieder neuekonsitente Daten.
Meine Frage an die Experten llautet nun:
Sinnvoll oder nicht ?? - im ZUsammenhang mit der Erzeugung einer KI? ?
Gute Zeit OSWALD

Code: Alles auswählen

#Eine vollständige Datenkohärenz liegt vor,
#wenn die Daten in einer  Arbeitsmappe mit den in der Datenquelle gespeicherten Daten
#synchronisiert sind. Das Ziel der vollständigen Datenkohärenz besteht darin, sicherzustellen,
#dass der gesamte Berichtsinhalt der Arbeitsmappe mit den Daten in der Datenquelle konsistent ist.

import matplotlib.pyplot as plt
import numpy
from sklearn import metrics

data = [[ 11 ,10], [ 24 ,91],
          [ 8 , 12], [ 48 ,80]]
          
# die erzeugte    Confusionsmatrix   jetzt hier einsetzen
#data =    [[1171 ,1294],
#             [1257, 1278]]

# nexte    Confusionsmatrix
#data  =     [[1281, 1243],
 #               [1252, 1224]]


# 
actual = numpy.random.binomial(1, 0.5,size = 5000)
print("                         actual   :", actual)

predicted = numpy.random.binomial(1,0.5,size = 5000)
print("                          predicted    :",predicted)

# hier die 

trained = numpy.random.binomial(1,0.5,size = 5000)
print("                          trained    :",trained)

confusion_matrix = metrics.confusion_matrix(actual, predicted)
print("Hier die Daten der  n e u e n       Confusionsmatrix   ", confusion_matrix)
print("Übertragen der neuen  Matrix auf   den Originalcode ")
cm_display = metrics.ConfusionMatrixDisplay(confusion_matrix = confusion_matrix, display_labels = [0, 1])

cm_display.plot()

plt.show()

[OSWALD]

16.2.2025
Hier zeige ch an einem Beispiel , dass man
spezifische sog. Zufallsdaten
aus allen Bereichen in Python gewinnen kann.
Im Beispiel geht es um die Darstellung von Punktmengen, die
nach vorgegebenem Winkel eingefärbt und je nach
unterschiedlicher Verteilung erstellt werden können.
Die erstellten Zufallszahlen können dann als
Matrizen abgelesen werden.
Man kann auch hier durch Veränderung
der Verteilungen oder der Anzahl der Werte
gut experimentieren(spielen)
'Python is great'
Gute Zeit OSWALD

Code: Alles auswählen

mport numpy as np
import matplotlib.pyplot as plt
n = 200
X = np.random.normal(0, 2 ,n)
Y = np.random.normal(0, 2, n)

# die 2000 Punkte sollen nach ihrem Winkel eingefärbt werden 
Phi = np.arctan2(Y, X)
plt.scatter(X, Y, c = Phi)
print("Hier die Zufallsdaten  von Phi (Unormalverteilt)  : ",Phi )
plt.show()



import numpy as np
import matplotlib.pyplot as plt
n = 20
Y = np.random.chisquare( 2 ,n)
X = np.random.chisquare( 2, n)
 
# die Punkte sollen nach ihrem    Winkel Phi       eingefärbt werden 
#Phi = np.sin(Y, X)
Phi = np.arctan(Y,X)
plt.scatter(X, Y, c = Phi)
print("Hier die Zufallesdaten von Phi (chiquadratverteilt)  : ", Phi )
print()
plt.show()

[OSWALD]

20.2.2025
Auf der Suche nach authentischen synthetischen Daten
habe ich 2D und 3D Matrizen an einem Beispiel ausprobiert.
Um ausreichende Mengen an Daten zu gewinnen, muss man nur
noch mit einem ausreichend großen Vektor multiplizieren.

Mit 3D RGB Matrizen lassen sich auch alle Farben bequem erzeugen.

Hierzu nun ein Beispiel

Code: Alles auswählen

import numpy as np
import matplotlib.pyplot  as plt

# zunächst   3x3-Graustufen-Bildmatrix
image_matrix = np.array([
    [  0, 128, 255],
    [ 64, 192,  32],
    [255, 128,   0]
])
print("                               Synth.Daten  2D    " ,  image_matrix)
plt.imshow(image_matrix, cmap='gray')
plt.colorbar()  # Farbleiste anzeigen
plt.show()
print()

#             RGB-Bild   mit  dreidimensionaler  Matrix,
#             mit   Farbkanälen       (Rot, Grün, Blau)  

# Beispiel einer 3x3-RGB-Bildmatrix
rgb_image_matrix = np.array([
    [[255,   0,   0], [  0, 255,   0], [  0,   0, 255]],             # Erste Zeile: Rot, Grün, Blau
    [[255, 255,   0], [  0, 255, 255], [255,   0, 255]],       # Zweite Zeile: Gelb, Cyan, Magenta
    [[192, 192, 192], [128, 128, 128], [ 64,  64,  64]]      # Dritte Zeile: Verschiedene Grautöne
])

print("                                 Synthetische Daten 3D  :"  ,rgb_image_matrix)

 
# RGB-Bild anzeigen
plt.imshow(rgb_image_matrix)
plt.show()

[OSWALD]

20.2.2025
Hier zeige ich noch einen weiteren Test mit
'kategorischen' Variable der nicht nur ganze Zahlen, etwa wie
der Chi2-Test , sondern auch irrationale Variable erlaubt.
Soweit aus dem Reich der Stochastik.
Guten Zeit OSWALD

Code: Alles auswählen

#Der etwas ungewöhnliche Name Log-Rang erklärt sich daher,
#dass sich das Verfahren aus einem Test herleiten lässt,
#der auf dem nat-Logarithmus der Ränge der Daten basiert.

import numpy as np
from scipy import stats
x = stats.CensoredData(
    uncensored=[6., 13., 21., 30., 37., 38., 49., 50.,
                63., 79., 86., 98., 10., 19.],
    right=[31., 4.7, 80., 82., 82., 49.]
)
print("                 x              :",x)                
y = stats.CensoredData(
    uncensored=[10., 10., 12., 13., 14., 15., 16., 17., 18., 20., 24., 24.,
                25., 28.,30., 33., 35., 37., 40., 40., 46., 48., 76., 81.,
                82., 91., 12., 81.],
    right=[34., 40., 70.]
 
    #right= [1, 2 ,  3,56,7,8,24]
)
print("                y         :",y)  
#Wir können die empirischen Überlebensfunktionen beider Gruppen wie folgt berechnen
#und visualisieren.

import numpy as np
import matplotlib.pyplot as plt
ax = plt.subplot()
ecdf_x = stats.ecdf(x)
print(ecdf_x)
ecdf_x.sf.plot(ax, label='CORONA-VIREN')


ecdf_y = stats.ecdf(y)
print(ecdf_y)

ecdf_y.sf.plot(ax, label='GRIPPE-VIREN')
ax.set_xlabel('Überlebenszeit (in Tagen))')
ax.set_ylabel('Synthetische Daten')
plt.show() 

#./../_images/scipy-stats-logrank-1_00_00.png
#Eine visuelle Überprüfung der empirischen Überlebensfunktionen lässt darauf schließen,
#dass die Überlebenszeiten beider Gruppen tendenziell unterschiedlich sind.
#Um formal zu beurteilen, ob der Unterschied auf dem 1%-Niveau signifikant ist,
#verwenden wir den Logrank-Test.

res = stats.logrank(x=x, y=y)
print(res)
res.statistic
print(res.statistic)
-2.73799
res.pvalue
0.00618
#Der p-Wert liegt unter 1 %, sodass wir die Daten als Beweis gegen die Nullhypothese
#zugunsten der Alternative betrachten können, d
#ass zwischen den beiden Überlebensfunktionen ein Unterschied besteht.

[OSWALD]

26.2.2025
Heute möchte ich zuerst meine ganz private
'Rechenmaschine' vorstellen und anschließend
mich endlich einmal gründlich den Logarithmen widmen.
Gute Zeit OSWALD

Code: Alles auswählen

# importing Tkinter and math 
import math  
from math import  *
import numpy as np
import tkinter
from tkinter import *

#import subprocess

class calc:
    def getandreplace(self): 

      
        self.expression = self.e.get() 
        self.newtext=self.expression.replace('/','y') 
        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) 
             
root=Tk() 
obj=calc(root)
root.mainloop()

[OSWALD]

28.2.2025
Logarithmen ,
weniger im Vordergrund
jedoch überall präsent .

In Python und seinen Bibliotheken (numpy)
sind Logarithmen sehr gut dokumentiert.
Dafür möchte ich einige Beispiele zeigen, :
Logarithmus mit Skalaren, Vektoren , Arrays und Matrizen.
Auch in der Analysis gibt es Zusammenhänge,
Insgesamt ein weites Feld.Ich fange einfach mal an:
Gute Zeit OSWALD

Code: Alles auswählen

# Quick examples of numpy log() function
import numpy as np
# Example 1: Get the log value of scalar
arr = np.array(2)
arr1 = np.log(arr)
print(arr) 
print(arr1)
# Example 2: Get the log values of a 1D array
arr = np.array([1, 4, 6])
log_values = np.log(arr)

print(log_values)

# Example 3: Get the log values of 2-D array
arr = np.arange(1, 7).reshape(2,3)
log_values = np.log(arr)
print(log_values)
# Example 4 : Get the log value of an array with base 2
arr = np.array([1, 4, 6])
log_values = np.log2(arr)
print(log_values)
# Example 5: Get the log value of an array with base 10

arr = np.array([1, 4, 6])
log_values = np.log10(arr)
print(log_values) 
print()
arr1 =[[ 6,  1,  2,  3,  4],
         [2, 1,  5,  1,  2],
         [3, 2, 1,  23,  1],
         [5, 7,  5 , 4,   23]]
log_values = np.log10(arr1)
print("                        Logarithmen von  arr1= :"  ,log_values)

[OSWALD]

1.3.2025
Beliebige Matrize logarithmieren und die neue
Matrix, bestehend aus Logarithmen
mit - Imshow() - visuell darstellen.

Damit glaube ich weitere
nützliche synthetische Daten gewinnen zu können.
Ich versuche diese Methode zu erweitern.
Die Umsetzung für KI etc. muss ich den Profis
überlassen.
Gute Zeit OSWALD

Code: Alles auswählen

import numpy  as np
from numpy import *
import matplotlib.pyplot as plt
in_array =  [[ 1,2,3,2,3,4,5,6,7,8,9,10,11,12,13,14],
              [17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32],
              [33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48],
              [49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64],
              [65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80],
              [81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96]]
print ("                Original:ArraY : ", in_array) 
in_array =  [[ 1,2,3,2,3,4,5,6,7,8,9,10,11,12,13,14],
              [17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32],
              [33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48],
              [49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64],
              [65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80],
              [81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96]]
out_array = np.log(in_array) 
print ("                 Logarithmen :",out_array)


# Matrix erstellen

 
# Figure und Axes erstellen
leinwand, diagramm = plt.subplots()

# imshow()-Methode des Axes-Objekt anwenden, Matrix ist Input
diagramm.imshow(out_array)

# Diagramm anzeigen
plt.show()