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)