from sklearn.cluster import KMeans
import pandas as pd

from matplotlib import pyplot as plt
%matplotlib inline

data = pd.read_csv("salary_nba.csv")
data

plt.scatter(data.Age,data['Salary'])

plt.xlabel('Age')
plt.ylabel('Salary')

km = KMeans(n_clusters=3)
y_predicted = km.fit_predict(data[['Age','Salary']])
y_predicted

array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 1, 2, 2, 2, 2], dtype=int32)

data['cluster']=y_predicted
data.head()

## Location of "Cluster Centers (x,y)"
kmeans.cluster_centers_

data1 = data[data.cluster==0]
data2 = data[data.cluster==1]
data3 = data[data.cluster==2]
plt.scatter(data1.Age,data1['Salary'],color='blue')
plt.scatter(data2.Age,data2['Salary'],color='orange')
plt.scatter(data3.Age,data3['Salary'],color='green')
plt.scatter(kmeans.cluster_centers_[:,0],kmeans.cluster_centers_[:,1],color='purple',marker='*',label='centroid')
plt.xlabel('Age')
plt.ylabel('Salary')
plt.legend()

sse = []
k_range = range(1,10)
for k in k_range:
    km = KMeans(n_clusters=k)
    km.fit(data[['Age','Salary']])
    sse.append(km.inertia_)

## label and plot the Elbow Graph
plt.xlabel('K')
plt.ylabel('Sum of squared error')
plt.plot(k_range,sse)

data = pd.read_csv('top_50_NBA.csv')

kmeans = KMeans(n_clusters = 4, random_state = 98)

x = np.column_stack((data['PTS'], data['USG%']))

## Fit to our Kmeans
kmeans.fit(x)

y_kmeans = kmeans.predict(x)

for i, j in zip(df_counting['Player'], y_kmeans):
    print(i, j)

James Harden 2
Paul George 1
Giannis Antetokounmpo 1
Joel Embiid 1
Stephen Curry 1
Kawhi Leonard 1
Devin Booker 1
Kevin Durant 1
Damian Lillard 1
Bradley Beal 1
Kemba Walker 1
Blake Griffin 1
Karl-Anthony Towns 1
Kyrie Irving 1
Donovan Mitchell 1
Zach LaVine 1
Russell Westbrook 1
Klay Thompson 3
Julius Randle 3
LaMarcus Aldridge 3
Jrue Holiday 3
DeMar DeRozan 3
Luka Doncic 3
Mike Conley 3
DAngelo Russell 3
CJ McCollum 3
Nikola Vucevic 3
Buddy Hield 3
Nikola Jokic 3
Tobias Harris 0
Lou Williams 3
Danilo Gallinari 0
John Collins 0
Trae Young 3
Jimmy Butler 0
Kyle Kuzma 0
Khris Middleton 0
Jamal Murray 0
Andrew Wiggins 0
J.J. Redick 0
Tim Hardaway 0
Bojan Bogdanovic 0
Andre Drummond 0
DeAaron Fox 0
Ben Simmons 0
Pascal Siakam 0
Spencer Dinwiddie 0
Jordan Clarkson 3
Collin Sexton 0
Clint Capela 0

points_usage_clustered, ax = plt.subplots()

# List of the 4 Clusters

cluster_1 = []
cluster_2 = []
cluster_3 = []
cluster_4 = []

# Add Cluster to each desinated cluster list above
for i in range(len(y_kmeans)):
    if(y_kmeans[i] == 0):
        cluster_1.append(x[i])
    elif(y_kmeans[i] == 1):
        cluster_2.append(x[i])
    elif(y_kmeans[i] == 2):
        cluster_3.append(x[i])
    elif(y_kmeans[i] == 3):
        cluster_4.append(x[i])
        
# vstack stacks things refer to numpy doc --> https://numpy.org/doc/stable/reference/generated/numpy.vstack.html

#vstacks is an array so array([[21.5, 25.6],[points, usage(%)],..])

cluster_1 = np.vstack(cluster_1)
cluster_2 = np.vstack(cluster_2)
cluster_3 = np.vstack(cluster_3)
cluster_4 = np.vstack(cluster_4)


# ax.scatter(x,y, label = 'name of what were plotting', s = size )
ax.scatter(cluster_1[:, 0], cluster_1[:, 1], label = "Cluster 1 (Bottom Top 50)")
ax.scatter(cluster_2[:, 0], cluster_2[:, 1], label = "Cluster 2 (Top Scorers in NBA)")
ax.scatter(cluster_3[:, 0], cluster_3[:, 1], label = "Cluster 3 (James Freaking Harden)")
ax.scatter(cluster_4[:, 0], cluster_4[:, 1], label = "Cluster 4 (Middle Top 50 Scorers) ")

## Heres the centroids! array([[20.56666667, 27.84666667], [x,y],..]) 
centers = kmeans.cluster_centers_

## Now we can plot the centroids (4 of them)
ax.scatter(centers[:, 0], centers[:, 1], c = 'black', s = 200, alpha = .5, label = 'Cluster Center')

