':
69 | break
70 | decoded.append(' '.join(words))
71 | if singleton:
72 | decoded = decoded[0]
73 | return decoded
74 |
75 |
76 | def sample_coco_minibatch(data, batch_size=100, split='train'):
77 | split_size = data['%s_captions' % split].shape[0]
78 | mask = np.random.choice(split_size, batch_size)
79 | captions = data['%s_captions' % split][mask]
80 | image_idxs = data['%s_image_idxs' % split][mask]
81 | image_features = data['%s_features' % split][image_idxs]
82 | urls = data['%s_urls' % split][image_idxs]
83 | return captions, image_features, urls
84 |
85 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/cs231n/data_utils.py:
--------------------------------------------------------------------------------
1 | import cPickle as pickle
2 | import numpy as np
3 | import os
4 | from scipy.misc import imread
5 |
6 | def load_CIFAR_batch(filename):
7 | """ load single batch of cifar """
8 | with open(filename, 'rb') as f:
9 | datadict = pickle.load(f)
10 | X = datadict['data']
11 | Y = datadict['labels']
12 | X = X.reshape(10000, 3, 32, 32).transpose(0,2,3,1).astype("float")
13 | Y = np.array(Y)
14 | return X, Y
15 |
16 | def load_CIFAR10(ROOT):
17 | """ load all of cifar """
18 | xs = []
19 | ys = []
20 | for b in range(1,6):
21 | f = os.path.join(ROOT, 'data_batch_%d' % (b, ))
22 | X, Y = load_CIFAR_batch(f)
23 | xs.append(X)
24 | ys.append(Y)
25 | Xtr = np.concatenate(xs)
26 | Ytr = np.concatenate(ys)
27 | del X, Y
28 | Xte, Yte = load_CIFAR_batch(os.path.join(ROOT, 'test_batch'))
29 | return Xtr, Ytr, Xte, Yte
30 |
31 |
32 | def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000,
33 | subtract_mean=True):
34 | """
35 | Load the CIFAR-10 dataset from disk and perform preprocessing to prepare
36 | it for classifiers. These are the same steps as we used for the SVM, but
37 | condensed to a single function.
38 | """
39 | # Load the raw CIFAR-10 data
40 | cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'
41 | X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)
42 |
43 | # Subsample the data
44 | mask = range(num_training, num_training + num_validation)
45 | X_val = X_train[mask]
46 | y_val = y_train[mask]
47 | mask = range(num_training)
48 | X_train = X_train[mask]
49 | y_train = y_train[mask]
50 | mask = range(num_test)
51 | X_test = X_test[mask]
52 | y_test = y_test[mask]
53 |
54 | # Normalize the data: subtract the mean image
55 | if subtract_mean:
56 | mean_image = np.mean(X_train, axis=0)
57 | X_train -= mean_image
58 | X_val -= mean_image
59 | X_test -= mean_image
60 |
61 | # Transpose so that channels come first
62 | X_train = X_train.transpose(0, 3, 1, 2).copy()
63 | X_val = X_val.transpose(0, 3, 1, 2).copy()
64 | X_test = X_test.transpose(0, 3, 1, 2).copy()
65 |
66 | # Package data into a dictionary
67 | return {
68 | 'X_train': X_train, 'y_train': y_train,
69 | 'X_val': X_val, 'y_val': y_val,
70 | 'X_test': X_test, 'y_test': y_test,
71 | }
72 |
73 |
74 | def load_tiny_imagenet(path, dtype=np.float32, subtract_mean=True):
75 | """
76 | Load TinyImageNet. Each of TinyImageNet-100-A, TinyImageNet-100-B, and
77 | TinyImageNet-200 have the same directory structure, so this can be used
78 | to load any of them.
79 |
80 | Inputs:
81 | - path: String giving path to the directory to load.
82 | - dtype: numpy datatype used to load the data.
83 | - subtract_mean: Whether to subtract the mean training image.
84 |
85 | Returns: A dictionary with the following entries:
86 | - class_names: A list where class_names[i] is a list of strings giving the
87 | WordNet names for class i in the loaded dataset.
88 | - X_train: (N_tr, 3, 64, 64) array of training images
89 | - y_train: (N_tr,) array of training labels
90 | - X_val: (N_val, 3, 64, 64) array of validation images
91 | - y_val: (N_val,) array of validation labels
92 | - X_test: (N_test, 3, 64, 64) array of testing images.
93 | - y_test: (N_test,) array of test labels; if test labels are not available
94 | (such as in student code) then y_test will be None.
95 | - mean_image: (3, 64, 64) array giving mean training image
96 | """
97 | # First load wnids
98 | with open(os.path.join(path, 'wnids.txt'), 'r') as f:
99 | wnids = [x.strip() for x in f]
100 |
101 | # Map wnids to integer labels
102 | wnid_to_label = {wnid: i for i, wnid in enumerate(wnids)}
103 |
104 | # Use words.txt to get names for each class
105 | with open(os.path.join(path, 'words.txt'), 'r') as f:
106 | wnid_to_words = dict(line.split('\t') for line in f)
107 | for wnid, words in wnid_to_words.iteritems():
108 | wnid_to_words[wnid] = [w.strip() for w in words.split(',')]
109 | class_names = [wnid_to_words[wnid] for wnid in wnids]
110 |
111 | # Next load training data.
112 | X_train = []
113 | y_train = []
114 | for i, wnid in enumerate(wnids):
115 | if (i + 1) % 20 == 0:
116 | print 'loading training data for synset %d / %d' % (i + 1, len(wnids))
117 | # To figure out the filenames we need to open the boxes file
118 | boxes_file = os.path.join(path, 'train', wnid, '%s_boxes.txt' % wnid)
119 | with open(boxes_file, 'r') as f:
120 | filenames = [x.split('\t')[0] for x in f]
121 | num_images = len(filenames)
122 |
123 | X_train_block = np.zeros((num_images, 3, 64, 64), dtype=dtype)
124 | y_train_block = wnid_to_label[wnid] * np.ones(num_images, dtype=np.int64)
125 | for j, img_file in enumerate(filenames):
126 | img_file = os.path.join(path, 'train', wnid, 'images', img_file)
127 | img = imread(img_file)
128 | if img.ndim == 2:
129 | ## grayscale file
130 | img.shape = (64, 64, 1)
131 | X_train_block[j] = img.transpose(2, 0, 1)
132 | X_train.append(X_train_block)
133 | y_train.append(y_train_block)
134 |
135 | # We need to concatenate all training data
136 | X_train = np.concatenate(X_train, axis=0)
137 | y_train = np.concatenate(y_train, axis=0)
138 |
139 | # Next load validation data
140 | with open(os.path.join(path, 'val', 'val_annotations.txt'), 'r') as f:
141 | img_files = []
142 | val_wnids = []
143 | for line in f:
144 | img_file, wnid = line.split('\t')[:2]
145 | img_files.append(img_file)
146 | val_wnids.append(wnid)
147 | num_val = len(img_files)
148 | y_val = np.array([wnid_to_label[wnid] for wnid in val_wnids])
149 | X_val = np.zeros((num_val, 3, 64, 64), dtype=dtype)
150 | for i, img_file in enumerate(img_files):
151 | img_file = os.path.join(path, 'val', 'images', img_file)
152 | img = imread(img_file)
153 | if img.ndim == 2:
154 | img.shape = (64, 64, 1)
155 | X_val[i] = img.transpose(2, 0, 1)
156 |
157 | # Next load test images
158 | # Students won't have test labels, so we need to iterate over files in the
159 | # images directory.
160 | img_files = os.listdir(os.path.join(path, 'test', 'images'))
161 | X_test = np.zeros((len(img_files), 3, 64, 64), dtype=dtype)
162 | for i, img_file in enumerate(img_files):
163 | img_file = os.path.join(path, 'test', 'images', img_file)
164 | img = imread(img_file)
165 | if img.ndim == 2:
166 | img.shape = (64, 64, 1)
167 | X_test[i] = img.transpose(2, 0, 1)
168 |
169 | y_test = None
170 | y_test_file = os.path.join(path, 'test', 'test_annotations.txt')
171 | if os.path.isfile(y_test_file):
172 | with open(y_test_file, 'r') as f:
173 | img_file_to_wnid = {}
174 | for line in f:
175 | line = line.split('\t')
176 | img_file_to_wnid[line[0]] = line[1]
177 | y_test = [wnid_to_label[img_file_to_wnid[img_file]] for img_file in img_files]
178 | y_test = np.array(y_test)
179 |
180 | mean_image = X_train.mean(axis=0)
181 | if subtract_mean:
182 | X_train -= mean_image[None]
183 | X_val -= mean_image[None]
184 | X_test -= mean_image[None]
185 |
186 | return {
187 | 'class_names': class_names,
188 | 'X_train': X_train,
189 | 'y_train': y_train,
190 | 'X_val': X_val,
191 | 'y_val': y_val,
192 | 'X_test': X_test,
193 | 'y_test': y_test,
194 | 'class_names': class_names,
195 | 'mean_image': mean_image,
196 | }
197 |
198 |
199 | def load_models(models_dir):
200 | """
201 | Load saved models from disk. This will attempt to unpickle all files in a
202 | directory; any files that give errors on unpickling (such as README.txt) will
203 | be skipped.
204 |
205 | Inputs:
206 | - models_dir: String giving the path to a directory containing model files.
207 | Each model file is a pickled dictionary with a 'model' field.
208 |
209 | Returns:
210 | A dictionary mapping model file names to models.
211 | """
212 | models = {}
213 | for model_file in os.listdir(models_dir):
214 | with open(os.path.join(models_dir, model_file), 'rb') as f:
215 | try:
216 | models[model_file] = pickle.load(f)['model']
217 | except pickle.UnpicklingError:
218 | continue
219 | return models
220 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/cs231n/datasets/get_coco_captioning.sh:
--------------------------------------------------------------------------------
1 | wget "http://cs231n.stanford.edu/coco_captioning.zip"
2 | unzip coco_captioning.zip
3 | rm coco_captioning.zip
4 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/cs231n/datasets/get_pretrained_model.sh:
--------------------------------------------------------------------------------
1 | wget http://cs231n.stanford.edu/pretrained_model.h5
2 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/cs231n/datasets/get_tiny_imagenet_a.sh:
--------------------------------------------------------------------------------
1 | wget http://cs231n.stanford.edu/tiny-imagenet-100-A.zip
2 | unzip tiny-imagenet-100-A.zip
3 | rm tiny-imagenet-100-A.zip
4 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/cs231n/gradient_check.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | from random import randrange
3 |
4 | def eval_numerical_gradient(f, x, verbose=True, h=0.00001):
5 | """
6 | a naive implementation of numerical gradient of f at x
7 | - f should be a function that takes a single argument
8 | - x is the point (numpy array) to evaluate the gradient at
9 | """
10 |
11 | fx = f(x) # evaluate function value at original point
12 | grad = np.zeros_like(x)
13 | # iterate over all indexes in x
14 | it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
15 | while not it.finished:
16 |
17 | # evaluate function at x+h
18 | ix = it.multi_index
19 | oldval = x[ix]
20 | x[ix] = oldval + h # increment by h
21 | fxph = f(x) # evalute f(x + h)
22 | x[ix] = oldval - h
23 | fxmh = f(x) # evaluate f(x - h)
24 | x[ix] = oldval # restore
25 |
26 | # compute the partial derivative with centered formula
27 | grad[ix] = (fxph - fxmh) / (2 * h) # the slope
28 | if verbose:
29 | print ix, grad[ix]
30 | it.iternext() # step to next dimension
31 |
32 | return grad
33 |
34 |
35 | def eval_numerical_gradient_array(f, x, df, h=1e-5):
36 | """
37 | Evaluate a numeric gradient for a function that accepts a numpy
38 | array and returns a numpy array.
39 | """
40 | grad = np.zeros_like(x)
41 | it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
42 | while not it.finished:
43 | ix = it.multi_index
44 |
45 | oldval = x[ix]
46 | x[ix] = oldval + h
47 | pos = f(x).copy()
48 | x[ix] = oldval - h
49 | neg = f(x).copy()
50 | x[ix] = oldval
51 |
52 | grad[ix] = np.sum((pos - neg) * df) / (2 * h)
53 | it.iternext()
54 | return grad
55 |
56 |
57 | def eval_numerical_gradient_blobs(f, inputs, output, h=1e-5):
58 | """
59 | Compute numeric gradients for a function that operates on input
60 | and output blobs.
61 |
62 | We assume that f accepts several input blobs as arguments, followed by a blob
63 | into which outputs will be written. For example, f might be called like this:
64 |
65 | f(x, w, out)
66 |
67 | where x and w are input Blobs, and the result of f will be written to out.
68 |
69 | Inputs:
70 | - f: function
71 | - inputs: tuple of input blobs
72 | - output: output blob
73 | - h: step size
74 | """
75 | numeric_diffs = []
76 | for input_blob in inputs:
77 | diff = np.zeros_like(input_blob.diffs)
78 | it = np.nditer(input_blob.vals, flags=['multi_index'],
79 | op_flags=['readwrite'])
80 | while not it.finished:
81 | idx = it.multi_index
82 | orig = input_blob.vals[idx]
83 |
84 | input_blob.vals[idx] = orig + h
85 | f(*(inputs + (output,)))
86 | pos = np.copy(output.vals)
87 | input_blob.vals[idx] = orig - h
88 | f(*(inputs + (output,)))
89 | neg = np.copy(output.vals)
90 | input_blob.vals[idx] = orig
91 |
92 | diff[idx] = np.sum((pos - neg) * output.diffs) / (2.0 * h)
93 |
94 | it.iternext()
95 | numeric_diffs.append(diff)
96 | return numeric_diffs
97 |
98 |
99 | def eval_numerical_gradient_net(net, inputs, output, h=1e-5):
100 | return eval_numerical_gradient_blobs(lambda *args: net.forward(),
101 | inputs, output, h=h)
102 |
103 |
104 | def grad_check_sparse(f, x, analytic_grad, num_checks=10, h=1e-5):
105 | """
106 | sample a few random elements and only return numerical
107 | in this dimensions.
108 | """
109 |
110 | for i in xrange(num_checks):
111 | ix = tuple([randrange(m) for m in x.shape])
112 |
113 | oldval = x[ix]
114 | x[ix] = oldval + h # increment by h
115 | fxph = f(x) # evaluate f(x + h)
116 | x[ix] = oldval - h # increment by h
117 | fxmh = f(x) # evaluate f(x - h)
118 | x[ix] = oldval # reset
119 |
120 | grad_numerical = (fxph - fxmh) / (2 * h)
121 | grad_analytic = analytic_grad[ix]
122 | rel_error = abs(grad_numerical - grad_analytic) / (abs(grad_numerical) + abs(grad_analytic))
123 | print 'numerical: %f analytic: %f, relative error: %e' % (grad_numerical, grad_analytic, rel_error)
124 |
125 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/cs231n/im2col.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 |
3 |
4 | def get_im2col_indices(x_shape, field_height, field_width, padding=1, stride=1):
5 | # First figure out what the size of the output should be
6 | N, C, H, W = x_shape
7 | assert (H + 2 * padding - field_height) % stride == 0
8 | assert (W + 2 * padding - field_height) % stride == 0
9 | out_height = (H + 2 * padding - field_height) / stride + 1
10 | out_width = (W + 2 * padding - field_width) / stride + 1
11 |
12 | i0 = np.repeat(np.arange(field_height), field_width)
13 | i0 = np.tile(i0, C)
14 | i1 = stride * np.repeat(np.arange(out_height), out_width)
15 | j0 = np.tile(np.arange(field_width), field_height * C)
16 | j1 = stride * np.tile(np.arange(out_width), out_height)
17 | i = i0.reshape(-1, 1) + i1.reshape(1, -1)
18 | j = j0.reshape(-1, 1) + j1.reshape(1, -1)
19 |
20 | k = np.repeat(np.arange(C), field_height * field_width).reshape(-1, 1)
21 |
22 | return (k, i, j)
23 |
24 |
25 | def im2col_indices(x, field_height, field_width, padding=1, stride=1):
26 | """ An implementation of im2col based on some fancy indexing """
27 | # Zero-pad the input
28 | p = padding
29 | x_padded = np.pad(x, ((0, 0), (0, 0), (p, p), (p, p)), mode='constant')
30 |
31 | k, i, j = get_im2col_indices(x.shape, field_height, field_width, padding,
32 | stride)
33 |
34 | cols = x_padded[:, k, i, j]
35 | C = x.shape[1]
36 | cols = cols.transpose(1, 2, 0).reshape(field_height * field_width * C, -1)
37 | return cols
38 |
39 |
40 | def col2im_indices(cols, x_shape, field_height=3, field_width=3, padding=1,
41 | stride=1):
42 | """ An implementation of col2im based on fancy indexing and np.add.at """
43 | N, C, H, W = x_shape
44 | H_padded, W_padded = H + 2 * padding, W + 2 * padding
45 | x_padded = np.zeros((N, C, H_padded, W_padded), dtype=cols.dtype)
46 | k, i, j = get_im2col_indices(x_shape, field_height, field_width, padding,
47 | stride)
48 | cols_reshaped = cols.reshape(C * field_height * field_width, -1, N)
49 | cols_reshaped = cols_reshaped.transpose(2, 0, 1)
50 | np.add.at(x_padded, (slice(None), k, i, j), cols_reshaped)
51 | if padding == 0:
52 | return x_padded
53 | return x_padded[:, :, padding:-padding, padding:-padding]
54 |
55 | pass
56 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/cs231n/im2col_cython.pyx:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | cimport numpy as np
3 | cimport cython
4 |
5 | # DTYPE = np.float64
6 | # ctypedef np.float64_t DTYPE_t
7 |
8 | ctypedef fused DTYPE_t:
9 | np.float32_t
10 | np.float64_t
11 |
12 | def im2col_cython(np.ndarray[DTYPE_t, ndim=4] x, int field_height,
13 | int field_width, int padding, int stride):
14 | cdef int N = x.shape[0]
15 | cdef int C = x.shape[1]
16 | cdef int H = x.shape[2]
17 | cdef int W = x.shape[3]
18 |
19 | cdef int HH = (H + 2 * padding - field_height) / stride + 1
20 | cdef int WW = (W + 2 * padding - field_width) / stride + 1
21 |
22 | cdef int p = padding
23 | cdef np.ndarray[DTYPE_t, ndim=4] x_padded = np.pad(x,
24 | ((0, 0), (0, 0), (p, p), (p, p)), mode='constant')
25 |
26 | cdef np.ndarray[DTYPE_t, ndim=2] cols = np.zeros(
27 | (C * field_height * field_width, N * HH * WW),
28 | dtype=x.dtype)
29 |
30 | # Moving the inner loop to a C function with no bounds checking works, but does
31 | # not seem to help performance in any measurable way.
32 |
33 | im2col_cython_inner(cols, x_padded, N, C, H, W, HH, WW,
34 | field_height, field_width, padding, stride)
35 | return cols
36 |
37 |
38 | @cython.boundscheck(False)
39 | cdef int im2col_cython_inner(np.ndarray[DTYPE_t, ndim=2] cols,
40 | np.ndarray[DTYPE_t, ndim=4] x_padded,
41 | int N, int C, int H, int W, int HH, int WW,
42 | int field_height, int field_width, int padding, int stride) except? -1:
43 | cdef int c, ii, jj, row, yy, xx, i, col
44 |
45 | for c in range(C):
46 | for yy in range(HH):
47 | for xx in range(WW):
48 | for ii in range(field_height):
49 | for jj in range(field_width):
50 | row = c * field_width * field_height + ii * field_height + jj
51 | for i in range(N):
52 | col = yy * WW * N + xx * N + i
53 | cols[row, col] = x_padded[i, c, stride * yy + ii, stride * xx + jj]
54 |
55 |
56 |
57 | def col2im_cython(np.ndarray[DTYPE_t, ndim=2] cols, int N, int C, int H, int W,
58 | int field_height, int field_width, int padding, int stride):
59 | cdef np.ndarray x = np.empty((N, C, H, W), dtype=cols.dtype)
60 | cdef int HH = (H + 2 * padding - field_height) / stride + 1
61 | cdef int WW = (W + 2 * padding - field_width) / stride + 1
62 | cdef np.ndarray[DTYPE_t, ndim=4] x_padded = np.zeros((N, C, H + 2 * padding, W + 2 * padding),
63 | dtype=cols.dtype)
64 |
65 | # Moving the inner loop to a C-function with no bounds checking improves
66 | # performance quite a bit for col2im.
67 | col2im_cython_inner(cols, x_padded, N, C, H, W, HH, WW,
68 | field_height, field_width, padding, stride)
69 | if padding > 0:
70 | return x_padded[:, :, padding:-padding, padding:-padding]
71 | return x_padded
72 |
73 |
74 | @cython.boundscheck(False)
75 | cdef int col2im_cython_inner(np.ndarray[DTYPE_t, ndim=2] cols,
76 | np.ndarray[DTYPE_t, ndim=4] x_padded,
77 | int N, int C, int H, int W, int HH, int WW,
78 | int field_height, int field_width, int padding, int stride) except? -1:
79 | cdef int c, ii, jj, row, yy, xx, i, col
80 |
81 | for c in range(C):
82 | for ii in range(field_height):
83 | for jj in range(field_width):
84 | row = c * field_width * field_height + ii * field_height + jj
85 | for yy in range(HH):
86 | for xx in range(WW):
87 | for i in range(N):
88 | col = yy * WW * N + xx * N + i
89 | x_padded[i, c, stride * yy + ii, stride * xx + jj] += cols[row, col]
90 |
91 |
92 | @cython.boundscheck(False)
93 | @cython.wraparound(False)
94 | cdef col2im_6d_cython_inner(np.ndarray[DTYPE_t, ndim=6] cols,
95 | np.ndarray[DTYPE_t, ndim=4] x_padded,
96 | int N, int C, int H, int W, int HH, int WW,
97 | int out_h, int out_w, int pad, int stride):
98 |
99 | cdef int c, hh, ww, n, h, w
100 | for n in range(N):
101 | for c in range(C):
102 | for hh in range(HH):
103 | for ww in range(WW):
104 | for h in range(out_h):
105 | for w in range(out_w):
106 | x_padded[n, c, stride * h + hh, stride * w + ww] += cols[c, hh, ww, n, h, w]
107 |
108 |
109 | def col2im_6d_cython(np.ndarray[DTYPE_t, ndim=6] cols, int N, int C, int H, int W,
110 | int HH, int WW, int pad, int stride):
111 | cdef np.ndarray x = np.empty((N, C, H, W), dtype=cols.dtype)
112 | cdef int out_h = (H + 2 * pad - HH) / stride + 1
113 | cdef int out_w = (W + 2 * pad - WW) / stride + 1
114 | cdef np.ndarray[DTYPE_t, ndim=4] x_padded = np.zeros((N, C, H + 2 * pad, W + 2 * pad),
115 | dtype=cols.dtype)
116 |
117 | col2im_6d_cython_inner(cols, x_padded, N, C, H, W, HH, WW, out_h, out_w, pad, stride)
118 |
119 | if pad > 0:
120 | return x_padded[:, :, pad:-pad, pad:-pad]
121 | return x_padded
122 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/cs231n/image_utils.py:
--------------------------------------------------------------------------------
1 | import urllib2, os, tempfile
2 |
3 | import numpy as np
4 | from scipy.misc import imread
5 |
6 | from cs231n.fast_layers import conv_forward_fast
7 |
8 |
9 | """
10 | Utility functions used for viewing and processing images.
11 | """
12 |
13 |
14 | def blur_image(X):
15 | """
16 | A very gentle image blurring operation, to be used as a regularizer for image
17 | generation.
18 |
19 | Inputs:
20 | - X: Image data of shape (N, 3, H, W)
21 |
22 | Returns:
23 | - X_blur: Blurred version of X, of shape (N, 3, H, W)
24 | """
25 | w_blur = np.zeros((3, 3, 3, 3))
26 | b_blur = np.zeros(3)
27 | blur_param = {'stride': 1, 'pad': 1}
28 | for i in xrange(3):
29 | w_blur[i, i] = np.asarray([[1, 2, 1], [2, 188, 2], [1, 2, 1]], dtype=np.float32)
30 | w_blur /= 200.0
31 | return conv_forward_fast(X, w_blur, b_blur, blur_param)[0]
32 |
33 |
34 | def preprocess_image(img, mean_img, mean='image'):
35 | """
36 | Convert to float, transepose, and subtract mean pixel
37 |
38 | Input:
39 | - img: (H, W, 3)
40 |
41 | Returns:
42 | - (1, 3, H, 3)
43 | """
44 | if mean == 'image':
45 | mean = mean_img
46 | elif mean == 'pixel':
47 | mean = mean_img.mean(axis=(1, 2), keepdims=True)
48 | elif mean == 'none':
49 | mean = 0
50 | else:
51 | raise ValueError('mean must be image or pixel or none')
52 | return img.astype(np.float32).transpose(2, 0, 1)[None] - mean
53 |
54 |
55 | def deprocess_image(img, mean_img, mean='image', renorm=False):
56 | """
57 | Add mean pixel, transpose, and convert to uint8
58 |
59 | Input:
60 | - (1, 3, H, W) or (3, H, W)
61 |
62 | Returns:
63 | - (H, W, 3)
64 | """
65 | if mean == 'image':
66 | mean = mean_img
67 | elif mean == 'pixel':
68 | mean = mean_img.mean(axis=(1, 2), keepdims=True)
69 | elif mean == 'none':
70 | mean = 0
71 | else:
72 | raise ValueError('mean must be image or pixel or none')
73 | if img.ndim == 3:
74 | img = img[None]
75 | img = (img + mean)[0].transpose(1, 2, 0)
76 | if renorm:
77 | low, high = img.min(), img.max()
78 | img = 255.0 * (img - low) / (high - low)
79 | return img.astype(np.uint8)
80 |
81 |
82 | def image_from_url(url):
83 | """
84 | Read an image from a URL. Returns a numpy array with the pixel data.
85 | We write the image to a temporary file then read it back. Kinda gross.
86 | """
87 | try:
88 | f = urllib2.urlopen(url)
89 | _, fname = tempfile.mkstemp()
90 | with open(fname, 'wb') as ff:
91 | ff.write(f.read())
92 | img = imread(fname)
93 | os.remove(fname)
94 | return img
95 | except urllib2.URLError as e:
96 | print 'URL Error: ', e.reason, url
97 | except urllib2.HTTPError as e:
98 | print 'HTTP Error: ', e.code, url
99 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/cs231n/layer_utils.py:
--------------------------------------------------------------------------------
1 | from cs231n.layers import *
2 | from cs231n.fast_layers import *
3 |
4 |
5 | def affine_relu_forward(x, w, b):
6 | """
7 | Convenience layer that perorms an affine transform followed by a ReLU
8 |
9 | Inputs:
10 | - x: Input to the affine layer
11 | - w, b: Weights for the affine layer
12 |
13 | Returns a tuple of:
14 | - out: Output from the ReLU
15 | - cache: Object to give to the backward pass
16 | """
17 | a, fc_cache = affine_forward(x, w, b)
18 | out, relu_cache = relu_forward(a)
19 | cache = (fc_cache, relu_cache)
20 | return out, cache
21 |
22 |
23 | def affine_relu_backward(dout, cache):
24 | """
25 | Backward pass for the affine-relu convenience layer
26 | """
27 | fc_cache, relu_cache = cache
28 | da = relu_backward(dout, relu_cache)
29 | dx, dw, db = affine_backward(da, fc_cache)
30 | return dx, dw, db
31 |
32 |
33 | def affine_bn_relu_forward(x, w, b, gamma, beta, bn_param):
34 | """
35 | Convenience layer that performs an affine transform, batch normalization,
36 | and ReLU.
37 |
38 | Inputs:
39 | - x: Array of shape (N, D1); input to the affine layer
40 | - w, b: Arrays of shape (D2, D2) and (D2,) giving the weight and bias for
41 | the affine transform.
42 | - gamma, beta: Arrays of shape (D2,) and (D2,) giving scale and shift
43 | parameters for batch normalization.
44 | - bn_param: Dictionary of parameters for batch normalization.
45 |
46 | Returns:
47 | - out: Output from ReLU, of shape (N, D2)
48 | - cache: Object to give to the backward pass.
49 | """
50 | a, fc_cache = affine_forward(x, w, b)
51 | a_bn, bn_cache = batchnorm_forward(a, gamma, beta, bn_param)
52 | out, relu_cache = relu_forward(a_bn)
53 | cache = (fc_cache, bn_cache, relu_cache)
54 | return out, cache
55 |
56 |
57 | def affine_bn_relu_backward(dout, cache):
58 | """
59 | Backward pass for the affine-batchnorm-relu convenience layer.
60 | """
61 | fc_cache, bn_cache, relu_cache = cache
62 | da_bn = relu_backward(dout, relu_cache)
63 | da, dgamma, dbeta = batchnorm_backward(da_bn, bn_cache)
64 | dx, dw, db = affine_backward(da, fc_cache)
65 | return dx, dw, db, dgamma, dbeta
66 |
67 |
68 | def conv_relu_forward(x, w, b, conv_param):
69 | """
70 | A convenience layer that performs a convolution followed by a ReLU.
71 |
72 | Inputs:
73 | - x: Input to the convolutional layer
74 | - w, b, conv_param: Weights and parameters for the convolutional layer
75 |
76 | Returns a tuple of:
77 | - out: Output from the ReLU
78 | - cache: Object to give to the backward pass
79 | """
80 | a, conv_cache = conv_forward_fast(x, w, b, conv_param)
81 | out, relu_cache = relu_forward(a)
82 | cache = (conv_cache, relu_cache)
83 | return out, cache
84 |
85 |
86 | def conv_relu_backward(dout, cache):
87 | """
88 | Backward pass for the conv-relu convenience layer.
89 | """
90 | conv_cache, relu_cache = cache
91 | da = relu_backward(dout, relu_cache)
92 | dx, dw, db = conv_backward_fast(da, conv_cache)
93 | return dx, dw, db
94 |
95 |
96 | def conv_bn_relu_forward(x, w, b, gamma, beta, conv_param, bn_param):
97 | a, conv_cache = conv_forward_fast(x, w, b, conv_param)
98 | an, bn_cache = spatial_batchnorm_forward(a, gamma, beta, bn_param)
99 | out, relu_cache = relu_forward(an)
100 | cache = (conv_cache, bn_cache, relu_cache)
101 | return out, cache
102 |
103 |
104 | def conv_bn_relu_backward(dout, cache):
105 | conv_cache, bn_cache, relu_cache = cache
106 | dan = relu_backward(dout, relu_cache)
107 | da, dgamma, dbeta = spatial_batchnorm_backward(dan, bn_cache)
108 | dx, dw, db = conv_backward_fast(da, conv_cache)
109 | return dx, dw, db, dgamma, dbeta
110 |
111 |
112 | def conv_relu_pool_forward(x, w, b, conv_param, pool_param):
113 | """
114 | Convenience layer that performs a convolution, a ReLU, and a pool.
115 |
116 | Inputs:
117 | - x: Input to the convolutional layer
118 | - w, b, conv_param: Weights and parameters for the convolutional layer
119 | - pool_param: Parameters for the pooling layer
120 |
121 | Returns a tuple of:
122 | - out: Output from the pooling layer
123 | - cache: Object to give to the backward pass
124 | """
125 | a, conv_cache = conv_forward_fast(x, w, b, conv_param)
126 | s, relu_cache = relu_forward(a)
127 | out, pool_cache = max_pool_forward_fast(s, pool_param)
128 | cache = (conv_cache, relu_cache, pool_cache)
129 | return out, cache
130 |
131 |
132 | def conv_relu_pool_backward(dout, cache):
133 | """
134 | Backward pass for the conv-relu-pool convenience layer
135 | """
136 | conv_cache, relu_cache, pool_cache = cache
137 | ds = max_pool_backward_fast(dout, pool_cache)
138 | da = relu_backward(ds, relu_cache)
139 | dx, dw, db = conv_backward_fast(da, conv_cache)
140 | return dx, dw, db
141 |
142 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/cs231n/optim.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 |
3 | """
4 | This file implements various first-order update rules that are commonly used for
5 | training neural networks. Each update rule accepts current weights and the
6 | gradient of the loss with respect to those weights and produces the next set of
7 | weights. Each update rule has the same interface:
8 |
9 | def update(w, dw, config=None):
10 |
11 | Inputs:
12 | - w: A numpy array giving the current weights.
13 | - dw: A numpy array of the same shape as w giving the gradient of the
14 | loss with respect to w.
15 | - config: A dictionary containing hyperparameter values such as learning rate,
16 | momentum, etc. If the update rule requires caching values over many
17 | iterations, then config will also hold these cached values.
18 |
19 | Returns:
20 | - next_w: The next point after the update.
21 | - config: The config dictionary to be passed to the next iteration of the
22 | update rule.
23 |
24 | NOTE: For most update rules, the default learning rate will probably not perform
25 | well; however the default values of the other hyperparameters should work well
26 | for a variety of different problems.
27 |
28 | For efficiency, update rules may perform in-place updates, mutating w and
29 | setting next_w equal to w.
30 | """
31 |
32 |
33 | def sgd(w, dw, config=None):
34 | """
35 | Performs vanilla stochastic gradient descent.
36 |
37 | config format:
38 | - learning_rate: Scalar learning rate.
39 | """
40 | if config is None: config = {}
41 | config.setdefault('learning_rate', 1e-2)
42 |
43 | w -= config['learning_rate'] * dw
44 | return w, config
45 |
46 |
47 | def adam(x, dx, config=None):
48 | """
49 | Uses the Adam update rule, which incorporates moving averages of both the
50 | gradient and its square and a bias correction term.
51 |
52 | config format:
53 | - learning_rate: Scalar learning rate.
54 | - beta1: Decay rate for moving average of first moment of gradient.
55 | - beta2: Decay rate for moving average of second moment of gradient.
56 | - epsilon: Small scalar used for smoothing to avoid dividing by zero.
57 | - m: Moving average of gradient.
58 | - v: Moving average of squared gradient.
59 | - t: Iteration number.
60 | """
61 | if config is None: config = {}
62 | config.setdefault('learning_rate', 1e-3)
63 | config.setdefault('beta1', 0.9)
64 | config.setdefault('beta2', 0.999)
65 | config.setdefault('epsilon', 1e-8)
66 | config.setdefault('m', np.zeros_like(x))
67 | config.setdefault('v', np.zeros_like(x))
68 | config.setdefault('t', 0)
69 |
70 | next_x = None
71 | beta1, beta2, eps = config['beta1'], config['beta2'], config['epsilon']
72 | t, m, v = config['t'], config['m'], config['v']
73 | m = beta1 * m + (1 - beta1) * dx
74 | v = beta2 * v + (1 - beta2) * (dx * dx)
75 | t += 1
76 | alpha = config['learning_rate'] * np.sqrt(1 - beta2 ** t) / (1 - beta1 ** t)
77 | x -= alpha * (m / (np.sqrt(v) + eps))
78 | config['t'] = t
79 | config['m'] = m
80 | config['v'] = v
81 | next_x = x
82 |
83 | return next_x, config
84 |
85 |
86 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/cs231n/setup.py:
--------------------------------------------------------------------------------
1 | from distutils.core import setup
2 | from distutils.extension import Extension
3 | from Cython.Build import cythonize
4 | import numpy
5 |
6 | extensions = [
7 | Extension('im2col_cython', ['im2col_cython.pyx'],
8 | include_dirs = [numpy.get_include()]
9 | ),
10 | ]
11 |
12 | setup(
13 | ext_modules = cythonize(extensions),
14 | )
15 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/frameworkpython:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | # what real Python executable to use
4 | PYVER=2.7
5 | PATHTOPYTHON=/usr/local/bin/
6 | PYTHON=${PATHTOPYTHON}python${PYVER}
7 |
8 | # find the root of the virtualenv, it should be the parent of the dir this script is in
9 | ENV=`$PYTHON -c "import os; print os.path.abspath(os.path.join(os.path.dirname(\"$0\"), '..'))"`
10 |
11 | # now run Python with the virtualenv set as Python's HOME
12 | export PYTHONHOME=$ENV
13 | exec $PYTHON "$@"
14 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/kitten.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aikorea/cs231n/4a3dcdef4deb553c7ba12f891aaa4ddd3ccf7e96/assignments2016/assignment3/kitten.jpg
--------------------------------------------------------------------------------
/assignments2016/assignment3/requirements.txt:
--------------------------------------------------------------------------------
1 | Cython==0.23.4
2 | Jinja2==2.8
3 | MarkupSafe==0.23
4 | Pillow==3.0.0
5 | Pygments==2.0.2
6 | appnope==0.1.0
7 | argparse==1.2.1
8 | backports-abc==0.4
9 | backports.ssl-match-hostname==3.5.0.1
10 | certifi==2015.11.20.1
11 | cycler==0.9.0
12 | decorator==4.0.6
13 | functools32==3.2.3-2
14 | gnureadline==6.3.3
15 | ipykernel==4.2.2
16 | ipython==4.0.1
17 | ipython-genutils==0.1.0
18 | ipywidgets==4.1.1
19 | jsonschema==2.5.1
20 | jupyter==1.0.0
21 | jupyter-client==4.1.1
22 | jupyter-console==4.0.3
23 | jupyter-core==4.0.6
24 | matplotlib==1.5.0
25 | mistune==0.7.1
26 | nbconvert==4.1.0
27 | nbformat==4.0.1
28 | notebook==4.0.6
29 | numpy==1.10.4
30 | path.py==8.1.2
31 | pexpect==4.0.1
32 | pickleshare==0.5
33 | ptyprocess==0.5
34 | pyparsing==2.0.7
35 | python-dateutil==2.4.2
36 | pytz==2015.7
37 | pyzmq==15.1.0
38 | qtconsole==4.1.1
39 | scipy==0.16.1
40 | simplegeneric==0.8.1
41 | singledispatch==3.4.0.3
42 | six==1.10.0
43 | terminado==0.5
44 | tornado==4.3
45 | traitlets==4.0.0
46 | wsgiref==0.1.2
47 |
--------------------------------------------------------------------------------
/assignments2016/assignment3/sky.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aikorea/cs231n/4a3dcdef4deb553c7ba12f891aaa4ddd3ccf7e96/assignments2016/assignment3/sky.jpg
--------------------------------------------------------------------------------
/assignments2016/assignment3/start_ipython_osx.sh:
--------------------------------------------------------------------------------
1 | # Assume the virtualenv is called .env
2 |
3 | cp frameworkpython .env/bin
4 | .env/bin/frameworkpython -m IPython notebook
5 |
--------------------------------------------------------------------------------
/aws-tutorial.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | title: AWS Tutorial
4 | permalink: /aws-tutorial/
5 | ---
6 |
7 | GPU 인스턴스를 사용할경우, 아마존 EC2에 GPU 인스턴스를 사용할 수 있는 아마존 머신 이미지 (AMI)가 있습니다. 이 튜토리얼은 제공된 AMI를 통해 자신의 EC2 인스턴스를 설정하는 방법에 대해서 설명합니다. **현재 CS231N 학생들에게 AWS크레딧을 제공하지 않습니다. AWS 스냅샷을 사용하기 위해 여러분의 예산을 사용하기 권장합니다.**
8 |
9 | **요약** AWS가 익숙한 분들: 사용할 이미지는
10 | `cs231n_caffe_torch7_keras_lasagne_v2` 입니다., AMI ID: `ami-125b2c72` region은 US WEST(N. California)입니다. 인스턴스는 `g2.2xlarge`를 사용합니다. 이 이미지에는 Caffe, Torch7, Theano, Keras 그리고 Lasagne가 설치되어 있습니다. 그리고 caffe의 Python binding을 사용할 수 있습니다. 생성한 인스턴스는 CUDA 7.5 와 CuDNN v3를 포함하고 있습니다.
11 |
12 | 첫째로, AWS계정이 아직 없다면 [AWS홈페이지](http://aws.amazon.com/)에 접속하여 "가입"이라고 적혀있는 노란색 버튼을 눌러 계정을 생성합니다. 버튼을 누르면 가입페이지가 나오며 아래 그림과 같이 나타납니다.
13 |
14 |
15 |
16 |
23 |
24 |
29 |
30 |
39 |
40 |
45 |
46 |
51 |
52 |
57 |
58 |
63 |
64 |
69 |
70 |
73 |
74 |
88 |
89 |
94 |
95 |
131 | 번역: 김우정 (gnujoow)
132 |
133 |
--------------------------------------------------------------------------------
/convnet-tips.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | permalink: /convnet-tips/
4 | ---
5 |
6 |
7 | ### Addressing Overfitting
8 |
9 | #### Data Augmentation
10 |
11 | - Flip the training images over x-axis
12 | - Sample random crops / scales in the original image
13 | - Jitter the colors
14 |
15 | #### Dropout
16 |
17 | - Dropout is just as effective for Conv layers. Usually people apply less dropout right before early conv layers since there are not that many parameters there compared to later stages of the network (e.g. the fully connected layers).
18 |
--------------------------------------------------------------------------------
/glossary.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | mathjax: true
4 | permalink: /glossary/
5 | ---
6 |
7 | 영어 --> 한글 번역시 용어의 통일성을 위한 단어장입니다. 새로운 용어에 대한 추가는 GitHub에 이슈를 파서 서로 논의해 보고 정하도록 하면 좋을 것 같습니다.
8 |
9 |
10 |
11 |
12 | | English |
13 | 한글 |
14 |
15 |
16 |
17 | | Accuracy | 정확도, 성능 |
18 | | Activation function | 활성 함수 |
19 | | Architecture | 구조 |
20 | | Backpropagation | (영어 그대로) |
21 | | Batch | 배치 |
22 | | Batch normalization | 배치 정규화 |
23 | | Bias | (영어 그대로) |
24 | | Chain rule | 연쇄 법칙 |
25 | | Class | 클래스 |
26 | | Classification | 분류 |
27 | | Classifier | 분류기 |
28 | | Column vector | 열 벡터 |
29 | | Convolution | 컨볼루션 |
30 | | Convolutional neural network | 컨볼루션 신경망 |
31 | | Covariance | 공분산 |
32 | | Cross entropy | (영어 그대로) |
33 | | Cross validation | 교차 검증 |
34 | | Depth | 깊이 |
35 | | Derivative | 미분값, 도함수 |
36 | | Dropout | (영어 그대로) |
37 | | Error | 에러, 오차 |
38 | | Evaluate | 평가하다 |
39 | | Feature | 특징, 표현, 피쳐 |
40 | | Filter | 필터 |
41 | | Forward propagation | (영어 그대로) |
42 | | Fully-connected | (영어 그대로) |
43 | | Gate | 게이트 |
44 | | Gradient | 그라디언트 |
45 | | GRU | (영어 그대로) |
46 | | Hyperparameter | (영어 그대로) |
47 | | Image | 이미지 |
48 | | Implement | 구현하다 |
49 | | Initialization | 초기화 |
50 | | Iteration | 반복 |
51 | | Label | 라벨 |
52 | | Layer | 레이어 |
53 | | Learning | 러닝, 학습 |
54 | | Loop | 루프 |
55 | | Loss (function) | 손실 함수 |
56 | | LSTM | (영어 그대로) |
57 | | Matrix | 행렬 |
58 | | Nearest neighbor | (영어 그대로) |
59 | | Network | 네트워크 |
60 | | Neural network | 신경망, 뉴럴 네트워크 |
61 | | Neuron | 뉴런 |
62 | | Node | 노드 |
63 | | Non-linearity | 비선형~ |
64 | | Optimization | 최적화 |
65 | | Overfitting | (영어 그대로) |
66 | | Padding | 패딩 |
67 | | Parameter | 파라미터 |
68 | | Performance | 성능 |
69 | | Pixel | 픽셀, 화소 |
70 | | Pooling | 풀링 |
71 | | Preprocessing | 전처리 |
72 | | Receptive Field | (영어 그대로) |
73 | | Regression | 회귀 |
74 | | Regularization | (영어 그대로) |
75 | | ReLU | (영어 그대로) |
76 | | Representation | 표현 |
77 | | Recurrent neural network (RNN) | 회귀신경망, RNN |
78 | | Row vector | 행 벡터 |
79 | | Score | 스코어, 점수 |
80 | | Sigmoid | (영어 그대로) |
81 | | Softmax | (영어 그대로) |
82 | | Training | 학습, 트레이닝 |
83 | | Tuning | 튜닝 |
84 | | Validation | 검증 |
85 | | Variable | 변수 |
86 | | Visualization | 시각화 |
87 | | Weights | 파라미터 값, 가중치 (문맥상 사용되는 의미에 따라) |
88 |
89 |
90 |
91 |
92 |
105 |
--------------------------------------------------------------------------------
/ipython-tutorial.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | title: IPython Tutorial
4 | permalink: /ipython-tutorial/
5 | ---
6 | cs231n 수업에서는 프로그래밍 과제 진행을 위해 [IPython notebooks](http://ipython.org/)을 사용합니다. IPython notebook을 사용하면 여러분의 브라우저에서 Python 코드를 작성하고 실행할 수 있습니다. Python notebook를 사용하면 여러 조각의 코드를 아주 쉽게 수정하고 실행할 수 있습니다. 이런 장점 때문에 IPython notebook은 계산과학분야에서 널리 사용되고 있습니다.
7 |
8 | IPython의 설치와 실행은 간단합니다. command line에서 다음 명령어를 입력하여 IPython을 설치합니다.
9 |
10 | ~~~
11 | pip install "ipython[notebook]"
12 | ~~~
13 |
14 | IPython의 설치가 완료되면 다음 명령어를 통해 IPython을 실행합니다.
15 |
16 | ~~~
17 | ipython notebook
18 | ~~~
19 |
20 | IPython이 실행되면, IPyhton을 사용하기 위해 웹 브라우저를 실행하여 http://localhost:8888 에 접속합니다. 모든 것이 잘 작동한다면 웹 브라우저에는 아래와 같은 화면이 나타납니다. 화면에는 현재 폴더에 사용가능한 Python notebook들이 나타납니다.
21 |
22 |
23 |
24 |
29 |
30 |
35 |
36 |
41 |
42 |
48 |
49 |
54 |
55 |
61 | 번역: 김우정 (gnujoow)
62 |
63 |
--------------------------------------------------------------------------------
/overview.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | title: Overview of Computer Vision and Visual Recognition
4 | permalink: /overview/
5 | ---
6 |
7 | Our introductory lecture covered the history of Computer Vision and many of its current applications, to help you understand the context in which this class is offered. See the [slides](http://vision.stanford.edu/teaching/cs231n/slides/lecture1.pdf) for details.
8 |
--------------------------------------------------------------------------------
/terminal-tutorial.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | title: Terminal.com Tutorial
4 | permalink: /terminal-tutorial/
5 | ---
6 | 과제를 진행하기 위해서, [Terminal](https://www.stanfordterminalcloud.com)을 사용하는 옵션을 제공합니다. Terminal에서 여러분의 결과물을 개발하고 테스트할 수 있습니다. 한가지 유의해야 할 것은 Terminal.com의 메인페이지를 사용하지 않고 cs231n 수업을 위해 특별히 할당된 서브도메인에 등록된 사이트를 사용합니다. [Terminal](https://www.stanfordterminalcloud.com)은 미리 설정된 커맨드 라인 환경(command line environment)에 접근할 수 있는 온라인 컴퓨팅 플랫폼입니다. 여러분이 과제를 진행하기 위해서 반드시 [Terminal](https://www.stanfordterminalcloud.com) 을 사용할 필요는 없습니다. 그러나 개발을 위한 필요사항들과 개발도구들이 미리 설정되어 있기 때문에 수고를 덜 수 있습니다.
7 |
8 | 이 튜토리얼은 Terminal을 사용하여 과제를 진행하기 위한 필수적인 과정들을 설명합니다. 가장 먼저, [여러분의 계정을 만듭니다.](https://www.stanfordterminalcloud.com/signup). 바로 전에 만든 계정으로 [Terminal](https://www.stanfordterminalcloud.com)에 로그인합니다.
9 |
10 | 각각의 과제마다 Terminal 스냅 샷 링크를 제공합니다. 이 스냅 샷들은 여러분의 결과물을 작성하고 실행할 시작 코드와 미리 설정된 command line 환경이 포함되어 있습니다.
11 |
12 | 여기 2015년 과제처럼 보이는 스냅 샷을 통해 예를 들어보겠습니다.
13 |
14 |
15 |
16 |
21 |
22 |
27 |
28 |
33 |
34 |
42 | 번역: 김우정 (gnujoow)
43 |
44 |
--------------------------------------------------------------------------------
/transfer-learning.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | permalink: /transfer-learning/
4 | ---
5 |
6 | (These notes are currently in draft form and under development)
7 |
8 | Table of Contents:
9 |
10 | - [Transfer Learning](#tf)
11 | - [Additional References](#add)
12 |
13 |
14 | ## Transfer Learning
15 |
16 | In practice, very few people train an entire Convolutional Network from scratch (with random initialization), because it is relatively rare to have a dataset of sufficient size. Instead, it is common to pretrain a ConvNet on a very large dataset (e.g. ImageNet, which contains 1.2 million images with 1000 categories), and then use the ConvNet either as an initialization or a fixed feature extractor for the task of interest. The three major Transfer Learning scenarios look as follows:
17 |
18 | - **ConvNet as fixed feature extractor**. Take a ConvNet pretrained on ImageNet, remove the last fully-connected layer (this layer's outputs are the 1000 class scores for a different task like ImageNet), then treat the rest of the ConvNet as a fixed feature extractor for the new dataset. In an AlexNet, this would compute a 4096-D vector for every image that contains the activations of the hidden layer immediately before the classifier. We call these features **CNN codes**. It is important for performance that these codes are ReLUd (i.e. thresholded at zero) if they were also thresholded during the training of the ConvNet on ImageNet (as is usually the case). Once you extract the 4096-D codes for all images, train a linear classifier (e.g. Linear SVM or Softmax classifier) for the new dataset.
19 | - **Fine-tuning the ConvNet**. The second strategy is to not only replace and retrain the classifier on top of the ConvNet on the new dataset, but to also fine-tune the weights of the pretrained network by continuing the backpropagation. It is possible to fine-tune all the layers of the ConvNet, or it's possible to keep some of the earlier layers fixed (due to overfitting concerns) and only fine-tune some higher-level portion of the network. This is motivated by the observation that the earlier features of a ConvNet contain more generic features (e.g. edge detectors or color blob detectors) that should be useful to many tasks, but later layers of the ConvNet becomes progressively more specific to the details of the classes contained in the original dataset. In case of ImageNet for example, which contains many dog breeds, a significant portion of the representational power of the ConvNet may be devoted to features that are specific to differentiating between dog breeds.
20 |
21 | **Pretrained models**. Since modern ConvNets take 2-3 weeks to train across multiple GPUs on ImageNet, it is common to see people release their final ConvNet checkpoints for the benefit of others who can use the networks for fine-tuning. For example, the Caffe library has a [Model Zoo](https://github.com/BVLC/caffe/wiki/Model-Zoo) where people share their network weights.
22 |
23 | **When and how to fine-tune?** How do you decide what type of transfer learning you should perform on a new dataset? This is a function of several factors, but the two most important ones are the size of the new dataset (small or big), and its similarity to the original dataset (e.g. ImageNet-like in terms of the content of images and the classes, or very different, such as microscope images). Keeping in mind that ConvNet features are more generic in early layers and more original-dataset-specific in later layers, here are some common rules of thumb for navigating the 4 major scenarios:
24 |
25 | 1. *New dataset is small and similar to original dataset*. Since the data is small, it is not a good idea to fine-tune the ConvNet due to overfitting concerns. Since the data is similar to the original data, we expect higher-level features in the ConvNet to be relevant to this dataset as well. Hence, the best idea might be to train a linear classifier on the CNN codes.
26 | 2. *New dataset is large and similar to the original dataset*. Since we have more data, we can have more confidence that we won't overfit if we were to try to fine-tune through the full network.
27 | 3. *New dataset is small but very different from the original dataset*. Since the data is small, it is likely best to only train a linear classifier. Since the dataset is very different, it might not be best to train the classifier form the top of the network, which contains more dataset-specific features. Instead, it might work better to train the SVM classifier from activations somewhere earlier in the network.
28 | 4. *New dataset is large and very different from the original dataset*. Since the dataset is very large, we may expect that we can afford to train a ConvNet from scratch. However, in practice it is very often still beneficial to initialize with weights from a pretrained model. In this case, we would have enough data and confidence to fine-tune through the entire network.
29 |
30 | **Practical advice**. There are a few additional things to keep in mind when performing Transfer Learning:
31 |
32 | - *Constraints from pretrained models*. Note that if you wish to use a pretrained network, you may be slightly constrained in terms of the architecture you can use for your new dataset. For example, you can't arbitrarily take out Conv layers from the pretrained network. However, some changes are straight-forward: Due to parameter sharing, you can easily run a pretrained network on images of different spatial size. This is clearly evident in the case of Conv/Pool layers because their forward function is independent of the input volume spatial size (as long as the strides "fit"). In case of FC layers, this still holds true because FC layers can be converted to a Convolutional Layer: For example, in an AlexNet, the final pooling volume before the first FC layer is of size [6x6x512]. Therefore, the FC layer looking at this volume is equivalent to having a Convolutional Layer that has receptive field size 6x6, and is applied with padding of 0.
33 | - *Learning rates*. It's common to use a smaller learning rate for ConvNet weights that are being fine-tuned, in comparison to the (randomly-initialized) weights for the new linear classifier that computes the class scores of your new dataset. This is because we expect that the ConvNet weights are relatively good, so we don't wish to distort them too quickly and too much (especially while the new Linear Classifier above them is being trained from random initialization).
34 |
35 |
36 | ## Additional References
37 |
38 | - [CNN Features off-the-shelf: an Astounding Baseline for Recognition](http://arxiv.org/abs/1403.6382) trains SVMs on features from ImageNet-pretrained ConvNet and reports several state of the art results.
39 | - [DeCAF](http://arxiv.org/abs/1310.1531) reported similar findings in 2013. The framework in this paper (DeCAF) was a Python-based precursor to the C++ Caffe library.
40 | - [How transferable are features in deep neural networks?](http://arxiv.org/abs/1411.1792) studies the transfer learning performance in detail, including some unintuitive findings about layer co-adaptations.
41 |
--------------------------------------------------------------------------------
/video-lectures.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | title: Video Lectures
4 | permalink: /video-lectures/
5 | ---
6 |
7 | 동영상 강의는 원래 강사인 Andrej Karpathy가 직접 유튜브에 올렸었지만, 몇 가지 문제로 인해 현재는 내려간 상태입니다.
8 | 그러나 [[이곳](https://archive.org/details/cs231n-CNNs)]에서 웹으로 강의를 듣거나 [토렌트 링크](https://archive.org/download/cs231n-CNNs/cs231n-CNNs_archive.torrent)를 통해 받을 수 있고, [새로 유튜브에 재생목록을 만들어주신 분](https://www.youtube.com/playlist?list=PLLvH2FwAQhnpj1WEB-jHmPuUeQ8mX-XXG)도 있습니다. 자막 파일은 [[여기](https://github.com/aikorea/cs231n/tree/master/captions)]에서 다운받으실 수 있습니다. (아직 진행 중이라 미완입니다.)
9 |
10 | 유튜브에서 자동생성되어 매우 안 좋은 상태였던 영어 자막을 수정하고 한글로 번역까지 해 주는 작업은 **김영범 (rollis0825), 황재하 (jaywhang), 이지훈 (jihoonl), 김석우 (sandrokim), 이준수 (jslee), 조재민 (j-min)** 님께서 수고해 주시고 계십니다!
11 |
--------------------------------------------------------------------------------