Upload 15 files

Ada_boost.py

@@ -0,0 +1,130 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import AdaBoostClassifier as ABC
+from sklearn.metrics import accuracy_score
+import matplotlib.pyplot as plt
+from sklearn.metrics import confusion_matrix
+
+
+
+class ada_boost_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+        # **AdaBoost**
+
+        Este algoritmo se basa en ir agrupando otros algoritmos de clasificación, para que en conjunto generen una predicción.
+
+        Asimismo, y a diferencia del algoritmo de Random Forest, es que el **voto** de cada estimador no valen lo mismo, es decir, existe un grado de importancia (**weight**) entre los estimadores que siendo estos ponderados por sus votos es que generan la predicción del algoritmo.
+
+        **Weak Learner (Decision Stump)**
+
+        Es un algoritmo que sencillamente clasifica los datos según un límite (similar a uno de los pasos del algoritmo de Decision Tree)
+
+        **Error**
+
+        - Primera iteración
+
+        $$
+        ϵ_{1} = \frac{desaciertos}{N}
+        $$
+
+        - A partir de la segunda iteración
+
+        $$
+        ϵ_{t} = \sum weights
+        $$
+
+        Nota: Si el error es mayor a 0.5, se intercambia la clasificación y se calcula el $error = 1 - error$
+
+        **Weights**
+
+        - Al inicio
+        $$
+        w_{0} = \frac{1}{N} para cada muestra
+        $$
+
+        - Luego
+
+        $$
+        w = \frac{w \cdot e^{- αyh(X)}}{\sum w}
+        $$
+
+        **Performance**
+
+        $$
+        \alpha = 0.5 \cdot log(\frac{1-ϵ_{t}}{ϵ_{t}})
+        $$
+
+        **Predicción**
+
+        $$
+        y = sign(\sum_{t}^{T} α_{t} \cdot h(X))
+        $$
+
+        **Training**
+
+        Se inicializan los pesos de cada muestra en $\frac{1}{N}$
+
+        - Entrenamos a un clasificador débil (se busca la mejor variable y límite para segmentar)
+        - Calculamos el error $ϵ_{t} = \sum_{desaciertos} weights$
+         - Cambiar el error y la polaridad si este es mayor a 0.5
+        - Calcular $\alpha = 0.5 \cdot log(\frac{1 - \epsilon_{t}}{ϵ_{t}})$
+        - Actualizar los pesos: $w = \frac{w \cdot e^{- αh(X)}}{Z}$
+
+'''
+        self.n_clf = 5
+
+    def params(self):
+        self.n_clf = st.slider('Numero de estimadores',
+                                    min_value=1,
+                                    max_value=15,
+                                    value=5)
+
+    def solve(self):
+        self.X, self.y = self.database.data, self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_clf = ABC(n_estimators=self.n_clf, random_state=1234)
+        self.sklearn_clf.fit(X_train, y_train)
+        y_pred = self.sklearn_clf.predict(X_test)
+        acc = accuracy_score(y_pred, y_test)
+
+        c1, c2 = st.columns([4, 1])
+        c2.metric('Acierto', value=f'{np.round(acc, 2)*100}%')
+        df = pd.DataFrame(confusion_matrix(y_pred, y_test))
+        labels = self.database.target_names
+        df.columns = labels
+        df.index = labels
+        c1.write('**Confusion Matrix**')
+        c1.dataframe(df)
+
+    def visualization(self):
+        n_features = int(self.database.data.shape[1])
+        self.x_feature = st.slider('Variables en eje x', 1, n_features, 1)
+        self.y_feature = st.slider('Variables en eje y', 1, n_features, 2)
+
+        self.X = np.c_[self.database.data[:, self.x_feature-1:self.x_feature], self.database.data[:, self.y_feature-1:self.y_feature]]
+        self.y = self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_clf = ABC(n_estimators=self.n_clf, random_state=1234)
+        self.sklearn_clf.fit(X_train, y_train)
+
+        x1_min, x1_max = self.X[:, 0].min() - 0.5, self.X[:, 0].max() + 0.5
+        x2_min, x2_max = self.X[:, 1].min() - 0.5, self.X[:, 1].max() + 0.5
+        h = 0.02 # Salto que vamos dando
+        x1_i = np.arange(x1_min, x1_max, h)
+        x2_i = np.arange(x2_min, x2_max, h)
+        x1_x1, x2_x2 = np.meshgrid(x1_i, x2_i)
+        y_pred = self.sklearn_clf.predict(np.c_[x1_x1.ravel(), x2_x2.ravel()])
+        y_pred = y_pred.reshape(x1_x1.shape)
+
+        plt.figure(1, figsize=(12, 8))
+        plt.pcolormesh(x1_x1, x2_x2, y_pred, cmap=plt.cm.Paired)
+        plt.scatter(self.X[:, 0], self.X[:, 1], c=self.y, edgecolors='k', cmap=plt.cm.Paired)
+        plt.xlim(x1_x1.min(), x1_x1.max())
+        plt.ylim(x2_x2.min(), x2_x2.max())
+        return plt.gcf()

Agglomerative_clustering.py

@@ -0,0 +1,50 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVR
+from sklearn.cluster import AgglomerativeClustering
+import matplotlib.pyplot as plt
+
+
+class agglomerative_clustering_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+        # **Agglomerative Clustering**
+
+        Agglomerative Clustering es un tipo de algoritmo que agrupa de manera jerárquica. De esta manera lo que se hace es considerar a cada observación como un cluster y luego ir juntando aquellos que sean más similares. Esto lo repetimos hasta alcanzar un numero de clusters deseado.
+
+        **Método**
+         - Inicializamos todos los puntos como clusters
+         - Tomamos dos clusters que se encuentren cercanos y los unificáramos en un único cluster.
+         - Repetimos el paso anterior hasta conseguir un numero de clusters deseado.
+
+        **Criterios para medir la similitud entre clusters**
+
+         - Distancia entre los puntos **más cercanos** de dos clusters distintos.
+         - Distancia entre los puntos **más lejanos** de dos clusters distintos.
+         - Distancia entre los promedios de cada cluster.
+
+        '''
+        self.x_feature = 1
+        self.y_feature = 2
+        self.n_clusters = 3
+
+    def params(self):
+        n_targets = len(set(self.database.target))
+        self.n_clusters = st.slider('Numero de clusters', 1, n_targets, 1)
+
+    def solve(self):
+        n_features = int(self.database.data.shape[1])
+        self.x_feature = st.slider('Variables en eje x', 1, n_features, 1)
+        self.y_feature = st.slider('Variables en eje y', 1, n_features, 2)
+        X = self.database.data
+        sklearn_clus = AgglomerativeClustering(self.n_clusters, linkage='single')
+        pred = sklearn_clus.fit_predict(X)
+        fig, ax = plt.subplots(figsize=(12,8))
+        ax.scatter(X[:, self.x_feature-1], X[:, self.y_feature-1], c=pred)
+        plt.title(f'{self.n_clusters} Clusters')
+        return fig

Decision_tree.py

