from sklearn import svm
import numpy as np
X = np.array([[1,2],[5,8],[2,3],[8,8],[1,0.6],[9,11],[6,0]])

y=np.array([0,1,0,1,0,1,0])
clf = svm.SVC(kernel='linear', C = 1.0) #Defincición modelo
clf.fit(X, y)  #Ajuste del modelo
print("Predicción del punto [2,2]", clf.predict([[2., 2.]])) #Predicción con el modelo anterior
print("Predicción del punto [7,8]",clf.predict([[7.,8.]]))
print("Los supports vector obtenidos son \n",clf.support_vectors_)

#Idea tomada de 
#http://scikit-learn.org/stable/auto_examples/svm/plot_svm_margin.html
#Idea tomada de 
#http://scikit-learn.org/0.17/auto_examples/svm/plot_separating_hyperplane.html

import math
SuVec=clf.support_vectors_
Inde=clf.intercept_
Param=clf.coef_
C2=-(Inde[0]/Param[0][1])
A2=-(Param[0][0]/Param[0][1])
xx = np.linspace(0,12)
yy=C2+(A2*xx)

A=Param[0][0]
B=Param[0][1]
C=Inde
p=SuVec[0][0]
q=SuVec[0][1]
#Calculamos distancia del punto a la recta separadora
d=(abs(p*A+q*B+C)/math.sqrt((A**2)+(B**2)))
yy2=(C2+d)+(A2*xx)
yy3=(C2-d)+(A2*xx)
#Otra forma de calcular el margin
margin = 1 / np.sqrt(np.sum(Param** 2))
print(d)
print(margin)
# Tomamos un support vector de una región
b=clf.support_vectors_[0]
yy2=A2*xx+(b[1]-A2*b[0])
#Tomamos un support vector de la otra región 
b2=clf.support_vectors_[-1]
yy3=A2*xx+(b2[1]-A2*b2[0])

import matplotlib.pyplot as plt
plt.plot(xx,yy)
plt.plot(xx,yy2,'k--')
plt.plot(xx,yy3,'k--')
#Sacamos en el gráfico los support vector
plt.scatter(SuVec[:, 0], SuVec[:, 1],s=400, facecolors='none',c='black',linewidths=4,
           alpha=0.2)
plt.scatter(X[:,0],X[:,1],c=y,cmap=plt.cm.Paired)
plt.show()

clf.decision_function(X)

print("Suport vectors. ", clf.support_vectors_ )
print("Indices de Support vectors: ", clf.support_)
print("Número de suport vectors en cada clase: ", clf.n_support_)
print("Constante en función de decisión: ", clf.intercept_)
print("Distancia de cada elementode X a cada hiperplano: ",clf.decision_function(X) )
print("acuracidad media entre los datos estimados y reales ",clf.score(X,y) )
print("Los parámetros del estimador",clf.get_params() )

print(__doc__)

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm
from sklearn.datasets import make_blobs


# Creamos 40 puntos separable, para esto se utiliza la función make_blobs
X, y = make_blobs(n_samples=40, centers=2, random_state=6)

# Ajustamos el modelo
clf = svm.SVC(kernel='linear', C=1000)
clf.fit(X, y) #Aquí hemos obtenido el modelo ajustado
print("Número de support vector: ",clf.n_support_)
print("support vector: ",clf.support_vectors_)
print(clf.get_params())
print(clf.coef_)
print(clf.intercept_)


plt.figure(figsize=(12,8))
plt.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=plt.cm.Paired)

# plot  decision function
ax = plt.gca()
#Con la instrucción anterior se toman los ejes para poder trabajar con ellos
xlim = ax.get_xlim()
ylim = ax.get_ylim()

# creamos una rejilla para evaluar el modelo
xx = np.linspace(xlim[0], xlim[1], 30)
yy = np.linspace(ylim[0], ylim[1], 30)
YY, XX = np.meshgrid(yy, xx)
xy = np.vstack([XX.ravel(), YY.ravel()]).T
Z = clf.decision_function(xy).reshape(XX.shape)

