<jupyter_start><jupyter_text>PCAEste modelo combina variables y maximiza.<jupyter_code>'''
Por defecto  si no le pasamos valores hace n_components = min(n_muestrs, n_features), usa toda l información, 
todas las columans
'''
pca = PCA(n_components=3)
'''
Una vez configurado llamamos fit aplicada a los datos de entrenamiento para que PCA se ajusta a los datos
'''
pca.fit(X_train)

'''
Estamos realizando una comparación entre PCA y IPCA.



Incremental PCA no manda todos los datos y por eso existe batch, no manda todos los datos a entrenar, combianndosl en un resutlado final
ulti para maquinas con bajos recursos
'''
ipca = IncrementalPCA(n_components=3, batch_size=10)
ipca.fit(X_train)
ipca<jupyter_output><empty_output><jupyter_text>Ajustados lso datos podemos Medimos la vairanza de los componenetes, veamos una represantación grafica<jupyter_code>'''
Genero  un rango como eje x desde 0 hasta los componentes que me arroja PCA, graficaqueroms el valro de la importancia graficando contra y
'''
plt.plot(range(len(pca.explained_variance_)), pca.explained_variance_ratio_, )
plt.show()<jupyter_output><empty_output><jupyter_text>Las componentes en el eje x relevantes serán 0, 1 , 2.De la gráfica se peude inferir que el primer componente aporta la mayoría de infromación, mientras que la seguna apenas llega al 12% y la 3 no hace nada. Una vez esto sabes que el algoritmo PCA aporta valor.Pasamos a confirgar la regresión logistica<jupyter_code>logistic = LogisticRegression(solver='lbfgs')
# TAMBIEN RECIBE 'liblinear', 'newton-cg', '', 'sag', 'saga'<jupyter_output><empty_output><jupyter_text>Para que la prueba sea existosa debemos aplciar nuestro entramiento y pruebas<jupyter_code>## PCA
dt_train = pca.transform(X_train)
dt_test = pca.transform(X_test)
# Enviamos a la regresión logistoica ambos dataframes

logistic.fit(dt_train, y_train)

# Mediremos alguna métrica como el acuracy
print("Score con PCA: ", logistic.score(dt_test, y_test))
## IPCA

dt_train = ipca.transform(X_train)
dt_test = ipca.transform(X_test)

# Enviamos a la regresión logistoica ambos dataframes
logistic.fit(dt_train, y_train)

# 
# Mediremos alguna métrica como el acuracy
print("Score con IPCA: ", logistic.score(dt_test, y_test))<jupyter_output>Score con IPCA:  0.8051948051948052<jupyter_text>Lo que nos dice es que tiene un acuracy de PCA: 78% e IPCA: 80%, nos damos cuenta que el rendimeinto es casi el mismo.l data set orignal tiene 13 features, utilizando PCA usamos 3 features artificiales para llegar a una predicción buena.  KERNELS Y KPCAEl kernel es una función matemática que toma mediciones que se comportan de manera no lineal y las proyecta en un especio dimensional más grande donde sean lienalmente separables.Nos ayudan a transformar dimensiones de  dos dimensines a N dimensiones , en la imagen los puntos de la izquierda no son linealmente separables:![kernel.png](./images/Kernel.png)A través d euna línea no hay forma de clasificarlos, si aplciamos una funcion de Kernel podemos trazar con un plano realizar una clasificación. Esa es la diea. Kernel proeycta para poder trabajar, algunos kernels frecuentes:![kernel.png](./images/Kernel-1.png)* Los lineales parten el espacio.* Los polinomianles son utiles para datos complesjos![kernel.png](./images/Kernel-2.png)  IMPLEMENTANTO KERNELS KPCAPara esta implemntación podemos partir de la celda que parte los datos de entrenamiento y pruebas, una vez cargados los datos podemos aplicar nuestras funciones de Kernel<jupyter_code>kpca = KernelPCA(n_components=4,kernel='poly')
kpca.fit(X_train)
# Aplico KPCA

dt_train = kpca.transform(X_train)
dt_test=kpca.transform(X_test)