@@ -0,0 +1,108 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.metrics import accuracy_score
+import matplotlib.pyplot as plt
+from sklearn.metrics import confusion_matrix
+
+
+
+class Decision_tree_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+        # **Decision Tree**
+
+        **Entropy**
+
+        $$
+        E = - \sum p(X) \cdot log_{2}(p(X))
+        $$
+
+        $$
+        p(X) = \frac{len(x)}{n}
+        $$
+
+        **Ganancia de información**
+
+        $$
+        IG = E(parent) - [weight \quad average] \cdot E(children)
+        $$
+
+        **Método (para construir el árbol)**
+
+        - Se comienza desde el primer nodo y para cada se selecciona la mejor separación en base a la ganancia de información.
+        - De la ganancia de información más alta se rescata la variable y el límite.
+        - Luego se aplica la segmentación a cada nodo, en base a la variable y limite encontrado.
+        - Se itera con estos pasos hasta cumplirse algún criterio
+         - **maximium depth**: cantidad de nodos máximos al final
+         - **minimum samples**: cantidad mínima de elementos que puede tener los nodos
+         - **no more class distribution**: No existen más elementos para segmentar
+
+        **Aproximación (predicción)**
+
+        - Se sigue las segmentaciones en el orden del árbol (de arriba a abajo)
+        - Cuando se llega a un nodo al final del árbol se predice según el valor más común en esa muestra.
+
+
+        '''
+        self.max_depth = 100
+        self.min_samples_split = 2
+        self.stop_criterion = 'max_depth'
+
+    def params(self):
+        self.stop_criterion = st.radio('Criterio de termino:', options=['max_depth', 'min_samples_split'])
+        if self.stop_criterion == 'max_depth': self.max_depth = st.slider('Valor max deph:', 1, 100, 10)
+        elif self.stop_criterion == 'min_samples_split': self.min_samples_split = st.slider('Valor min_samples_split:', 2, 1000, 5)
+
+
+    def solve(self):
+        self.X, self.y = self.database.data, self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        if self.stop_criterion == 'max_depth': self.sklearn_clf = DecisionTreeClassifier(max_depth=self.max_depth, random_state=1234)
+        elif self.stop_criterion == 'min_samples_split': self.sklearn_clf = DecisionTreeClassifier(min_samples_split=self.min_samples_split, random_state=1234)
+
+        self.sklearn_clf.fit(X_train, y_train)
+        y_pred = self.sklearn_clf.predict(X_test)
+        acc = accuracy_score(y_pred, y_test)
+
+        c1, c2 = st.columns([4, 1])
+        c2.metric('Acierto', value=f'{np.round(acc, 2)*100}%')
+        df = pd.DataFrame(confusion_matrix(y_pred, y_test))
+        labels = self.database.target_names
+        df.columns = labels
+        df.index = labels
+        c1.write('**Confusion Matrix**')
+        c1.dataframe(df)
+
+    def visualization(self):
+        n_features = int(self.database.data.shape[1])
+        self.x_feature = st.slider('Variables en eje x', 1, n_features, 1)
+        self.y_feature = st.slider('Variables en eje y', 1, n_features, 2)
+
+        self.X = np.c_[self.database.data[:, self.x_feature-1:self.x_feature], self.database.data[:, self.y_feature-1:self.y_feature]]
+        self.y = self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        if self.stop_criterion == 'max_depth': self.sklearn_clf = DecisionTreeClassifier(max_depth=self.max_depth, random_state=1234)
+        elif self.stop_criterion == 'min_samples_split': self.sklearn_clf = DecisionTreeClassifier(min_samples_split=self.min_samples_split, random_state=1234)
+        self.sklearn_clf.fit(X_train, y_train)
+
+        x1_min, x1_max = self.X[:, 0].min() - 0.5, self.X[:, 0].max() + 0.5
+        x2_min, x2_max = self.X[:, 1].min() - 0.5, self.X[:, 1].max() + 0.5
+        h = 0.02 # Salto que vamos dando
+        x1_i = np.arange(x1_min, x1_max, h)
+        x2_i = np.arange(x2_min, x2_max, h)
+        x1_x1, x2_x2 = np.meshgrid(x1_i, x2_i)
+        y_pred = self.sklearn_clf.predict(np.c_[x1_x1.ravel(), x2_x2.ravel()])
+        y_pred = y_pred.reshape(x1_x1.shape)
+
+        plt.figure(1, figsize=(12, 8))
+        plt.pcolormesh(x1_x1, x2_x2, y_pred, cmap=plt.cm.Paired)
+        plt.scatter(self.X[:, 0], self.X[:, 1], c=self.y, edgecolors='k', cmap=plt.cm.Paired)
+        plt.xlim(x1_x1.min(), x1_x1.max())
+        plt.ylim(x2_x2.min(), x2_x2.max())
+        return plt.gcf()

ICA.py

@@ -0,0 +1,80 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVR
+from sklearn.decomposition import FastICA
+import matplotlib.pyplot as plt
+
+class ICA_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+        # **ICA (Independent Component Analysis)**
+
+        ICA es un método que se utiliza para identificar las componentes de una señal multivariada. De esta manera es que podemos extraer un componente que se encuentre mezclados con otros.
+
+         - A $X$ restarle su media $\bar{X}$
+         - Transformar $X$ de manera que las potenciales correlaciones entre las componentes sean removidas y que la varianza para cada componente sea igual a 1. (Hacer que la matriz de covarianza se parezca a la matriz de identidad)
+
+          $$
+          \hat{x} = E \cdot \sqrt{D} \cdot E^{T} \cdot x
+          $$
+
+           - $D$: Diagonal con valores propios (de la matriz de covarianzas)
+           - $E$: Matrix con vectores propios (de la matriz de covarianzas)
+
+         - Escoger valores aleatorios para armar la matriz $W$.
+         - Calcular los nuevos valores para $W$
+
+          $$
+          w_{i} = \frac{1}{n} \sum X \cdot tanh(W^{T} \cdot X) - \frac{1}{n} \sum X \cdot (1 - tanh^{2}(W^{T} \cdot X) \cdot W)
+          $$
+
+        $$
+        w_{i} = w_{i} - \sum_{j=1}^{p-1} (w_{p}^{T}w_{j})w_{j}
+        $$
+
+         - Normalizar $w_{p}$
+
+        $$
+        w_{p} = \frac{w_{p}}{||w_{p}||}
+        $$
+
+         - Chequear condición de termino. Si no se cumple volvemos a calcular los nuevos valores de $w$
+
+
+        $$
+        w_{p}^{T}w_{p+1} - 1 < Tolerance
+        $$
+
+         - Calcular las fuentes independientes como $S = W \cdot X$'''
+
+        self.x_feature = 1
+        self.y_feature = 2
+        self.n_components = 2
+
+    def params(self):
+        n_features = int(self.database.data.shape[1])
+        self.n_components = st.slider('Numero de componentes', 1, n_features, 2)
+
+    def solve(self):
+        self.x_feature = st.slider('Componente eje x', 1, self.n_components, 1)
+        self.y_feature = st.slider('Componente eje y', 1, self.n_components, 2)
+        X = self.database.data
+        y = self.database.target
+        sklearn_clus = FastICA(n_components=self.n_components)
+        X_proyected_sk = sklearn_clus.fit_transform(X)
+
+        x1 = X_proyected_sk[:, self.x_feature-1]
+        x2 = X_proyected_sk[:, self.y_feature-1]
+
+        plt.figure(1, figsize=(12, 8))
+        plt.scatter(x1, x2, c=y, edgecolors='none', alpha=0.8, cmap=plt.cm.get_cmap('viridis', len(y)))
+        plt.xlabel(f'Componente {self.x_feature}')
+        plt.ylabel(f'Componente {self.y_feature}')
+        plt.colorbar()
+
+        return plt.gcf()

