Este artículo fue publicado como parte del Blogatón de ciencia de datos.

Introducción

Los teléfonos móviles vienen en todo tipo de precios, características, especificaciones y todo. La estimación y predicción de precios es una parte importante de la estrategia del consumidor. Decidir el precio correcto de un producto es muy importante para el éxito de mercado de un producto. Un nuevo producto que se tiene que lanzar, debe tener el precio correcto para que los consumidores encuentren adecuado comprar el producto.

Imagen: https://www.pexels.com/photo/close-up-of-man-using-mobile-phone-248528/

 El problema

Los datos contienen información sobre las características, especificaciones, etc. del teléfono móvil y su rango de precios. Las diversas características e información se pueden utilizar para predecir el rango de precios de un teléfono móvil.

Las características de los datos son las siguientes:

1. Potencia de la batería en mAh

2. Tiene BlueTooth o no

3. Velocidad de reloj del microprocesador

4. El teléfono tiene soporte dual sim o no

5. Megapíxeles de la cámara frontal

6. Tiene soporte 4G o no

7. Memoria Interna en GigaBytes

8. Fondo Móvil en Cm

9. Peso del teléfono móvil

10. Número de núcleos en el procesador

11. Megapíxeles de la cámara principal

12. Altura de resolución de píxeles

13. Ancho de resolución de píxeles

14. RAM en MB

15. Altura de la pantalla del móvil en cm

16. Ancho de la pantalla del móvil en cm

17. Mayor tiempo después de una sola carga

18. 3g o no

19. Tiene pantalla táctil o no

20. Tiene wifi o no

Metodología

Procederemos con la lectura de los datos y luego realizaremos el análisis de datos. La práctica de examinar datos utilizando métodos analíticos o estadísticos para identificar información significativa se conoce como análisis de datos. Después del análisis de datos, descubriremos la distribución de datos y los tipos de datos. Entrenaremos 4 algoritmos de clasificación para predecir la salida. También compararemos las salidas. Comencemos con la implementación del proyecto.

Primero, importamos las bibliotecas.

importar numpy como np # álgebra lineal importar pandas como pd # procesamiento de datos, E/S de archivos CSV (por ejemplo, pd.read_csv) importar seaborn como sns importar matplotlib.pylab como plt %matplotlib en línea

Ahora, leemos los datos y vemos una descripción general de los datos.

train_data=pd.read_csv('/kaggle/input/mobile-price-classification/train.csv') train_data.head()

Salida:

Ahora, usaremos la función de información para ver el tipo de datos en el conjunto de datos.

train_data.info ()

Salida:

RangeIndex: 2000 entradas, 0 a 1999 Columnas de datos (total 21 columnas): # Columna Recuento no nulo Dtype --- ------ -------------- ---- - 0 battery_power 2000 no nulo int64 1 blue 2000 no nulo int64 2 clock_speed 2000 no nulo float64 3 dual_sim 2000 no nulo int64 4 fc 2000 no nulo int64 5 four_g 2000 no nulo int64 6 int_memory 2000 no nulo int64 7 m_dep 2000 no nulo float64 8 mobile_wt 2000 no nulo int64 9 n_cores 2000 no nulo int64 10 pc 2000 no nulo int64 11 px_height 2000 no nulo int64 12 px_width 2000 no nulo int64 13 ram 2000 no nulo int64 sc_h 14 no nulo int2000 64 sc_w 15 no nulo int2000 64 talk_time 16 no nulo int2000 64 three_g 17 no nulo int2000 64 touch_screen 18 no nulo int2000 64 wifi 19 no nulo int2000 64 precio_rango 20 no nulo tipos: float2000(64), int64(2) uso de memoria: 64 KB

Ahora, eliminamos los puntos de datos con datos faltantes.

tren_datos_f = tren_datos[tren_datos['sc_w'] != 0] tren_datos_f.forma

Salida:

(1820, 21)

Visualicemos el número de elementos en cada clase de teléfonos móviles.

#clases sns.set() price_plot=train_data_f['price_range'].value_counts().plot(kind='bar') plt.xlabel('price_range') plt.ylabel('Count') plt.show()

Salida:

