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:

Facebook 360 video:


  • 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:
      • what is our task?
        • 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
    • read papers (nvd, disney)
    • Homework


  • 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:



Commonly Used Variables in Falcor





532. K-diff Pairs in an Array



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

217. Contains Duplicate



  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.


class Solution {
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;


class Solution {
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:


Time: O(nlogn) Space O(1)


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