KNN.py

@@ -0,0 +1,79 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.metrics import accuracy_score
+import matplotlib.pyplot as plt
+from sklearn.metrics import confusion_matrix
+
+
+
+class KNN_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = '''
+                        # **Algoritmo KNN (K Nearest Neighbor)**
+
+                Este algoritmo se basa en que, para predecir una clasificación sobre un nuevo dato, lo primero que debemos hacer es calcula la **distancia euclidiana** con el resto de los datos, **seleccionar los k datos con menor distancia** (más cercanos) y por ultimo **asignar la clasificación en función a la moda** (categoría más repetida) de esos k datos seleccionados.
+
+                **Distancia Euclidiana**
+
+                $$
+                Dist= \sqrt(\sum_{i=1}^n (Xtest_{i} - Xtrain_{i})^2))
+                $$
+
+                '''
+        self.neighbors = 5
+
+    def params(self):
+        self.neighbors = st.slider('Numero de vecinos',
+                                    min_value=0,
+                                    max_value=15,
+                                    value=5)
+
+    def solve(self):
+        self.X, self.y = self.database.data, self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_clf = KNeighborsClassifier(self.neighbors)
+        self.sklearn_clf.fit(X_train, y_train)
+        y_pred = self.sklearn_clf.predict(X_test)
+        acc = accuracy_score(y_pred, y_test)
+
+        c1, c2 = st.columns([4, 1])
+        c2.metric('Acierto', value=f'{np.round(acc, 2)*100}%')
+        df = pd.DataFrame(confusion_matrix(y_pred, y_test))
+        labels = self.database.target_names
+        df.columns = labels
+        df.index = labels
+        c1.write('**Confusion Matrix**')
+        c1.dataframe(df)
+
+    def visualization(self):
+        n_features = int(self.database.data.shape[1])
+        self.x_feature = st.slider('Variables en eje x', 1, n_features, 1)
+        self.y_feature = st.slider('Variables en eje y', 1, n_features, 2)
+
+        self.X = np.c_[self.database.data[:, self.x_feature-1:self.x_feature], self.database.data[:, self.y_feature-1:self.y_feature]]
+        self.y = self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_clf = KNeighborsClassifier(self.neighbors)
+        self.sklearn_clf.fit(X_train, y_train)
+
+        x1_min, x1_max = self.X[:, 0].min() - 0.5, self.X[:, 0].max() + 0.5
+        x2_min, x2_max = self.X[:, 1].min() - 0.5, self.X[:, 1].max() + 0.5
+        h = 0.02 # Salto que vamos dando
+        x1_i = np.arange(x1_min, x1_max, h)
+        x2_i = np.arange(x2_min, x2_max, h)
+        x1_x1, x2_x2 = np.meshgrid(x1_i, x2_i)
+        y_pred = self.sklearn_clf.predict(np.c_[x1_x1.ravel(), x2_x2.ravel()])
+        y_pred = y_pred.reshape(x1_x1.shape)
+
+        plt.figure(1, figsize=(12, 8))
+        plt.pcolormesh(x1_x1, x2_x2, y_pred, cmap=plt.cm.Paired)
+        plt.scatter(self.X[:, 0], self.X[:, 1], c=self.y, edgecolors='k', cmap=plt.cm.Paired)
+        plt.xlim(x1_x1.min(), x1_x1.max())
+        plt.ylim(x2_x2.min(), x2_x2.max())
+        return plt.gcf()

LDA.py

@@ -0,0 +1,94 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVR
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
+import matplotlib.pyplot as plt
+
+class LDA_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+        # **LDA (Linear Discrimination Analysis)**
+
+        **Objetivo**
+
+        Reducir el número de variables (**features**).
+        El objetivo es proyectar un conjunto de datos a un espacio dimensional más reducido. (Similar a como se hacía con **PCA**)
+
+        **PCA vs LDA**
+
+        - **PCA**: Encontrar los ejes que maximizan la varianza en los datos.
+        - **LDA**: El interés esta puesto en los ejes que maximizan la separación entre clases de datos.
+        - **LDA**: es un tipo de **aprendizaje supervisado** (utiliza la clasificación (etiquetas) de los datos para entrenar al algoritmo), en cambio **PCA** es un tipo de **aprendizaje no supervisado** (sin etiquetas)
+
+        **Within-class scatter matrix**
+
+        $$
+        S_{w} = \sum_{c} S_{c}
+        $$
+
+        $$
+        S_{c} = \sum_{i \in c} (x_{i} - \bar{x_{c}}) \cdot (x_{i} - \bar{x_{c}})^{T}
+        $$
+
+        **Between class scatter matrix**
+
+        $$
+        S_{B} = \sum_{c} η \cdot (\bar{x_{c}} - \bar{x}) \cdot (\bar{x_{c}} - \bar{x})^{T}
+        $$
+
+        **Vectores y valores propios**
+
+        Calcular los vectores y valores propios de la siguiente matriz:
+
+        $$
+        S_{W}^{-1} S_{B}
+        $$
+
+
+        **Método**
+
+        - Calcular $S_{B}$
+        - Calcular $S_{W}$
+        - Calcular los vectores y valores propios de $S_{W}^{-1} S_{B}$
+        - Ordenar los vectores propios en función de los valores propios de manera decreciente
+        - Escoger los primeros k vectores propios los cuales vendrán a representar las nuevas k dimensiones
+        - Transformar los datos en las nuevas dimensiones (**se hace con producto punto**) '''
+
+        self.x_feature = 1
+        self.y_feature = 2
+        self.n_components = 2
+
+    def params(self):
+        self.n_clases = len(set(self.database.target))
+        self.n_features = int(self.database.data.shape[1])
+        self.min = int(np.min([self.n_clases-1, self.n_features]))
+        if self.min == 1: pass
+        elif self.min == 2: self.n_components = 2
+        else: self.n_components = st.slider('Numero de componentes', 2, self.min, 2)
+
+    def solve(self):
+        if self.min == 1: pass
+        else:
+            self.x_feature = st.slider('Componente eje x', 1, self.n_components, 1)
+            self.y_feature = st.slider('Componente eje y', 1, self.n_components, 2)
+            X = self.database.data
+            y = self.database.target
+            sklearn_clus = LinearDiscriminantAnalysis(n_components=self.n_components)
+            sklearn_clus.fit(X, y)
+            X_proyected_sk = sklearn_clus.transform(X)
+
+            x1 = X_proyected_sk[:, self.x_feature-1]
+            x2 = X_proyected_sk[:, self.y_feature-1]
+
+            plt.figure(figsize=(12, 8))
+            plt.scatter(x1, x2, c=y, edgecolors='none', alpha=0.8, cmap=plt.cm.get_cmap('viridis', len(y)))
+            plt.xlabel(f'Componente {self.x_feature}')
+            plt.ylabel(f'Componente {self.y_feature}')
+            plt.colorbar()
+
+            return plt.gcf()

Linear_regression.py

@@ -0,0 +1,82 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error
+import matplotlib.pyplot as plt
+
+class linear_regression_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+        # **Linear Regression**
+
+
+        **Predicción (aproximación)**
+        $$
+        \hat{y} = wx + b
+        $$
+
+        **Función de costos**
+
+        $$
+        Loss = MSE = \frac{1}{N} \sum_{i=1}^n (y_{i} - \hat{y_{i}})^2
+        $$
+
+        **Calculo del gradiente**
+
+
+        $$
+        \left[\begin{array}{ll}\frac{d_{loss}}{dw} \\ \frac{d_{loss}}{db} \end{array} \right] = \left[\begin{array}{ll} \frac{1}{N} \sum -2x_{i}(y_{i} - (wx_{i} + b)) \\ \frac{1}{N} \sum -2(y_{i} - (wx_{i} + b)) \end{array} \right]
+        $$
+
+        **Método del Descenso del Gradiente**
+
+        - Inicializar los pesos ($w$) y el sesgo ($b$)
+        - Iteramos
+          - Calcular el gradiente
+          - Actualizamos los parámetros (lr=learning rate)
+
+        $$
+        w = w - lr*dw
+        $$
+
+        $$
+        b = b-lr*db
+        $$
+
+        - Terminamos de iterar
+        '''
+
+    def solve(self):
+        self.X, self.y = self.database.data, self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_regr = LinearRegression()
+        self.sklearn_regr.fit(X_train, y_train)
+        y_pred = self.sklearn_regr.predict(X_test)
+        acc = mean_squared_error(y_pred, y_test)
+        st.metric('MSE (Mean Square Error)', value=f'{np.round(acc, 2)}')
+
+    def visualization(self):
+        n_features = int(self.database.data.shape[1])
+        self.x_feature = st.slider('Variable en eje x', 1, n_features, 1)
+
+        self.X = self.database.data[:, self.x_feature-1:self.x_feature]
+        self.y = self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_regr = LinearRegression()
+        self.sklearn_regr.fit(X_train, y_train)
+
+        x1_min = self.X.min()
+        x1_max = self.X.max()
+
+        x_pred = np.linspace(x1_min, x1_max, 100).reshape([100, 1])
+        y_pred = self.sklearn_regr.predict(x_pred)
+
+        plt.figure(1, figsize=(12, 8))
+        plt.scatter(self.X, self.y, edgecolors='k', cmap=plt.cm.Paired)
+        plt.plot(x_pred, y_pred)
+        return plt.gcf()