# plot decision boundary y margins
# Ojo aquí uso "ax.contour" entonces saca el contorno. En otros ejemplos pongo "ax.contourf"
#y se dibuja el interior de la zona
ax.contour(XX, YY, Z, colors='k', levels=[-1, 0, 1], alpha=0.5,
           linestyles=['--', '-', '--'])

# coloco los support vector 
ax.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1], s=100,
           linewidth=1, facecolors='none',marker="X",c="red")
plt.show()

print(__doc__)

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets

def make_meshgrid(x, y, h=.02):
    """Para crear una malla de puntos base para dibujar las regiones

    Parametros
    ----------
    x: Datos que sirven de base para obtener las coordenadas x de la malla
    y: Datos que sirven de base para obtener las coordenadas y de la malla
    h: paso entre puntos de la malla, es  optcional

    Returns
    -------
    xx, yy : ndarray conteniendo las coordenadas x e y de la malla.
    """
    x_min, x_max = x.min() - 1, x.max() + 1 #Maximo y mínimo eje x de la malla
    y_min, y_max = y.min() - 1, y.max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))
    return xx, yy #Devuelve las coordenadas de la malla

def plot_contours(ax, clf, xx, yy, **params):
    """Dibujar las regiones de decisión obtenidas en el SVM.

    Parámetros
    ----------
    ax: Objeto de tipo axes de  matplotlib 
    clf: un clasificador
    xx: meshgrid ndarray
    yy: meshgrid ndarray
    params: Un diccionario de parámetros que se pasa a la función contourf, optional
    """
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) #Para cada elemento de la malla obtengo la predicción 
    Z = Z.reshape(xx.shape)
    out = ax.contourf(xx, yy, Z, **params) 
    #contourf vrea el contorno. Ver el enlace https://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.contourf.html
    return out

# importo los datos con los que se va a trabajar
iris = datasets.load_iris()
print(iris.keys()) #Imprimo las claves del diccionario
print(iris.DESCR)  #Imprimo la descripción
# Se selecciona sólo las dos primeras features.
X = iris.data[:, :2]
y = iris.target

# Creamos una instancia de SVM y ajustamos los datos. No escalamos nuestros datos
# Ya que queremos trazar los vectores de soporte.
C = 1.0  # SVM regularization parameter
models = (svm.SVC(kernel='linear', C=C),
          svm.LinearSVC(C=C),
          svm.SVC(kernel='rbf', gamma=0.7, C=C),
          svm.SVC(kernel='poly', degree=3, C=C))
models = (clf.fit(X, y) for clf in models)

# title for the plots
titles = ('SVC con linear kernel',
          'LinearSVC (linear kernel)',
          'SVC con RBF kernel',
          'SVC con polynomial (degree 3) kernel')

# definimos una red 2x2 para dibujar

fig, sub = plt.subplots(2, 2) #crean subplots de tamaño 2x2 
fig.set_size_inches(15,15)
plt.subplots_adjust(wspace=0.4, hspace=0.4)


X0, X1 = X[:, 0], X[:, 1] #selecciona las dos primeras columnas de los datos
xx, yy = make_meshgrid(X0, X1)

print("clase de \"fig\": %s" % type(fig))

for clf, title, ax in zip(models, titles, sub.flatten()):
    #Como sus es de la clase np.array sub.flatten crea una copia estendida de sub
    #Es similar a ravel tambien de numpy
    plot_contours(ax, clf, xx, yy,
                  cmap=plt.cm.coolwarm, alpha=0.8)
    ax.scatter(X0, X1, c=y, cmap=plt.cm.coolwarm, s=20, edgecolors='k')
    ax.set_xlim(xx.min(), xx.max())
    ax.set_ylim(yy.min(), yy.max())
    ax.set_xlabel('Sepal length')
    ax.set_ylabel('Sepal width')
    ax.set_xticks(())
    ax.set_yticks(())
    ax.set_title(title)

plt.show()

from sklearn import svm

