Misc Notes On Machine Learning

Cost Function: J(θ)
Partial derivative of cost function for each theta parameter: dJ/dt0, dJ/dt1, etc.

function [jVal, gradient] = costFunction(theta)
    jVal = [...code to compute J(theta)...];
    gradient = [...code to compute derivative of J(theta)...];
end

options = optimset('GradObj', 'on', 'MaxIter', 100);
initialTheta = zeros(2,1);
[optTheta, functionVal, exitFlag] = fminunc(@costFunction, initialTheta, options);

y∈ {0,1...n}
h0(x) =  P(y=0|x;θ)
h1(x) =  P(y=1|x;θ) 
....
prediction = max(hθ(x))

J(θ) = (−1/m)  Sum ( (y(i) * log(hθ(x(i))))  +  (1−y(i)) * log(1−hθ(x(i))) ) + ( lambda / (2m) ) sum(square(theta_parameters))

Gradient: 

∂J(θ) / ∂θj = ( 1/m) * Sum( (hθ(x(i))−y(i)) * x(i) )   +  (lambda/m) * θj   % Correction only for j > 0
          in other words ...
dJ/dtj = (1/m) * Sum ( distance * xj ) + lambda_correction  ;   // xj = jth feature in each input entry

n0 = Number of input features (tuple size for each x). Let this be 3.
n1 = Hidden layer size. i.e. activation units.   Let this be 4.
n2 = Output layer size. i.e. activation unit. Let this be 1 as we consider binary classification.

W1 = Weight matrix for layer 1. This is 4x3. Every row in W matrix represents activation unit. Every column associated feature weight.
     W(i,j) represents the weight the activation unit i assigns for the j'th feature in x.

W2 = Weight matrix for layer 2. This is 1x4. i.e. Number of activation units here is just 1. 
     The input feature size of layer n is the units size of layer (n-1).

b1 = Constant bias introduced in Layer 1.  Size is  3x1. Each activation unit introduces different bias.
b2 = Constant bias introduced in Layer 2.  Size is  1x1. 

Z1 = W1 * X + b1           // This is Linear output result for Layer 1. Result is 4x1 values.
A1 = g(Z1) = sigmoid(Z1)   // This is non-Linear output result for Layer 1. 4x1 size.
                           // If the relation is all linear, you can have g = Identity function.
                           // Otherwise this maps (-inf, +inf) to (0, 1).

Z2 = W2 * A1 + b2          // Linear output for output layer 2. Result size is: 1x1
A2 = g(Z2) = sigmoid(Z2)   // Logistic non-linear output. Result size is: 1x1

Note: There is no W0, b0.

Total Cost of this neural network:  J(W1, W2, b1, b2) = Sum( Cost(y, expected-y) )

If we randomly initialize W, b then we can move W's and b's towards optimal direction.

The equation is partially differentiable Computing partial derivatives is cheap ... otherwise,
we may still be able to calculate it manually, keeping all factors same except varying one factor.

Let us use the notation:

dW[i] =  dJ/dWi     : Partial derivative of Cost function wrt weights for layer i. 
                      Note: Actual partial derivative is calculated for each weight in that weight matrix.

db[i] =  dJ/dbi     : Partial derivative wrt bias parameters of layer i.

Algorithm:

Repeat until cost difference converges :

    Compute predicted values: y1 ... ym
    This involves forward propagation and computing Z's and A's.

    For the given W, b:

    Compute values for dW[2] and db[2] i.e. for Layer 2.
    This is where backpropagation comes.

    W2 = W2 - alpha * dW[2];   // Adjust the weights for Layer 2.
    b2 = b2 - alpha * db[2];   // Adjust biases for Layer 2.

    // Computing of dW2 is quite involved, some high level details is given below ...
    dZ2 = A2 - Y  // Y is expected values
    dW2 = 1/m * dZ2 * A1' // A1' = Transpose of previous layer output
    db2 = 1/m * np.sum(dZ2, axis=1, keepdims=1)


    Compute values for dW[1] and db[1] i.e. for Layer 1.

    W1 = W1 - alpha * dW[1];   // Adjust the weights for Layer 1.
    b1 = b1 - alpha * db[1];   // Adjust biases for Layer 1.

    // Like before computation is involved.
    dZ1 = (W2' * dZ2) .*  sigmoid(z1) // elementwise product  
    dW1 = 1/m * dZ1. X'
    db1 = 1/m * np.sum(dZ1, axis=1, keepdims=true)

.
.
^
│
│
│
Price      │            ╱o                                                                                                    
│           ╱                                                                                                      
│        o ╱      h(Size) = ϴ   + ϴ   * Size                                                                           
│         ╱                  0     1                                                                              
│        ╱o
│     o ╱                                                                                                          
│      ╱                                                                                                           
└─────╱────────────────────────────────────────────>                                                            
     ϴ                                                                                                          
      0      Size 

* Extract meaning from complicated data
* Detect trends and identify patterns too complex for humans to notice
* Learn by example
* Speed advantages

# import load_iris function from datasets module
from sklearn.datasets import load_iris

# save "bunch" object containing iris dataset and its attributes

iris = load_iris()     #  type(iris)  is  <class 'sklearn.utils.Bunch'>

# store feature matrix in "X"
X = iris.data                    # X.shape  is (150, 4)

# store response vector in "y"
y = iris.target                  # y.shape  is (150,)

## scikit-learn 4-step modeling pattern
# **Step 1:** Import the class you plan to use

from sklearn.neighbors import KNeighborsClassifier

# **Step 2:** "Instantiate" the "estimator"
#  "Estimator" is scikit-learn's term for model

knn = KNeighborsClassifier(n_neighbors=1)

# Can specify tuning parameters (aka "hyperparameters") during this step
print(knn)

      KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
                 metric_params=None, n_jobs=1, n_neighbors=1, p=2,
                 weights='uniform')

# Step 3:** Fit the model with data (aka "model training")

knn.fit(X, y)

# **Step 4:** Predict the response for a new observation

knn.predict([[3, 5, 4, 2]])   # Can pass multiple rows/observations.

array([2])   // Single prediction for single input row. Numpy Array.

X_new = [[3, 5, 4, 2], [5, 4, 3, 2]]
knn.predict(X_new)

array([2, 1])     // Multiple inputs / multiple predictions.

## Using a different value for K (i.e. change hyperparameters )
# knn = KNeighborsClassifier(n_neighbors=5)
# Then you can repeat the whole thing ...
...

array([1, 1])    // Different models (or tunings) may predict differently.

## Using a different classification model
from sklearn.linear_model import LogisticRegression

logreg = LogisticRegression()
logreg.fit(X, y)
logreg.predict(X_new)

array([2, 0])

# Evaluation procedure #1: Train and test on the entire dataset

# compute classification accuracy for the logistic regression model

y_pred = logreg.predict(X)           # Pass entire training set on the trained model.
len(y_pred)                          # It is 150

from sklearn import metrics
print(metrics.accuracy_score(y, y_pred))   # y vs y_pred

      0.96

# Known as training accuracy when you train and test the model on the same data

# For KNN (K=5)
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X, y)
y_pred = knn.predict(X)
print(metrics.accuracy_score(y, y_pred))

     0.96666              # Slightly better than logistic

# For KNN = 1, the training accuracy is 1 !!!

     1.0                  # KNN=1 model defines 'anything at that (x1,y1) is z1 by definition.
                          # This does not imply KNN=1 is a good model.

# Evaluation procedure #2: Train and test set split.

from sklearn.model_selection import train_test_split

# Randomly pick 40% rows for testing. Remaining 60% is for training.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=4)

logreg = LogisticRegression()
logreg.fit(X_train, y_train)
y_pred = logreg.predict(X_test)

# compare actual response values (y_test) with predicted response values (y_pred)
print(metrics.accuracy_score(y_test, y_pred)) 

    0.95 

# Repeat above for KNN = 5  i.e. split train/test data.
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
print(metrics.accuracy_score(y_test, y_pred))

  0.9666666666666667

# For K=1, it yields  0.95

# Can we locate an even better value for K?
k_range = list(range(1, 26))
scores = []
for k in k_range:
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_train, y_train)
    y_pred = knn.predict(X_test)
    scores.append(metrics.accuracy_score(y_test, y_pred))

import matplotlib.pyplot as plt

# allow plots to appear within the notebook

# %matplotlib inline # For notebook as magic command

# plot the relationship between K and testing accuracy
plt.plot(k_range, scores)
plt.xlabel('Value of K for KNN')
plt.ylabel('Testing Accuracy')

# You can see that Accuracy is max between K=7 to k=15
# You may decide to pick K=11 for your model, for example.