# Una vez reducido los datos en dimensionalidad hacemos la regresión logistca
logistic = LogisticRegression(solver="lbfgs")
logistic.fit(dt_train, y_train)
print("SCORE KPCA :", logistic.score(dt_test, y_test))<jupyter_output>SCORE KPCA : 0.7987012987012987<jupyter_text>E verdadero traabajo es saber cuando implementar un kernel para levantar a un espacio dimensional sueprior.  ¿Que es la regularización y cómo aplicarla? Esta técnica nos va a ayudar a cunado nuestros features nos botan de overfittin. La regularización consiste en disminuir la complijidad del modelo a través de una penalización aplciada a sus variables más irrelevantes.En la siguiente imagen, representan neustros datos.Los puntos rojos son nuestros datos de entrenamientoLos verdes son los datos de prueba.Sucede un overfitting. La regresión (línea rojo) es perfecta para los datos de entrenamiento, al medirlo respecto s los datos de prueba vamos a ver si tienen errores, y así será ya que los datos de entrenamiento son un data set mucho menor que los de prueba, y no representan toda la variedad allí afuera.La regularización introduce un poco de sesgo para reducir la vairanza de los datos. La varianza es la distancia de lso puntos rojos y verdes a la línea de regresión. Introducir un poco de sesgo hace qu enuestra nueva predicción no es ajustada a los datos de entrenameinto pero mejora el desempeño respecto a todos los datos. (Derecha)![regularizacion.png](./images/Regularización.PNG)* Para aplicar regularización necesitamos tener en cuenta el concepto de pérdida. Dice que tan lejso estamos del valro real del valro que queremos predecir, a menor pérdida mejro modelo. La pérdia tienede a disminuir y ajustar conforme a las iteraciones.* En el mundo real se comporta como la línea roja. La introducció de nuevos valores genera pérdida, y este valro será la regla base para el overfiting, para poder utilizar la regularización![perdida.on](./images/Perdida.PNG) Existen 3 tipso de regularización:1. L1- Lasso(Least Absolute Shrinkage and Selection Operator): Reducir la complejidad a través de la eliminación de features que no aportan demasiado al modelo. Una forma matemática de volver 0 os features que introducen ruido.Esta formula es la optimización de la regresión lineal a través del método de lso mínimos cuadrados.La primera sumatoria es la minimización,  el segundo término con término lmbda es la penalización lazo, beta es la pendiente,  lo que dice la segunda expresión es que penzalice lso datos cuya pendiente no varíe tanto. Penaliza con un valor absolto.![regularizacion.on](./images/Regularización-L1.PNG)2. L2- Ridge: Reducción la complejidad disminuyendo el impacto de ciertos features a nuestro modelo, no los veulve 0 pero los penaliza, los features siguen aportando información a largo plazo.  Es casi identica a Lasso, y penaliza la pendiente al cuadrado. Esta diferencia entre funcioens, en el moemnto de penzalizar la pendiente el componente cuadrático hace que no sea cero nunca en cada recursión siempre tendrá un valor.![regulariza.on](./images/Regularización-L2.PNG) LASSO VS RIDGE* No hay campeón absoluto definitivo para todos los problemas* Si hay pocos features que se relacionen directamente con la variable a predecir: PROBAR LASSO* Si hay varios features relaciones con la variable a predecir: PROBAR RIDGE3. ElasticNet: Es una combinación de las dos anteriores.  IMPLEMENTACIÓN DE TÉCNICA DE REGULARIZACIÓNUtilizaremos dos regresores (Scikitlearn) que integran modelo lineal con respectiva regularización.  Usando el data set de la felicidad exploraremos las relaciones de los features. Este data set nos intenta dar una varible continua para medir el índice de felicidad.<jupyter_code>from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Lasso
from sklearn.linear_model import Ridge

# Métricas y mediciones, y particiones de datasets
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error


dataset = pd.read_csv('./data/felicidad.csv')
dataset.describe()<jupyter_output><empty_output><jupyter_text>Dividiremos el data set en features y targets. Los features sepuede seleccionar de manera manual.<jupyter_code># Features
X = dataset[['gdp','family', 'lifexp', 'freedom', 'corruption', 'generosity', 'dystopia']]

