Multi-Label Dimensionality Reduction

1. % CCA examples
   
2. % This script demonstrates how to use the CCA function.
   
3. %
   
4. % Copyright(c) Liang Sun (sun.liang@asu.edu), Shuiwang Ji (shuiwang.ji@asu.edu), and Jieping Ye (jieping.ye@asu.edu), Arizona State Univerisity
   
5. %
   
6. 
   
7. clear all; clc;
   
8. addpath('../Functions');
   
9. 
   
10. 
    
11. % % We generate 200 samples, with dimensionality 10 and 100
    
12. % d1 = 100;
    
13. % d2 = 10;
    
14. % n = 200;
    
15. % X = rand(d1, n);
    
16. % Y = rand(d2, n);
    
17. 
    
18. % load the synthetic data
    
19. % The dimensionality of X and Y are 1000 and 20, respectively.
    
20. % and the sample size is 400.
    
21. data_path = '../Data/Synthetic_1.mat';
    
22. S = load(data_path);
    
23. X = S.X;
    
24. Y = S.Y;
    
25. 
    
26. 
    
27. % ********** Examples of using CCA *********
    
28. %=============================================================
    
29. % Part 1. We show different usages of CCA when alg='eig'.
    
30. opts = [];
    
31. opts.alg = 'eig';
    
32. opts.PrjX = 1;
    
33. opts.PrjY = 1;
    
34. opts.regX = 0.1;
    
35. opts.regY = 1;
    
36. [W_x, W_y, corr_list] = CCA(X, Y, opts);
    
37. 
    
38. % We verify the correlation coefficient in the projected spaces
    
39. X_p = W_x' * colCenter(X);
    
40. Y_p = W_y' * colCenter(Y);
    
41. c_list = zeros(size(W_x, 2), 1);
    
42. if isfield(opts, 'regX')
    
43.     regX = opts.regX;
    
44. else
    
45.     regX = 0;
    
46. end
    
47. if isfield(opts, 'regY')
    
48.     regY = opts.regY;
    
49. else
    
50.     regY = 0;
    
51. end
    
52. for i = 1:size(X_p, 1)
    
53.     x_p = X_p(i, :)';   
    
54.     y_p = Y_p(i, :)';
    
55.     % We consider regularization for both X and Y.
    
56.     denom1 = x_p' * x_p + regX * W_x(:, i)' * W_x(:, i);
    
57.     denom2 = y_p' * y_p + regY * W_y(:, i)' * W_y(:, i);
    
58.     c = x_p' * y_p / sqrt(denom1) / sqrt(denom2);
    
59.     c_list(i) = c;
    
60. end
    
61. 
    
62. if norm(c_list-corr_list)<1e-10
    
63.     display('verfirication is successful for PrjX=1 and PrjY=1');
    
64. else
    
65.     display('verification failed for PrjX=1 and PrjY=1');
    
66. end
    
67. 
    
68. % only projection for X is computed
    
69. opts = [];
    
70. opts.alg = 'eig';
    
71. opts.PrjX = 1;
    
72. opts.PrjY = 0;
    
73. opts.regX = 0.1;
    
74. opts.regY = 1;
    
75. [W_x1, W_y1, corr_list1] = CCA(X, Y, opts);
    
76. % compute the difference between this setting and the last setting.
    
77. d_W_x1 = norm(W_x - W_x1);
    
78. d_c1 = norm(corr_list - corr_list1);
    
79. if d_W_x1<1e-10 && d_c1<1e-10
    
80.     display('equivalence is verified for (PrjX, PrjY) is (1,0) and (1,1)');
    
81. else
    
82.     display('equivalence is not verified for (PrjX, PrjY) is (1,0) and (1,1)');
    
83. end
    
84. 
    
85. % only projection for Y is computed
    
86. opts = [];
    
87. opts.alg = 'eig';
    
88. opts.PrjX = 0;
    
89. opts.PrjY = 1;
    
90. opts.regX = 0.1;
    
91. opts.regY = 1;
    
92. [W_x2, W_y2, corr_list2] = CCA(X, Y, opts);
    
93. % compute the difference between this setting and the last setting.
    
