[Microsoft Cognitive Toolkit]Classify Cancer Using Feed Forward Network

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

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

立即领取

感谢您参与论坛问题回答

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

+2 论坛币

The purpose of this tutorial is to familiarize you with quickly combining components from the CNTK python library to perform a classification task. You may skip Introduction section, if you have already completed the Logistic Regression tutorial or are familiar with machine learning.
IntroductionProblem
A cancer hospital has provided data and wants us to determine if a patient has a fatal malignant cancer vs. a benign growth. This is known as a classification problem. To help classify each patient, we are given their age and the size of the tumor. Intuitively, one can imagine that younger patients and/or patient with small tumor size are less likely to have malignant cancer. The data set simulates this application where the each observation is a patient represented as a dot where red color indicates malignant and blue indicates a benign disease. Note: This is a toy example for learning, in real life there are large number of features from different tests/examination sources and doctors'  experience that play into the diagnosis/treatment decision for a patient.

本帖隐藏的内容

Classify Cancer Using Feed Forward Network.pdf (104.57 KB)

2017-9-17 02:26:21 上传

扫码加我 拉你入群

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

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

分享0 收藏1 回帖

关键词：Microsoft Cognitive Toolkit Micro soft

1. # Import the relevant components
   
2. from __future__ import print_function # Use a function definition from future version (say 3.x from 2.7 interpreter)
   
3. import matplotlib.pyplot as plt
   
4. %matplotlib inline
   
5. 
   
6. import numpy as np
   
7. import sys
   
8. import os
   
9. 
   
10. import cntk as C
    
11. import cntk.tests.test_utils
    
12. cntk.tests.test_utils.set_device_from_pytest_env() # (only needed for our build system)
    
13. C.cntk_py.set_fixed_random_seed(1) # fix a random seed for CNTK components

复制代码

1. # Helper function to generate a random data sample
   
2. def generate_random_data_sample(sample_size, feature_dim, num_classes):
   
3.     # Create synthetic data using NumPy.
   
4.     Y = np.random.randint(size=(sample_size, 1), low=0, high=num_classes)
   
5. 
   
6.     # Make sure that the data is separable
   
7.     X = (np.random.randn(sample_size, feature_dim)+3) * (Y+1)
   
8.     X = X.astype(np.float32)   
   
9.     # converting class 0 into the vector "1 0 0",
   
10.     # class 1 into vector "0 1 0", ...
    
11.     class_ind = [Y==class_number for class_number in range(num_classes)]
    
12.     Y = np.asarray(np.hstack(class_ind), dtype=np.float32)
    
13.     return X, Y

复制代码

1. # Create the input variables denoting the features and the label data. Note: the input
   
2. # does not need additional info on number of observations (Samples) since CNTK first create only
   
3. # the network tooplogy first
   
4. mysamplesize = 64
   
5. features, labels = generate_random_data_sample(mysamplesize, input_dim, num_output_classes)

复制代码

1. # Plot the data
   
2. import matplotlib.pyplot as plt
   
3. %matplotlib inline
   
4. 
   
5. # given this is a 2 class
   
6. colors = ['r' if l == 0 else 'b' for l in labels[:,0]]
   
7. 
   
8. plt.scatter(features[:,0], features[:,1], c=colors)
   
9. plt.xlabel("Scaled age (in yrs)")
   
10. plt.ylabel("Tumor size (in cm)")
    
11. plt.show()

复制代码

1. Model Creation
   
2. Our feed forward network will be relatively simple with 2 hidden layers (num_hidden_layers) with each layer having 50 hidden nodes (hidden_layers_dim).
   
3. In [10]:
   
4. # Figure 3
   
5. Image(url="http://cntk.ai/jup/feedforward_network.jpg", width=200, height=200)

复制代码

1. Feed forward network setup
   
2. 
   
3. In [13]:
   
4. def linear_layer(input_var, output_dim):
   
5. input_dim = input_var.shape[0]
   
6. 
   
7. weight = C.parameter(shape=(input_dim, output_dim))
   
8. bias = C.parameter(shape=(output_dim))
   
9. 
   
10. return bias + C.times(input_var, weight)
    
11. 
    
