import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import DBSCAN
from sklearn.preprocessing import StandardScaler

X, y = make_blobs(n_samples = 300, centers=4, cluster_std=0.5, random_state=0)
plt.scatter(X[:,0], X[:,1])
plt.show()

scaler = StandardScaler()
dbscan = DBSCAN(eps=0.5)
clusters = dbscan.fit_predict(scaler.fit_transform(X))

plt.scatter(X[:,0], X[:,1], c=clusters)
plt.show()

#######################################################################################

import numpy as np
from matplotlib import pyplot as plt

# przewidywanie wyjścia sieci: y_pred = X * W1 * W2
# neuron składa się z sumatora xi*wi oraz (zazwyczaj) funkcji aktywacji
# w tym przypadku nie mamy tych funkcji, natomiast jeśli chcielibyśmy taką dodać,
# to znalazłyby się po każdym zsumowaniu:
#    H = np.dot(X,W1)
#    H = activation(H)
#    y_pred = np.dot(H,W2)
#    y_pred = activation(y_pred)
#    return y_pred
# w tym miejscu również dokonujemy wszelkich zmian związanych ze wzorami zawartymi w poszczególnych sieciach.
# jeśli np na wyjściu sieci mamy suma Wi * e^(xi-xc)/fi, to po prostu na początku robimy sobie jakiegoś temp_X,
# który przyjmuje te egzotyczne wartości, np. temp_X = [math.exp((xi-xc)/fi) for xi in X], a potem już używamy
# zamiast X temp_X.
# wzór podany wyżej jest zupełnie przypadkowy, nie patrzyłem na to, co kmdr Praczyk ma w prezentacji. Przedstawiam
# tu po prostu sposób działania.
def prediction(X,W1,W2):
    H = np.dot(X,W1)
    y_pred = np.dot(H,W2)
    return y_pred

# funkcja licząca, jak bardzo sieć się myli w stosunku do rzeczywistego wyniku
def loss(y_true, y_pred):
    return abs(y_pred - y_true)

def sim(X,y_true, W1,W2):
    # sumujemy błąd dla wszystkich przewidywań i wszystkich wyjść z aktualnymi wagami
    fi = 0
    for x,y in zip(X,y_true):
        temp = prediction(x,W1,W2)
        fi += loss(y, temp)

    print(fi)

    for i in range(2000):
        # losujemy nowe wagi
        temp_W1 = np.random.random([2,3])
        temp_W2 = np.random.random([3,1])

        # ponownie liczymy błąd, tym razem z nowymi wagami
        fj = 0
        for x,y in zip(X,y_true):
            temp = prediction(x,temp_W1,temp_W2)
            fj += loss(y, temp)

        # jeżeli nowe wagi wypadły lepiej, to podmieniamy stare, jeżeli nie to nic nie robimy
        if fj < fi:
            W1 = temp_W1
            W2 = temp_W2
            fi = fj
            print(fi)

    return W1,W2

# wartości wejścia i oczekiwanego wyjścia
X = np.array([[2, 5],[2, 11], [3, 4], [3, 3], [2, 5], [9, 8], [0, 3], [6, 1], [3, 5], [0, 9], [4, 4], [8, 2], [6, 8], [9, 3], [2, 7], [6, 5], [2, 5], [0, 7], [3, 8], [4, 8], [2, 5], [7, 3], [3, 6], [7, 3], [3, 3], [3, 0],
              [3, 9], [3, 7], [6, 6], [1, 3], [2, 2], [7, 7]])
y_true = np.array([7, 13, 7, 6, 7, 17, 3, 7, 8, 9, 8, 10, 14, 12, 9, 11, 7, 7, 11, 12, 7, 10, 9, 10, 6, 3, 12, 10, 12, 4, 4, 14])

#randomowe wartości wag: 2 neurony wejściowe, 3 w warstwie wewnętrznej, jeden na wyjściu
W1 = np.random.random([2,3])
W2 = np.random.random([3,1])

# wchodzimy z wagami do funkcji optymalizującej (np. monte carlo, symulowane wyżarzanie)
W1,W2 = sim(X,y_true,W1,W2)

osx = [i for i in range(32)]
osy = [prediction(x,W1,W2) for x in X]

plt.plot(osx, osy)
plt.plot(osx, y_true, c='r')
plt.show()







#######################################################################################
# jeśli wam się wywala colab to proszę zainstalujcie sobie te biblioteki
# po instalacji Runtime -> Reset runtime
# !pip install tensorflow==1.14.0
# !pip install -U keras

import numpy as np
from matplotlib import pyplot as plt
import keras
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import RMSprop

# wartości wejścia i wyjścia
X = np.array([[2, 5],[2, 11], [3, 4], [3, 3], [2, 5], [9, 8], [0, 3], [6, 1], [3, 5], [0, 9], [4, 4], [8, 2], [6, 8], [9, 3], [2, 7], [6, 5], [2, 5], [0, 7], [3, 8], [4, 8], [2, 5], [7, 3], [3, 6], [7, 3], [3, 3], [3, 0],
              [3, 9], [3, 7], [6, 6], [1, 3], [2, 2], [7, 7]])
y_true = np.array([7, 13, 7, 6, 7, 17, 3, 7, 8, 9, 8, 10, 14, 12, 9, 11, 7, 7, 11, 12, 7, 10, 9, 10, 6, 3, 12, 10, 12, 4, 4, 14])

# klasa tworząca pustą sieć
model = Sequential()
# dodawanie kolejnych warstw (poza wejściową, która jest określona w INPUT_SHAPE)
# tutaj dodajemy jedną warstwę ukrytą z 3 neuronami i jedna wyjściową z jednym
# nie dodajemy żadnych funkcji aktywacji ze względu na zakres oczekiwanych wyjść sieci
# ale istnieje taka opcja za pomocą dodania w argumencie activation='relu/softmax/sigmoid/tanh'
model.add(Dense(units=3, input_shape=(2,)))
model.add(Dense(units=1))

# podsumowanie sieci
print(model.summary())

# kompilacja sieci - określenie przebiegu uczenia
model.compile(optimizer=RMSprop(), loss='binary_crossentropy', metrics=['accuracy'])

# batch size - co ile sprawdzana jest dokładność działania sieci
# epochs - liczba iteracji (ile razy przechodzimy przez cały zbiór uczący)
history = model.fit(X,y_true,batch_size=2, epochs=10)

# tu możemy wyświetlić informacje na temat argumentów, które uwzględniliśmy przy kompilacji
# tj. loss i accuracy
print(history.history)

y_pred = model.predict(X)
osx = [i for i in range(32)]

plt.plot(osx, y_pred)
plt.plot(osx, y_true, c='r')
plt.show()