94. % note that the sign may be different
    
95. sign_change = sign(W_y2(1,:) ./ W_y(1,:));
    
96. d_W_y2 = norm(W_y - W_y2 * diag(sign_change));
    
97. d_c2 = norm(corr_list - corr_list2);
    
98. if d_W_y2<1e-10 && d_c2<1e-10
    
99.     display('equivalence is verfied for (PrjX, PrjY) is (0,1) and (1,1)');
    
100. else
     
101.     display('equivalence is not verfied for (PrjX, PrjY) is (0,1) and (1,1)');
     
102. end
     
103. 
     
104. %=============================================================
     
105. % Part 2. Use ls and ls-lsqr implementation and verify the equivalence relationship in the un-regularized setting.
     
106. % Compare ls and eig implementations
     
107. % Generate the data
     
108. 
     
109. opts = [];
     
110. opts.alg = 'ls';
     
111. opts.PrjX = 1;
     
112. opts.PrjY = 0;
     
113. W_x_ls = CCA(X, Y, opts);
     
114. 
     
115. % Compute W_x_eig for the corresponding eig implementations.
     
116. opts = [];
     
117. opts.alg = 'eig';
     
118. opts.PrjX = 1;
     
119. opts.PrjY = 1;
     
120. [W_x_eig_c1, W_y_eig_c1, corr_list_c1] = CCA(X, Y,opts);
     
121. 
     
122. % compute the difference
     
123. d_ls_eig_eq = norm(W_x_ls*W_x_ls' - W_x_eig_c1*W_x_eig_c1');
     
124. if d_ls_eig_eq<1e-10
     
125.     display('ls implementation is equivalent to eig implementation');
     
126. else
     
127.     display('ls implementation is not equivalent to eig implementation');
     
128. end
     
129. 
     
130. % test ls-lsqr implementation
     
131. opts = [];
     
132. opts.alg = 'ls-lsqr';
     
133. opts.PrjX = 1;
     
134. opts.PrjY = 0;
     
135. opts.lsqr_tol = 1e-6;
     
136. W_x_ls_lsqr = CCA(X, Y, opts);
     
137. % compute the difference
     
138. d_ls_lsqr_eq = norm(W_x_ls*W_x_ls' - W_x_ls_lsqr*W_x_ls_lsqr');
     
139. if d_ls_lsqr_eq<1e-5
     
140.     display('ls implementation is equivalent to ls-lsqr implementation');
     
141. else
     
142.     display('ls implementation is not equivalent to ls-lsqr implementation');
     
143. end
     
144. 
     
145. 
     
146. % test 2-norm regularized ls
     
147. opts = [];
     
148. opts.alg = 'ls';
     
149. opts.PrjX = 1;
     
150. opts.PrjY = 0;
     
151. opts.reg_2norm = 1;
     
152. W_x_ls_2reg = CCA(X, Y, opts);
     
153. 
     
154. % display('check 1-norm regularization for ls implementation');
     
155. % test 1-norm regularized ls
     
156. opts = [];
     
157. opts.alg = 'ls';
     
158. opts.PrjX = 1;
     
159. opts.PrjY = 0;
     
160. opts.reg_1norm = 0.2;
     
161. W_x_ls_1reg = CCA(X, Y, opts);
     
162. 
     
163. % test 1-norm and 2-norm regularization together for ls
     
164. opts = [];
     
165. opts.alg = 'ls';
     
166. opts.PrjX = 1;
     
167. opts.PrjY = 0;
     
168. opts.reg_1norm = 0.2;
     
169. opts.reg_2norm = 1;
     
170. W_x_ls_12reg = CCA(X, Y, opts);
     
171. 
     
172. % test 2-norm regularization for ls-lsqr
     
173. opts = [];
     
174. opts.alg = 'ls-lsqr';
     
175. opts.PrjX = 1;
     
176. opts.PrjY = 0;
     
177. opts.reg_2norm = 1;
     
178. opts.lsqr_tol = 1e-6;
     
179. W_x_ls_lsqr_2reg = CCA(X, Y, opts);
     
180. 
     
181. 
     
