Today also we continue discussing  Signature verification methods. We reviewed the stages involved with Signature verification. Then we also enumerated the feature extraction techniques. After that, we compared online and offline verification techniques. We also discussed the limitations of image processing and the adaptations for video processing.Then we proceeded to discussing image embedding in general.
We discussed Convolutional Neural Network (CNN) in image and object embedding in a shared space followed by shape signature and image retrieval.
The purpose of the embedding is to map an image to a point in the embedding space so that it is close to a point attributed to a 3D model of a similar object. A large amount of training data consisting of images synthesized from 3D shapes is used to train the CNN.
By using synthesized images, the embedding space is computed from clean 3D models without noise. This enables better object similarities. In addition 2D shape views are tossed in which boost the shape matching. This use of embedding space is a novel approach and enables a better domain for subsequent image and shape retrievals. Moreover the embedding space does away with linear classifiers. This yields robust comparision of real world images to 3D models. Previously, this was susceptible to image nuisance factors from real world images and the linear classifiers could not keep up. On the other hand the use of CNN mitigates this because it does better with image invariance learning  - a technique that focuses on the salient invariant embedded objects rather than noise.
The CNN approach consists of four major components: embedding space construction, training image synthesis, CNN training phase, and the final testing phase. In the first phase, a collection of 3D images is embedded into a common space. In the second phase, the training data is synthesized using 3D shapes in a rendering process which yields annotations as well.  In the third phase, a network is trained to learn the mapping between images and 3D shape induced embedding space. Lastly, the trained network is applied on new images to obtain an embedding into the shared space. This facilitates image and shape retrieval.
The shared embedding space allows new images to be introduced into the space anytime. The CNN merely takes the new image as input and uses the output.  If we have to embed new shapes, then it must preserve the pairwise distances between the added shape and the existing shapes within the space. The embedding space is constructed from an initial collection of 3D shapes. Introducing new shapes subsequently tends to violate the space. Instead if we could treat this an optimization problem, then we can preserve the criteria for the embedding space.
The embedding space is where both real-world images and shapes co-exist.  The space organizes latent objects between images and shapes. In order to do this, the objects are initialized from a set of 3D models.  The are pure and complete representation of objects. They don't suffer from the noise in images. The distance between 3D models is both informative and precise. With the help of 3D models, the embedding space becomes robust. 

We continue discussing  Signature verification methods. We reviewed the stages involved with Signature verification. Then we also enumerated the feature extraction techniques. After that, we compared online and offline verification techniques. We also discussed the limitations of image processing and the adaptations for video processing.Then we proceeded to discussing image embedding in general.
We discussed Convolutional Neural Network (CNN) in image and object embedding in a shared space followed by shape signature and image retrieval.
The purpose of the embedding is to map an image to a point in the embedding space so that it is close to a point attributed to a 3D model of a similar object. A large amount of training data consisting of images synthesized from 3D shapes is used to train the CNN.
By using synthesized images, the embedding space is computed from clean 3D models without noise. This enables better object similarities. In addition 2D shape views are tossed in which boost the shape matching. This use of embedding space is a novel approach and enables a better domain for subsequent image and shape retrievals. Moreover the embedding space does away with linear classifiers. This yields robust comparision of real world images to 3D models. Previously, this was susceptible to image nuisance factors from real world images and the linear classifiers could not keep up. On the other hand the use of CNN mitigates this because it does better with image invariance learning  - a technique that focuses on the salient invariant embedded objects rather than noise.
The CNN approach consists of four major components: embedding space construction, training image synthesis, CNN training phase, and the final testing phase. In the first phase, a collection of 3D images is embedded into a common space. In the second phase, the training data is synthesized using 3D shapes in a rendering process which yields annotations as well.  In the third phase, a network is trained to learn the mapping between images and 3D shape induced embedding space. Lastly, the trained network is applied on new images to obtain an embedding into the shared space. This facilitates image and shape retrieval.
The shared embedding space allows new images to be introduced into the space anytime. The CNN merely takes the new image as input and uses the output.  If we have to embed new shapes, then it must preserve the pairwise distances between the added shape and the existing shapes within the space. The embedding space is constructed from an initial collection of 3D shapes. Introducing new shapes subsequently tends to violate the space. Instead if we could treat this an optimization problem, then we can preserve the criteria for the embedding space.