X = [[0], [1], [2], [3]] #Variable independeiente
Y = [0, 1, 2, 3] #Variable dependiente con cuatro categorías
clf = svm.SVC(decision_function_shape='ovo')  #función decisión one-vs-one 
#shape=n_clases*(n_clases-1)/2
clf.fit(X, Y) 

#Recordar que con decision_funcion se obtiene la distancia de cada punto 
#a los hiperpalnos de separación


dec = clf.decision_function([[1]])
print(dec.shape)
print(dec.shape[1]) # 4 classes: 4*3/2 = 6
print(dec)

clf.decision_function_shape = "ovr"
dec = clf.decision_function([[1]])
print(dec.shape)
print(dec.shape[1]) # 4 classes
print(dec)

print("Clasificación en cada una de las clases:",clf.predict(X))

lin_clf = svm.LinearSVC()
lin_clf.fit(X, Y) 

dec = lin_clf.decision_function([[1]])
print(dec.shape)
dec.shape[1]
print('Clasificación en cada una de las clases ',lin_clf.predict(X))

print(__doc__)

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm

#Definimos la función que se encargará de dibujar las funciones de decisión
def plot_decision_function(classifier, sample_weight, axis, title):
    # dibujamos decision function
    xx, yy = np.meshgrid(np.linspace(-4, 5, 500), np.linspace(-4, 5, 500))

    Z = classifier.decision_function(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)

    
    #Dibujamos los contronos
    axis.contourf(xx, yy, Z, alpha=0.75, cmap=plt.cm.bone) 
    # Dibujamos los puntos
    axis.scatter(X[:, 0], X[:, 1], c=y, s=100 * sample_weight, alpha=0.9,
                 cmap=plt.cm.bone, edgecolors='black')

    axis.axis('off')
    axis.set_title(title)


# Generamos 20 puntos
np.random.seed(0) #establecemos una semilla fija
#Generamos los valores de la X, una matriz (20,2) obtenida de una distribución normal
#Los 10 primeros son una  N(1,2) y los 10 últimos una N(0,1)
X = np.r_[np.random.randn(10, 2) + [1, 1], np.random.randn(10, 2)] 
print("Valores de la X: ", X)
y = [1] * 10 + [-1] * 10 
print("Valores de la y ",y)
#Establecemos los pesos aleatorios (deben ser >0) para cada fila de la X
sample_weight_last_ten = abs(np.random.randn(len(X)))
#Todos los pesos igual a 1
sample_weight_constant = np.ones(len(X))
# y pesos más grandes a algunos valores atípicos.
#a los últimos elementos de la muestra se les asigna un peso elevado
sample_weight_last_ten[15:] *= 5
sample_weight_last_ten[9] *= 15

# Para referencia, primer ajuste sin pesos de clase.

# Ajuste del modelo

clf_weights = svm.SVC()
# Al método fit se le asigna el parámetro sample_weight que es el array que contiene 
#los pesos indicados anteriormente e introducidos en la variable sample_weight_last_ten
clf_weights.fit(X, y, sample_weight=sample_weight_last_ten)

clf_no_weights = svm.SVC()
#Ajustamos el modelo sin pesos
clf_no_weights.fit(X, y)

# **** para cambiar el tamaño del gráfico se utiliza el parámetro "figsize"
fig, axes = plt.subplots(1, 2, figsize=(14, 6))
plot_decision_function(clf_no_weights, sample_weight_constant, axes[0],
                       "Constant weights")
plot_decision_function(clf_weights, sample_weight_last_ten, axes[1],
                       "Modified weights")

plt.show()

print(__doc__)

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm

# creamos clusters with 1000 and 100 puntos
rng = np.random.RandomState(0)
n_samples_1 = 1000
n_samples_2 = 100 #Esta es la clase 1 que tiene muchos menos elemento que la clase cero
X = np.r_[1.5 * rng.randn(n_samples_1, 2),
          0.5 * rng.randn(n_samples_2, 2) + [2, 2]]