182. % %=============================================================
     
183. % Part 3. Use 2s and 2s-lsqr implementation
     
184. % Comparison in the un-regularized setting.
     
185. opts = [];
     
186. opts.alg = '2s';
     
187. opts.PrjX = 1;
     
188. opts.PrjY = 0;
     
189. W_x_2s = CCA(X, Y, opts);
     
190. d_2s_eig_eq1 = norm(W_x_2s*W_x_2s' - W_x_eig_c1*W_x_eig_c1');
     
191. if d_2s_eig_eq1<1e-10
     
192.     display('2s implementation is equivalent to eig implementation in un-regularized setting');
     
193. else
     
194.     display('2s implementation is not equivalent to eig implementation in un-regularized setting');
     
195. end
     
196. 
     
197. 
     
198. % Compute projection for 2s-lsqr in the un-regularized setting.
     
199. opts = [];
     
200. opts.alg = '2s-lsqr';
     
201. opts.PrjX = 1;
     
202. opts.PrjY = 0;
     
203. opts.lsqr_tol = 1e-6;
     
204. W_x_2s_lsqr = CCA(X, Y, opts);
     
205. % compute the difference
     
206. d_2s_lsqr_eq = norm(W_x_2s*W_x_2s' - W_x_2s_lsqr*W_x_2s_lsqr');
     
207. if d_2s_lsqr_eq<1e-5
     
208.     display('2s implementation is equivalent to 2s-lsqr implementation (without regularization)');
     
209. else
     
210.     display('ls implementation is not equivalent to ls-lsqr implementation (without regularization)');
     
211. end
     
212. 
     
213. 
     
214. % Comparison in the regularization setting
     
215. opts = [];
     
216. opts.alg = '2s';
     
217. opts.PrjX = 1;
     
218. opts.PrjY = 0;
     
219. opts.reg_2norm = 1;
     
220. W_x_2s_reg = CCA(X, Y, opts);
     
221. 
     
222. % Compute projection for eig implementation
     
223. opts = [];
     
224. opts.alg = 'eig';
     
225. opts.PrjX = 1;
     
226. opts.PrjY = 0;
     
227. opts.regX = 1;
     
228. [W_x_eig_c2, W_y_eig_c2, corr_list_c2] = CCA(X, Y, opts);
     
229. d_2s_eig_eq2 = norm(W_x_2s_reg*W_x_2s_reg' - W_x_eig_c2*W_x_eig_c2');
     
230. if d_2s_eig_eq2<1e-10
     
231.     display('2s implementation is equivalent to eig implementation in regularization setting');
     
232. else
     
233.     display('2s implementation is not equivalent to eig implementation in regularization setting');
     
234. end
     
235. 
     
236. % Compute projection for 2s-lsqr with regularization
     
237. opts = [];
     
238. opts.alg = '2s-lsqr';
     
239. opts.PrjX = 1;
     
240. opts.PrjY = 0;
     
241. opts.lsqr_tol = 1e-6;
     
242. opts.reg_2norm = 1;
     
243. W_x_2s_lsqr_reg = CCA(X, Y, opts);
     
244. % compute the difference
     
245. d_2s_lsqr_reg_eq = norm(W_x_2s_reg*W_x_2s_reg' - W_x_2s_lsqr_reg*W_x_2s_lsqr_reg');
     
246. if d_2s_lsqr_reg_eq<1e-5
     
247.     display('2s implementation is equivalent to 2s-lsqr implementation (with regularization)');
     
248. else
     
249.     display('ls implementation is not equivalent to ls-lsqr implementation (with regularization)');
     
250. end

复制代码

1. % In this script, we demonstrate how to use the HSL function.
   
2. %
   
3. % Copyright(c) Liang Sun (sun.liang@asu.edu), Shuiwang Ji (shuiwang.ji@asu.edu), and Jieping Ye (jieping.ye@asu.edu), Arizona State Univerisity
   
4. %
   
5. 
   
6. clear all; clc;
   
7. addpath('../Functions');
   
8. 
   
9. % Step 1. Load the Scene data set
   
10. data_path = '../Data/Scene.mat';
    