Entonces, hay teléfonos móviles en 4 rangos de precios. El número de elementos es casi similar.

Distribución de datos

Analicemos algunas características de los datos y veamos su distribución.

En primer lugar, vemos cómo se reparten los mAh de la batería.

sns.set(rc={'figure.figsize':(5,5)}) ax=sns.displot(data=train_data_f["battery_power"]) plt.show()

Salida:

Ahora, vemos el recuento de cuántos dispositivos tienen Bluetooth y cuántos no.

sns.set(rc={'figure.figsize':(5,5)}) ax=sns.displot(data=train_data_f["blue"]) plt.show()

Salida:

Entonces, podemos ver que la mitad de los dispositivos tienen Bluetooth y la otra mitad no.

A continuación, analizamos la profundidad del móvil (en cm).

sns.set(rc={'figure.figsize':(5,5)}) ax=sns.displot(data=train_data_f["m_dep"]) plt.show()

Salida:

Algunos móviles son muy delgados y algunos tienen casi un cm de grosor.

De manera similar, la distribución de datos se puede analizar para todas las características de datos. Implementarlo será muy simple.

Veamos si faltan valores o datos.

X=train_data_f.drop(['price_range'], axis=1) y=train_data_f['price_range'] #valores perdidos X.isna().any()

Salida:

battery_power False blue False clock_speed False dual_sim False fc False four_g False int_memory False m_dep False mobile_wt False n_cores False pc False px_height False px_width False ram False sc_h False sc_w False talk_time False three_g False touch_screen False wifi False dtype: bool

Dividamos los datos.

#train prueba división de datos de sklearn.model_selection import train_test_split X_train, X_valid, y_train, y_valid= train_test_split(X, y, test_size=0.2, random_state=7)

Ahora, definimos una función para crear una matriz de confusión.

#matriz de confusión de sklearn.metrics import Classification_report, confusion_matrix, precision_score def my_confusion_matrix(y_test, y_pred, plt_title): cm=confusion_matrix(y_test, y_pred) print(classification_report(y_test, y_pred)) sns.heatmap(cm, annot=True, fmt='g', cbar=False, cmap='BuPu') plt.xlabel('Valores previstos') plt.ylabel('Valores reales') plt.title(plt_title) plt.show() return cm

Ahora que la función está definida, podemos proceder con la implementación de los algoritmos de clasificación.

Clasificador de bosque aleatorio

Un bosque aleatorio es un método de aprendizaje automático supervisado creado a partir de técnicas de árboles de decisión. Este algoritmo se utiliza para anticipar el comportamiento y los resultados en una variedad de sectores, incluidos la banca y el comercio electrónico.

Un bosque aleatorio es un enfoque de aprendizaje automático para resolver problemas de regresión y clasificación. Hace uso del aprendizaje conjunto, que es una técnica que combina múltiples clasificadores para resolver problemas complicados.

Un método de bosque aleatorio se compone de una gran cantidad de árboles de decisión. El 'bosque' del algoritmo de bosque aleatorio se entrena mediante embolsado o agregación de arranque. El embolsado es un conjunto de metaalgoritmos que aumenta la precisión de los algoritmos de aprendizaje automático.

El resultado está determinado por el algoritmo (bosque aleatorio) basado en las predicciones de los árboles de decisión. Pronostica promediando o promediando la salida de varios árboles. La precisión del resultado mejora a medida que crece el número de árboles.

Image Source: https://miro.medium.com/max/5752/1*5dq_1hnqkboZTcKFfwbO9A.png

Un sistema de bosque aleatorio se basa en una variedad de árboles de decisión. Cada árbol de decisión se compone de nodos que representan decisiones, nodos hoja y un nodo raíz. El nodo hoja de cada árbol representa el resultado final del árbol de decisión. El producto final se elige mediante un procedimiento de votación por mayoría. En esta situación, la salida seleccionada por la mayoría de los árboles de decisión se convierte en la salida final del sistema de bosque aleatorio. Ahora implementemos el algoritmo de bosque aleatorio.

Primero, construimos el modelo.

