## Paper Reading: View Direction and Bandwidth Adaptive 360 Degree Video Streaming using a Two-Tier System

Each segment is coded as a base-tier (BT) chunk, and multiple enhancement-tier (ET) chunks.

BT chunks:

represent the entire 360 view at a low bit rate and are pre-fetched in a long display buffer to smooth the network jitters effectively and guarantee that any desired FOV can be rendered with minimum stalls.

ET chunks:

Assessment:

## 03102018

• Gensim Tutorial:
• Use google-news model as pre-trained model
• clustering based on distance matrix
• Question: how do we do the clustering?
• should cluster on the keywords?
• should cluster on the keywords-related words?
• Leg dissection demo:
• 18 cameras 30frames 10G
• 5 cameras 100 frames 6G
• Question:
• we cannot change focal length now. we can only change the viewpoint
• if we want dynamic, we should have dynamic mesh?
• Foveated ray-tracing:
• input: eye ray + 1spp
• output: foveated image
• question: If we use foveated image as ground truth, what should be the denoising algorithm for the ground truth?
• TODO:
• read G3D code and change sample number
• Homework

## Hello

• Cross entropy
• H(p,q) = D(p||q) + H(p)
• H(p) is some inherent randomness in p
• D(p||q) is what we care about. we can try to get D(p||q) by calculating cross entropy.
• Conclusion: a model is good is that it assign good approximation to the observed data. So we need to find some good q
• Main points:
• Example: She loves her. (It’s a correct string, but English is not like this. It should be “She loves herself.”)
• We need a meaning pair.
• Two orthogonal dimensions:
• probability for the strings.
•  Units Prob String {anbn|n>=1} P(w1, w2,…, wn) Structure A tree structure PCFG
• L1 = L2: Language 1 is equal to Language 2
• Weak equivalence
• Sense of string are the same.
• Strong equivalence
• Structure of language 1 and 2 are the same.
• G1 = G2 iff {x| G1 generates string x} = {x|G2 generates string x} (all and only the same structures)
•  G1 G2 S->a s s->s a s->e s->e
• G1 and G2 are weak equivalent (they generate the same strings) but not strong equivalent
• Example: Jon loves mary
• Questions:
• How to measure equivalence?
• binary judgements?
• EM
• Question: How to find a good model? Expectation maximization (EM)
• The structure of model is given, we need to find the parameters for the model.
• Coin: H H H H T T T T T T
•
• MLE: argmax [p(x|mu)]
• Solve:
• Result: p = k/n
• HMM <A,B, pi>

## The test speed of neural network?

Basically, the time spent on testing depends on:

• the complexity of the neural network
• For example, the fastest network should be the fully-connected network.
• CNN should be faster than LSTM because LSTM is sequential (sequential = slow)
• Currently, there are many ways to compress deep learning model (remove nodes with lighter weight)
• the complexity of data
• Try to build parallel models.

Analyze of different deep learning models:

• RNN
• CNN
• LSTM
• GRU
• Seq2seq:
• used for NLP
• Autoencoder:
• learn the features and reduce dimension’

Other machine learning models:

• random forest
• used for classification

Machine learning thought:

## 532. K-diff Pairs in an Array

Description:

https://leetcode.com/problems/k-diff-pairs-in-an-array/description

Code:

Time & Space:
O(nlog(n)) & O(n)

## 217. Contains Duplicate

Description:

https://leetcode.com/problems/contains-duplicate/#/description

Algorithm:

1. Use sort, very easy
2. Don’t use sort, use a array to record the appearance of words. If a word appears for more than 1 times, return true.

Code1:

```class Solution { public: bool containsDuplicate(vector<int>& nums) { if (nums.size() < 2) return false; sort(nums.begin(), nums.end()); for (int i = 0; i < nums.size() - 1;i++) { if (nums[i] == nums[i+1]) return true; } return false; } };```

Code2:

```class Solution { public: bool containsDuplicate(vector& nums) { int min = INT_MAX; int max = INT_MIN; for (int i = 0; i < nums.size(); ++i) { if (nums[i] > max) { max = nums[i]; }```

``` ```

``` if (nums[i] < min) { min = nums[i]; } } vector exists(max - min + 1, false); for (int i = 0; i < nums.size(); ++i) { if (exists[nums[i] - min]) { return true; } else { exists[nums[i] - min] = true; } } return false; } };```

Time & Space:

Code1:

Time: O(nlogn) Space O(1)

Code2:

Time: O(n), Space O(n)