11. S = load(data_path);
    
12. X_all  = S.D';
    
13. Y_all = S.L';
    
14. N = size(X_all, 2);
    
15. 
    
16. % Randomly select 1000 samples for training
    
17. random_N = randperm(N);
    
18. tr_idx = random_N(1:1000)';
    
19. X = X_all(:, tr_idx);
    
20. Y = Y_all(:, tr_idx);
    
21. 
    
22. % % use a random data set for testing
    
23. % X = rand(10, 10);
    
24. % Y = [1 0 0 1 0 1 1 0 1 0;
    
25. %        0 1 1 0 1 0 0 0 0 1;
    
26. %        1 0 1 1 0 0 0 1 0 1];
    
27. 
    
28. % Note that in our implementation, each column correponds to a data point,
    
29. % and each row corresponds to a feature.
    
30. [d, n] = size(X);
    
31. k = size(Y, 1);
    
32. 
    
33. % Step 2. Perform HSL using different implemetations
    
34. % Step 2.1 HSL by solving eigenvalue problem
    
35. % Without regularization: solving the generalized eigenvalue problem
    
36. opts = [];
    
37. opts.Lap_type = 'clique';
    
38. opts.alg = 'eig';
    
39. W_eig_clique = HSL(X, Y, opts);
    
40. 
    
41. opts = [];
    
42. opts.Lap_type = 'star';
    
43. opts.alg = 'eig';
    
44. W_eig_star = HSL(X, Y, opts);
    
45. 
    
46. opts = [];
    
47. opts.Lap_type = 'zhou';
    
48. opts.alg = 'eig';
    
49. W_eig_zhou = HSL(X, Y, opts);
    
50. 
    
51. % Solving Generalized Eigenvalue Problem with Regularization
    
52. opts = [];
    
53. opts.Lap_type = 'clique';
    
54. opts.alg = 'eig';
    
55. opts.reg_eig = 1;
    
56. W_eig_reg = HSL(X, Y, opts);
    
57. 
    
58. % Step 2.2 Solving Least Squares
    
59. % without regularization
    
60. opts = [];
    
61. opts.Lap_type = 'clique';
    
62. opts.alg = 'ls';
    
63. W_ls = HSL(X, Y, opts);
    
64. 
    
65. % Solving Least Squares with Regularization using SVD
    
66. opts = [];
    
67. opts.Lap_type = 'clique';
    
68. opts.alg = 'ls';
    
69. opts.reg_2norm = 1;
    
70. opts.reg_1norm = 0.1;
    
71. W_ls_reg = HSL(X, Y, opts);
    
72. 
    
73. % Solving Least Square with Regularization using LSQR
    
74. opts = [];
    
75. opts.Lap_type = 'clique';
    
76. opts.alg = 'ls-lsqr';
    
77. opts.reg_2norm = 1;
    
78. W_ls_lsqr_reg = HSL(X, Y, opts);
    
79. 
    
80. % Step 2.3 Applying Two-Stage Approach with regularization
    
81. opts = [];
    
82. opts.Lap_type = 'clique';
    
83. opts.alg = '2s';
    
84. opts.reg_2norm = 1;
    
85. W_2s_reg = HSL(X, Y, opts);
    
86. 
    
87. % Applying Two-Stage Approach with Regularization using LSQR
    
88. opts = [];
    
89. opts.Lap_type = 'clique';
    
90. opts.alg = '2s-lsqr';
    
91. opts.reg_2norm = 1;
    
92. W_2s_lsqr_reg = HSL(X, Y, opts);

复制代码

1. % LDA_example.m
   
2. % This script demonstrates how to use the LDA function.
   
3. %
   
4. % Copyright(c) Liang Sun (sun.liang@asu.edu), Shuiwang Ji (shuiwang.ji@asu.edu), and Jieping Ye (jieping.ye@asu.edu), Arizona State Univerisity
   
5. %
   
6. 
   
7. clear all; clc;
   
8. addpath('../Functions');
   
9. 
   
10. % Generate a random data set
    
11. d = 15;
    
12. k = 3;
    
13. n = 10;
    
14. X = rand(d, n);
    
