Install Tensorflow Keras

Platform Windows 10

1> Create virtual env

#conda create -n tensorflow pip python=3.5

2> activate env
#activate tensorflow
#conda info --envs

3> Install tensorflow
#conda install -c conda-forge tensorflow
this will install tensorflow 1.10.0
#python -m pip install --upgrade pip
#pip install setuptools==39.1.0

3> Install keras
#pip install keras==2.2.2

4> Install other package
#pip install matplotlib
#pip install sklearn
#pip install pydot

5> Install spyder separately so that you can launch it without activating your virtual env
#conda install spyder

Natural Language Processing: Q & A

Question: What is Tokenization? What is the purpose of it?
Answer: Breaking the sentence into constituent words is called as Tokenization. It is the basic step of Stopwords removal, stemming, lemmatization, parsing, text mining, etc.




Question: Why we need to remove stop words?
Answer: Stopwords are those words which don't contribute much towards meaning of the sentence like a, the, and,etc. Tasks like text classification, where we classify text into different categories, we remove stopwords to give more focus to words which contribute to the meaning of the text.

Question: Why we do stemming?
Answer: It is the process of reducing inflected words to their root word. Retrieving, Searching and Identifying more forms of a word returns more results. In absence of this many results might have been missed. That's why stemming is integral part of search queries and information retrieval. 


Question: Whats the difference between stemming and lemmatization?
Answer:
Stemming is a crude form that remove end of words but sometime remove derivational affixes.
Lemmatization refers to use of  vocabulary and morphological analysis of words, the main aim is to  remove inflectional endings only and return the base or dictionary form(lemma) of a word.
E.g: Word: SAW
Stemming:  S
Lemmatization: See or Saw depending on form (noun or verb) it is used.

Question: Give one use case of stemming.
Answer: Search Engine (E.g: Google, Bing)


Question: N-gram is combination of N keywords together. How many bigrams can be formed from given below sentence.
"Google is the most popular search engine"
 Answer: 6
Bigrams: "Google is, is the, the most, most popular, popular  search, search engine"

Question:  Difference Between CountVectorizer and HashVectorizer?

Answer:
HashingVectorizer :
-  If dataset is large and there is no use for the resulting dictionary of tokens
- You have maxed out your computing resources and it’s time to optimize
CountVectorizer:
-  If need is to access the actual tokens.
-  If you are worried about hash collisions (when matrix size is small)

Question: Arrange below components of Text classification model into right sequence.

Gradient Descent, Text Predictors, Text cleaning, Text annotation, Model tuning

Answer:  Correct Sequence: Text Cleaning to remove noise, creating more features using annotation, converting text to numerical form(predictors), using gradient descent to create the model and then tunning the model.

Difference between Ordinary Least Square (OLS) and Gradient Descent to find best fit line

Ordinary Least Square(OLS):

- Non Iterative method to find best fit line such that the sum of squares of diff of Observed and Predicted values is minimized.

Error = (y_pred – y_act)^2
Line => y = bo + b1x

y_i =  Actual Value

- Above formula is for Univariate(one variable)

- For multivariate case, when we have many variables, the formula becomes complicated and requires too much calculation while implementing in software. 

- fail for collinear predictors(correlation between features)

- can be run in parallel but its still much complicated and expensive.

Gradient Descent:

- finds the linear model parameters iteratively.

- applies to non-linear model as well.

- works well for collinear predictors

- saves lot of time in calculation as it can be run parallely and distribute load across multiple processors.

•Cost Function, J(m,c) = (y_pred – y_act)^2 / No. of data point
•Hypothesis: y_pred = c + mx

Deep Learning: Create Neural Network to Recognize plus and cross image

Problem:
1> Consider Image of size 3*3 for plus and cross
2> In terms of input plus = [0,1,0,1,1,1,0,1,0], cross = [1,0,1,0,1,0,1,0,1]


Algorithm:
1> Error at Output Layer = (Out_exp - Oct_pre)*Oct_pre*(1 - Oct_pre)
2>  Re calculate Weight = Weight + learning*error*input
3> Error at Hidden Layer = w11*error1 + w12*error2

Code:
import numpy as np
import os
import random
import cv2, os
import matplotlib.pyplot as plt
import math

