TASK 1 (Ranking and evaluation)
1.1 P@2, P@R, AP
P@2 = 1/2 P@R = 1/3 P@R1 = 1/2, P@R2 = 1/2, P@R3 = 0, AP = (1/2 + 1/2 + 0) / 3 = 1/3
1.2 DCG@2, iDCG@2, nDCG@2
DCG@2 = 0 + 3 / 1 = 3 iDCG@2 = 3 + 2 / 1 = 5 nDCG@2 = 3/5 = 60%
1.3 Function dcg that computes DCG@k
1. def dcg(rels, k): 2. sum = rels[0] 3. for i in range(1, k): 4. sum += rels[i] / log2(i+1) 5. return sum
1.4 Function ndcg that computes nDCG@k
1. def ndcg(rels, k): 2. dcg_val = dcg(rels, k) 3. sorted_rels = sort(rels, DESC) 4. idcg_val = dcg(sorted_rels, k) 5. return dcg_val / idcg_val
TASK 2 (Encodings)
2.1 Function unary_encode that encodes given sequence of integers
1. def unary_encode(input): 2. result = [] 3. for x in input: 4. for i in range(0, x-1): 5. result.add(0) 6. result.add(1) 7. return result
2.2 Expected number of bits in sequence of n integers i.i.d from {1, ..., n}
1. The code length for integer i is exactly i
2. For a random integer from {1, ..., n}, the expected code length is sum_i (i * 1/n) = 1/n * sum_i i = 1/n * 1/2 * n * (n+1) = (n+1) / 2
3. The expected number of bits in the whole sequence is hence n * (n+1) / 2
2.3 Is this encoding entropy-optimal for the distribution from task 2.2
1. The entropy H of the distribution from 2.2 is -sum_i 1/n * log_2 (1/n) = 1/n * log_2 n * sum_i 1 = log_2 n 2. The expected code length is (n+1)/2 3. For entropy-optimality, we should have expected code length = entropy + O(1) 4. So the answer is NO.
2.4 Name a prefix-free entropy-optimal encoding for the distribution from task 2.2
1. Just encode each integer with a fixed number of ceil(log_2 n) bits 2. This is prefix-free, because for two different codes of the same length, none can be the prefix of the other 3. Since ceil(log_2 n) <= log_2 + 1, this encoding is entropy-optimal
TASK 3 (Fuzzy search and UTF-8)
3.1 (5 points) ED(x, y), ED(y, x), PED(x, y), PED(y, x) for x = cute and y = computer
ED(cute, computer) = 4 ... insert omp and r ED(computer, cute) = 4 ... ED is symmetric PED(cute, computer) = ED(cute, compute) = 3 PED(computer, cute) = ED(computer, cute) = 4
3.2 (5 points) Find x and y with ED(x, y) = 2 and comm($$x$$, $$y$$) = max{|x|, |y|} - 4
1. max{|x|, |y|} - 4 is the lower bound from the lecture for q = 3 and ED(x, y) = 2
2. The lower bound is achieved when destroying the maximal number of q-grams with each edit distance operation, in this case 3
3. For example, x = AXXA, y = BXXB
3.3 (10 points) Function valid_utf8_char8 that checks if a given array of three bytes is valid UTF-8 for a single character
1. def valid_utf8_char(bytes):
# Check that first byte start with 1110 and the other two with 10
# 10000000b = 128, 11000000b = 192, 11100000b = 224, 11110000b = 240
3. if (bytes[0] & 240 != 224 OR bytes[1] & 192 != 128 OR bytes[2] & 192 != 128):
4. return False
# Check that the code point is >= 2048
# 11100000b = 224, 10100000b = 160
5. if (bytes[0] > 224 OR bytes[1] >= 160):
6. return True
7. return False
TASK 4 (Naive Bayes)
4.1 (10 points) Function naive_bayes_predict that predicts the class for a given document
1. def naive_bayes_predict(pc, pwc, words): 2. best_c, bestp = -1, -1 3. for c in range(0, len(pc)): 4. p = pc[c] 5. for w in words: 6. p *= pwc[w][c] 7. if p > best_p: 8. best_p, best_c = p, c 9. return best_c
4.2 (5 points) Same prediction for d_1 and d_2 = d_1.d_1
1. If p(c | d1) = P_c * p_c, then p(c | d2) = P_c² * p_c. 2. If the p_c are all equal, then p(c1 | d1) < p(c2 | d1) <=> P_c1 < P_c2 <=> P_c1² < P_c2² <=> p(c1 | d2) < p(c1 | d2)
4.3 (5 points) Is the statement from 4.2 also true if the pc are not all equal?
1. Assume two classes c1 and c2 with p(c1) = 1/4 and p(c2) = 3/4 2. Let d1 consist of one word w with p(c1, w) = 2/3 and p(c2, w) = 1/3 3. Then p(c1 | d1) = 2/3 * 1/4 = 1/6 and p(c2 | d1) = 1/3 * 3/4 = 1/4 => class c2 is more likely 4. But p(c1 | d2) = 2/3 * 2/3 * 1/4 = 1/9 and p(c2 | d2) = 1/3 * 1/3 * 3/4 = 1/12 => class c1 is more likely 5. So the statement from 4.2 is not true in general if the pc are not all equal
TASK 5 (Latent Semantic Indexing)
5.1 (10 points) Determine the matrices U and S of the SVD of A
1. The product A * AT is [[15, 9], [9, 15]] 2. One eigenvector is easily seen to be (1, 1) with eigenvalue 9 * 15 = 24 3. The other eigenvector is then (1, -1) with eigenvalue 6 4. The matrix U is hence 1/2 * sqrt(2) * [[1, 1], [1, -1]] 5. The matrix S is diag(sqrt(24), sqrt(6)) = sqtr(6) * diag(2, 1)
5.2 Function compute_V that computes V from A, U, S
1. def compute_V(A, U, S, V, m, n):
2. r = len(S)
# A has shape m x n, U has shape m x r, S has r entries
# We can assume that V has shape r x n and is filled with zeroes
# According to ES10, V = S^-1 * UT * A
3. for i in range(0, r):
4. for j in range(0, n):
5. for k in range(0, m):
6. V[i, j] += U[k, i] * A[k, j] / S[i]
TASK 6 (Hidden Markov Model)
6.1 (5 points) Probability that second state is plus if sequence is good, good, good
1. Pr(h1 = plus) * Pr(o1 = good | h1 = plus) * Pr(h2 = plus | h1 = plus) * Pr(o2 = good | h2 = plus) = 1/2 * 1/3 * 1/3 * 1/3 = 1/54 2. Pr(h1 = minus) * Pr(o1 = good | h1 = minus) * Pr(h2 = plus | h1 = minus) * Pr(o2 = good | h2 = plus) = 1/2 * 2/3 * 2/3 * 1/3 = 4/54 3. Pr(h2 = plus) = 1/54 + 4/54 = 5/54
6.2 (5 points) Most likely sequence of hidden states for great, bad, great
1. Pr(great | minus) = 0 and Pr(bad | plus) = 0 2. Hence the only sequence of hidden states with non-zero probability is plus, minus, plus 3. This is hence the most likely sequence of hidden states
6.3 (5 points) Function compute_likelihood that computes likelihood of a given sequence of observations and hidden states
1. def compute_likelihood(o, h): 2. result = 1 3. for i in range(0, len(o)): 4. result *= iprob[i] if i == 0 else tprob[h[i], h[i-1]] 5. result *= eprob[h[i], o[i]] 6. return result
6.4 (5 points) Function brute_force_hmm that computes the most likely sequence of hidden states for given sequence of three observations
1. def brute_force_hmm(o1, o2, o3): 2. k = len(iprob) # Number of hidden states 3. best_l, best_h = 0, [] 4. for h1 in range(0, k): 5. for h2 in range(0, k): 6. for h3 in range(0, k): 7. l = compute_likelihood([o1, o2, o3], [h1, h2, h3]) 8. if l > best_l: 9. best_l, best_h = l, [h1, h2, h3] 10. return best_h