12. In [14]:
    
13. def dense_layer(input_var, output_dim, nonlinearity):
    
14. l = linear_layer(input_var, output_dim)
    
15. 
    
16. return nonlinearity(l)
    
17. 
    
18. In [15]:
    
19. # Define a multilayer feedforward classification model
    
20. def fully_connected_classifier_net(input_var, num_output_classes, hidden_layer_dim,
    
21. num_hidden_layers, nonlinearity):
    
22. 
    
23. h = dense_layer(input_var, hidden_layer_dim, nonlinearity)
    
24. for i in range(1, num_hidden_layers):
    
25. h = dense_layer(h, hidden_layer_dim, nonlinearity)
    
26. 
    
27. return linear_layer(h, num_output_classes)
    
28. 
    
29. The network output z will be used to represent the output of a network across.
    
30. In [16]:
    
31. # Create the fully connected classfier
    
32. z = fully_connected_classifier_net(input, num_output_classes, hidden_layers_dim,
    
33. num_hidden_layers, C.sigmoid)
    
34. 
    
35. In [17]:
    
36. def create_model(features):
    
37. with C.layers.default_options(init=C.layers.glorot_uniform(), activation=C.sigmoid):
    
38. h = features
    
39. for _ in range(num_hidden_layers):
    
40. h = C.layers.Dense(hidden_layers_dim)(h)
    
41. last_layer = C.layers.Dense(num_output_classes, activation = None)
    
42. 
    
43. return last_layer(h)
    
44. 
    
45. z = create_model(input)

复制代码

1. # Instantiate the trainer object to drive the model training
   
2. learning_rate = 0.5
   
3. lr_schedule = C.learning_rate_schedule(learning_rate, C.UnitType.minibatch)
   
4. learner = C.sgd(z.parameters, lr_schedule)
   
5. trainer = C.Trainer(z, (loss, eval_error), [learner])
   
6. 
   
7. First lets create some helper functions that will be needed to visualize different functions associated with training.
   
8. In [21]:
   
9. # Define a utility function to compute the moving average sum.
   
10. # A more efficient implementation is possible with np.cumsum() function
    
11. def moving_average(a, w=10):   
    
12.     if len(a) < w:
    
13.         return a[:]    # Need to send a copy of the array
    
14.     return [val if idx < w else sum(a[(idx-w):idx])/w for idx, val in enumerate(a)]
    
15. 
    
16. 
    
17. # Defines a utility that prints the training progress
    
18. def print_training_progress(trainer, mb, frequency, verbose=1):   
    
19.     training_loss = "NA"
    
20.     eval_error = "NA"
    
21. 
    
22.     if mb%frequency == 0:
    
23.         training_loss = trainer.previous_minibatch_loss_average
    
24.         eval_error = trainer.previous_minibatch_evaluation_average
    
25.         if verbose:
    
26.             print ("Minibatch: {}, Train Loss: {}, Train Error: {}".format(mb, training_loss, eval_error))
    
27.         
    
28.     return mb, training_loss, eval_error

复制代码

1. In [22]:
   
2. # Initialize the parameters for the trainer
   
3. minibatch_size = 25
   
4. num_samples = 20000
   
5. num_minibatches_to_train = num_samples / minibatch_size

复制代码

1. In [23]:
   
2. # Run the trainer and perform model training
   
3. training_progress_output_freq = 20
   
4. 
   
5. plotdata = {"batchsize":[], "loss":[], "error":[]}
   
6. 
   
7. for i in range(0, int(num_minibatches_to_train)):
   
8.     features, labels = generate_random_data_sample(minibatch_size, input_dim, num_output_classes)
   
9.    
   
10.     # Specify the input variables mapping in the model to actual minibatch data for training
    
11.     trainer.train_minibatch({input : features, label : labels})
    
12.     batchsize, loss, error = print_training_progress(trainer, i,
    
13.                                                      training_progress_output_freq, verbose=0)
    
14.    
    
15.     if not (loss == "NA" or error =="NA"):
    
16.         plotdata["batchsize"].append(batchsize)
    
17.         plotdata["loss"].append(loss)
    
18.         plotdata["error"].append(error)

复制代码