y = [0] * (n_samples_1) + [1] * (n_samples_2)

# Ajuste del modelo y obtención del hiperplano de separación.
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(X, y)

# Ajuste del modelo y obtención plano de separación usando pesos.
wclf = svm.SVC(kernel='linear', class_weight={1: 10}) # Aquí se indica el peso de la clase
wclf.fit(X, y)

# Gráfico hiperplanos separación y muestras
plt.figure(figsize=(12,8))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired, edgecolors='k')
plt.legend()

# Dibujando función de decisión para ambos clasificadores
ax = plt.gca() #Se obtiene el elemento axis
xlim = ax.get_xlim()
ylim = ax.get_ylim()

# generamos la red de puntos
xx = np.linspace(xlim[0], xlim[1], 30)
yy = np.linspace(ylim[0], ylim[1], 30)
YY, XX = np.meshgrid(yy, xx)
xy = np.vstack([XX.ravel(), YY.ravel()]).T

# Obtención del hiperplano de sepparación 
Z = clf.decision_function(xy).reshape(XX.shape)

# Dibujo del gráfico de las bandas de decisión y los margins
a = ax.contour(XX, YY, Z, colors='k', levels=[0], alpha=0.5, linestyles=['-'])

# Obención del hiperpalno de separación para clases con pesos
Z = wclf.decision_function(xy).reshape(XX.shape)

# Trazado del límite de decisión y los márgenes para las clases ponderadas.
b = ax.contour(XX, YY, Z, colors='r', levels=[0], alpha=0.5, linestyles=['-'])

plt.legend([a.collections[0], b.collections[0]], ["non weighted", "weighted"],
           loc="upper right")
plt.show()

print(__doc__)

import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm

# Aquí generamos la malla donde se calcula la función de decisión
xx, yy = np.meshgrid(np.linspace(-3, 3, 500),
                     np.linspace(-3, 3, 500))
np.random.seed(0)
X = np.random.randn(300, 2)
Y = np.logical_xor(X[:, 0] > 0, X[:, 1] > 0) 
# con el anterior comando se generan T y F dependiendo si el valor es positivo o negativo

# Ajuste del modelo
clf = svm.NuSVC() #Aquí se indica un modelo no lineal
clf.fit(X, Y) #ajuste del modelo

#  Dibujo de la función de decisión para cada punto de la malla.
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.figure(figsize=(12,8))
plt.imshow(Z, interpolation='nearest',
           extent=(xx.min(), xx.max(), yy.min(), yy.max()), aspect='auto',
           origin='lower', cmap=plt.cm.PuOr_r)
contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
                       linetypes='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=Y, cmap=plt.cm.Paired,
            edgecolors='k')
plt.xticks(())
plt.yticks(())
plt.axis([-3, 3, -3, 3])
plt.show()

print(__doc__)

import numpy as np
from sklearn.svm import SVR
import matplotlib.pyplot as plt

# #############################################################################
# Generamos los datos
X = np.sort(5 * np.random.rand(40, 1), axis=0)
y = np.sin(X).ravel()

# #############################################################################
# Añadimos ruido al target
y[::5] += 3 * (0.5 - np.random.rand(8))
plt.figure(figsize=(12,8))
# #############################################################################
# Ajuste del modelo de regresión
svr_rbf = SVR(kernel='rbf', C=1e3, gamma=0.1)
svr_lin = SVR(kernel='linear', C=1e3)
svr_poly = SVR(kernel='poly', C=1e3, degree=2)
y_rbf = svr_rbf.fit(X, y).predict(X) # Aquí tendriamos los valores estimados del modelo
y_lin = svr_lin.fit(X, y).predict(X)
y_poly = svr_poly.fit(X, y).predict(X)

# #############################################################################
# Mostrando los resultados
lw = 2
plt.scatter(X, y, color='darkorange', label='data') #el label sirve para ponerlo después en la leyenda
plt.plot(X, y_rbf, color='navy', lw=lw, label='RBF model')
plt.plot(X, y_lin, color='c', lw=lw, label='Linear model')
plt.plot(X, y_poly, color='cornflowerblue', lw=lw, label='Polynomial model')
plt.xlabel('data')
plt.ylabel('target')
plt.title('Support Vector Regression')
plt.legend()
plt.show()

