Github:Stanford Machine Learning Course

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

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

立即领取

感谢您参与论坛问题回答

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

+2 论坛币

本帖隐藏的内容

https://github.com/zhouxc/Stanford-Machine-Learning-Course

扫码加我 拉你入群

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

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

分享0 收藏4 回帖

关键词：Learning stanford earning machine GitHub

1. #! /usr/bin/python
   
2. # driver.py
   
3. 
   
4. # imports
   
5. from __future__ import division
   
6. from optparse import OptionParser
   
7. import sys
   
8. import os
   
9. 
   
10. from util import *
    
11. from dataset import DataSet
    
12. from hmm import *
    
13. 
    
14. import sys
    
15. 
    
16. 
    
17. def split_into_categories(d):
    
18.     """given a dataset d, return a dict mapping categories
    
19.     to arrays of observation sequences.  Only splits the training data"""
    
20.     a = {}
    
21.     for seqnum in range(len(d.train_output)):
    
22.         seq = d.train_output[seqnum]
    
23.         category = d.states[d.train_state[seqnum][0]]
    
24.         if category in a:
    
25.             a[category].append(seq)
    
26.         else:
    
27.             a[category] = [seq]
    
28. 
    
29.     return a
    
30. 
    
31. 
    
32. def train_N_state_hmms_from_data(filename, num_states, debug=False):
    
33.     """ reads all the data, then split it up into each category, and then
    
34.     builds a separate hmm for each category in data """
    
35.     dataset = DataSet(filename)
    
36.     category_seqs = split_into_categories(dataset)
    
37.    
    
38.     # Build a hmm for each category in data
    
39.     hmms = {}
    
40.     for cat, seqs in category_seqs.items():
    
41.         if debug:
    
42.             print "\n\nLearning %s-state HMM for category %s" % (num_states, cat)
    
43.         
    
44.         model = HMM(range(num_states), dataset.outputs)
    
45.         model.learn_from_observations(seqs, debug)
    
46.         hmms[cat] = model
    
47.         if debug:
    
48.             print "The learned model for %s:" % cat
    
49.             print model
    
50.     return (hmms, dataset)
    
51. 
    
52. 
    
53. 
    
54. 
    
55. @print_timing
    
56. def compute_classification_performance(hmms, dataset, debug=False):
    
57.     if debug:
    
58.         print "Classifying test sequences"
    
59.     total = 0
    
60.     errors = 0
    
61.     for seqnum in range(len(dataset.test_output)):
    
62.         total += 1
    
63.         seq = dataset.test_output[seqnum]
    
64.         actual_category = dataset.states[dataset.test_state[seqnum][0]]
    
65.         log_probs = [(cat, hmms[cat].log_prob_of_sequence(seq))
    
66.                      for cat in hmms.keys()]
    
67.         # Want biggest first...
    
68.         log_probs.sort(lambda a,b: cmp(b[1], a[1]))
    
69.         if debug:
    
70.             ll_str = " ".join(["%s=%.4f" % (c, v) for c,v in log_probs])
    
71.             #print "Actual: %s; [%s]" % (actual_category, ll_str)
    
72. 
    
73.         # Sorted, so the first one is the one we predicted.
    
74.         best_cat = log_probs[0][0]
    
75.         if actual_category != best_cat:
    
76.             errors += 1
    
77.     fraction_incorrect = errors * 1.0 / total
    
78.     #if debug:
    
79.     print "Classification mistakes: %d / %d = %.3f" % (errors, total, fraction_incorrect)
    
80.     return fraction_incorrect
    
81.    
    
82. 
    
83. def main(argv=None):
    
84.     if argv is None:
    
85.         argv = sys.argv
    
86. 
    
87.     usage = "usage: %prog [options] N datafile (pass -h for more info)"
    
88.     parser = OptionParser(usage)
    
89.     parser.add_option("-v", "--verbose",
    
90.                       action="store_true", dest="verbose", default=False,
    
91.                       help="Print extra debugging info")
    
92. 
    
93.     (options, args) = parser.parse_args(argv[1:])
    
94.     if len(args) != 2:
    
95.         print "ERROR: Missing arguments"
    
96.         parser.print_usage()
    
97.         sys.exit(1)
    
98.         
    
99.     num_states = int(args[0])
    
100.     filename = args[1]
     
101.     filename = normalize_filename(filename)
     
102. 
     
103.     # Read all the data, then split it up into each category
     
104.     # Build models from the category data files
     
105.     hmms, dataset = train_N_state_hmms_from_data(filename, num_states, options.verbose)
     
106.    
     