We continue discussing  Signature verification methods. We reviewed the stages involved with Signature verification. Then we also enumerated the feature extraction techniques. After that, we compared online and offline verification techniques. We also discussed the limitations of image processing and the adaptations for video processing.Then we proceeded to discussing image embedding in general.
We discussed Convolutional Neural Network (CNN) in image and object embedding in a shared space followed by shape signature and image retrieval.
The purpose of the embedding is to map an image to a point in the embedding space so that it is close to a point attributed to a 3D model of a similar object. A large amount of training data consisting of images synthesized from 3D shapes is used to train the CNN.
By using synthesized images, the embedding space is computed from clean 3D models without noise. This enables better object similarities. In addition 2D shape views are tossed in which boost the shape matching. This use of embedding space is a novel approach and enables a better domain for subsequent image and shape retrievals. Moreover the embedding space does away with linear classifiers. This yields robust comparision of real world images to 3D models. Previously, this was susceptible to image nuisance factors from real world images and the linear classifiers could not keep up. On the other hand the use of CNN mitigates this because it does better with image invariance learning  - a technique that focuses on the salient invariant embedded objects rather than noise.


#codingexercise
Get the maximum contiguous product for short integer arrays
double maxProduct(List <int> A)
{
double max = Int_min;
if ( A == null || A.Count == 0)
    return max;
for (int I = 0; I  < A.Count ; i++)
{
   double product = A [i];
   max = Math.max (product, max);
   for ( int j = i-1; j >=0; j--)
   {
         product = product × A [j];
         max = Math.max (product, max);
   }
}
return max;
}

An essay in the techniques of innovation
I have explored some common themes for innovations in design as shown in the documents under references section. I would like to enumerate some that resonate with me a lot:
Simplicity – A jigsaw puzzle, a screw driver, a simpler user interface like Bose audio speak eloquently to their functionality by virtue of simplicity. Sometimes minimal design works well not only to highlight the purpose of the item but also to conserve what doesn’t need to be expressed.
Multi-functionality – Nothing delights a customer than offering value in terms of more than what was required from the product. A Swiss army knife is handy and sought after for this purpose. This is probably a direct opposite of the example cited above but it is as essential to design as the first one.  Japanese restrooms genuinely feel like a spaceship. Combining values into a product also delights customers.
Automation – Anything that improves convenience for a user and improves the experience is welcome to design ideas. This does not mean reducing the touchpoints with the customer but rewarding those that the customer likes and reducing the others that gets in the way or increases onus. A fidget spinner or a top is popular because it entices the player to try it again with minimal involvement.
Elegance – This comes from thinking through all the usages for the product and playing up the features that matter most in an aesthetic way. I borrow this idea from professionals who go above and beyond to realize a design. As an example, perhaps any stick would do for a door handle, but a rubbery grip would do more for the user if the door and the users remain the same.
The techniques for innovation must have a lot of textbooks and curated articles online. I found them to be exhaustive and these are merely those that I could apply.
References:
1. https://1drv.ms/w/s!Ashlm-Nw-wnWs130GlgiZX7PI1RR
2. https://1drv.ms/w/s!Ashlm-Nw-wnWsXwBts-27OY5yxqw
3. https://1drv.ms/w/s!Ashlm-Nw-wnWsXDw5eIxh5v_TSsQ

4. https://1drv.ms/w/s!Ashlm-Nw-wnWkTzXCEGrAysjDkzk

#codingexercise
Get the maximum contiguous product for short integer arrays
double maxProduct(List <int> A)
{
double max = Int_min;
if ( A == null || A.Count == 0)
    return max;
for (int I = 0; I  < A.Length ; i++)
{
   double product = A [i];
   max = Math.max (product, max);
   for ( int j = i +1; j < A.Length; j++)
   {
         product = product × A [j];
         max = Math.max (product, max);
   }
}
return max;
}

