def fetch_sets(n_train=70, n_val=25, n_test=25, actors=None):
if actors is None:
actors = act
if not os.path.exists('cropped'):
get_all()
train_set = []
validation_set = []
test_set = []
train_labels = []
validation_labels = []
test_labels = []
total_num = n_train + n_val + n_test
faces_gray = {}
faces_rgb = {}
actor_label = 0 #0 to 5
np.random.seed(0)
for a in actors: #do this per actor
name = a.split()[1].lower() #last name of actor
# This would print all the files and directories
dirs = os.listdir('cropped')
imgs_of_actor_gray = []
imgs_of_actor_rgb = []
for filename in dirs:
if name in filename: #if pic has this last name
im_gray = imread("cropped/" + filename, flatten=True)
im_rgb = imread("cropped_rgb/" + filename)[:, :, :3]
im_gray = im_gray.flatten() #flatten image
imgs_of_actor_gray.append(im_gray)
imgs_of_actor_rgb.append(im_rgb)
#plt.ion()
#plt.imshow(im, cmap=cm.gray)
#break
num_imgs = len(imgs_of_actor_gray)
if num_imgs >= total_num:
np.random.shuffle(imgs_of_actor_gray)
np.random.shuffle(imgs_of_actor_rgb)
img_size_gray = len(imgs_of_actor_gray[0])
train_set_gray = zeros((n_train, img_size_gray))
valid_set_gray = zeros((n_val, img_size_gray))
test_set_gray = zeros((n_test, img_size_gray))
dim1, dim2, dim3 = imgs_of_actor_rgb[0].shape
train_set_rgb = zeros((n_train, dim1, dim2, dim3))
valid_set_rgb = zeros((n_val, dim1, dim2, dim3))
test_set_rgb = zeros((n_test, dim1, dim2, dim3))
j = 0
for i in range(0, n_train):
train_set_gray[j][:] = imgs_of_actor_gray[i]
train_set_rgb[j, :, :, :] = imgs_of_actor_rgb[i]
j += 1
j = 0
for i in range(n_train, n_train + n_val):
valid_set_gray[j][:] = imgs_of_actor_gray[i]
valid_set_rgb[j, :, :, :] = imgs_of_actor_rgb[i]
j += 1
j = 0
for i in range(n_train + n_val, n_train + n_val + n_test):
test_set_gray[j][:] = imgs_of_actor_gray[i]
test_set_rgb[j, :, :, :] = imgs_of_actor_rgb[i]
j += 1
faces_gray["train" + str(actor_label)] = train_set_gray
faces_gray["valid" + str(actor_label)] = valid_set_gray
faces_gray["test" + str(actor_label)] = test_set_gray
faces_rgb["train" + str(actor_label)] = train_set_rgb
faces_rgb["valid" + str(actor_label)] = valid_set_rgb
faces_rgb["test" + str(actor_label)] = test_set_rgb
else:
raise ValueError(
'Not enough data to produce sets of %s - %d needed, %d found' %
(a, total_num, num_imgs))
actor_label += 1
savemat('faces.mat', faces_gray)
savemat('faces_10.mat', faces_rgb)
def main():
# 선형회귀와 같은 파라미터
# 특징 벡터의 차원 설정
dimension = 10
# 비선형 플래그
nonlinear = False
# 전체 데이터의 수
num_of_samples = 1000
# 노이즈의 진폭
noise_amplitude = 0.01
# 하이퍼 파라미터의 설정
batch_size = 10
max_epoch = 10000
learning_rate = 1e-3
momentum = 0.9 # 이 값을 하면 모멘트법이 됩니다
regularize_coeff = 0.0 # 이 값을 하면 L2 노름에 의한 법칙이 걸립니다
# 전체 데이터 구하기
# NOTE: 여기에서는 미니배치 동작만을 보기 위해서
# 일단 전체 데이터를 취득하고 나서 배치 단위로 잘라서 반환합니다
# 그러나, 미니배치법이 필요하게 되는 상황에서는
# 전체 데이터를 한번에 읽어 들이지 않는 경우가 보통이므로
# 수 배치분을 읽어 들여 버퍼하고 나서 1배치만 반환해야 합니다
# 이러한 경우, python의 기능을 살려
# 순서를 따라 읽어 들이는 제너레이터를 작성하는 것이 유효합니다
data_train, (X_test, Y_test) = get_all(dimension,
nonlinear,
num_of_samples,
noise_amplitude,
return_coefficient_matrix=False)
A_test = coeff(X_test)
# 손실의 이력
train_losses = []
test_losses = []
# 파라미터의 초기값
D_hat = np.zeros(dimension + 1)
# 에포크에 대해서의 루프
for epoch in range(max_epoch):
print("epoch: {0} / {1}".format(epoch, max_epoch))
# 배치 단위로 분할
data_train_batch = get_batch(data_train, batch_size)
# 1에포크 분 학습
loss, D_hat = train_epoch(data_train_batch, D_hat, learning_rate,
momentum, regularize_coeff)
# 손실을 이력에 저장
train_losses.append(loss)
# 전형적인 코드에서는 어떤 에포크에 한 번 테스트를 실시하고
# 도중 경과가 어느 정도의 범화성능을 나타내는지 확인하지만
# 여기에서는 매회 테스트를 실시하고 있습니다
Y_hat = A_test.dot(D_hat)
E = Y_hat - Y_test
test_loss = E.T.dot(E)
test_losses.append(test_loss)
# 실험기록용
parameters = {
"linearity": "nonlinear" if nonlinear else "linear",
"dimension": dimension,
"num_of_samples": num_of_samples,
"batch_size": batch_size,
"max_epoch": max_epoch,
"learning_rate": learning_rate,
"momentum": momentum,
"regularize_coeff": regularize_coeff,
}
# 결과 표시
visualize_result("linear_regression_iterative_solution",
A_test[:, 0:2],
Y_test,
Y_hat,
parameters,
losses=(train_losses, test_losses))
def main():
# 선형회귀와 같은 파라미터
# 특징 벡터의 차원의 설정
dimension = 10
# 비선형 플래그
nonlinear = True
# 전체 데이터 수
num_of_samples = 1000
# 노이즈 진폭
noise_amplitude = 0.01
# 선형회귀와 공통의 하이퍼 파라미터
batch_size = 10
max_epoch = 10000
learning_rate = 1e-3
momentum = 0.0
regularize_coeff = 0.0
# 뉴럴 네트워크 특유의 하이퍼 파라미터
# 중간층의 유닛수(채널 수)
# NOTE: 여기에서는 1층만으로 하지만
# 리스트에 값을 붙여 나감으로써 층을 추가할 수 있습니다
# 단지, 메모리 사용량에는 주의하세요!
num_units = [
50,
100,
]
# 전체 데이터 구하기
data_train, (X_test, Y_test) = get_all(dimension,
nonlinear,
num_of_samples,
noise_amplitude,
return_coefficient_matrix=False)
# 손실의 이력
train_losses = []
test_losses = []
# 파라미터의 초기값
W_hat = init_weights(num_units, dimension)
for epoch in range(max_epoch):
print("epoch: {0}/{1}".format(epoch, max_epoch))
# 배치 단위로 분할
data_train_batch = get_batch(data_train, batch_size)
# 1에포크 분 학습
train_loss, W_hat = train_epoch(data_train_batch, W_hat, learning_rate,
momentum, regularize_coeff)
# 결과를 이력에 저장
train_losses.append(train_loss)
# 테스트 데이터로의 피팅
Y_hat = forward(X_test, W_hat)[-1][:, 0]
E = Y_hat - Y_test
test_loss = E.T.dot(E)
test_losses.append(test_loss)
# 실험 기록용
parameters = {
"linearity": "nonlinear" if nonlinear else "linear",
"dimension": dimension,
"num_of_samples": num_of_samples,
"batch_size": batch_size,
"max_epoch": max_epoch,
"learning_rate": learning_rate,
"momentum": momentum,
"regularize_coeff": regularize_coeff,
"num_units": num_units,
}
# 결과 표시
visualize_result("neural_network",
X_test[:, 0:2],
Y_test,
Y_hat,
parameters,
losses=(train_losses, test_losses))
import os.path
import get_data
import crop_faces
import partition_data_set
import tensorflow as tf
import part1
if __name__ == '__main__':
get_data.get_all() # download images of actors
crop_faces.crop_all() # crop all images using bounding boxes and colour = False
partition_data_set.partition_data() # split up images into validation, training, and test sets
train_dict = partition_data_set.get_train_dict()
test_dict = partition_data_set.get_test_dict()
print partition_data_set.get_dict_size(train_dict)
# part1 - create a fully connected network for classifying 6 actors with a single hidden layer
def main():
# 실험용 파라미터 설정
# dimension, nonlinear, num_of_samples를 바꿔서 결과를 비교해주세요
# NOTE: 이것들은 실험을 위한 데이터 세트 자체를 변경하는 것이므로
# 알고리즘 동작을 규정하는 파라미터와는 다릅니다
# 특징 벡터의 차원
dimension = 100
# 비선형 플래그
# True -> 초평면
# False -> 초곡면
# 선형회귀는 초평면 모델이므로 당연히 False쪽이 좋은 측정결과를 줍니다
nonlinear = False
# 전체 데이터의 수
num_of_samples = 1000
# 노이즈의 진폭
noise_amplitude = 0.01
# 전체 데이터 구하기
# NOTE: 테스트 데이터에는 표식 '_test'를 붙이고 있지만,
# 학습용 데이터에 대해서는 계산을 실행하는 코드 안에서 식을 쉽게 찾을 수 있도록
# '_train'과 같은 표식은 붙이지 않습니다
(A, Y), (A_test, Y_test) = get_all(
dimension, nonlinear, num_of_samples, noise_amplitude
)
# 역행렬에 의한 측정값
start = time.time()
# (A^tA)^(-1) A^t Y 를 직접 계산
D_hat_inv = (np.linalg.inv(A.T.dot(A)).dot(A.T)).dot(Y)
print("D_hat_inv: {0:.16f}[s]".format(time.time() - start))
# 연립방정식의 해답에 의한 측정값
start = time.time()
# A.tA * D = A.t Y 를 D 에 대해서 푼다
D_hat_slv = np.linalg.solve(A.T.dot(A), A.T.dot(Y))
print("D_hat_slv: {0:.16f}[s]".format(time.time() - start))
# 2해의 차
dD = np.linalg.norm(D_hat_inv - D_hat_slv)
print("difference of two solutions: {0:.4e}".format(dD))
# NOTE: 2개의 해에 그다지 차이가 없다는 것을 확인할 수 있으므로
# 이하 플롯에서는 D_hat_slv만을 이용합니다
# 테스트 데이터로의 피팅
Y_hat = A_test.dot(D_hat_slv)
mse = np.linalg.norm(Y_test-Y_hat) / dimension
print("test error: {:.4e}".format(mse))
# 실험기록용
parameters = {
"linearity": "nonlinear" if nonlinear else "linear",
"dimension": dimension,
"num_of_samples": num_of_samples,
}
# 결과 표시
# NOTE: 표시용에 2차원만 건네고 있습니다
visualize_result(
"linear_regression_analytic_solution",
A_test[:, :2], Y_test, Y_hat, parameters
)
import os.path
import get_data
import crop_faces
import partition_data_set
import tensorflow as tf
import part1
if __name__ == '__main__':
get_data.get_all() # download images of actors
crop_faces.crop_all(
) # crop all images using bounding boxes and colour = False
partition_data_set.partition_data(
) # split up images into validation, training, and test sets
train_dict = partition_data_set.get_train_dict()
test_dict = partition_data_set.get_test_dict()
print partition_data_set.get_dict_size(train_dict)
# part1 - create a fully connected network for classifying 6 actors with a single hidden layer