KMeans on Handwritten Digits

import numpy as np
import matplotlib.pyplot as plt

from scipy.stats import norm

# def fL(x) :
#     if x < 0 or x > 1 :
#         return 0
#     return 2*(1-x)

# def fR(x) :
#     return fL(1-x)

# def fM(x) :
#     if x < 0 or 1/8 < x < 3/8 or 5/8 < x < 7/8 or 1 < x:
#         return 0
#     return 2

def fL(x) :
    return norm.pdf(x, loc=.2, scale=0.1)

def fR(x) :
    return fL(1-x)

def fM(x) :
    return norm.pdf(x, loc=0.5, scale=0.2)
    # return 1

step = 0.002
xs = np.arange(0-3.5*step,1+3.5*step,step)
FLs = [fL(x) for x in xs]
FRs = [fR(x) for x in xs]
FMs = [fM(x) for x in xs]

print(f"Norms: {np.sum(FLs)*step} {np.sum(FRs)*step} {np.sum(FMs)*step}")

plt.scatter(xs,FLs)
plt.scatter(xs,FRs)
plt.scatter(xs,FMs)
plt.show()

targets = [(fL(x) + fR(x) + fM(x))/3 for x in xs]
plt.scatter(xs,targets)
plt.show()

def f1(x) :
    return (fL(x) + fM(x))/2

def f2(x) :
    return (fR(x) + fM(x))/2

# def overlap(fA, fB, x):
    # return np.sqrt( fA(x)*fB(x) )
    # return (fA(x) + fB(x))/2
    # return min(fA(x), fB(x))

f1s = np.array([f1(x) for x in xs])
f2s = np.array([f2(x) for x in xs])
overlaps1 = [min(one,two) for one, two in zip(f1s,f2s)]
overlap_size = np.sum(overlaps1)*step
overlaps1 /= np.sum(overlaps1)*step

print(f"Norms: {np.sum(f1s)*step} {np.sum(f2s)*step} {overlap_size}->{np.sum(overlaps1)*step}")

plt.scatter(xs,f1s)
plt.scatter(xs,f2s)
plt.scatter(xs,overlaps1)
plt.show()

p = overlap_size/(np.sum(f1s)*step)
print(f"{p=}")
f1s_sub = (f1s-p*overlaps1)/(1-p)
f2s_sub = (f2s-p*overlaps1)/(1-p)
overlaps2 = [min(one,two) for one, two in zip(f1s_sub,f2s_sub)]
overlaps2 /= np.sum(overlaps2)*step

print(f"Norms: {np.sum(f1s_sub)*step} {np.sum(f2s_sub)*step} {np.sum(overlaps2)*step}")

plt.scatter(xs,f1s_sub)
plt.scatter(xs,f2s_sub)
plt.scatter(xs,overlaps2)
plt.show()

f1s_subsub = 2*f1s_sub-overlaps2
f2s_subsub = 2*f2s_sub-overlaps2
overlaps3 = [min(one,two) for one, two in zip(f1s_subsub,f2s_subsub)]
overlaps3 /= np.sum(overlaps3)*step

print(f"Norms: {np.sum(f1s_subsub)*step} {np.sum(f2s_subsub)*step} {np.sum(overlaps3)*step}")

plt.scatter(xs,f1s_subsub)
plt.scatter(xs,f2s_subsub)
plt.scatter(xs,overlaps3)
plt.show()

f1s_subsubsub = 2*f1s_subsub-overlaps3
f2s_subsubsub = 2*f2s_subsub-overlaps3
overlaps4 = [min(one,two) for one, two in zip(f1s_subsubsub,f2s_subsubsub)]
overlaps4 /= np.sum(overlaps4)*step

print(f"Norms: {np.sum(f1s_subsubsub)*step} {np.sum(f2s_subsubsub)*step} {np.sum(overlaps4)*step}")

plt.scatter(xs,f1s_subsubsub)
plt.scatter(xs,f2s_subsubsub)
plt.scatter(xs,overlaps4)
plt.show()

alls_1sub = (f1s_sub + f2s_sub + overlaps1)/3
print(f"Norms: {np.sum(alls_1sub)*step}")

plt.scatter(xs,targets)
plt.scatter(xs,alls_1sub)
plt.show()

alls_2sub = (f1s_subsub + f2s_subsub + overlaps2)/3
print(f"Norms: {np.sum(alls_2sub)*step}")

plt.scatter(xs,targets)
plt.scatter(xs,alls_2sub)
plt.show()

alls_3sub = (f1s_subsubsub + f2s_subsubsub + overlaps3)/3
print(f"Norms: {np.sum(alls_3sub)*step}")

plt.scatter(xs,alls_3sub)
plt.show()

print(xs)
this is an intentional error

# Generate 1000 numbers from a normal distribution
import numpy as np

np.random.seed(0)
numbers = np.random.normal(size=1000)

print(numbers)

# Generate another array ys from the normal distribution
import numpy as np

np.random.seed(0)
ys = np.random.normal(size=len(xs))

print(ys)

## Setup ##

#usual suspects
import pandas as pd
import numpy as np

# data
from sklearn import datasets
digits=datasets.load_digits()

# preprocessing
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.3, random_state=2023)

#model
from sklearn.cluster import KMeans
model = KMeans(n_clusters=10)


# visualization
from sklearn.manifold import TSNE
import matplotlib as mpl
import matplotlib.patches as mp
import matplotlib.pyplot as plt

# metrics
from sklearn.metrics import confusion_matrix, classification_report