#codingexercise
A step array is an array of integer where each element has a difference of atmost k with its neighbor. Given a key x, we need to find the index value of k if multiple element exist return the index of any  occurrence of key.
Input : arr[] = {4, 5, 6, 7, 6}
           k = 1
           x = 6
Output : 2


int GetIndex(List<int> A, int x, int k)
{
int i = 0;
while (i < A.Length)
{
if (A[i] == x)
   return i;
i = i + Math.Max(1, Math.Abs(A[i]-x)/k);
}
return -1;
}

Get the nth number of the Golomb sequence

int a (uint n)
{
if ( n == 0)
      return 0;
if  (n == 1) 
      return 1;
return 1 + a(n – a(a(n-1)));
}

 Get Max product from an integer array
public int maxProduct(List<int> input)
{
int lo = 1;
int hi = 1;
int result = 1;
for (int i = 0; i < input.Count; i++)
{
if (input[i]  == 0)
{
lo = 1;
hi = 1;
}
else{
   int temp = hi * input[i];
   if (input[i] > 0)
   {
       hi = temp;
       lo = Math.Min(lo * input[i], 1);
   }
   else
   {
      lo = temp;
      hi = Math.Max(lo * input[i], 1);
   }
}
if (result < hi)
    result = hi;
}
return result;
}
This is for contiguous subsequence.
We could also write the above if else in dynamic programming with recursion to include either the current element or exclude it. If an element is not included we multiply 1. If it is included we multiply the element to the maximum  of the recursion found as for example in positive integer array
int getMaxProduct(List<int> A, int index)
{
assert (A.all (x=> x>=0));
if (index  == A.Length)
     return 1;
int remaining = GetMaxProduct (A, index +1);
return Math.max (A [index] * remaining,  1 * remaining) ;
}
which is the same as saying replace all 0 with 1 in the sorted positive integer array
Therefore we can even sort the integer array replace all 0 with 1 and trim the odd count negative number to the left of zero
double GetMaxProduct (List <int> A)
{
A.sort ();
A.replaceAll(0, 1);
int count = A.Count (x => x < 0);
if (count > 0 && count % 2 == 1)
{
    A.replace (A.min (x => x < 0), 1);
}
return A.Product ();
}

We were discussing Signature verification methods. We reviewed the stages involved with Signature verification. Then we also enumerated the feature extraction techniques. After that, we compared online and offline verification techniques. We also discussed the limitations of image processing and the adaptations for video processing.Then we proceeded to discussing image embedding in general.
We discussed Convolutional Neural Network (CNN) in image and object embedding in a shared space followed by shape signature and image retrieval.
The purpose of the embedding is to map an image to a point in the embedding space so that it is close to a point attributed to a 3D model of a similar object. A large amount of training data consisting of images synthesized from 3D shapes is used to train the CNN.
By using synthesized images, the embedding space is computed from clean 3D models without noise. This enables better object similarities. In addition 2D shape views are tossed in which boost the shape matching. This use of embedding space is a novel approach and enables a better domain for subsequent image and shape retrievals. Moreover the embedding space does away with linear classifiers. This yields robust comparision of real world images to 3D models. Previously, this was susceptible to image nuisance factors from real world images and the linear classifiers could not keep up. On the other hand the use of CNN mitigates this because it does better with image invariance learning  - a technique that focuses on the salient invariant embedded objects rather than noise.

#codingexercise
We covered a few probability distributions earlier - uniform, normal, exponential. Let us describe the Poisson distribution for x success in n trials with success probability p each:
double GetProbabilityXevents(double n, double x. double p)
{
Debug.Assert( n  >= 0 && x >= 0 && p >= 0);
return GetNChooseX(n,x)*Math.pow(p,x)*Math.pow((1-p), (n-x));
}