# Make prediction for single out-of-sample data ...
# It is obvious ....

knn.predict([[3, 5, 4, 2]])

    array([1])

import seaborn as sns
sns.pairplot(data, x_vars=['TV','Radio','Newspaper'], y_vars='Sales', size=7, aspect=0.7, kind='reg')

# 3 Scatter plots displayed i.e. TV vs Sales, Radio Vs Sales, Newspaper Vs Sales

# Visualize iris dataset correation.

sns.pairplot(iris,hue='species',palette='Dark2')

# Create a kde plot of sepal_length versus sepal width for setosa species of flower.

setosa = iris[iris['species']=='setosa']
sns.kdeplot( setosa['sepal_width'], setosa['sepal_length'],
                 cmap="plasma", shade=True, shade_lowest=False)

# Single value density plot is histogram or density plot.
# 2 Variables density plot is KDE. Kernel density estimate 
# or density contours or 2D bins or Hex bins.
#

X = data[['TV', 'Radio', 'Newspaper']]    # Feature matrix - Data frame - numpy matrix compatible.
y = data['Sales']                         # Response Vector - Pandas Series - numpy array compatible. 

from sklearn.linear_model import LinearRegression

linreg = LinearRegression()

linreg.fit(X_train, y_train)    # fit the model to the training data (learn the coefficients)

          LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)

simple_train = ['call you tonight', 'Call me a cab', 'please call me... PLEASE!']

from sklearn.feature_extraction.text import CountVectorizer
vect = CountVectorizer()

# learn the 'vocabulary' of the training data (occurs in-place)
#
# Note: We are not associating any Y values here. This is just to learn Universal vocabulary.
#
vect.fit(simple_train)

vect.get_feature_names()

    ['cab', 'call', 'me', 'please', 'tonight', 'you']

#
# We got 6 words out of 3 sentences inputs that we have given !!!
# transform training data into a 'document-term matrix'
#
simple_train_dtm = vect.transform(simple_train)
simple_train_dtm

<3x6 sparse matrix of type '<class 'numpy.int64'>'
    with 9 stored elements in Compressed Sparse Row format>

# convert sparse matrix to a dense matrix
simple_train_dtm.toarray()

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

# examine the vocabulary and document-term matrix together
pd.DataFrame(simple_train_dtm.toarray(), columns=vect.get_feature_names())

   cab   call    me  please  tonight   you
0    0   1       0   0       1         1
1    1   1       1   0       0         0
2    0   1       1   2       0         0

# This is called **Bag of Words** or "Bag of n-grams" representation. 
# we completely ignore the relative position information of the words in the document.

# check the type of the document-term matrix
type(simple_train_dtm)

     scipy.sparse.csr.csr_matrix

# examine the sparse matrix contents
print(simple_train_dtm)

  (0, 1)    1    
  (0, 4)    1
  (0, 5)    1
  (1, 0)    1
  (1, 1)    1
  (1, 2)    1
  (2, 1)    1
  (2, 2)    1
  (2, 3)    2   # Third input has the 4th word "Please" 2 times.

# transform testing data into a document-term matrix (using existing vocabulary)
simple_test_dtm = vect.transform(simple_test)
simple_test_dtm.toarray()

 array([[0, 1, 1, 1, 0, 0]], dtype=int64)

# read file into pandas using a relative path
path = 'data/sms.tsv'
sms = pd.read_table(path, header=None, names=['label', 'message'])

# alternative: read file into pandas from a URL
# url = 'https://raw.githubusercontent.com/justmarkham/pycon-2016-tutorial/master/data/sms.tsv'
# sms = pd.read_table(url, header=None, names=['label', 'message'])

# examine the shape
sms.shape

      (5572, 2)

# examine the first 10 rows
sms.head(10)

   label     message
0    ham     Go until jurong point, crazy.. Available only ...
1    ham     Ok lar... Joking wif u oni...
2    spam    Free entry in 2 a wkly comp to win FA Cup fina...
3    ham     U dun say so early hor... U c already then say...
4    ham     Nah I don't think he goes to usf, he lives aro...
5    spam    FreeMsg Hey there darling it's been 3 week's n...
6    ham     Even my brother is not like to speak with me. ...
7    ham     As per your request 'Melle Melle (Oru Minnamin...
8    spam    WINNER!! As a valued network customer you have...
9    spam    Had your mobile 11 months or more? U R entitle...