# target
y = dataset[['score']]
X.shape
y.shape<jupyter_output><empty_output><jupyter_text>Ahora partiremos en training y test. Recordar el orden de traintest.<jupyter_code>X_train, X_test, y_train, y_test = train_test_split(X, y,test_size =0.25 )<jupyter_output><empty_output><jupyter_text>Comparación de lso 3 modelosPara este ejericio se escogió analziar la pérdida mediante error medio cuadrático, exsten diferentes formas de calcular la pérdiad y estos aportan difentes valores<jupyter_code># LINEAL


#Regresor lienar
modelLinear = LinearRegression().fit(X_train,y_train)

#Calculamso predicción de este modelo con los datos de test
y_predict_linear = modelLinear.predict(X_test)



# LASSO
#  alfa equinvaldrán  a lambda a  lo mismo, a mayor lambda mayor penzalizaión tendremos. en LASSO  RIDGE nos permite regular la penzalicación
modelLasso = Lasso(alpha=0.02).fit(X_train,y_train)

#Predicción para comprabar si fue mejro o peor que el modelo lineal
y_predict_lasso = modelLasso.predict(X_test)

# RIDGE

modelRidge = Ridge(alpha=1).fit(X_train,y_train)

# Prediccón
y_predict_ridge = modelRidge.predict(X_test)<jupyter_output><empty_output><jupyter_text>En esta línea compararemos los modelos y las pérdiads de cada uno<jupyter_code># Datos de prueba vs lo predicho
linear_loss = mean_squared_error(y_test, y_predict_linear)
mss_l =" Linear Loss: "+ str(linear_loss)
mss_l
lasso_loss = mean_squared_error(y_test, y_predict_lasso)
mss_lasso =" Lasso Loss: "+ str(lasso_loss)
mss_lasso
ridge_loss = mean_squared_error(y_test, y_predict_ridge)
mss_ridge =" Ridge Loss: "+ str(ridge_loss)
mss_ridge<jupyter_output><empty_output><jupyter_text>¿Como afecta los coeficientes cada una de las regresiones? Los coeficientes son los valores con los cuales opera nuestros features. En lasso verermos los ceros, y en ridge nunca será cero.<jupyter_code>modelLasso.coef_
modelRidge.coef_<jupyter_output><empty_output><jupyter_text>Explicación de la implementación* Menor perdida es mejor, en neustro caso la regresión ridge, no significa que la regularización 2 sea mejor, solo es para este data sets.* Los coeficioentes Corresponden a cada una de las columnas o features del data set que estamos evaluando. ```python"Lasso -> [1.32337717, 0.8196846 , 0.45499173, 0.83670887, 0..., 0.33457367, 0.90319282]) " ,"dataset-> ['gdp','family', 'lifexp', 'freedom', 'corruption', 'generosity', 'dystopia']"```Los número más grandes del array indica que esa columna tiene más peso. Por ejemplo en el coeficiente LASSO tiene más peso el indice percapita como muy importante, pero e índice de corrupción no lo encontró relevante...ironicamente.  Elastic NetBridna todo el espectro lineal posible. Si alfa es 0 se ocmporta como ridge si alfa es 1 se comporta coo lasso.Con esta técncia probamos ambas sin perder inforamción L1-L2.* Supera las limitacioens individuales de ellas* Si hace falta expereincia o el conocimiento matemático de fondo , puede ser la pcionón prefente para probar la  regualrización.<jupyter_code>from sklearn.linear_model import ElasticNet

# Se llama un constructor
modelElastic= ElasticNet(random_state=0, alpha=1)

# Se entrena el modelo
modelElastic.fit(X_train, y_train)

# Se hace la predicción con los datos de prueba
y_predic_elastic = modelElastic.predict(X_test)

# Se halla el error mediante cuadrados
elastic_loss = mean_squared_error(y_test, y_predic_elastic)
elastic_loss<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.06186291739894552, 'fraction_numerical': 0.011775043936731107, 'mean_word_length': 5.856024096385542, 'pattern_counts': {'":': 0, '<': 47, '<?xml version=': 0, '>': 49, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '353684', 'license': 'MIT', 'n_tokens_mistral': 3972, 'n_tokens_neox': 3825, 'n_words': 1383, 'path': 'NoteBooks/Curso de Scikit-learn/Jupyter Notes/Optimización de Features.ipynb', 'repo_name': 'Alejandro-sin/Learning_Notebooks', 'size': '11380'}