15. Y = rand_label(k, n);
    
16. 
    
17. % Part 1.  No regularization
    
18. % solve the generalized eigenvalue problem
    
19. opts = [];
    
20. opts.alg = 'eig';
    
21. W_eig0 = LDA(X, Y, opts);
    
22. 
    
23. % solve the least squares problem
    
24. opts = [];
    
25. opts.alg = 'ls';
    
26. W_ls0 = LDA(X, Y, opts);
    
27. 
    
28. % apply the two-stage approach
    
29. opts = [];
    
30. opts.alg = '2s';
    
31. W_2s0 = LDA(X, Y, opts);
    
32. 
    
33. % Verify the equivalence relationship in un-regularized setting
    
34. d_eig_ls_0 = norm(W_eig0 * W_eig0' - W_ls0 * W_ls0');
    
35. if d_eig_ls_0 < 1e-10
    
36.     display('eig is equivalent to ls in un-regularized setting');
    
37. else
    
38.     display('eig is not equivalent to ls in un-regularized setting');
    
39. end
    
40. 
    
41. d_eig_2s_0 = norm(W_eig0 * W_eig0' - W_2s0 * W_2s0');
    
42. if d_eig_2s_0 < 1e-10
    
43.     display('eig is equivalent to 2s in un-regularized setting');
    
44. else
    
45.     display('eig is not equivalent to 2s in un-regularized setting');
    
46. end
    
47. 
    
48. % Part 2. Regularization is applied for eig and 2s
    
49. % Verify the equivalence relationship in the regularized setting
    
50. opts = [];
    
51. opts.alg = 'eig';
    
52. opts.reg_eig = 1;
    
53. W_eig1 = LDA(X, Y, opts);
    
54. 
    
55. 
    
56. opts = [];
    
57. opts.alg = '2s';
    
58. opts.reg_2norm = 1;
    
59. W_2s1 = LDA(X, Y, opts);
    
60. d_eig_2s_1 = norm(W_eig1(:,1:(k-1)) * W_eig1(:,1:(k-1))' - W_2s1 * W_2s1');
    
61. if d_eig_2s_1 < 1e-10
    
62.     display('eig is equivalent to 2s in regularized setting');
    
63. else
    
64.     display('eig is not equivalent to 2s in regularized setting');
    
65. end

复制代码

1. % % SSL_example.m
   
2. % This script demonstrates how to use the SSL function..
   
3. %
   
4. % Copyright(c) Liang Sun (sun.liang@asu.edu), Shuiwang Ji (shuiwang.ji@asu.edu), and Jieping Ye (jieping.ye@asu.edu), Arizona State Univerisity
   
5. %
   
6. 
   
7. clear all; clc;
   
8. addpath('../Functions');
   
9. load ../Data/wine.mat
   
10. dim_shared = 2;
    
11. 
    
12. % Please uncomment the following lines if you want to test one of the text
    
13. % data, it might take some time.
    
14. % load science.mat
    
15. % dim_shared = 15;
    
16. 
    
17. % transpose the data in winexy.mat
    
18. X_tr = X_tr';
    
19. Y_tr = Y_tr';
    
20. X_te = X_te';
    
21. Y_te = Y_te';
    
22. 
    
23. X_tr_backup = X_tr;
    
24. X_te_backup = X_te;
    
25. 
    
26. 
    
27. %% ML-LS
    
28. method = 'ML-LS';
    
29. [X_tr, X_te] = preprocess(X_tr_backup, X_te_backup, method);
    
30. clear param;
    
31. param.r =dim_shared;
    
32. param.alpha = 10^-4;
    
33. param.beta = 10^-5;
    
34. model = SSL(X_tr, Y_tr, param);
    
35. 
    
36. % tune the bias for F1
    
37. model.bias = change_bias_for_F1(X_tr', Y_tr', model.W);
    
38. perf = perf_evaluate_multi_label(X_te',Y_te',model.W, model.bias)

复制代码

在这里: https://bbs.pinggu.org/thread-4182469-1-1.html

其他资料在这里：https://bbs.pinggu.org/thread-3747424-1-1.html