107.     # See how well we do in classifying test sequences
     
108.     fraction_incorrect = compute_classification_performance(hmms, dataset, options.verbose)   
     
109.    
     
110.     return 0
     
111. 
     
112. if __name__ == "__main__":
     
113.     sys.exit(main())

复制代码

1. function [theta, J_history] = gradientDescent(X, y, theta, alpha, num_iters)
   
2. %GRADIENTDESCENT Performs gradient descent to learn theta
   
3. %   theta = GRADIENTDESENT(X, y, theta, alpha, num_iters) updates theta by
   
4. %   taking num_iters gradient steps with learning rate alpha
   
5. 
   
6. % Initialize some useful values
   
7. m = length(y); % number of training examples
   
8. J_history = zeros(num_iters, 1);
   
9. 
   
10. for iter = 1:num_iters
    
11. 
    
12.     % ====================== YOUR CODE HERE ======================
    
13.     % Instructions: Perform a single gradient step on the parameter vector
    
14.     %               theta.
    
15.     %
    
16.     % Hint: While debugging, it can be useful to print out the values
    
17.     %       of the cost function (computeCost) and gradient here.
    
18.     %
    
19. 
    
20.         H = X * theta;
    
21.         T = [0 ; 0];
    
22.         for i = 1 : m,
    
23.                 T = T + (H(i) - y(i)) * X(i,:)';       
    
24.         end
    
25.        
    
26.         theta = theta - (alpha * T) / m;
    
27.        
    
28.     % ============================================================
    
29. 
    
30.     % Save the cost J in every iteration   
    
31.     J_history(iter) = computeCost(X, y, theta);
    
32. 
    
33. end
    
34. 
    
35. end

复制代码

1. %% Machine Learning Online Class - Exercise 3 | Part 1: One-vs-all
   
2. 
   
3. %  Instructions
   
4. %  ------------
   
5. %
   
6. %  This file contains code that helps you get started on the
   
7. %  linear exercise. You will need to complete the following functions
   
8. %  in this exericse:
   
9. %
   
10. %     lrCostFunction.m (logistic regression cost function)
    
11. %     oneVsAll.m
    
12. %     predictOneVsAll.m
    
13. %     predict.m
    
14. %
    
15. %  For this exercise, you will not need to change any code in this file,
    
16. %  or any other files other than those mentioned above.
    
17. %
    
18. 
    
19. %% Initialization
    
20. clear ; close all; clc
    
21. 
    
22. %% Setup the parameters you will use for this part of the exercise
    
23. input_layer_size  = 400;  % 20x20 Input Images of Digits
    
24. num_labels = 10;          % 10 labels, from 1 to 10   
    
25.                           % (note that we have mapped "0" to label 10)
    
26. 
    
27. %% =========== Part 1: Loading and Visualizing Data =============
    
28. %  We start the exercise by first loading and visualizing the dataset.
    
29. %  You will be working with a dataset that contains handwritten digits.
    
30. %
    
31. 
    
32. % Load Training Data
    
33. fprintf('Loading and Visualizing Data ...\n')
    
34. 
    
35. load('ex3data1.mat'); % training data stored in arrays X, y
    
36. m = size(X, 1);
    
37. 
    
38. % Randomly select 100 data points to display
    
39. rand_indices = randperm(m);
    
40. sel = X(rand_indices(1:100), :);
    
41. 
    
42. displayData(sel);
    
43. 
    
44. fprintf('Program paused. Press enter to continue.\n');
    
45. pause;
    
46. 
    
47. %% ============ Part 2: Vectorize Logistic Regression ============
    
48. %  In this part of the exercise, you will reuse your logistic regression
    
49. %  code from the last exercise. You task here is to make sure that your
    
50. %  regularized logistic regression implementation is vectorized. After
    
51. %  that, you will implement one-vs-all classification for the handwritten
    
52. %  digit dataset.
    
53. %
    
54. 
    
55. fprintf('\nTraining One-vs-All Logistic Regression...\n')
    
56. 
    
57. lambda = 0.1;
    
58. [all_theta] = oneVsAll(X, y, num_labels, lambda);
    
59. 
    
60. fprintf('Program paused. Press enter to continue.\n');
    
61. pause;
    
62. 
    
63. 
    
64. %% ================ Part 3: Predict for One-Vs-All ================
    
65. %  After ...
    
66. pred = predictOneVsAll(all_theta, X);
    
67. 
    
68. fprintf('\nTraining Set Accuracy: %f\n', mean(double(pred == y)) * 100);

复制代码

你好啊

回帖看内容

感谢分享！

感谢分享

感谢分享