<jupyter_start><jupyter_text>Ejercicio k-Nearest Neighbor App ReviewsEn este ejercicio vas a trabajar con una base de datos de reviews de una aplicación. Entre los datos podemos encontrar el texto de la review, las estrellas, así como el sentimiento del comentario (si es algo bueno o malo).El objetivo es montar un algoritmo de clasificación que prediga el rating, en función del sentimiento del comentario y la cantidad de palabras empleadas en el mismo. Para ello tendrás que utilizar un algoritmo de tipo KNN.  Importamos las librerías que vamos a utilizar<jupyter_code>import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

from matplotlib.colors import ListedColormap
import matplotlib.patches as mpatches
import seaborn as sns

%matplotlib inline
plt.rcParams['figure.figsize'] = (16, 9)
plt.style.use('ggplot')

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix<jupyter_output><empty_output><jupyter_text>Leemos nuestro archivo de entrada<jupyter_code>dataframe = pd.read_csv(r"data/reviews_sentiment.csv", sep=";")
dataframe.head(10)
dataframe.describe()
dataframe.hist()
print(dataframe.groupby('Star Rating').size())
sns.catplot(x='Star Rating',data=dataframe,kind="count", aspect=3) # relación de aspecto
sns.catplot(x='wordcount',data=dataframe,kind="count", aspect=3) # relación de aspecto<jupyter_output><empty_output><jupyter_text>Para facilitar el ejercicio, las columnas que utilizaremos serán: wordcount con la cantidad de palabras utilizadas y sentimentValue con un valor entre -4 y 4 que indica si el comentario fue valorado como positivo o negativo Nuestras etiquetas, serán las estrellas que dieron los usuarios a la app, que son valores discretos del 1 al 5  Rápidas visualizaciones y análisis  Preparamos el dataset<jupyter_code>X = dataframe[['wordcount', 'sentimentValue']].values
y = dataframe['Star Rating'].values

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state =0)
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)<jupyter_output><empty_output><jupyter_text>Creamos el Modelo<jupyter_code>n_neighbors = 7

knn = KNeighborsClassifier(n_neighbors)
knn.fit(X_train, y_train)

print('Accuracy of K-NN classifier on training set: {:.2f}'
     .format(knn.score(X_train, y_train)))
print('Accuracy of K-NN classifier on test set: {:.2f}'
     .format(knn.score(X_test, y_test)))<jupyter_output>Accuracy of K-NN classifier on training set: 0.90
Accuracy of K-NN classifier on test set: 0.86<jupyter_text>Resultados obtenidos<jupyter_code>pred = knn.predict(X_test)
print(confusion_matrix(y_test, pred))
print(classification_report(y_test, pred))
h = .02  # step size in the mesh

# Create color maps
cmap_light = ListedColormap(['#FFAAAA', '#ffcc99', '#ffffb3','#b3ffff','#c2f0c2'])
cmap_bold = ListedColormap(['#FF0000', '#ff9933','#FFFF00','#00ffff','#00FF00'])

# we create an instance of Neighbours Classifier and fit the data.
clf = KNeighborsClassifier(n_neighbors, weights='distance')
clf.fit(X, y)

# Plot the decision boundary. For that, we will assign a color to each
# point in the mesh [x_min, x_max]x[y_min, y_max].
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1 # columna 0 en x, resto y sumo 1 para verlo mejor (más margen)
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1 # columna 1 en y, resto y sumo 1 para verlo mejor (más margen)
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) # predice dos columnas que tienen todas las combinaciones x-y
# Put the result into a color plot
Z = Z.reshape(xx.shape)
plt.figure()
plt.pcolormesh(xx, yy, Z, cmap=cmap_light)

# Plot also the training points
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap_bold,
                edgecolor='k', s=20)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())

patch0 = mpatches.Patch(color='#FF0000', label='1')
patch1 = mpatches.Patch(color='#ff9933', label='2')
patch2 = mpatches.Patch(color='#FFFF00', label='3')
patch3 = mpatches.Patch(color='#00ffff', label='4')
patch4 = mpatches.Patch(color='#00FF00', label='5')
plt.legend(handles=[patch0, patch1, patch2, patch3,patch4])

    
plt.title("5-Class classification (k = %i, weights = '%s')"
              % (n_neighbors, 'distance'))

plt.show()<jupyter_output>C:\Users\Admin\AppData\Roaming\Python\Python37\site-packages\ipykernel_launcher.py:21: MatplotlibDeprecationWarning: Auto-removal of grids by pcolor() and pcolormesh() is deprecated since 3.5 and will be removed two minor releases later; please call grid(False) first.<jupyter_text>¿Cómo obtener el mejor valor de k?<jupyter_code>k_range = range(1,20,2)
scores = []
for k in k_range:
    knn = KNeighborsClassifier(n_neighbors= k)
    knn.fit(X_train, y_train)
    scores.append(knn.score(X_test, y_test))

plt.figure()
plt.xlabel('k')
plt.ylabel('accuracy')
plt.scatter(k_range, scores)
plt.xticks([0,5,10,15,20])<jupyter_output><empty_output><jupyter_text>PrediccionesEjemplo: supongamos que nos llega una review de 5 palabras y sentimiento 1<jupyter_code>nuevo_transformado = scaler.transform([[5, 1.0]]) # word count, sentiment value
print(clf.predict(nuevo_transformado))
print(clf.predict_proba(scaler.transform([[5,1.0]])))
knn = KNeighborsClassifier(n_neighbors= 7)
knn.fit(X_train, y_train)
print(knn.predict(nuevo_transformado))
print(knn.predict_proba(nuevo_transformado))
clf
knn.weights<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12128146453089245, 'fraction_numerical': 0.021299067065657453, 'mean_word_length': 6.014814814814815, 'pattern_counts': {'":': 0, '<': 27, '<?xml version=': 0, '>': 27, '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': '7', 'dir': 'jupyter-structured-clean-dedup', 'id': '422171', 'license': 'MIT', 'n_tokens_mistral': 2180, 'n_tokens_neox': 2083, 'n_words': 543, 'path': '4-Machine_Learning/1-Supervisado/6-KNN/Ejercicio_k-NearestNeighbor.ipynb', 'repo_name': 'erfederuiz/thebridge_ft_nov21', 'size': '5681'}