# examine the class distribution
sms.label.value_counts()

      ham     4825
      spam     747
      Name: label, dtype: int64

# convert label to a numerical variable
sms['label_num'] = sms.label.map({'ham':0, 'spam':1})

# check that the conversion worked
sms.head(10)

          label  message                                             label_num
      0  ham     Go until jurong point, crazy.. Available only ...   0
      1  ham     Ok lar... Joking wif u oni...                       0

# how to define X and y (from the iris data) for use with a MODEL
X = iris.data
y = iris.target
print(X.shape)
print(y.shape)

        (150L, 4L)
        (150L,)

# how to define X and y (from the SMS data) for use with COUNTVECTORIZER
X = sms.message
y = sms.label_num
print(X.shape)
print(y.shape)

        (5572L,)
        (5572L,)

# split X and y into training and testing sets
from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

# ## Part 4: Vectorizing our dataset

# instantiate the vectorizer
vect = CountVectorizer()

# learn training data vocabulary, then use it to create a document-term matrix
vect.fit(X_train)
X_train_dtm = vect.transform(X_train)

# equivalently: combine fit and transform into a single step
X_train_dtm = vect.fit_transform(X_train)

# examine the document-term matrix
X_train_dtm

      <4179x7456 sparse matrix of type '<type 'numpy.int64'>'       # 4179 inputs; 7456 words.
        with 55209 stored elements in Compressed Sparse Row format>

# transform testing data (using fitted vocabulary) into a document-term matrix
X_test_dtm = vect.transform(X_test)
X_test_dtm

      <1393x7456 sparse matrix of type '<type 'numpy.int64'>'      # 1393 Inputs; 7456 words;
          with 17604 stored elements in Compressed Sparse Row format>

# ## Part 5: Building and evaluating a model
# 
# We will use [multinomial Naive Bayes](http://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.MultinomialNB.html):
# 
# > The multinomial Naive Bayes classifier is suitable for classification with **discrete features** 
# (e.g., word counts for text classification). The multinomial distribution normally requires integer feature counts. 
# However, in practice, fractional counts such as tf-idf may also work.

# import and instantiate a Multinomial Naive Bayes model
from sklearn.naive_bayes import MultinomialNB
nb = MultinomialNB()

# train the model using X_train_dtm
nb.fit(X_train_dtm, y_train)

    Wall time: 3 ms

# make class predictions for X_test_dtm
y_pred_class = nb.predict(X_test_dtm)

# calculate accuracy of class predictions
from sklearn import metrics
metrics.accuracy_score(y_test, y_pred_class)

   0.98851399856424982

# print the confusion matrix
metrics.confusion_matrix(y_test, y_pred_class)

   array([[1203,    5],
          [  11,  174]])


# print message text for the false positives (ham incorrectly classified as spam)
X_test[y_test < y_pred_class]

      574               Waiting for your call.
      3375             Also andros ice etc etc
      45      No calls..messages..missed calls
      3415             No pic. Please re-send.
      1988    No calls..messages..missed calls
      Name: message, dtype: object

# print message text for the false negatives (spam incorrectly classified as ham)
X_test[y_test > y_pred_class]

    3132    LookAtMe!: Thanks for your purchase of a video...
    5       FreeMsg Hey there darling it's been 3 week's n...
    3530    Xmas & New Years Eve tickets are now on sale f...
    684     Hi I'm sue. I am 20 years old and work as a la...
    1875    Would you like to see my XXX pics they are so ...
    1893    CALL 09090900040 & LISTEN TO EXTREME DIRTY LIV...
    4298    thesmszone.com lets you send free anonymous an...
    4949    Hi this is Amy, we will be sending you a free ...
    2821    INTERFLORA - It's not too late to order Inter...
    2247    Hi ya babe x u 4goten bout me?' scammers getti...
    4514    Money i have won wining number 946 wot do i do...
    Name: message, dtype: object

# example false negative
X_test[3132]

  "LookAtMe!: Thanks for your purchase of a video clip from LookAtMe!, 
  you've been charged 35p. Think you can do better? Why not send a video in a MMSto 32323."

# calculate predicted probabilities for X_test_dtm (poorly calibrated)
y_pred_prob = nb.predict_proba(X_test_dtm)[:, 1]
y_pred_prob

    array([  2.87744864e-03,   1.83488846e-05,   2.07301295e-03, ...,
             1.09026171e-06,   1.00000000e+00,   3.98279868e-09])