# lets plot the Legend, which will include the labels for each of our 4 clusters above
ax.legend(loc ='best', prop = {'size': 8})

## Labeling the x-axis and y-axis
ax.set_xlabel('Points Per Game')
ax.set_ylabel('Usage (%)')

## Naming our Scattered Plot!!!!
points_usage_clustered.suptitle("Clustered Points and Usage")

plt.show()

import pandas as pd

data = pd.read_csv('diabetes.csv',header='infer')
data.head()

Y = (data['class'] == 'tested_positive')*1
X = data.drop('class',axis=1)

from sklearn import cluster, metrics

## group into 2 clusters tested positive and tested negative
k_means = cluster.KMeans(n_clusters = 2)
# Fit
k_means.fit(X)

metrics.confusion_matrix(Y,k_means.labels_)

array([[421,  79],
       [182,  86]])

metrics.adjusted_rand_score(Y,k_means.labels_)

import pandas as pd

data = pd.read_csv('animals.csv')
names = data['Name']
Y = data['Class']
## Drop Name Column and Class (predictor) Column
X = data.drop(['Name','Class'],axis=1)
data

import numpy as np
# convert X to a matrix using nunpy
X.to_numpy()
X

array([[1, 0, 1, 0, 0, 0, 1, 0],
       [0, 1, 0, 1, 0, 0, 0, 1],
       [0, 1, 0, 1, 1, 0, 0, 1],
       [1, 0, 1, 0, 1, 0, 0, 0],
       [0, 1, 0, 1, 1, 0, 1, 0],
       [0, 1, 0, 1, 0, 0, 1, 1],
       [1, 0, 1, 0, 0, 1, 1, 0],
       [1, 0, 0, 1, 0, 1, 1, 0],
       [1, 0, 1, 0, 0, 0, 1, 0],
       [0, 1, 1, 0, 1, 0, 0, 1],
       [0, 1, 0, 1, 1, 0, 1, 1],
       [1, 0, 0, 1, 1, 0, 1, 0],
       [1, 0, 1, 0, 0, 0, 1, 0],
       [0, 1, 0, 1, 1, 0, 0, 1],
       [0, 1, 0, 1, 1, 0, 1, 0],
       [0, 1, 0, 1, 1, 0, 1, 1]])

from scipy.cluster import hierarchy
import matplotlib.pyplot as plt

%matplotlib inline
from pandas import Series
import numpy as np

Z = hierarchy.linkage(X.to_numpy(), 'complete')

dn = hierarchy.dendrogram(Z,labels=names.tolist(),orientation='left')

Z = hierarchy.linkage(X.to_numpy(), 'complete')
labels = hierarchy.fcluster(Z, t = 1.1)
labels

array([1, 4, 5, 2, 3, 4, 1, 1, 1, 2, 6, 1, 1, 5, 3, 6], dtype=int32)

Y

0        mammal
1       reptile
2          fish
3        mammal
4     amphibian
5       reptile
6        mammal
7          bird
8        mammal
9          fish
10      reptile
11         bird
12       mammal
13         fish
14    amphibian
15      reptile
Name: Class, dtype: object

metrics.adjusted_rand_score(Y,labels)

Z = hierarchy.linkage(X.to_numpy(), 'complete')
labels = hierarchy.fcluster(Z, t=1)
labels

array([1, 5, 6, 3, 4, 5, 1, 2, 1, 3, 7, 2, 1, 6, 4, 7], dtype=int32)

metrics.adjusted_rand_score(Y,labels)

import pandas as pd

data = pd.read_csv('traffic.csv')
data.head()

X = data.dropt('data', axis = 1 )
y = data['class']
y = y.map({'none': 0, 'afternoon': 1, 'evening': 2})

X = X.drop('class',axis=1)
X.head()

mean_value = X.mean()
X = X.fillna(mean_value)
X.head()

from sklearn import cluster

k_means = cluster.KMeans(n_clusters=3)
k_means.fit(X) 
values = k_means.cluster_centers_
labels = k_means.labels_

from sklearn import metrics

metrics.confusion_matrix(y, k_means.labels_)

array([[ 0, 71, 23],
       [ 0,  4, 19],
       [36, 13,  9]])

metrics.adjusted_rand_score(y,k_means.labels_)

0.3557396125157386

import matplotlib.pyplot as plt
%matplotlib inline

plt.plot(k_means.cluster_centers_.T)
plt.legend(['Cluster 0','Cluster 1','Cluster 2'])

import pandas as pd
import matplotlib

%matplotlib inline

data = pd.read_csv("2d_data.csv", header= None, names = ['x1','x2'])

#plot scatter graph
data.plot.scatter(x=0,y=1, label = 'data', color = 'green' )
data.head()

from sklearn import cluster
import numpy as np