print(__doc__)

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.font_manager
from sklearn import svm

plt.figure(figsize=(12,8))
xx, yy = np.meshgrid(np.linspace(-5, 5, 500), np.linspace(-5, 5, 500))
# Generate train data
X = 0.3 * np.random.randn(100, 2)
print("Dimensión matriz X:",X.shape)
#X es una matriz de una distribución normal de media 0.3 y varianza 1
X_train = np.r_[X + 2, X - 2]
print((X+2)[0:4,:])
print(80*'-')
print((X-2)[0:4,:])
print(80*'-')
print(X_train[0:4,:])
print(80*'-')
print(X_train[100:104,:])

print(X_train.shape)
#como puede verse por los resultados que se obtienen con las anteriores instrucciones:
# 1.- Se obtiene la matriz X+2 (a cada elemento de X se le suma 2)
# 2.- Se obtiene la matriz X-2
# 3.- Se ponen los elementos de la matriz X+2 y debajo los de la matriz X-2

#Con lo anterior he generado el training, es decir los datos que sirven para hacer el modelo
# A continuación saco los datos del test, es decir los datos para probar si son o no del modelo

# Generamos nuevas observaciones
X = 0.3 * np.random.randn(20, 2)
X_test = np.r_[X + 2, X - 2]
#Los datos anteriores son construidos siguiendo el mismo modelo que los del train, luego deberían
#dar en la prueba que siguen el mismo modelo
# Generamos alguna nueva observación anormal de una distribución U entre -4 y 4
X_outliers = np.random.uniform(low=-4, high=4, size=(20, 2))
#Los datos anteriores deberían dar que siguen modelo diferente

# Ajuste del modelo, ***se utiliza OneClassSVM para problemas de novelty detection
clf = svm.OneClassSVM(nu=0.1, kernel="rbf", gamma=0.1)
clf.fit(X_train)
y_pred_train = clf.predict(X_train)
y_pred_test = clf.predict(X_test)
y_pred_outliers = clf.predict(X_outliers)
n_error_train = y_pred_train[y_pred_train == -1].size
n_error_test = y_pred_test[y_pred_test == -1].size
n_error_outliers = y_pred_outliers[y_pred_outliers == 1].size

# plot the line, the points, and the nearest vectors to the plane
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.title("Novelty Detection")
plt.contourf(xx, yy, Z, levels=np.linspace(Z.min(), 0, 7), cmap=plt.cm.PuBu)
a = plt.contour(xx, yy, Z, levels=[0], linewidths=2, colors='darkred')
plt.contourf(xx, yy, Z, levels=[0, Z.max()], colors='palevioletred')

s = 40
b1 = plt.scatter(X_train[:, 0], X_train[:, 1], c='white', s=s, edgecolors='k')
#Con lo anterior coloco lo puntos X-train, color=blanco
b2 = plt.scatter(X_test[:, 0], X_test[:, 1], c='blueviolet', s=s,
                 edgecolors='k')
#Con lo anterior coloco los puntos X_test, de color blueviolet
c = plt.scatter(X_outliers[:, 0], X_outliers[:, 1], c='gold', s=s,
                edgecolors='k')
#Con lo anterior coloco los puntos outliers de color 'gold'
plt.axis('tight')
plt.xlim((-5, 5))
plt.ylim((-5, 5))
plt.legend([a.collections[0], b1, b2, c],
           ["learned frontier", "training observations",
            "new regular observations", "new abnormal observations"],
           loc="upper left",
           prop=matplotlib.font_manager.FontProperties(size=11))
plt.xlabel(
    "error train: %d/200 ; errors novel regular: %d/40 ; "
    "errors novel abnormal: %d/40"
    % (n_error_train, n_error_test, n_error_outliers))
plt.show()