import pandas as pd
import matplotlib.pyplot as plt
from matplotlib import style
style.use("fivethirtyeight")
import numpy as np


data = np.array([[2.5,0.5,2.2,1.9,3.1,2.3,2,1,1.5,1.1],[2.4,0.7,2.9,2.2,3.0,2.7,1.6,1.1,1.6,0.9]])
print(data)
fig = plt.figure()
ax0 = fig.add_subplot(111)

ax0.scatter(data[0],data[1])

plt.show()

import pandas as pd
import matplotlib.pyplot as plt
from matplotlib import style
style.use("fivethirtyeight")
import numpy as np


data = np.array([[2.5,0.5,2.2,1.9,3.1,2.3,2,1,1.5,1.1],[2.4,0.7,2.9,2.2,3.0,2.7,1.6,1.1,1.6,0.9]])
print(data)
fig = plt.figure()
ax0 = fig.add_subplot(111)

ax0.scatter(data[0],data[1])
ax0.scatter(data[0],np.ones_like(data[1])*min(data[1])-0.2,color="red")
ax0.scatter(np.ones_like(data[0])*min(data[0])-0.2,data[1],color="blue")
ax0.arrow(min(data[0])-0.2,min(data[1])-0.2,0,max(data[1])-0.5,width=0.01,color="blue",alpha=0.4,length_includes_head="True")
ax0.arrow(min(data[0])-0.2,min(data[1])-0.2,max(data[0])-0.3,0,width=0.01,color="red",alpha=0.4,length_includes_head="True")
ax0.vlines(data[0],min(data[1])-0.2,data[1],colors="red",linestyles="--",linewidth=0.7)
ax0.hlines(data[1],min(data[0])-0.2,data[0],colors="blue",linestyles="--",linewidth=0.7)


plt.show()

import numpy as np
import pandas as pd
from ipywidgets import interact,interactive,fixed,interact_manual
import matplotlib.pyplot as plt
from matplotlib import style
from mpl_toolkits.mplot3d import Axes3D
style.use('fivethirtyeight')


def f(x,y):
    
    data = np.array([[2.5,0.5,2.2,1.9,3.1,2.3,2,1,1.5,1.1],[2.4,0.7,2.9,2.2,3.0,2.7,1.6,1.1,1.6,0.9]])
    data[0] = data[0]-np.mean(data[0])
    data[1] = data[1]-np.mean(data[1])
 
    # Create Axes

    fig = plt.figure(figsize=(10,10))
    ax0 = fig.add_subplot(121)
    ax0.set_aspect('equal')
    ax0.set_ylim(-2,2)
    ax0.set_xlim(-2,2)
    ax0.set_title('Search for Principal component',fontsize=14)
    ax0.set_xlabel('PC x value',fontsize=10)
    ax0.set_ylabel('PC y value',fontsize=10)
    



    #vec = np.array([0.6778734,0.73517866])
    vec = np.array([x,y])

    ax0.scatter(data[0],data[1])
    ax0.plot(np.linspace(min(data[0]),max(data[0])),(vec[1]/vec[0])*np.linspace(min(data[0]),max(data[0])),linewidth=1.5,color="black",linestyle="--")



    b_on_vec_list = [[],[]]
    for i in range(len(data[0])):
        a = vec
        b = np.array([data[0][i],data[1][i]])
        b_on_a = (np.dot(a,b)/np.dot(a,a))*a
        b_on_vec_list[0].append(b_on_a[0])
        b_on_vec_list[1].append(b_on_a[1])
        ax0.scatter(b_on_a[0],b_on_a[1],color='red')
        ax0.plot([b_on_a[0],b[0]],[b_on_a[1],b[1]],"r--",linewidth=1)


    ax1 = fig.add_subplot(122,projection='3d')
    ax1.set_aspect('equal')
    ax1.set_ylim(0,1)
    ax1.set_xlim(0,1)
    ax1.set_title('Varicane with respect to the 1. PC',fontsize=14)
    ax1.set_xlabel('PC x value',fontsize=10)
    ax1.set_ylabel('PC y value',fontsize=10)
    ax1.set_zlabel('variance',fontsize=10)

    

    # Transform data
    e_vec = (1/np.sqrt(np.dot(vec,vec.T)))*vec
    data_trans = np.dot(data.T,e_vec)
    
    # Plot the data
    ax0.scatter(data_trans,np.zeros_like(data_trans),c='None',edgecolor='black')
    # Plot the twisted line
    ax0.plot(np.linspace(min(data_trans),max(data_trans),10),np.zeros_like(data_trans),linestyle='--',color='grey',linewidth=1.5)
    # Plot the circles
    for i in range(len(data_trans)):
        ax0.add_artist(plt.Circle((0,0),data_trans[i],linewidth=0.5,linestyle='dashed',color='grey',fill=False))

    # Calculate the variance    
    ax0.text(0,-1.4,'variance= {0}'.format(str(np.round(np.var(data_trans),3))),fontsize=20)


    # Plot the variance with respect to the principal component vector

    # Initialize the meshgrid
    cross_x,cross_y =np.meshgrid(np.linspace(0.001,1,num=20),np.linspace(0.001,1,num=20))
    # Create the iterators in the format [(0.01,0.01),(0.01,0.0620),(0.01,0.114),...(0.0620,0.01),(0.0620,0.0620),(0.0620,0.1141),...(0.999,0.01),(0.999,0.0620),...(0.999,0.999)]
    x_y_pairs = []
    for i in range(len(cross_y)):
        x_y_pairs.append(list(zip(cross_x[i],cross_y[i])))
    flatten_x_y_pairs = [np.array(list(x_y)) for sublist in x_y_pairs for x_y in sublist]


    variances = []
    for i in flatten_x_y_pairs:
        e_vec = (1/np.sqrt(np.dot(i,i.T)))*i
        data_trans = np.dot(data.T,e_vec.T)
        variances.append(np.var(data_trans))

    
        
    index_of_max_variance = np.where(variances == max(variances))[0][0]
    # PLot the variance surface
    ax1.scatter(cross_x,cross_y,np.array(variances).reshape(20,20),alpha=0.8)


    # Mark the point with the highest variance
    vec_point = np.array([x,y])
    e_vec_point = (1/np.sqrt(np.dot(vec_point,vec_point.T)))*vec_point
    data_trans_point = np.dot(data.T,e_vec_point.T)
    ax1.scatter(x,y,np.var(data_trans_point)+0.01,color="orange",s=100)
    
    
    
    

    plt.show()
    
    