lr = 1 #learning rate
#Initialize Bias and Weights
bias = [random.random() for x in range(4)]
bias_out = [random.random() for x in range(2)]
h, w = 10, 5
weight_hid = [[random.random() for x in range(w)] for y in range(h)]
h, w = 5, 3
weight_out = [[random.random() for x in range(w)] for y in range(h)]

def flatten_image(image_path):
    image = cv2.imread(image_path)
    image_grayscale = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY )
    size=(3,3)
    resized_image = cv2.resize(image_grayscale, size)
    image_flatten = resized_image.flatten()
    for i in range(len(image_flatten)):
        if image_flatten[i] > 150:
            image_flatten[i] = 1
        else:
            image_flatten[i] = 0
    return image_flatten    

def sigmoid(x):
    return 1/(1+math.exp(-x))

def hidden_layer(x):
    hid_outputP = [0,0,0,0]
    #hid_error = [0,0,0,0]

    for i in range(0,4):
        hid_outputP[i] = bias[i]*weight_hid[0][i+1]
        for j in range(0,9):
            hid_outputP[i] =  hid_outputP[i] + x[j]*weight_hid[j+1][i+1]
         
        hid_outputP[i] = sigmoid(hid_outputP[i])
    return hid_outputP

def output_layer(h, result, plus):
    outputP = [0,0]
    error = [0,0]
    for i in range(0,2):
        outputP[i] = bias_out[i]
        for j in range(0,4):
            outputP[i] =  outputP[i] + h[j]*weight_out[j+1][i+1]

    outputP[0] = sigmoid(outputP[0])
    outputP[1] = sigmoid(outputP[1])
    #Calculate Error at Output Layer
    error[0] = (result[0] - outputP[0])*outputP[0]*(1 - outputP[0])
    error[1] = (result[1] - outputP[1])*outputP[1]*(1 - outputP[1])

    #Calculate Error at Hidden Layer
    for i in range(1,5):
        error_hid[i] = (error[0]*weight_out[i][1] + error[1]*weight_out[i][2])*h[i-1]*(1 - h[i-1])
    #Recalculate Weight to Output Layer
    for i in range(1,5):
        weight_out[i][1] =  weight_out[i][1] + error[0]*h[i-1]*lr
        weight_out[i][2] =  weight_out[i][2] + error[1]*h[i-1]*lr
       
    #Recalculate Weight to Hidden Layer
    for i in range(1,5):
        for j in range(1,10):
            weight_hid[j][i] = weight_hid[j][i] + error_hid[i]*plus[j-1]

def predict(input):
    input_hid = hidden_layer(input)
    outputP = [0,0]
    for i in range(0,2):
        outputP[i] = bias_out[i]
        for j in range(0,4):
            outputP[i] =  outputP[i] + input_hid[j]*weight_out[j+1][i+1]

    outputP[0] = sigmoid(outputP[0])
    outputP[1] = sigmoid(outputP[1])   
    print(outputP[0],outputP[1]) 
 
result_plus = [0.9, 0.1]
result_cross = [0.1, 0.9]
error_hid = [0,0,0,0,0]

#Image can be taken from : https://github.com/bansalrishi/MachineLearningWithPython_UD

#E.g: Path in GitHub: Data/NN/plus.jpg

plus_path = 'Data/NN/plus.jpg'
plus = flatten_image(plus_path)
plus_cross = 'Data/NN/cross.jpg'
cross = flatten_image(plus_cross)

for i in range(200) :
    #print("Running loop i=%s"%i)   
    H = hidden_layer(plus)
    output_layer(H, result_plus, plus)
    H = hidden_layer(cross)
    output_layer(H, result_cross,cross)
   
print("Giving input as cross")
predict(cross)
print("Giving input as plus")
predict(plus)


Output:

Giving input as cross
0.12235658465850822 0.8819751642398935
Giving input as plus
0.881445602118824 0.11705488953094145

StandardScaler: Why fit_transform for train data and only transform for test data?

StandardScaler: Why fit_transform for train data and only transform for test data?

Below are the steps to perform Feature Scaling after the Train and Test Split

# Perform Feature Scaling
from sklearn.preprocessing import StandardScaler
sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.transform(X_test)