#construyendo el modelo desde sklearn.ensemble import RandomForestClassifier rfc=RandomForestClassifier(bootstrap= True, max_depth= ​​7, max_features= 15, min_samples_leaf= 3, min_samples_split= 10, n_estimators= 200, random_state=7)

Ahora, hacemos el entrenamiento y la predicción.

rfc.fit(X_tren, y_tren) y_pred_rfc=rfc.predict(X_valid)

Apliquemos la función para las métricas de precisión.

print('Puntuación de precisión del clasificador de bosque aleatorio: ',accuracy_score(y_valid,y_pred_rfc)) cm_rfc=my_confusion_matrix(y_valid, y_pred_rfc, 'Matriz de confusión de bosque aleatorio')

Salida:

Puntuación de precisión del Clasificador Forestal aleatorio: 0.9093406593406593 Recuerda de precisión Soporte de puntuación F1 0 0.98 0.97 0.97 95 1 0.90 0.92 0.91 92 2 0.82 0.86 0.84 86 3 0.93 0.88 0.90 91 Precisión 0.91 364 Macro AVG 0.91 0.91 0.91 364 Ponderado AVG 0.91 0.91 0.91 364

Entonces, podemos ver que el algoritmo de bosque aleatorio tiene una buena precisión en la predicción.

Bayes ingenuos

La probabilidad condicional es la base del teorema de Bayes. La probabilidad condicional nos ayuda a evaluar la probabilidad de que algo ocurra si algo más ha ocurrido previamente.

Imagen: Ilustración de cómo funciona un clasificador Gaussian Naive Bayes (GNB)

Fuente: https://www.researchgate.net/figure/Illustration-of-how-a-Gaussian-Naive-Bayes-GNB-classifier-works-For-each-data-point_fig8_255695722

Gaussian Naive Bayes es una variación de Naive Bayes que permite datos continuos y sigue la distribución normal de Gauss. El teorema de Bayes es la base de una familia de algoritmos de clasificación de aprendizaje automático supervisados ​​conocidos como naive Bayes. Es un enfoque de categorización básico con mucho poder. Cuando la dimensionalidad de las entradas es alta, son útiles. El clasificador Naive Bayes también se puede utilizar para resolver problemas de clasificación complejos.

Implementemos el clasificador Gaussiano NB.

de sklearn.naive_bayes importar GaussianNB gnb = GaussianNB()

Ahora, realizamos el entrenamiento y la predicción.

gnb.fit(X_tren, y_tren) y_pred_gnb=gnb.predict(X_valid)

Ahora, podemos comprobar la precisión.

print('Puntuación de precisión del clasificador de NB gaussiano: ',accuracy_score(y_valid,y_pred_gnb)) cm_rfc=my_confusion_matrix(y_valid, y_pred_gnb, 'Matriz de confusión de NB gaussiano')

Salida:

Puntuación de precisión del Clasificador Gaussian NB: 0.8461538461538461 Recuerda de precisión Puntuación F1 Soporte 0 0.93 0.92 0.92 95 1 0.79 0.73 0.76 92 2 0.74 0.80 0.77 86 3 0.92 0.93 0.93 91 Precisión 0.85 364 Macro AVG 0.84 0.85 0.84 364 Ponderado Avg 0.85 0.85 0.85 364

Podemos ver que el modelo está funcionando bien.

Clasificador KNN

El método K Nearest Neighbor es un tipo de técnica de aprendizaje supervisado que se utiliza para clasificación y regresión. Es un enfoque flexible que también se puede usar para completar los valores faltantes y volver a muestrear conjuntos de datos. K Vecino más cercano examina K Vecinos más cercanos (puntos de datos) para pronosticar la clase o el valor continuo para un nuevo punto de datos, como su nombre lo indica.

Imagen: https://blakelobato1.medium.com/k-nearest-neighbor-classifier-implement-homemade-class-compare-with-sklearn-import-6896f49b89e

El método K-NN guarda todos los datos disponibles y clasifica un nuevo punto de datos en función de su similitud con los datos existentes. Esto implica que los datos nuevos pueden clasificarse rápidamente en una categoría bien definida utilizando el método K-NN. El algoritmo K-NN es un algoritmo no paramétrico, lo que significa que no hace suposiciones sobre los datos subyacentes. También se conoce como algoritmo de aprendizaje perezoso, ya que no aprende del conjunto de entrenamiento de inmediato; en cambio, guarda el conjunto de datos y realiza una acción sobre él cuando llega el momento de clasificarlo.