Logit.py

@@ -0,0 +1,106 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression as LR_sk
+from sklearn.metrics import accuracy_score
+import matplotlib.pyplot as plt
+from sklearn.metrics import confusion_matrix
+
+
+
+class Logit_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+        # **Logistic Regresion**
+
+        **Predicción (Aproximación)**
+
+        $$
+        z = wx + b
+        $$
+
+        $$
+        \hat{y} = \frac{1}{1+e^{-z}}
+        $$
+
+        **Función de perdida (cross entropy)**
+
+        $$
+        loss = \frac{1}{N} \sum_{i=1}^{n} [y^{i}log(\hat{y(x^{i})}) + (1-y^{i})log(1 - \hat{y(x^{i})})]
+        $$
+
+        **Gradientes**
+
+        $$
+        \left[\begin{array}{ll} \frac{d_{loss}}{dw} \\ \frac{d_{loss}}{db} \end{array}\right] = \left[\begin{array}{ll} \frac{1}{N} \sum 2x_{i}(\hat{y} - y_{i}) \\ \frac{1}{N} \sum 2(\hat{y} - y_{i}) \end{array}\right]
+        $$
+
+        **Metodo de Gradient Descent**
+        - Iniciar parámetros
+        - Iterar
+         - Calcular el error (loss)
+         - Actualizar los pesos ($lr$=learning rate)
+
+         $$
+        w = w - lr*dw
+         $$
+
+         $$
+         b = b - lr*db
+         $$
+
+        - Terminar de iterar
+        '''
+        self.x_feature = 1
+        self.y_feature = 2
+
+    def params(self):
+        pass
+
+    def solve(self):
+        self.X, self.y = self.database.data, self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_clf = LR_sk(max_iter=1000, random_state=1234)
+        self.sklearn_clf.fit(X_train, y_train)
+        y_pred = self.sklearn_clf.predict(X_test)
+        acc = accuracy_score(y_pred, y_test)
+
+        c1, c2 = st.columns([4, 1])
+        c2.metric('Acierto', value=f'{np.round(acc, 2)*100}%')
+        df = pd.DataFrame(confusion_matrix(y_pred, y_test))
+        labels = self.database.target_names
+        df.columns = labels
+        df.index = labels
+        c1.write('**Confusion Matrix**')
+        c1.dataframe(df)
+
+    def visualization(self):
+        n_features = int(self.database.data.shape[1])
+        self.x_feature = st.slider('Variables en eje x', 1, n_features, 1)
+        self.y_feature = st.slider('Variables en eje y', 1, n_features, 2)
+
+        self.X = np.c_[self.database.data[:, self.x_feature-1:self.x_feature], self.database.data[:, self.y_feature-1:self.y_feature]]
+        self.y = self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_clf = LR_sk(max_iter=1000, random_state=1234)
+        self.sklearn_clf.fit(X_train, y_train)
+
+        x1_min, x1_max = self.X[:, 0].min() - 0.5, self.X[:, 0].max() + 0.5
+        x2_min, x2_max = self.X[:, 1].min() - 0.5, self.X[:, 1].max() + 0.5
+        h = 0.02 # Salto que vamos dando
+        x1_i = np.arange(x1_min, x1_max, h)
+        x2_i = np.arange(x2_min, x2_max, h)
+        x1_x1, x2_x2 = np.meshgrid(x1_i, x2_i)
+        y_pred = self.sklearn_clf.predict(np.c_[x1_x1.ravel(), x2_x2.ravel()])
+        y_pred = y_pred.reshape(x1_x1.shape)
+
+        plt.figure(1, figsize=(12, 8))
+        plt.pcolormesh(x1_x1, x2_x2, y_pred, cmap=plt.cm.Paired)
+        plt.scatter(self.X[:, 0], self.X[:, 1], c=self.y, edgecolors='k', cmap=plt.cm.Paired)
+        plt.xlim(x1_x1.min(), x1_x1.max())
+        plt.ylim(x2_x2.min(), x2_x2.max())
+        return plt.gcf()

Naive_bayes.py

@@ -0,0 +1,97 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.naive_bayes import GaussianNB
+from sklearn.metrics import accuracy_score
+import matplotlib.pyplot as plt
+from sklearn.metrics import confusion_matrix
+
+
+
+class naive_bayes_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+        # **Naive Bayes**
+
+        Particularmente, este algoritmo no lo conocía, y por lo que he visto hasta ahora funciona como un **clasificador** basándose principalmente en el **teorema de bayes**.
+
+        **Teorema de bayes**
+
+        $$
+        P(A/B) = \frac{P(B/A) \cdot P(A)}{P(B)}
+        $$
+
+        Eso sí, para aprovechar este teorema es que se tiene que cumplir la condición de que los atributos o **componentes del vector X sean independientes entre sí (Se asume que los eventos son independientes)**.
+
+        $$
+        P(y/X) = \frac{P(X/y) \cdot P(y)}{P(X)} = \frac{P(x_{1}/y) \quad ... \quad P(x_{n}/y) \cdot P(y)}{P(X)}
+        $$
+
+        Así, luego la manera de escoger a que clasificación pertenece el vector X, es calculando todas las probabilidades condicionales (**Nota**: el $P(x)$ lo podemos omitir ya que va a estar presente en todas las ecuaciones)
+
+
+        $$
+        y = argmax_{y} \quad P(x_{1}/y) \quad ... \quad P(x_{n}/y) \cdot P(y)
+        $$
+
+        $$
+        y = argmax_{y} \quad log(P(x_{1}/y)) + \quad ... \quad + log(P(x_{n}/y)) + log(P(y))
+        $$
+
+
+        **Por último, nos falta definir:**
+
+        $P(y)$: Frecuencia (cantidad de veces que está presente la clasificación y en los datos)
+
+        $$
+        P(x_{i}/y) = \frac{1}{\sqrt{2\pi \sigma_{y}^{2}}} \cdot e^{(-\frac{(x_{i} - \mu_{y})^2}{2σ_{y}^{2}})}
+        $$
+        '''
+
+    def solve(self):
+        self.X, self.y = self.database.data, self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_clf = GaussianNB()
+        self.sklearn_clf.fit(X_train, y_train)
+        y_pred = self.sklearn_clf.predict(X_test)
+        acc = accuracy_score(y_pred, y_test)
+
+        c1, c2 = st.columns([4, 1])
+        c2.metric('Acierto', value=f'{np.round(acc, 2)*100}%')
+        df = pd.DataFrame(confusion_matrix(y_pred, y_test))
+        labels = self.database.target_names
+        df.columns = labels
+        df.index = labels
+        c1.write('**Confusion Matrix**')
+        c1.dataframe(df)
+
+    def visualization(self):
+        n_features = int(self.database.data.shape[1])
+        self.x_feature = st.slider('Variables en eje x', 1, n_features, 1)
+        self.y_feature = st.slider('Variables en eje y', 1, n_features, 2)
+
+        self.X = np.c_[self.database.data[:, self.x_feature-1:self.x_feature], self.database.data[:, self.y_feature-1:self.y_feature]]
+        self.y = self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_clf = GaussianNB()
+        self.sklearn_clf.fit(X_train, y_train)
+
+        x1_min, x1_max = self.X[:, 0].min() - 0.5, self.X[:, 0].max() + 0.5
+        x2_min, x2_max = self.X[:, 1].min() - 0.5, self.X[:, 1].max() + 0.5
+        h = 0.02 # Salto que vamos dando
+        x1_i = np.arange(x1_min, x1_max, h)
+        x2_i = np.arange(x2_min, x2_max, h)
+        x1_x1, x2_x2 = np.meshgrid(x1_i, x2_i)
+        y_pred = self.sklearn_clf.predict(np.c_[x1_x1.ravel(), x2_x2.ravel()])
+        y_pred = y_pred.reshape(x1_x1.shape)
+
+        plt.figure(1, figsize=(12, 8))
+        plt.pcolormesh(x1_x1, x2_x2, y_pred, cmap=plt.cm.Paired)
+        plt.scatter(self.X[:, 0], self.X[:, 1], c=self.y, edgecolors='k', cmap=plt.cm.Paired)
+        plt.xlim(x1_x1.min(), x1_x1.max())
+        plt.ylim(x2_x2.min(), x2_x2.max())
+        return plt.gcf()