We can observe the use of different function for train and test set. The question arises, why we use different function and if we use same fit_transform for both train and test set, will be it be right?

Lets see manual steps to compute Scaling:

First Case: Using Same Function:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)

X_train(scaled) =  (X_train - X_train_mean) / X_train_std_devia

X_test(scaled) =  (X_test - X_train_mean) / X_train_std_devia

Second Case: Using Different Function:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)

X_train(scaled) =  (X_train - X_train_mean) / X_train_std_devia

X_test(scaled) =  (X_test - X_test_mean) / X_test_std_devia

So, if we observe the difference between first and second case, it is the use of X_train_mean and X_test_mean in computing the X_test(Scaled). 

The question is which approach is better/correct. In real scenario we want to know the model which we built, how it performs on new data. What happen if samples in new data is very few. Will we get good mean and standard deviation values? What happen if there is only one reading? So, we use First Case. Same approach we take when we build model using libraries. For e.g: PCA

from sklearn.decomposition import PCA
pca = PCA(n_components = 2)
X_train = pca.fit_transform(X_train)
X_test = pca.transform(X_test)

Machine Learning Interview Questions & Answers(Complex)

Machine Learning Interview Questions & Answers(Complex)

Question: Whats the difference between Black-box and white-box models?
Ans:

• accurate and ‘black-box’:
  Black-box models such as neural networks, gradient boosting models or complicated ensembles often provide great accuracy. The inner workings of these models are harder to understand and they don’t provide an estimate of the importance of each feature on the model predictions, nor is it easy to understand how the different features interact.
• weaker and ‘white-box’:
  Simpler models such as linear regression and decision trees on the other hand provide less predictive capacity and are not always capable of modelling the inherent complexity of the dataset (i.e. feature interactions). They are however significantly easier to explain and interpret.

More Read

Question:What is the difference between Surogate and LIME interpretability Technique?
Ans: Surrogate models are (generally simpler) models that are used to explain a more complex model. Linear models and decision tree models are often used because of their simple interpretation. The surrogate model is created to represent the decision making process of the complex model (the response function) and is a model trained on the input and model predictions, rather than input and targets.  Surrogate models provide a layer of global interpretability on top of non-linear and non-monotonic models, but they should not be relied on exclusively.The general idea behind LIME is the same as surrogate models. LIME however does not build a global surrogate model that represents the entire dataset and only builds local surrogate models (linear models) that explain the predictions at local regions.

More Read

Question: Explain LIME interpretability Technique in detail ?
Ans: 
Link

Question: What are the Random Forest Importances? Explain in Detail?
Ans:
Link

Python Django Interview Questions & Answers

Python Django Interview Questions & Answers

Question: What are Django shortcut functions?

Ans: The package django.shortcuts collects helper functions and classes that “span” multiple levels of MVC. These functions/classes introduce controlled coupling for convenience’s sake.

More Read 

Question: What is the function of render()?
Ans: render() Combines a given template with a given context dictionary and returns an HttpResponse object with that rendered text. Django does not provide a shortcut function which returns a TemplateResponse because the constructor of TemplateResponse offers the same level of convenience as render() .

More Read

Question: What is the diff between {{ }} and {% %}?
Ans: There are three category in the template in Django: 

1> Template Variable {{ }}: To render variables in the template or displaying variables.

2> Template Tag {% %}: For sentences such as if and for or to call tags such as load, static, etc.

3> Template Filter:  {{variable |filter:arg}}

Question:What does CSRF token mean?

Ans: Cross-site request forgery, also known as one-click attack or session riding and abbreviated as CSRF (sometimes pronounced sea-surf) or XSRF, is a type of malicious exploit of a website where unauthorized commands are transmitted from a user that the web application trusts.




Question: How does Django CSRF work?

Ans: When receiving the form submission, Django checks that the alphanumeric string value from the hidden form field matches and the csrftoken cookie received from the browser. ... A CSRF attack might come in the form of a malicious web site that includes an iframe. The iframe includes a POST form and some JavaScript.

Question: How long is CSRF token?

Ans: That said, assuming an attacker can do 100,000 requests per second, it should take around 2.93 million years on average to brute force a 64-bit CSRF token. (And there shouldn't be more than one token in the whole token space, unlike with session id's.) So, maybe 64 bits is enough.