Realicemos la implementación del clasificador.

from sklearn.neighbors import KNeighborsClassifier knn = KNeighborsClassifier(n_neighbors=3,leaf_size=25)

Ahora, entrenamos los datos y hacemos nuestras predicciones.

knn.fit(X_tren, y_tren) y_pred_knn=knn.predict(X_valid)

Ahora, comprobamos la precisión.

print('Puntuación de precisión del clasificador KNN: ',accuracy_score(y_valid,y_pred_knn)) cm_rfc=my_confusion_matrix(y_valid, y_pred_knn, 'KNN Confusion Matrix')

Salida:

Puntuación de precisión del clasificador: 0.9340659340659341 Recuerda de precisión Soporte de puntuación F1 0 0.99 0.98 0.98 95 1 0.93 0.97 0.95 92 2 0.87 0.88 0.88 86 3 Precisión 0.94 0.90 Macro AVG 0.92 91 0.93 364 Ponderado Avg 0.93 0.93 0.93 364

El clasificador KNN es bastante hábil en su tarea.

Clasificador SVM

Support Vector Machine, o SVM, es una técnica destacada de aprendizaje supervisado que se utiliza tanto para problemas de clasificación como de regresión. Sin embargo, se utiliza principalmente en el aprendizaje automático con fines de clasificación.

El propósito del algoritmo SVM es encontrar la línea óptima o el límite de decisión para categorizar el espacio n-dimensional para que podamos simplemente colocar puntos de datos nuevos en la categoría adecuada en el futuro. Un hiperplano es el límite de elección óptimo.

cheque así artículo para obtener más información sobre SVM.

Imagen: https://www.javatpoint.com/machine-learning-support-vector-machine-algorithm

Hagamos la implementación de SVM.

desde sklearn import svm svm_clf = svm.SVC(decision_function_shape='ovo')

svm_clf.fit(X_tren, y_tren) y_pred_svm=svm_clf.predict(X_valid)

Ahora, comprobamos la precisión.

print('Puntuación de precisión del clasificador SVM: ',accuracy_score(y_valid,y_pred_svm)) cm_rfc=my_confusion_matrix(y_valid, y_pred_svm, 'SVM Confusion Matrix')

Salida:

Puntuación de precisión del clasificador SVM: 0.9587912087912088 Recuerda de precisión Puntuación F1 Soporte 0 0.98 0.98 0.98 95 1 0.93 0.97 0.95 92 2 0.94 0.93 0.94 86 3 0.99 0.96 0.97 91 Precisión 0.96 364 Macro Avg 0.96 0.96 0.96 364 Ponderado AVG 0.96 0.96 0.96 364

Podemos ver que el clasificador SVM está dando la mejor precisión.

Enlace al código: https://www.kaggle.com/prateekmaj21/mobile-price-prediction

Conclusión

En este artículo, analizamos la clasificación. Los clasificadores representan la intersección de la teoría de máquinas avanzada y la aplicación práctica. Estos algoritmos son más que un simple mecanismo de clasificación para organizar instancias de datos sin etiquetar en agrupaciones distintas. Los clasificadores incluyen un conjunto único de reglas dinámicas que incluyen un mecanismo de interpretación para tratar con valores ambiguos o desconocidos, todos los cuales se adaptan al tipo de entradas que se analizan. La mayoría de los clasificadores también utilizan estimaciones de probabilidad, que permiten a los usuarios finales ajustar la categorización de datos mediante funciones de utilidad.

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor. 

Relacionado:

• Coinsmart. El mejor intercambio de Bitcoin y criptografía de Europa.
• Platoblockchain. Inteligencia del Metaverso Web3. Conocimiento amplificado. ACCESO LIBRE.
• CriptoHawk. Radar de altcoins. Prueba gratis.
• Fuente: https://www.analyticsvidhya.com/blog/2022/02/learn-mobile-price-prediction-through-four-classification-algorithms/