PCA.py

@@ -0,0 +1,78 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVR
+from sklearn.decomposition import PCA as PCA_sk
+import matplotlib.pyplot as plt
+
+class PCA_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+        # **PCA (Principal Component Analysis)**
+
+        El objetivo principal con este método es definir una nueva dimensión para el set de datos (siendo estas nuevas dimensiones ortogonales y por tanto independientes).
+
+        **Varianza**
+
+        $$
+        var(X) = \frac{1}{n} \sum (X_{i} - \bar{X})^2
+        $$
+
+        **Matriz de Covarianzas**
+
+        $$
+        Cov(X, Y) = \frac{1}{n} \sum (X_{i} - \bar{X})(Y_{i} - \bar{Y})^T
+        $$
+
+        $$
+        Cov(X, X) = \frac{1}{n} \sum (X_{i} - \bar{X})(X_{i} - \bar{X})^T
+        $$
+
+        **Valores y Vectores Propios**
+
+        Los vectores propios apuntan en la dirección donde se genera la máxima varianza y el correspondiente valor propio indica el grado de importancia del vector.
+
+        $$
+        A \vec{v} = λ \vec{v}
+        $$
+
+        **Metodo**
+        - Sustraer al vector X su media.
+        - Calcular la Cov(X, X)
+        - Calcular los vectores y valores propios de las matrices de covarianza
+        - Ordenar los vectores propios según su importancia (en base a su valor propio) en orden decreciente
+        - Escoger los primeros k vectores propios y estos pasaran a ser las nuevas k dimensiones
+        - Por último, transformar (proyectar) los datos en las nuevas dimensiones (esto se hace con un producto punto)'''
+
+        self.x_feature = 1
+        self.y_feature = 2
+        self.n_components = 2
+
+    def params(self):
+        n_features = int(self.database.data.shape[1])
+        self.n_components = st.slider('Numero de componentes', 1, n_features, 2)
+
+    def solve(self):
+        self.x_feature = st.slider('Componente eje x', 1, self.n_components, 1)
+        self.y_feature = st.slider('Componente eje y', 1, self.n_components, 2)
+        X = self.database.data
+        y = self.database.target
+        sklearn_clus = PCA_sk(n_components=self.n_components)
+        sklearn_clus.fit(X)
+        X_proyected_sk = sklearn_clus.transform(X)
+
+        x1 = X_proyected_sk[:, self.x_feature-1]
+        x2 = X_proyected_sk[:, self.y_feature-1]
+
+        plt.figure(1, figsize=(12, 8))
+        plt.scatter(x1, x2, c=y, edgecolors='none', alpha=0.8, cmap=plt.cm.get_cmap('viridis', len(y)))
+        plt.xlabel(f'Componente {self.x_feature}')
+        plt.ylabel(f'Componente {self.y_feature}')
+        plt.colorbar()
+
+        #fig = plt.show().get_fig()
+        return plt.gcf()

Perceptron.py

@@ -0,0 +1,73 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import Perceptron as P_sk
+from sklearn.metrics import mean_squared_error
+import matplotlib.pyplot as plt
+
+
+class perceptron_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+        # **Perceptron**
+
+        Este es el modelo más sencillo y que sirve de introducción a los modelos de redes neuronales. En particular, su funcionamiento es bastante similar al modelo de regresión linear. con la diferencia de que ocupa una función de activación en la salida (**función no lineal**).
+
+        **Modelo Lineal**
+
+        $$
+        f(w, b) = w^{t}x + b
+        $$
+
+        **Función de Activación**
+
+        $$
+        z(x) \in (0, 1) \quad si \quad x \geq 0
+        $$
+
+        **Aproximación (predicción)**
+
+        $$
+        \hat{y} = z(w^{t}x + b)
+        $$
+
+        **Reglas de actualización (aquí se encuentra incluido el bias)**
+
+        $$
+        w = w + \Delta w = w + lr(y_{i} - \hat{y_{i}})x_{i}
+        $$
+        '''
+
+    def solve(self):
+        self.X, self.y = self.database.data, self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_regr = P_sk(random_state=1234)
+        self.sklearn_regr.fit(X_train, y_train)
+        y_pred = self.sklearn_regr.predict(X_test)
+        acc = mean_squared_error(y_pred, y_test)
+        st.metric('MSE (Mean Square Error)', value=f'{np.round(acc, 2)}')
+
+    def visualization(self):
+        n_features = int(self.database.data.shape[1])
+        self.x_feature = st.slider('Variable en eje x', 1, n_features, 1)
+
+        self.X = self.database.data[:, self.x_feature-1:self.x_feature]
+        self.y = self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_regr = P_sk(random_state=1234)
+        self.sklearn_regr.fit(X_train, y_train)
+
+        x1_min = self.X.min()
+        x1_max = self.X.max()
+
+        x_pred = np.linspace(x1_min, x1_max, 100).reshape([100, 1])
+        y_pred = self.sklearn_regr.predict(x_pred)
+
+        plt.figure(1, figsize=(12, 8))
+        plt.scatter(self.X, self.y, edgecolors='k', cmap=plt.cm.Paired)
+        plt.plot(x_pred, y_pred)
+        return plt.gcf()