# calculate AUC
metrics.roc_auc_score(y_test, y_pred_prob)

  0.98664310005369604

# ## Part 6: Comparing models
# 
# We will compare multinomial Naive Bayes with [logistic regression](http://scikit-learn.org/stable/modules/linear_model.html#logistic-regression):
# 
# > Logistic regression, despite its name, is a **linear model for classification** rather than regression. 
# Logistic regression is also known in the literature as logit regression, maximum-entropy classification (MaxEnt) 
# or the log-linear classifier. In this model, the probabilities describing the possible outcomes of a 
# single trial are modeled using a logistic function.

# import and instantiate a logistic regression model
from sklearn.linear_model import LogisticRegression
logreg = LogisticRegression()

# train the model using X_train_dtm
logreg.fit(X_train_dtm, y_train)

    Wall time: 39 ms

# make class predictions for X_test_dtm
y_pred_class = logreg.predict(X_test_dtm)

# calculate predicted probabilities for X_test_dtm (well calibrated)
y_pred_prob = logreg.predict_proba(X_test_dtm)[:, 1]
y_pred_prob

  array([ 0.01269556,  0.00347183,  0.00616517, ...,  0.03354907,
        0.99725053,  0.00157706])

# calculate accuracy
metrics.accuracy_score(y_test, y_pred_class)

   0.9877961234745154

# calculate AUC
metrics.roc_auc_score(y_test, y_pred_prob)

   0.99368176123143015

# 
# show default parameters for CountVectorizer
vect

    CountVectorizer(analyzer=u'word', binary=False, decode_error=u'strict',
            dtype=<type 'numpy.int64'>, encoding=u'utf-8', input=u'content',
            lowercase=True, max_df=1.0, max_features=None, min_df=1,
            ngram_range=(1, 1), preprocessor=None, stop_words=None,
            strip_accents=None, token_pattern=u'(?u)\\b\\w\\w+\\b',
            tokenizer=None, vocabulary=None)


# However, the vectorizer is worth tuning.
# 
# - **stop_words:** string {'english'}, list, or None (default)
#     - If 'english', a built-in stop word list for English is used.
#     - If a list, that list is assumed to contain stop words, all of which will be removed from the resulting tokens.
#     - If None, no stop words will be used.

# remove English stop words
vect = CountVectorizer(stop_words='english')

# - **ngram_range:** tuple (min_n, max_n), default=(1, 1)
#     - The lower and upper boundary of the range of n-values for different n-grams to be extracted.
#     - All values of n such that min_n <= n <= max_n will be used.
#
#  ngram is used to recognize words appearing together as single entity/word.
#
#      >>> v = CountVectorizer(ngram_range=(1, 2))
#      >>> pprint(v.fit(["an apple a day keeps the doctor away"]).vocabulary_)
#      {u'an': 0,
#       u'an apple': 1,
#       u'apple': 2,
#       u'apple day': 3,
#       u'away': 4,
#       u'day': 5,
#       u'day keeps': 6,
#       u'doctor': 7,
#       u'doctor away': 8,
#       u'keeps': 9,
#       u'keeps the': 10,
#       u'the': 11,
#       u'the doctor': 12}

# include 1-grams and 2-grams
vect = CountVectorizer(ngram_range=(1, 2))

# - **max_df:** float in range [0.0, 1.0] or int, default=1.0
#     - When building the vocabulary, ignore terms that have a document frequency strictly higher than the given threshold (corpus-specific stop words).
#     - If float, the parameter represents a proportion of documents.
#     - If integer, the parameter represents an absolute count.

# ignore terms that appear in more than 50% of the documents # Max document frequency
vect = CountVectorizer(max_df=0.5)


# - **min_df:** float in range [0.0, 1.0] or int, default=1
#     - When building the vocabulary, ignore terms that have a document frequency strictly lower than the given threshold. (This value is also called "cut-off" in the literature.)
#     - If float, the parameter represents a proportion of documents.
#     - If integer, the parameter represents an absolute count.

# only keep terms that appear in at least 2 documents   # Min document frequency.
vect = CountVectorizer(min_df=2)

Terminology            Computation        sklearn-function           Comments

Accuracy                 (TP+TN)/Total      accuracy_score()   Not good for skewed classes.
                                                               1-Accuracy = Classification Error Rate

