Spaces:
Sleeping
Sleeping
File size: 5,964 Bytes
51b4510 5ffb625 51b4510 8d89392 51b4510 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 |
import pandas as pd
data = pd.read_csv('train1.csv')
data.head()
data.corr()
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report, accuracy_score
import matplotlib.pyplot as plt
import seaborn as sns
# Split dataset into independent and dependent variables
X = data.drop('price_range', axis=1)
y = data['price_range']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
knn = KNeighborsClassifier(n_neighbors=5, metric = 'minkowski' , p=1)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
print("Accuracy:", accuracy_score(y_test, y_pred))
print("Classification Report:\n", classification_report(y_test, y_pred))
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns # Import seaborn for scatterplot
# Create a new data point
new_data_point = pd.DataFrame({
'battery_power': [1500],
'blue': [1],
'clock_speed': [2.5],
'dual_sim': [1],
'fc': [16],
'four_g': [1],
'int_memory': [32],
'm_dep': [0.5],
'mobile_wt': [150],
'n_cores': [8],
'pc': [20],
'px_height': [1080],
'px_width': [1920],
'ram': [4000],
'sc_h': [15],
'sc_w': [8],
'talk_time': [10],
'three_g': [1],
'touch_screen': [1],
'wifi': [1]
})
# Predict the price range for the new data point
predicted_price_range = knn.predict(new_data_point)
print("Predicted price range for the new data point:", predicted_price_range[0])
# Visualize the data (example with a scatter plot)
plt.figure(figsize=(10, 6))
sns.scatterplot(x='ram', y='battery_power', hue='price_range', data=data)
plt.title('Mobile Phone Price Range')
plt.xlabel('RAM')
plt.ylabel('Battery Power')
plt.show()
# **KMeans**
from sklearn.cluster import KMeans
from sklearn.metrics import adjusted_rand_score, confusion_matrix
kmeans = KMeans(n_clusters=4, random_state=42)
kmeans.fit(X)
#Predict cluster assignments
cluster_labels = kmeans.labels_
#Evaluate the clustering performance by comparing clusters with actual price_range labels
# We use Adjusted Rand Index (ARI) and a confusion matrix for evaluation
ari = adjusted_rand_score(y, cluster_labels)
print(f"Adjusted Rand Index (ARI): {ari}")
conf_matrix = confusion_matrix(y, cluster_labels)
# Visualize the confusion matrix
plt.figure(figsize=(8, 6))
sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Blues", xticklabels=range(4), yticklabels=range(4))
plt.xlabel("Cluster Labels")
plt.ylabel("Actual Price Range")
plt.title("Confusion Matrix: K-Means Clustering vs Actual Price Range")
plt.show()
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)
plt.figure(figsize=(8, 6))
sns.scatterplot(x=X_pca[:, 0], y=X_pca[:, 1], hue=cluster_labels, palette="Set1", s=100, edgecolor="k")
plt.title("K-Means Clusters Visualization (2D PCA Projection)")
plt.xlabel("PCA Component 1")
plt.ylabel("PCA Component 2")
plt.show()
# prompt: adjusted_rand_score
from sklearn.metrics import adjusted_rand_score
# Assuming 'y' is the true labels and 'cluster_labels' are the predicted cluster assignments
ari = adjusted_rand_score(y, cluster_labels)
print(f"Adjusted Rand Index (ARI): {ari}")
# Define the prediction function
def predict_price_range(battery_power, blue, clock_speed, dual_sim, fc, four_g, int_memory, m_dep, mobile_wt, n_cores, pc, px_height, px_width, ram, sc_h, sc_w, talk_time, three_g, touch_screen, wifi):
new_data_point = pd.DataFrame({
'battery_power': [battery_power],
'blue': [blue],
'clock_speed': [clock_speed],
'dual_sim': [dual_sim],
'fc': [fc],
'four_g': [four_g],
'int_memory': [int_memory],
'm_dep': [m_dep],
'mobile_wt': [mobile_wt],
'n_cores': [n_cores],
'pc': [pc],
'px_height': [px_height],
'px_width': [px_width],
'ram': [ram],
'sc_h': [sc_h],
'sc_w': [sc_w],
'talk_time': [talk_time],
'three_g': [three_g],
'touch_screen': [touch_screen],
'wifi': [wifi]
})
prediction = knn.predict(new_data_point)
return f"Predicted price range: {prediction[0]}"
# Create the Gradio interface
import gradio as gr
interface = gr.Interface(
fn=predict_price_range,
inputs=[
gr.Slider(minimum=0, maximum=3000, step=1, label="Battery Power"),
gr.Checkbox(label="Bluetooth"),
gr.Slider(minimum=0, maximum=3.0, step=0.1, label="Clock Speed (GHz)"),
gr.Checkbox(label="Dual SIM"),
gr.Slider(minimum=0, maximum=50, step=1, label="Front Camera (MP)"),
gr.Checkbox(label="4G"),
gr.Slider(minimum=0, maximum=256, step=1, label="Internal Memory (GB)"),
gr.Slider(minimum=0, maximum=1, step=0.1, label="Mobile Depth (cm)"),
gr.Slider(minimum=100, maximum=3000, step=1, label="Mobile Weight (g)"),
gr.Slider(minimum=1, maximum=8, step=1, label="Number of Cores"),
gr.Slider(minimum=0, maximum=100, step=1, label="PC"),
gr.Slider(minimum=0, maximum=4000, step=1, label="Pixel Height"),
gr.Slider(minimum=0, maximum=4000, step=1, label="Pixel Width"),
gr.Slider(minimum=0, maximum=8000, step=1, label="RAM (MB)"),
gr.Slider(minimum=0, maximum=20, step=1, label="Screen Height (cm)"),
gr.Slider(minimum=0, maximum=20, step=1, label="Screen Width (cm)"),
gr.Slider(minimum=0, maximum=100, step=1, label="Talk Time (hours)"),
gr.Checkbox(label="3G"),
gr.Checkbox(label="Touch Screen"),
gr.Checkbox(label="WiFi")
],
outputs="text",
title="Mobile Price Range Predictor",
description="Enter the features of a mobile phone to predict its price range."
)
if __name__ == "__main__":
interface.launch()
|