Random_forest.py

@@ -0,0 +1,98 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestClassifier as rf
+from sklearn.metrics import accuracy_score
+import matplotlib.pyplot as plt
+from sklearn.metrics import confusion_matrix
+
+
+
+class random_forest_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = '''
+        # **Random Forest**
+
+        Este algoritmo se construye en base al algoritmo de **Decision Tree**. Así, lo que se hace es:
+
+        - Definir cantidad de estimadores (**Decision Tree**)
+        - Cada estimador entrenarlo con una muestra del set de datos de entrenamiento, variando así la cantidad de variables y la cantidad de datos con la cual se entrenan estos estimadores.
+        - Luego, para generar la predicción de algoritmo, lo que se hace es consultar a cada estimador su predicción y "**de manera democrática**" se escoge la opción más "**votada**"
+        '''
+        self.n_trees = 100
+        self.min_samples_split = 2
+        self.max_depth = 100
+        self.n_feats = None
+        self.stop_criterion = 'max_depth'
+
+
+    def params(self):
+        self.stop_criterion = st.radio('Criterio de termino:', options=['max_depth', 'min_samples_split'])
+        if self.stop_criterion == 'max_depth': self.max_depth = st.slider('Valor max deph:', 1, 100, 10)
+        elif self.stop_criterion == 'min_samples_split': self.min_samples_split = st.slider('Valor min_samples_split:', 2, 1000, 5)
+        self.n_trees = st.slider('Cantidad de estimadores: ', 1, 100, 3)
+        self.n_feats = st.slider('Fraccion de categorias para contruir los estimadores: ', 0.0, 1.0, 0.5)
+
+    def solve(self):
+        self.X, self.y = self.database.data, self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        if self.stop_criterion == 'max_depth': self.sklearn_clf = rf(n_estimators=self.n_trees,
+                                                                max_depth=self.max_depth,
+                                                                max_features=self.n_feats,
+                                                                random_state=1234)
+        elif self.stop_criterion == 'min_samples_split': self.sklearn_clf = rf(n_estimators=self.n_trees,
+                                                                min_samples_split=self.min_samples_split,
+                                                                max_features=self.n_feats,
+                                                                random_state=1234)
+
+        #self.sklearn_clf = rf(n_estimators=self.n_trees)
+        self.sklearn_clf.fit(X_train, y_train)
+        y_pred = self.sklearn_clf.predict(X_test)
+        acc = accuracy_score(y_pred, y_test)
+
+        c1, c2 = st.columns([4, 1])
+        c2.metric('Acierto', value=f'{np.round(acc, 2)*100}%')
+        df = pd.DataFrame(confusion_matrix(y_pred, y_test))
+        labels = self.database.target_names
+        df.columns = labels
+        df.index = labels
+        c1.write('**Confusion Matrix**')
+        c1.dataframe(df)
+
+    def visualization(self):
+        n_features = int(self.database.data.shape[1])
+        self.x_feature = st.slider('Variables en eje x', 1, n_features, 1)
+        self.y_feature = st.slider('Variables en eje y', 1, n_features, 2)
+
+        self.X = np.c_[self.database.data[:, self.x_feature-1:self.x_feature], self.database.data[:, self.y_feature-1:self.y_feature]]
+        self.y = self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        if self.stop_criterion == 'max_depth': self.sklearn_clf = rf(n_estimators=self.n_trees,
+                                                                max_depth=self.max_depth,
+                                                                max_features=self.n_feats,
+                                                                random_state=1234)
+        elif self.stop_criterion == 'min_samples_split': self.sklearn_clf = rf(n_estimators=self.n_trees,
+                                                                min_samples_split=self.min_samples_split,
+                                                                max_features=self.n_feats,
+                                                                random_state=1234)
+        self.sklearn_clf.fit(X_train, y_train)
+
+        x1_min, x1_max = self.X[:, 0].min() - 0.5, self.X[:, 0].max() + 0.5
+        x2_min, x2_max = self.X[:, 1].min() - 0.5, self.X[:, 1].max() + 0.5
+        h = 0.02 # Salto que vamos dando
+        x1_i = np.arange(x1_min, x1_max, h)
+        x2_i = np.arange(x2_min, x2_max, h)
+        x1_x1, x2_x2 = np.meshgrid(x1_i, x2_i)
+        y_pred = self.sklearn_clf.predict(np.c_[x1_x1.ravel(), x2_x2.ravel()])
+        y_pred = y_pred.reshape(x1_x1.shape)
+
+        plt.figure(1, figsize=(12, 8))
+        plt.pcolormesh(x1_x1, x2_x2, y_pred, cmap=plt.cm.Paired)
+        plt.scatter(self.X[:, 0], self.X[:, 1], c=self.y, edgecolors='k', cmap=plt.cm.Paired)
+        plt.xlim(x1_x1.min(), x1_x1.max())
+        plt.ylim(x2_x2.min(), x2_x2.max())
+        return plt.gcf()

SVC.py