def bisect(data, k, seed = 1):
    labels = pd.Series(np.zeros(data.shape[0]))
    
    SSE = []
    k_means = cluster.KMeans(n_clusters=1, random_state=seed)
    k_means.fit(data)
    SSE.append(k_means.inertia_)
    print('Iteration 0  SSE =', SSE)
    
    clusterID = [np.arange(0,data.shape[0]).tolist()]

    for numClusters in np.arange(1,k): 
        s_data = data.iloc[clusterID[SSE.index(max(SSE))]]
        k_means = cluster.KMeans(n_clusters=2, random_state=seed)
        k_means.fit(s_data)

        label = [[],[]]

        for i in range(0, s_data.shape[0]):
            if k_means.labels_[i]==0:  
                label[0].append(clusterID[SSE.index(max(SSE))][i])
            elif k_means.labels_[i]==1: 
                label[1].append(clusterID[SSE.index(max(SSE))][i])

        for j in range(0, 2):
            if j == 0:
                labels[label[j]] = labels[label[j][0]]
            elif j == 1:
                labels[label[j]] = numClusters
            clusterID.append(label[j])
            SSE.append(((s_data[k_means.labels_==j]-k_means.cluster_centers_[j])**2).sum().sum())
        
        clusterID.pop(SSE.index(max(SSE)))
        SSE.pop(SSE.index(max(SSE)))

        print('Iteration', numClusters, ' SSE =', SSE)

    return labels

data['labels'] = bisect(data, 8, 1)
data.plot.scatter(x='x1',y='x2',c='labels',colormap='jet')

import pandas as p

data = p.read_csv('train.csv')
data.head()

data = data.drop('date',axis=1)
Y = data['Occupancy']
X = data.drop('Occupancy',axis=1)

import numpy as np
from sklearn import tree
from sklearn.metrics import accuracy_score
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt
%matplotlib inline

maxdepths = [1, 5, 10, 50, 100]
treeAcc = []

for depth in maxdepths:
    clf = tree.DecisionTreeClassifier(max_depth=depth)
    scores = cross_val_score(clf, X, Y, cv=5)
    treeAcc.append(scores.mean())

plt.plot(maxdepths, treeAcc, 'ro-')
plt.xlabel('Maximum depth')
plt.ylabel('Accuracy')

from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
%matplotlib inline

numNeighbors = [1, 5, 10, 15, 20, 25, 30]
knn_acc = []

for nn in numNeighbors:
    clf = KNeighborsClassifier(n_neighbors=nn)
    scores = cross_val_score(clf, X, Y, cv=5)
    knn_acc.append(scores.mean())
    
plt.plot(numNeighbors, knn_acc, 'ro-', color = 'blue')
plt.xlabel('Number of neighbors')
plt.ylabel('Accuracy')

from sklearn import linear_model

regularizers = [0.001, 0.01, 0.1, 0.5, 1]
logistic_acc = []
for C in regularizers:
    clf = linear_model.LogisticRegression(C=C)
    scores = cross_val_score(clf, X, Y, cv=5)
    logistic_acc.append(scores.mean())
print(logistic_acc)

plt.plot(regularizers, logistic_acc, 'ro-')
plt.xlabel('Regularizer')
plt.ylabel('Accuracy')

data = p.read_csv('test.csv',header='infer')
data = data.drop('date',axis=1)
Y_test = data['Occupancy']
X_test = data.drop('Occupancy',axis=1)

from sklearn import tree
from sklearn.metrics import accuracy_score

bestdepth = 5
clf = tree.DecisionTreeClassifier(max_depth=bestdepth)
clf = clf.fit(X, Y)
Ypred = clf.predict(X_test)
tree_acc = accuracy_score(Y_test, Ypred)

bestNN = 5
clf = KNeighborsClassifier(n_neighbors=nn)
clf = clf.fit(X, Y)
Ypred = clf.predict(X_test)
knn_acc = accuracy_score(Y_test, Ypred)

bestC = 1
clf = linear_model.LogisticRegression(C=bestC)
clf = clf.fit(X, Y)
Ypred = clf.predict(X_test)
logistic_acc = accuracy_score(Y_test, Ypred)

methods = ['Dtree', 'KNN', 'Logistic']
plt.bar([1,2,3], [tree_acc, knn_acc, logistic_acc])
plt.xticks([1.5,2.5,3.5], methods)
plt.ylim(0.9,1.0)

import pandas as pd

data = pd.read_csv("PRSA_data.csv")
data.head()

data = data.drop('No', 1)
data = data.drop('cbwd', 1)
data = data.drop('year', 1)

# Drop any columns with missing values
data = data.dropna()
data.head()

Y = pd.DataFrame(data['pm2.5'])
X = pd.DataFrame(data.drop('pm2.5',1))
X.head()

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split( X,Y,test_size =0.3, random_state=1)

from sklearn import linear_model
from sklearn.metrics import mean_squared_error, r2_score
import matplotlib.pyplot as plt
import numpy as np

# Create linear regression object
regr = linear_model.LinearRegression()

# Fit regression model to the training set
regr.fit(X_train, y_train)

# Apply model to the test set
y_pred_test = regr.predict(X_test)


# Evaluate the results

print("Root mean squared error = %.4f" % np.sqrt(mean_squared_error(y_test, y_pred_test)))
print("R-square = %.4f" % r2_score(y_test, y_pred_test))
print('Slope Coefficients:', regr.coef_ )
print('Intercept:', regr.intercept_)

plt.scatter(y_test, y_pred_test)