Sensitivity/Recall/TPR   TP/(TP+FN)         recall_score()     Given it is positive, how accurate your prediction ?
                                                               Should be high when you can't afford to lose positive.
                                                               E.g. Cancer screening. FP is OK, but FN is not OK.

Specificity (TNR)        TN/(TN+FP)         --not-available--  Given it is negative, How accurate your prediction ? 
                                                               E.g. Defense interview. FN is OK, but FP is not OK.

False Positive Rate      FP/(FP+TN)         ----------------   False Alarm Rate; 1-Specificity; 

Precision                TP/(TP+FP)        precision_score    Probability that Alarm is genuine.

F1 Score =   2 * ( Precision * Recall / (Precision+Recall) )

# IMPORTANT: first argument is true values, second argument is predicted probabilities
fpr, tpr, thresholds = metrics.roc_curve(y_test, y_pred_prob)
plt.plot(fpr, tpr)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.0])
plt.title('ROC curve for diabetes classifier')
plt.xlabel('False Positive Rate (1 - Specificity)')
plt.ylabel('True Positive Rate (Sensitivity)')
plt.grid(True)

# define a function that accepts a threshold and prints sensitivity and specificity
def evaluate_threshold(threshold):
    print('Sensitivity:', tpr[thresholds > threshold][-1])
    print('Specificity:', 1 - fpr[thresholds > threshold][-1])

# IMPORTANT: first argument is true values, second argument is predicted probabilities
print(metrics.roc_auc_score(y_test, y_pred_prob))

   0.7245657568238213  # Single number summary metric for your classifier model. Higher, better.

# calculate cross-validated AUC
from sklearn.model_selection import cross_val_score
cross_val_score(logreg, X, y, cv=10, scoring='roc_auc').mean()

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

dataset = pd.read_csv('Data.csv')     // This is dataframe of N columns.

X = dataset.iloc[:, :-1].values       // Everything except last column
y = dataset.iloc[:, 3].values         // Last column

# Taking care of missing data. We want to fill the missing values by mean of other values.
# Alternative way: Use the value from the nearest neighbor vs mean.
#

from sklearn.preprocessing import Imputer
# Axis = 0 uses mean of the column for missing value. axis=1 for mean of row.
imputer = Imputer(missing_values = 'NaN', strategy = 'mean', axis=0)
imputer = imputer.fit(X[:, 1:3])
X[:, 1:3] = imputer.transform(X[:, 1:3])

# Encoding categorical data
# from sklearn.preprocessing import LabelEncoder, OneHotEncoder, etc.

from sklearn.preprocessing import StandardScaler
import numpy as np

data = np.array([[0, 0], [0, 0], [1, 1], [1, 1]])
scaler = StandardScaler()
scaled_data = scaler.fit_transform(data)

print(data)
[[0 0]
 [0 0]
 [1 1]
 [1 1]]

print(scaled_data)
[[-1. -1.]
 [-1. -1.]
 [ 1.  1.]
 [ 1.  1.]]

scaled_data.mean(axis = 0)
array([0., 0.])

scaled_data.std(axis = 0)
array([1., 1.])

# Visualize correlation ..
import seaborn as sns
sns.heatmap(df.corr())
sns.heatmap(df.corr(), annot=True)

#
# Visualize missing data ...
# Missing values appear as yellow bars.

sns.heatmap(train.isnull(),yticklabels=False,cbar=False,
     cmap='viridis')sns.heatmap(train.isnull(),
     yticklabels=False,cbar=False,cmap='viridis')


# Also see:
sns.pairplot(df)             # Plot for each pair
sns.distplot(df['Price'])    # Plot distribution of Price.

import pandas as pd
mx3 = np.arange(6).reshape(3,2)

       array([[0, 1],
           [2, 3],
           [4, 5]])

df = pd.DataFrame(mx3,index='R1 R2 R3'.split(), columns='C1 C2'.split())
df
              C1  C2
          R1   0   1
          R2   2   3
          R3   4   5

# If you want to fill the data column wise. ....
mx3 = np.arange(6).reshape(3,2).transpose()

     array([[0, 2, 4],
       [1, 3, 5]])

df = pd.DataFrame(mx3,index='R1 R2'.split(), columns='C1 C2 C3'.split())
df
         C1  C2  C3
    R1   0   2   4
    R2   1   3   5