@@ -0,0 +1,143 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn import svm
+from sklearn.metrics import accuracy_score
+import matplotlib.pyplot as plt
+from sklearn.metrics import confusion_matrix
+
+
+
+class SVC_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+                        # **Support Vector Machine**
+
+        Este algoritmo tiene por objetivo la búsqueda de un hiperplano que segregue los datos atendiendo a estas dos condiciones:
+
+        $$
+        wx - b = 0
+        $$
+
+        $$
+        max \quad \frac{2}{||w||}
+        $$
+
+        **Linear model (2 categorías (1 y -1))**
+
+        $$
+        wx - b = 0
+        $$
+
+        $$
+        wx_{i} - b \geq 1 \quad si \quad y_{i} = 1
+        $$
+
+        $$
+        wx_{i} - b \leq 1 \quad si \quad y_{i} = -1
+        $$
+
+        **Estas 3 ecuaciones se resumen en la siguiente:**
+
+        $$
+        y_{i}(wx_{i} - b) \geq 1
+        $$
+
+        **Función de costos (loss)**
+
+        $$
+        loss = λ||w||^2 + \frac{1}{n} \sum_{i=1}^{n} max(0, 1-y_{i}(wx_{i}-b))
+        $$
+
+        De esta manera las **derivadas** en función de los parámetros siguen las siguientes reglas:
+
+        - si $y_{i}(xw - b) \geq 1$:
+
+        $$
+        \left[\begin{array}{ll} \frac{d_{loss}}{d_{w_{k}}} \\ \frac{d_{loss}}{db} \end{array} \right] = \left [\begin{array}{ll} 2 \lambda w_{k} \\ 0 \end{array} \right]
+        $$
+
+        - si $y_{i}(xw - b) < 1$:
+
+        $$
+        \left[\begin{array}{ll}\frac{d_{loss}}{d_{w_{k}}} \\ \frac{d_{loss}}{db} \end{array} \right] = \left[\begin{array}{ll} 2\lambda w_{k} - y_{i} \cdot x_{i} \\ y_{i} \end{array} \right]
+        $$
+
+        **Reglas de actualización (Gradient Descent)**
+
+        - Inicializar parámetros
+        - Iterar
+         - Calcular loss
+         - Calcular gradiente
+         - Actualizar parámetros
+
+         $$
+        w = w - lr \cdot dw
+         $$
+
+         $$
+        b = b - lr \cdot db
+         $$
+
+        - Terminar de iterar
+        '''
+        self.kernel = 'linear'
+        self.gamma = 2
+        self.degree = 3
+
+    def params(self):
+        tipo = st.selectbox('Tipo de kernel', options=['linear',
+                                                        'poly',
+                                                        'rbf'])
+        self.kernel = tipo
+        self.gamma = st.slider('Parametro gamma', 1, 10, 2)
+        if tipo == 'poly': self.degree = st.slider('Cantidad de grados del polinomio', 1, 10, 3)
+
+
+    def solve(self):
+        self.X, self.y = self.database.data, self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_clf = svm.SVC(kernel=self.kernel, gamma=self.gamma, random_state=1234)
+        self.sklearn_clf.fit(X_train, y_train)
+        y_pred = self.sklearn_clf.predict(X_test)
+        acc = accuracy_score(y_pred, y_test)
+
+        c1, c2 = st.columns([4, 1])
+        c2.metric('Acierto', value=f'{np.round(acc, 2)*100}%')
+        df = pd.DataFrame(confusion_matrix(y_pred, y_test))
+        labels = self.database.target_names
+        df.columns = labels
+        df.index = labels
+        c1.write('**Confusion Matrix**')
+        c1.dataframe(df)
+
+    def visualization(self):
+        n_features = int(self.database.data.shape[1])
+        self.x_feature = st.slider('Variables en eje x', 1, n_features, 1)
+        self.y_feature = st.slider('Variables en eje y', 1, n_features, 2)
+
+        self.X = np.c_[self.database.data[:, self.x_feature-1:self.x_feature], self.database.data[:, self.y_feature-1:self.y_feature]]
+        self.y = self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        self.sklearn_clf = svm.SVC(kernel=self.kernel, gamma=self.gamma, random_state=1234)
+        self.sklearn_clf.fit(X_train, y_train)
+
+        x1_min, x1_max = self.X[:, 0].min() - 0.5, self.X[:, 0].max() + 0.5
+        x2_min, x2_max = self.X[:, 1].min() - 0.5, self.X[:, 1].max() + 0.5
+        h = 0.02 # Salto que vamos dando
+        x1_i = np.arange(x1_min, x1_max, h)
+        x2_i = np.arange(x2_min, x2_max, h)
+        x1_x1, x2_x2 = np.meshgrid(x1_i, x2_i)
+        y_pred = self.sklearn_clf.predict(np.c_[x1_x1.ravel(), x2_x2.ravel()])
+        y_pred = y_pred.reshape(x1_x1.shape)
+
+        plt.figure(1, figsize=(12, 8))
+        plt.pcolormesh(x1_x1, x2_x2, y_pred, cmap=plt.cm.Paired)
+        plt.scatter(self.X[:, 0], self.X[:, 1], c=self.y, edgecolors='k', cmap=plt.cm.Paired)
+        plt.xlim(x1_x1.min(), x1_x1.max())
+        plt.ylim(x2_x2.min(), x2_x2.max())
+        return plt.gcf()

SVR.py

@@ -0,0 +1,139 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVR
+from sklearn.metrics import mean_squared_error
+import matplotlib.pyplot as plt
+
+class SVR_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+        # **SVR (Support Vector Regression)**
+
+        El objetivo es encontrar la función $f(x)$ que produzca el valor $y$ con una distancia no más lejana que $\epsilon$ para cada uno de los puntos de entrenamiento $x$.
+
+        **Linear SVM Regression: Primal Formula**
+
+        Supongamos que estamos trabajando con un set de datos X (multivariable) y con una variable dependiente y.
+
+        Entonces la función lineal seria:
+
+        $$
+        f(X) = X^{T}\beta + b
+        $$
+
+        Luego, para asegurar que los parámetros $\beta$ sean lo más chicos (flat) posibles es que se busca minimizar:
+
+        $$
+        J(\beta) = \frac{1}{2}\beta^{T}\beta
+        $$
+
+        Restringido bajo las siguientes condiciones:
+
+        $$
+        |y_{n} - (X_{n}^{T}\beta + b)| \leq \epsilon \quad \forall n \in N
+        $$
+
+        Como es posible que no exista una función $f(x)$ que pueda satisfacer estas condiciones se introduce los términos $ℇ_{n}$ y $ℇ_{n}^{*}$ las cuales vienen a representar algo así como variables de holgura.
+
+        Así, luego nuestra función objetivo cambia a:
+
+        $$
+        J(\beta) = \frac{1}{2}\beta^{T}\beta + C\sum_{n=1}^{N} (ℇ_{n} + ℇ_{n}^{*})
+        $$
+
+        Sujeto a:
+
+        $$
+        y_{n} - (X_{n}^{T} \beta +b) \leq \epsilon + ℇ_{n} \quad \forall n \in N
+        $$
+
+        $$
+        (X_{n}^{T} \beta +b) - y_{n}\leq \epsilon + ℇ_{n}^{*} \quad \forall n \in N
+        $$
+
+        $$
+        ℇ_{n}^{*} \geq 0 \quad \forall n \in N
+        $$
+
+        $$
+        ℇ_{n} \geq 0 \quad \forall n \in N
+        $$
+
+        **Nota**: $C$ Son un conjunto de valores todos positivos que tiene por función penalizar las observaciones que se escapen del margen $\epsilon$
+
+        **Nonlinear SVM Regression**
+
+        En caso de que el problema no se pueda adaptar bien utilizando un modelo lineal, podemos adaptar todo este desarrollo cambiando el producto punto $X_{i}^{T}X_{j}$ por $G(X_{i}, X_{j})$.
+
+        | Kernel Name | Kernel Function |
+        |-------------|-----------------|
+        |Linear (dot product)| $G(X_{i}, X_{j}) = X_{i}^{T}X_{j}$|
+        |Gaussian|$G(X_{i}, X_{j}) = e^{-\lvert \rvert X_{i} - X_{j}^{2} \lvert \rvert}$|
+        |Polynomial|$G(X_{i}, X_{j}) = (1 + X_{i}^{T}X_{j})^{q}$|
+
+        **Nota:** $q$ es el grado del polinomio
+
+        **Fuente**: https://www.mathworks.com/help/stats/understanding-support-vector-machine-regression.html
+
+'''
+
+    def params(self):
+        self.selected_kernel = st.selectbox('Tipo de kernel:', options=['linear', 'poly', 'rbf', 'sigmoid'])
+        if self.selected_kernel == 'poly': self.degree = st.slider('Grados del polinomio', 1, 6, 3)
+        min = float(np.min([0, np.min(self.database.target)]))/2
+        max = float(np.max(self.database.target))/2
+        mean = float(np.mean(self.database.target))/2
+        self.C = st.slider('Parametro de penalizacion C:', 1.0, 4*max, 4*mean)
+        self.epsilon = st.slider('Epsilon: ', min, max, mean)
+
+    def solve(self):
+        self.X, self.y = self.database.data, self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        if self.selected_kernel == 'poly': self.sklearn_regr = SVR(kernel=self.selected_kernel,
+                                                                    degree=self.degree,
+                                                                    C=self.C,
+                                                                    epsilon=self.epsilon)
+        else: self.sklearn_regr = SVR(kernel=self.selected_kernel,
+                                        C=self.C,
+                                        epsilon=self.epsilon)
+        self.sklearn_regr.fit(X_train, y_train)
+        y_pred = self.sklearn_regr.predict(X_test)
+        acc = mean_squared_error(y_pred, y_test)
+        st.metric('MSE (Mean Square Error)', value=f'{np.round(acc, 2)}')
+
+    def visualization(self):
+        n_features = int(self.database.data.shape[1])
+        self.x_feature = st.slider('Variable en eje x', 1, n_features, 1)
+
+        self.X = self.database.data[:, self.x_feature-1:self.x_feature]
+        self.y = self.database.target
+        X_train, X_test, y_train, y_test = train_test_split(self.X, self.y, test_size=self.test_size, random_state=1234)
+        if self.selected_kernel == 'poly': self.sklearn_regr = SVR(kernel=self.selected_kernel,
+                                                                    degree=self.degree,
+                                                                    C=self.C,
+                                                                    epsilon=self.epsilon)
+        else: self.sklearn_regr = SVR(kernel=self.selected_kernel,
+                                        C=self.C,
+                                        epsilon=self.epsilon)
+        self.sklearn_regr.fit(X_train, y_train)
+
+        x1_min = self.X.min()
+        x1_max = self.X.max()
+
+        x_pred = np.linspace(x1_min, x1_max, 100).reshape([100, 1])
+        y_pred = self.sklearn_regr.predict(x_pred)
+        y_pred_up = [i+self.epsilon for i in y_pred]
+        y_pred_down = [i-self.epsilon for i in y_pred]
+
+
+        plt.figure(1, figsize=(12, 8))
+        plt.scatter(self.X, self.y, edgecolors='k', cmap=plt.cm.Paired)
+        plt.plot(x_pred, y_pred, color='red') # linea de prediccion
+        plt.plot(x_pred, y_pred_up, linestyle='--', color='green')
+        plt.plot(x_pred, y_pred_down, linestyle='--', color='green')
+        return plt.gcf()