interact(f,x=(0.001,1,0.001),y=(0.001,1,0.001))

import numpy as np
data = np.array([[2.5,0.5,2.2,1.9,3.1,2.3,2,1,1.5,1.1],[2.4,0.7,2.9,2.2,3.0,2.7,1.6,1.1,1.6,0.9]])
ex = np.array([[1,0]])
ey = np.array([[0,1]])

print(data.shape)
print(ex.shape)

print(np.dot(data.T,ey.T)) #  As you can see this is exactly the y component (x dimension) of our dataset

import matplotlib.pyplot as plt
from matplotlib import style
style.use('fivethirtyeight')
import numpy as np
import matplotlib.patches as patches

def f(lamb):

    # Unit vectors
    e_x = np.array([1,0])
    e_y = np.array([0,1])


    # Area spanned by the unit vectors
    print(np.cross(e_x,e_y)) # Area spanned by the unit vectors == 1


    # Any 2D matrix A of the shape (A-lambda*I)
    A = np.array([[2-lamb,3],[3,0.5-lamb]])



    # Transform the unit vectors by the matrix A --> Unsurprisingly this is exactly the matrix A but otherwise the notation
    # of "the determinant describes the change of the area spanned by the unit vectors after trasnformation" makes no sense 

    # Plot the vectors
    fig = plt.figure(figsize=(10,10))
    ax0 = fig.add_subplot(111)
    ax0.set_xlim(-5,8)
    ax0.set_ylim(-5,8)
    ax0.set_aspect('equal')

    # Vector of matrix A
    ax0.arrow(0,0,A[0][0],A[0][1],color="red",linewidth=1,head_width=0.05) #First vector 
    ax0.arrow(0,0,A[1][0],A[1][1],color="blue",linewidth=1,head_width=0.05) # Second vector



    # Area spanned by the vectors**
    ax0.arrow(A[0][0],A[0][1],A[1][0],A[1][1],color="blue",linestyle='dashed',alpha=0.3,linewidth=1,head_width=0.05)
    ax0.arrow(A[1][0],A[1][1],A[0][0],A[0][1],color="red",linestyle='dashed',alpha=0.3,linewidth=1,head_width=0.05)
    ax0.add_patch(patches.Polygon(xy=[[0,0],[A[0][0],A[0][1]],[A[0][0]+A[1][0],A[0][1]+A[1][1]],[A[1][0],A[1][1]]],fill=True,alpha=0.1,color='yellow'))
    
    # Add text which shows the calculation of the determinant and the area
    ax0.text(3,-0,s=r'$determinant = a_{11}*a_{22}-a_{21}*a_{12}$'+'= {0}'.format(np.round(A[0][0]*A[1][1]-A[1][0]*A[0][1],3)))
    #ax0.text(3,-1,s='area = {0}'.format(np.round(np.cross(A.T[0],A.T[1]),3)))
    ax0.text(3,-0.5,s=r'$determinant$'+'= {0}*{1}-{2}*{3} = {4}'.format(A[0][0],A[1][1],A[1][0],A[0][1],np.round(A[0][0]*A[1][1]-A[1][0]*A[0][1],3)))
    ax0.text(3,-4,s='**Mind that in this case the value of the determinant \n and the area(cross product --> Yellow shaded) are the same \n since the area spanned by the unit vectors is 1',fontsize=8)
    
    
    # Plot the eigenvectors
    ax0.arrow(0,0,0.61505,-0.788491,color="black",linestyle='dashed',alpha=0.3,linewidth=1,head_width=0.05)
    ax0.arrow(0,0,0.78771,0.6159,color="black",linestyle='dashed',alpha=0.3,linewidth=1,head_width=0.05)
    
    # Caclulate (A-lambda I)*nu for different values of lambda using the found eigenvectors. The result must be
    # 0 when nu is perpendicular to (A-lambda I)
    # Mind that for the calculation of v1 and v2 we have to solve the linear system of equations (A-lambda I)*v=0
    # for v1 and v2   
    
    v1 = -3*(((-1+0.5*lamb)/(-9-2*lamb+lamb**2)))/(2-lamb)
    v2 = (-1+0.5*lamb)/(-9-2*lamb+lamb**2)
    v = np.array((1/np.sqrt(v1**2+v2**2))*np.array([v1,v2]))
    ax0.text(3,-1,s=r'$(A-$'+'{0}'.format(lamb)+r'$I)*\nu$'+'= {0}'.format(np.round(np.dot(A,v),3)))
    ax0.arrow(0,0,-v[0]*0.5,-v[1]*0.5,color="green",alpha=0.8,linewidth=1,head_width=0.05) # We draw the eigenvector for lambda
                                                                                        # Mind v[0]*0.5 and v[1]*0.5 --> The *0.5
                                                                                        # is solely done for visualization purposes
    
   
    
    
    
    
    plt.show()
    
