Github:Machine Learning using Matlab

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

本帖隐藏的内容

machine-learning-matlab-master.zip (4.56 MB)

2016-4-25 09:10:15 上传

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏4 回帖

关键词：Learning earning machine GitHub MATLAB

LOGISTIC REGRESSION

1. clc; clear; close all;
   
2. 
   
3. load datax.dat;
   
4. load datay.dat;
   
5. 
   
6. X = [ones(size(datax, 1),1) datax];
   
7. Y = datay;
   
8. 
   
9. m = size(X,1);
   
10. n = size(X,2)-1;
    
11. 
    
12. %initialize
    
13. theta = zeros(n+1,1);
    
14. thetaold = ones(n+1,1);
    
15. 
    
16. while ( ((theta-thetaold)'*(theta-thetaold)) > 0.0000001 )
    
17.         %calculate dellltheta
    
18.     dellltheta = zeros(n+1,1);
    
19.         for j=1:n+1,
    
20.                 for i=1:m,
    
21.                         dellltheta(j,1) = dellltheta(j,1) + [Y(i,1) - (1/(1 + exp(-theta'*X(i,:)')))]*X(i,j);
    
22.                 end;
    
23.         end;
    
24.         %calculate hessian
    
25.         H = zeros(n+1, n+1);
    
26.         for j=1:n+1,
    
27.                 for k=1:n+1,
    
28.                                 for i=1:m,
    
29.                                         H(j,k) = H(j,k) -[1/(1 + exp(-theta'*X(i,:)'))]*[1-(1/(1 + exp(-theta'*X(i,:)')))]*[X(i,j)]*[X(i,k)];
    
30.                                 end;
    
31.                 end;
    
32.         end;
    
33.         thetaold = theta;
    
34.         theta = theta - inv(H)*dellltheta;
    
35.         (theta-thetaold)'*(theta-thetaold)
    
36. end
    
37. 
    
38. 
    
39. 
    
40. %part b
    
41. figure(1); hold on;
    
42. X0 = []; Y0 = []; X1 = []; Y1 = [];
    
43. 
    
44. %training points
    
45. for i=1:m,
    
46.         if Y(i)==0
    
47.                 X0 = [X0 X(i,2)];
    
48.                 Y0 = [Y0 X(i,3)];
    
49.         else
    
50.                 X1 = [X1 X(i,2)];
    
51.                 Y1 = [Y1 X(i,3)];
    
52.         end;
    
53. end;
    
54. scatter(X0, Y0, 'o');
    
55. scatter(X1, Y1, '+');
    
56. 
    
57. %decision boundary
    
58. Xb = -2:0.01:8;
    
59. Yb = (0.5 - theta(1) - theta(2)*Xb)/(theta(3));
    
60. plot(Xb, Yb);

复制代码

Locally-Weighted-Linear-Regression

1. clc; clear; close all;
   
2. 
   
3. load datax.dat;
   
4. load datay.dat;
   
5. 
   
6. X = [ones(size(datax, 1),1) datax];
   
7. Y = datay;
   
8. 
   
9. m = size(X,1);
   
10. n = size(X,2)-1;
    
11. 
    
12. %part a
    
13. figure(1); hold on;
    
14. theta = inv(X'*X)*X'*Y;
    
15. scatter (q2x, Y);
    
16. Xp = -6:0.01:13;
    
17. Yp = theta(1) + theta(2)*Xp;
    
18. plot (Xp, Yp);
    
19. 
    
20. %part b
    
21. figure(2); hold on;
    
22. W = zeros(m);
    
23. t = 0.8;
    
24. LWRXp = -6:0.01:13;
    
25. LWRYp = [];
    
26. for temp = 1:size(LWRXp,2),
    
27.         for i=1:m,
    
28.                 W(i,i) = 0.5 * exp(-((LWRXp(temp)-X(i,2))^2)/(2*t*t));
    
29.         end;
    
30.         theta = inv(X'*W*X)*X'*W*Y;
    
31.         LWRYp(temp) = theta(1)+theta(2)*LWRXp(temp);
    
32. end;
    
33. scatter (q2x, Y);
    
34. plot (LWRXp, LWRYp);
    
35. 
    
36. %part c
    
37. figure(3); hold on;
    
38. scatter (q2x, Y);
    
39. W = zeros(m);
    
40. t_array = [0.1, 0.3, 2,10];
    
41. LWRXp = -6:0.01:13;
    
42. LWRYp = [];
    
43. for t=1:4,
    
44.         for temp = 1:size(LWRXp,2),
    
45.                 for i=1:m,
    
46.                         W(i,i) = 0.5 * exp(-((LWRXp(temp)-X(i,2))^2)/(2*t_array(t)*t_array(t)));
    
47.                 end;
    
48.                 theta = inv(X'*W*X)*X'*W*Y;
    
49.                 LWRYp(t,temp) = theta(1)+theta(2)*LWRXp(temp);
    
50.         end;
    
51. end;
    
52. plot (LWRXp, LWRYp);

复制代码

Linear Regression With Polynomial Basis

1. clc; clear; close all;
   
2. 
   
3. %fileread
   
4. Xtrain_tmp = []; Ytrain_tmp = [];
   
5. Xtest_tmp = []; Ytest_tmp = [];
   
6. 
   
7. fileID = fopen('q3.dat');
   
8. 
   
9. for linenum = 1:101
   
10.         C = textscan(fileID,'%s', 8, 'CommentStyle',{'"', '"'});
    
11.         if strcmp(C{1,1},'?') == 0
    
12.                 Xtrain_tmp = [Xtrain_tmp; C{1,1}(2:8,1)'];
    
13.                 Ytrain_tmp = [Ytrain_tmp; C{1,1}(1,1)];
    
14.         end
    
15. end;
    
16. Xtrain = str2double(Xtrain_tmp);
    
17. Ytrain = str2double(Ytrain_tmp);
    
18. mtrain = size(Xtrain,1);
    
19. 
    
20. for linenum = 102:399
    
21.         C = textscan(fileID,'%s', 8, 'CommentStyle',{'"', '"'});
    
22.         if strcmp(C{1,1},'?') == 0
    
23.                 Xtest_tmp = [Xtest_tmp; C{1,1}(2:8,1)'];
    
24.                 Ytest_tmp = [Ytest_tmp; C{1,1}(1,1)];
    
25.         end
    
26. end;
    
27. Xtest = str2double(Xtest_tmp);
    
28. Ytest = str2double(Ytest_tmp);
    
29. mtest = size(Xtest,1);
    
30. 
    
31. %normalize
    
32. XMin = min([Xtrain; Xtest]);
    
33. XMax = max([Xtrain; Xtest]);
    
34. YMin = mean([Ytrain; Ytest]);
    
35. YMax = std([Ytrain; Ytest]);
    
36. Xtrain = (Xtrain - repmat(XMin,mtrain,1))./(repmat(XMax,mtrain,1) - repmat(XMin,mtrain,1));
    
37. Xtest = (Xtest - repmat(XMin,mtest,1))./(repmat(XMax,mtest,1) - repmat(XMin,mtest,1));
    
38. Ytrain = (Ytrain - repmat(YMin,mtrain,1))./(repmat(YMax,mtrain,1) - repmat(YMin,mtrain,1));
    
39. Ytest = (Ytest - repmat(YMin,mtest,1))./(repmat(YMax,mtest,1) - repmat(YMin,mtest,1));
    
40. 
    
41. fclose(fileID);
    
42. max_dimension = 10;
    
43. 
    
44. % part a and b
    
45. training_error = zeros(max_dimension,1);
    
46. test_error = zeros(max_dimension,1);
    
47. figure(1); hold on;
    
48. for d = 1:max_dimension
    
49.         X = [ones(size(Xtrain, 1),1) Xtrain];
    
50.         Xtest_s = [ones(size(Xtest, 1),1) Xtest];
    
51.         for j=2:8,
    
52.                 for k=2:d,
    
53.                         X = [X X(:,j).^k];
    
54.                         Xtest_s = [Xtest_s Xtest_s(:,j).^k];
    
55.                 end;
    
56.         end;
    
57.        
    
58.         theta_closed = pinv(X'*X)*X'*Ytrain;
    
59.        
    
60.         n = size(X,2)-1;
    
61.         alpha = 0.01;
    
62.         theta_grad = zeros(n+1,1);
    
63.         for k = 1:1000,
    
64.                 for i=1:mtrain,
    
65.                         theta_grad = theta_grad + alpha * (Ytrain(i) - theta_grad'*X(i,:)') * X(i,:)';
    
66.                 end;
    
67.         end;
    
68.        
    
69.         difference = norm(theta_grad - theta_closed)/size(theta_grad,1);
    
70.        
    
71.         for i=1:mtrain,
    
72.                 training_error(d) = training_error(d) + (Ytrain(i) -(theta_grad'*X(i,:)'))^2;
    
73.         end;
    
74.         for i=1:mtest,
    
75.                 test_error(d) = test_error(d) + (Ytest(i) -(theta_grad'*Xtest_s(i,:)'))^2;
    
76.         end;
    
77. end;
    
78. plot (1:max_dimension, training_error);
    
79. plot (1:max_dimension, test_error);
    
80. 
    
81. % part c and d
    
82. training_error = zeros(max_dimension,1);
    
83. test_error = zeros(max_dimension,1);
    
84. figure (2); hold on;
    
85. scatter (Xtrain(:,3), Ytrain);
    
86. for d = 1:max_dimension
    
87.         X = [ones(size(Xtrain, 1),1) Xtrain(:,3)];
    
88.         Xtest_s = [ones(size(Xtest, 1),1) Xtest(:,3)];
    
89.         for j=2:2,
    
90.                 for k=2:d,
    
91.                         X = [X X(:,j).^k];
    
92.                         Xtest_s = [Xtest_s Xtest_s(:,j).^k];
    
93.                 end;
    
94.         end;
    
95. 
    
96.         n = size(X,2)-1;
    
97. 
    
98.         alpha = 0.01;
    
99.         theta_grad = zeros(n+1,1);
    
100.         for k = 1:1000,
     
101.                 for i=1:mtrain,
     
102.                         theta_grad = theta_grad + alpha * (Ytrain(i) - theta_grad'*X(i,:)') * X(i,:)';
     
103.                 end;
     
104.         end;
     
105.        
     
106.         if ((d==1)||(d==2)||(d==8))
     
107.                 X_plot = 0:0.01:1;
     
108.                 Y_plot = [];
     
109.                 for i=0:0.01:1,
     
110.                         X_matrix = [1];
     
111.                         for k = 1:d,
     
112.                                 X_matrix = [X_matrix; i.^k];
     
113.                         end;
     
114.                         Y_plot = [Y_plot, theta_grad'*X_matrix];
     
115.                 end;
     
116.                 plot (X_plot,Y_plot);
     
117.         end;
     
118.        
     
119.         for i=1:mtrain,
     
120.                 training_error(d) = training_error(d) + (Ytrain(i) -(theta_grad'*X(i,:)'))^2;
     
121.         end;
     
122.         for i=1:mtest,
     
123.                 test_error(d) = test_error(d) + (Ytest(i) -(theta_grad'*Xtest_s(i,:)'))^2;
     
124.         end;
     
125. end;
     
126. 
     
127. figure(3); hold on;
     
128. plot (1:max_dimension, training_error);
     
129. plot (1:max_dimension, test_error);
     
130. 
     
131. %part e
     
132. training_error = zeros(6,1);
     
133. test_error = zeros(6,1);
     
134. figure (4); hold on;
     
135. d=8;
     
136. gn=0;
     
137. for gamma = [0.01, 0.1, 1, 10, 100, 1000]
     
138.         gn = gn+1;
     
139.         X = [ones(size(Xtrain, 1),1) Xtrain(:,3)];
     
140.         Xtest_s = [ones(size(Xtest, 1),1) Xtest(:,3)];
     
141.         for j=2:2,
     
142.                 for k=2:d,
     
143.                         X = [X X(:,j).^k];
     
144.                         Xtest_s = [Xtest_s Xtest_s(:,j).^k];
     
145.                 end;
     
146.         end;
     
147. 
     
148.         n = size(X,2)-1;
     
149. 
     
150.         alpha = 0.01;
     
151.         theta_grad = zeros(n+1,1);
     
152.         for k = 1:1000,
     
153.                 for i=1:mtrain,
     
154.                         theta_grad = theta_grad + alpha * ((Ytrain(i) - theta_grad'*X(i,:)') * X(i,:)' - gamma*theta_grad);
     
155.                 end;
     
156.         end;
     
157.        
     
158.         X_plot = 0:0.01:1;
     
159.         Y_plot = [];
     
160.         for i=0:0.01:1,
     
161.                 X_matrix = [1];
     
162.                 for k = 1:d,
     
163.                         X_matrix = [X_matrix; i.^k];
     
164.                 end;
     
165.                 Y_plot = [Y_plot, theta_grad'*X_matrix];
     
166.         end;
     
167.         plot (X_plot,Y_plot);
     
168. 
     
169.        
     
170.         for i=1:mtrain,
     
171.                 training_error(gn) = training_error(gn) + (Ytrain(i) -(theta_grad'*X(i,:)'))^2;
     
172.         end;
     
173.         for i=1:mtest,
     
174.                 test_error(gn) = test_error(gn) + (Ytest(i) -(theta_grad'*Xtest_s(i,:)'))^2;
     
175.         end;
     
176. end;
     
177. figure(5);
     
178. semilogx ([0.01, 0.1, 1, 10, 100, 1000], training_error, [0.01, 0.1, 1, 10, 100, 1000], test_error);
     
179. 
     
180. 
     
181. %part f
     
182. XYdata = [Xtrain Ytrain];
     
183. I_rand = XYdata(randperm(size(Xtrain,1)), :);
     
184. Xtrain = I_rand(:,1:7);
     
185. Ytrain = I_rand(:,8);
     
186. test_error = zeros(6,5);
     
187. test_error_avg = zeros(6,1);
     
188. mtrain_new = 80;
     
189. mtest_new = 20;
     
190. 
     
191. figure (6); hold on;
     
192. scatter (Xtrain(:,3), Ytrain);
     
193. d=8;
     
194. gn=0;
     
195. for gamma = [0.01, 0.1, 1, 10, 100, 1000]
     
196.         gn = gn+1;
     
197.         for cn = 1:5
     
198.                 if (cn==5)
     
199.                         Xnewtrain = [Xtrain(1:20*(cn-1),:)];
     
200.                 else
     
201.                         Xnewtrain = [Xtrain(1:20*(cn-1),:);Xtrain(20*cn+1:100,:)];
     
202.                 end
     
203.                 Xnewtest = [Xtrain(1+20*(cn-1):20*cn,:)];
     
204.                
     
205.                 X = [ones(size(Xnewtrain, 1),1) Xnewtrain(:,3)];
     
206.                 Xtest_s = [ones(size(Xnewtest, 1),1) Xnewtest(:,3)];
     
207.                 for j=2:2,
     
208.                         for k=2:d,
     
209.                                 X = [X X(:,j).^k];
     
210.                                 Xtest_s = [Xtest_s Xtest_s(:,j).^k];
     
211.                         end;
     
212.                 end;
     
213. 
     
214.                 n = size(X,2)-1;
     
215. 
     
216.                 alpha = 0.01;
     
217.                 theta_grad = zeros(n+1,1);
     
218.                 for k = 1:1000,
     
219.                         for i=1:mtrain_new,
     
220.                                 theta_grad = theta_grad + alpha * ((Ytrain(i) - theta_grad'*X(i,:)') * X(i,:)' - gamma*theta_grad);
     
221.                         end;
     
222.                 end;
     
223. 
     
224.                 for i=1:mtest_new,
     
225.                         test_error(gn,cn) = test_error(gn) + (Ytest(i) -(theta_grad'*Xtest_s(i,:)'))^2;
     
226.                 end;
     
227.         end;
     
228.         test_error_avg(gn) = ( test_error(gn,1) + test_error(gn,2) + test_error(gn,3) + test_error(gn,4) + test_error(gn,5) ) / 5;
     
229. end;
     
230. figure(7);
     
231. semilogx ([0.01, 0.1, 1, 10, 100, 1000], test_error_avg);

复制代码

1. clc; clear; close all;
   
2. 
   
3. % Note: Run wrapper.pl first
   
4. 
   
5. [Ytrain, Xtrain] = libsvmread('q4train_mod.dat');
   
6. [Ytest, Xtest] = libsvmread('q4test_mod.dat');
   
7. 
   
8. mtrain = size(Xtrain,1);
   
9. mtest = size(Xtest,1);
   
10. n = size(Xtrain,2);
    
11. 
    
12. % part a
    
13. % learn perceptron
    
14. Xtrain_perceptron = [ones(mtrain,1) Xtrain];
    
15. Xtest_perceptron = [ones(mtest,1) Xtest];
    
16. alpha = 0.1;
    
17. %initialize
    
18. theta_perceptron = zeros(n+1,1);
    
19. trainerror_mag = 100000;
    
20. iteration = 0;
    
21. %loop
    
22. while (trainerror_mag>1000)
    
23.         iteration = iteration+1;
    
24.         for i = 1 : mtrain
    
25.                 Ypredict_temp = sign(theta_perceptron'*Xtrain_perceptron(i,:)');
    
26.                 theta_perceptron = theta_perceptron + alpha*(Ytrain(i)-Ypredict_temp)*Xtrain_perceptron(i,:)';
    
27.         end
    
28.         Ytrainpredict_perceptron = sign(theta_perceptron'*Xtrain_perceptron')';
    
29.         trainerror_mag = (Ytrainpredict_perceptron - Ytrain)'*(Ytrainpredict_perceptron - Ytrain)
    
30. end
    
31. Ytestpredict_perceptron = sign(theta_perceptron'*Xtest_perceptron')';
    
32. testerror_mag = (Ytestpredict_perceptron - Ytest)'*(Ytestpredict_perceptron - Ytest)
    
33. 
    
34. %part b
    
35. theta_svm = svmtrain(Ytrain, Xtrain, '-t 0');
    
36. [Ytestpredict_svm, svm_accuracy, decision_values] = svmpredict(Ytest, Xtest, theta_svm);
    
37. 
    
38. %part c
    
39. accuracy = zeros(9,1);
    
40. for mtemp = 1000:1000:9000
    
41.         theta_svm = svmtrain(Ytrain(1:mtemp,:), Xtrain(1:mtemp,:), '-t 0');
    
42.         [Ytestpredict_svm, accuracy_temp, decision_values] = svmpredict(Ytest, Xtest, theta_svm);
    
43.         accuracy(mtemp/1000) = accuracy_temp(1,1);
    
44. end
    
45. plot (1000:1000:9000, accuracy);
    
46. 
    
47. %part d
    
48. numberofSV = theta_svm.nSV;
    
49. 
    
50. [spamValues,spamIndex] = sort(theta_svm.sv_coef,'ascend');
    
51. hamindices = theta_svm.sv_indices(spamIndex(1:5));
    
52. spamindices = theta_svm.sv_indices(spamIndex(theta_svm.totalSV-4:theta_svm.totalSV))
    
53. 
    
54. for i=1:numberofSV
    
55.         Y(i) = Ytrain(theta_svm.sv_indices(i));
    
56.         alpha_svm(i) = theta_svm.sv_coef(i)./Y(i);
    
57. end
    
58. 
    
59. %part e
    
60. w = theta_svm.SVs' * theta_svm.sv_coef;
    
61. b = -theta_svm.rho;
    
62. if theta_svm.Label(1) == -1
    
63.   w = -w;
    
64.   b = -b;
    
65. end
    
66. distance = 1/norm(w);
    
67. 
    
68. %part f
    
69. theta_svm = svmtrain(Ytrain, Xtrain, '-t 2');
    
70. [Ytestpredict_svm, rbf_accuracy, decision_values] = svmpredict(Ytest, Xtest, theta_svm);
    
71. 
    
72. %part g
    
73. XtrainMean = repmat(mean(Xtrain),mtrain,1);
    
74. XtrainVariance = repmat(std(Xtrain),mtrain,1);
    
75. Xtrain_n = (Xtrain - XtrainMean)./(XtrainVariance);
    
76. XtestMean = repmat(mean(Xtest),mtest,1);
    
77. XtestVariance = repmat(std(Xtest),mtest,1);
    
78. Xtest_n = (Xtest - XtrainMean)./(XtrainVariance);
    
79. 
    
80. theta_svm = svmtrain(Ytrain, Xtrain_n, '-t 0');
    
81. [Ytestpredict_svm, norm_svm_accuracy, decision_values] = svmpredict(Ytest, Xtest_n, theta_svm);
    
82. theta_svm = svmtrain(Ytrain, Xtrain_n, '-t 2');
    
83. [Ytestpredict_svm, norm_rbf_accuracy, decision_values] = svmpredict(Ytest, Xtest_n, theta_svm);
    
84. 
    
85. %part h
    
86. rbf_accuracy = zeros(19,1);
    
87. i = 0;
    
88. for gamma_i = 0.00010:0.00005:0.00100
    
89.         i = i+1;
    
90.         arguments_i  = strcat('-t 2 -g',{' '},num2str(gamma_i))
    
91.         theta_svm = svmtrain(Ytrain, Xtrain, arguments_i{1,1})
    
92.         [Ytestpredict_svm, temp_rbf_accuracy, decision_values] = svmpredict(Ytest, Xtest, theta_svm);
    
93.         rbf_accuracy(i) = temp_rbf_accuracy(1,1);
    
94. end
    
95. plot (0.00010:0.00005:0.00100, rbf_accuracy);
    
96. 
    
97. %part i
    
98. %in report

复制代码

感谢分享

look it thanks

kankan