k_mean_clustering.py

@@ -0,0 +1,79 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVR
+from sklearn.cluster import KMeans as KM
+import matplotlib.pyplot as plt
+
+
+def plot(X, clusters, centroids, x_feature, y_feature):
+    fig, ax = plt.subplots(figsize=(12, 8))
+
+    for i, index in enumerate(clusters):
+      x = X[index].T[x_feature-1]
+      y = X[index].T[y_feature-1]
+      point = np.array([x, y])
+      ax.scatter(*point)
+
+    for point in centroids:
+        x = point[x_feature-1]
+        y = point[y_feature-1]
+        points = np.array([x, y])
+        ax.scatter(*points, marker="o", linewidth=15)
+
+    return fig
+
+class k_mean_clustering_st:
+    def __init__(self, database, test_size=0.2):
+        self.database = database
+        self.test_size = test_size
+        self.desc = r'''
+        # **K-Mean Clustering**
+
+        El objetivo en esta ocasión es segmentar información desclasificada (**unsupervised learning**)
+
+        Así, este método asigna a una muestra de datos una clase en base a la distancia promedio entre los datos.
+
+        **Iterative Optimization**
+
+        - Inicializamos los centros de manera aleatoria
+        - Iteramos hasta converger
+         - Actualizamos las clasificaciones de los datos utilizando el centroide.
+         - Actualizamos el centroide. (este corresponde a la posición del centro para una clase)
+
+
+        **Distancia entre vectores**
+
+        $$
+        d(p, q) = \sqrt{\sum (p_{i} - q_{i})^{2}}
+        $$
+        '''
+        self.x_feature = 1
+        self.y_feature = 2
+        self.n_clusters = 3
+        self.max_iter = 150
+
+    def params(self):
+        self.n_features = int(self.database.data.shape[1])
+        self.n_clusters = st.slider('Numero de segmentos', 1, 10, 3)
+        self.max_iter = st.slider('Numero maximo de iteraciones', 100, 200, 150)
+
+    def solve(self):
+        self.x_feature = st.slider('Variables en eje x', 1, self.n_features, 1)
+        self.y_feature = st.slider('Variables en eje y', 1, self.n_features, 2)
+        X = self.database.data
+        sklearn_clus = KM(n_clusters=self.n_clusters, max_iter=self.max_iter)
+        sklearn_clus.fit(X)
+        pred = sklearn_clus.predict(X)
+        classes = np.unique(pred)
+        clusters = [[] for i in classes]
+        for idx, value in enumerate(pred):
+          clusters[value].append(idx)
+
+        return plot(X=X,
+                    clusters=clusters,
+                    centroids=sklearn_clus.cluster_centers_,
+                    x_feature=self.x_feature,
+                    y_feature=self.y_feature)