interact(f,lamb=(-5,5,0.001))
 

import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.cross_validation import train_test_split
import matplotlib.pyplot as plt
from matplotlib import style
style.use('fivethirtyeight')
import pandas as pd


"""1. Collect the data"""

df = pd.read_table('data\Wine.txt',sep=',',names=['Alcohol','Malic_acid','Ash','Alcalinity of ash','Magnesium','Total phenols',
                                                 'Flavanoids','Nonflavanoid_phenols','Proanthocyanins','Color_intensity','Hue',
                                                 'OD280/OD315_of_diluted_wines','Proline'])

target = df.index


"""2. Normalize the data""" 


df = StandardScaler().fit_transform(df)



"""3. Calculate the covariance matrix"""        

COV = np.cov(df.T) # We have to transpose the data since the documentation of np.cov() sais 
                   # Each row of `m` represents a variable, and each column a single
                   # observation of all those variables 


"""4. Find the eigenvalues and eigenvectors of the covariance matrix""" 

eigval,eigvec = np.linalg.eig(COV)
print(np.cumsum([i*(100/sum(eigval)) for i in eigval])) # As you can see, the first two principal components contain 55% of
                                                        # the total variation while the first 8 PC contain 90%



"""5. Use the principal components to transform the data - Reduce the dimensionality of the data"""

# The wine dataset is 13 dimensional and we want to reduce the dimensionality to 2 dimensions 
# Therefore we use the two eigenvectors with the two largest eigenvalues and use this vectors 
# to transform the original dataset.
# We want to have 2 Dimensions hence the resulting dataset should be a 178x2 matrix.
# The original dataset is a 178x13 matrix and hence the "principal component matrix" must be of 
# shape 13*2 where the 2 columns contain the covariance eigenvectors with the two largest eigenvalues

PC = eigvec.T[0:2]



data_transformed = np.dot(df,PC.T) # We have to transpose PC because it is of the format 2x178


# Plot the data

fig = plt.figure(figsize=(10,10))
ax0 = fig.add_subplot(111)


ax0.scatter(data_transformed.T[0],data_transformed.T[1])
for l,c in zip((np.unique(target)),['red','green','blue']):
    ax0.scatter(data_transformed.T[0,target==l],data_transformed.T[1,target==l],c=c,label=l)

ax0.legend()



plt.show()

from sklearn.decomposition import PCA
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.cross_validation import train_test_split
import matplotlib.pyplot as plt
from matplotlib import style
style.use('fivethirtyeight')
import pandas as pd


"""1. Collect the data"""

df1 = pd.read_table('data\Wine.txt',sep=',',names=['Alcohol','Malic_acid','Ash','Alcalinity of ash','Magnesium','Total phenols',
                                                 'Flavanoids','Nonflavanoid_phenols','Proanthocyanins','Color_intensity','Hue',
                                                 'OD280/OD315_of_diluted_wines','Proline'])

target1 = df1.index


"""2. Normalize the data""" 


df1 = StandardScaler().fit_transform(df)


"""3. Use the PCA and reduce the dimensionality"""

PCA_model = PCA(n_components=2,random_state=42) # We reduce the dimensionality to two dimensions and set the
                                                            # random state to 42
data_transformed = PCA_model.fit_transform(df1,target)*(-1) # If we omit the -1 we get the exact same result but rotated by 180 degrees --> -1 on the y axis turns to 1.
                                                            # This is due to the definition of the vectors. We can define a vector a as [-1,-1] and as [1,1] 
                                                            # the lines spanned is the same --> remove the *(-1) and you will see

# Plot the data

fig = plt.figure(figsize=(10,10))
ax0 = fig.add_subplot(111)


ax0.scatter(data_transformed.T[0],data_transformed.T[1])
for l,c in zip((np.unique(target)),['red','green','blue']):
    ax0.scatter(data_transformed.T[0,target==l],data_transformed.T[1,target==l],c=c,label=l)

ax0.legend()



plt.show()