def main(_):
pp.pprint(flags.FLAGS.__flags)
if FLAGS.output_width is None:
FLAGS.output_width = FLAGS.output_height
if FLAGS.crop_width is None:
FLAGS.crop_width = FLAGS.crop_height
if not os.path.exists(FLAGS.checkpoint_dir):
os.makedirs(FLAGS.checkpoint_dir)
if not os.path.exists(FLAGS.sample_dir):
os.makedirs(FLAGS.sample_dir)
if not os.path.exists(FLAGS.test_dir):
os.makedirs(FLAGS.test_dir)
run_config = tf.ConfigProto()
run_config.gpu_options.allow_growth = True
with tf.Session(config=run_config) as sess:
dsgan = DSGAN(sess,
depth_lambda=FLAGS.depth_lambda,
semantic_lambda=FLAGS.semantic_lambda,
batch_size=FLAGS.batch_size,
input_width=FLAGS.input_width,
input_height=FLAGS.input_height,
crop_width=FLAGS.crop_width,
crop_height=FLAGS.crop_width,
input_c_dim=FLAGS.input_c_dim,
output_width=FLAGS.output_width,
output_height=FLAGS.output_height,
output_c_dim=FLAGS.output_c_dim,
gf_dim=FLAGS.gf_dim,
df_dim=FLAGS.df_dim,
dataset_name=FLAGS.dataset,
checkpoint_dir=FLAGS.checkpoint_dir,
sample_dir=FLAGS.sample_dir,
is_crop=FLAGS.is_crop)
if FLAGS.is_train:
dsgan.train(FLAGS)
else:
if not dsgan.load(FLAGS.checkpoint_dir):
raise Exception("[!] Train a model first, then run test mode")
data = load_mat('../nyu_depth_v2_labeled.mat')
train_test = load_mat('../splits.mat')
test_idxs = [int(x - 1) for x in train_test["testNdxs"]]
FLAGS.batch_size = 4
for idx in test_idxs:
dsgan.sample_model(data, 1, idx, FLAGS.test_dir, FLAGS)
def test_utils():
print("Test Utils")
num = 1
mat_file = utils.load_mat(DEPTH_DIR)
RGB_list = utils.get_RGB_batch(mat_file, 0, 9, 480, 640, 240, 320, False)
vis(RGB_list[0])
depth_list = utils.get_depth_batch(mat_file, 0, 9, 480, 640, 240, 320,
False)
vis(utils.color_depth(np.array([depth_list[num]], dtype="float")))
semantic_list = utils.get_semantic_batch(mat_file, 0, 9, 480, 640, 240,
320, False)
vis(utils.color_semantic(np.array([semantic_list[num]], dtype="float")))
break
x = R[idx:, idx]
if np.linalg.norm(x) == 0.:
continue
e = np.zeros_like(x)
e[0] = np.linalg.norm(x)
u = x - e
v = u / np.linalg.norm(u)
Q_cnt = np.identity(m)
Q_cnt[idx:, idx:] -= 2.0 * np.outer(v, v) #
R = np.dot(Q_cnt, R) #R=P1P2..PnA
Q = np.dot(Q_cnt, Q) #Q=P1P2P3...Pn
return np.round(Q.T, 3), np.round(R, 3) #保留三位
# return Q.T,R
if __name__ == "__main__":
path = r'data.txt'
matrix = load_mat(path, "HR")
if matrix.size == 0:
print("input Error!")
sys.exit()
Q, R = Householder_Reduction(matrix)
m, _ = Q.shape
m, n = R.shape
print(np.round(np.dot(Q, R), 2))
print("Q=")
print_mat(Q, m, m)
print("R=")
print_mat(R, m, n)
import linear_svm
import matplotlib.pyplot as plt
import utils
from sklearn import preprocessing, metrics
from linear_classifier import LinearSVM_twoclass
############################################################################
# Part 0: Loading and Visualizing Data #
# We start the exercise by first loading and visualizing the dataset. #
# The following code will load the dataset into your environment and plot #
# the data. #
############################################################################
# load ex6data1.mat
X,y = utils.load_mat('data/ex4data1.mat')
utils.plot_twoclass_data(X,y,'x1', 'x2',['neg','pos'])
plt.savefig('fig1.pdf')
############################################################################
# Part 1: Hinge loss function and gradient #
############################################################################
C = 1
theta = np.zeros((X.shape[1],))
J,grad = linear_svm.svm_loss_twoclass(theta,X,y,C)
print "J = ", J, " grad = ", grad
import utils
from sklearn.preprocessing import PolynomialFeatures
############################################################
# Problem 3.2: Implementing Regularized Linear Regression
############################################################
if __name__ == "__main__":
grader = graderUtil.Grader()
reg_submission = grader.load('reg_linear_regressor_multi')
util_submission = grader.load('utils')
test_regressor = reg_submission.RegularizedLinearReg_SquaredLoss()
# Load the housing test dataset.
X, y, Xtest, ytest, Xval, yval = utils.load_mat('ex2data1.mat')
XX = np.vstack([np.ones((X.shape[0],)),X]).T
poly = PolynomialFeatures(degree=6,include_bias=False)
X_poly = poly.fit_transform(np.reshape(X,(len(X),1)))
X_poly, mu, sigma = utils.feature_normalize(X_poly)
# add a column of ones to X_poly
XX_poly = np.vstack([np.ones((X_poly.shape[0],)),X_poly.T]).T
print(X, XX_poly)
# map Xtest and Xval into the same polynomial features
X_poly_test = poly.fit_transform(np.reshape(Xtest,(len(Xtest),1)))
X_poly_val = poly.fit_transform(np.reshape(Xval,(len(Xval),1)))
#!/usr/bin/env python
from utils import load_mat
import numpy as np
import matplotlib.pylab as pl
from matplotlib.patches import Ellipse
data = load_mat('heightWeight')
data = data['heightWeightData']
sex = data[:, 0]
x = data[:, 1]
y = data[:, 2]
male_arg = (sex == 1)
female_arg = (sex == 2)
x_male = x[male_arg]
y_male = y[male_arg]
x_female = x[female_arg]
y_female = y[female_arg]
fig = pl.figure()
ax = fig.add_subplot(111)
ax.plot(x_male, y_male, 'bx')
ax.plot(x_female, y_female, 'ro')
pl.savefig('gaussHeightWeight_1.png')
def draw_ell(cov, xy, color):
u, v = np.linalg.eigh(cov)
angle = np.arctan2(v[0][1], v[0][0])
angle = (180 * angle / np.pi)
# here we time u2 with 5, assume 95% are in this ellipse
#!/usr/bin/env python
from sklearn.naive_bayes import MultinomialNB
from utils import load_mat
import numpy as np
import matplotlib.pylab as pl
data = load_mat('XwindowsDocData')
xtrain = data['xtrain']
ytrain = data['ytrain']
clf = MultinomialNB()
clf.fit(xtrain, ytrain.ravel())
counts = clf.feature_count_
y_counts = clf.class_count_
for i in range(len(counts)):
pl.figure()
pl.bar(np.arange(len(counts[i])), counts[i] / y_counts[i])
pl.title('p(xj=1|y=%d)' % (i + 1))
pl.savefig('naiveBayesBowDemo_%d.png' % i)
pl.show()
#!/usr/bin/env python
from utils import load_mat
from matplotlib import pylab as pl
import numpy as np
data = load_mat('mnistAll')
mnist = data['mnist']
train_images = mnist['train_images'][0][0] # 28*28*60000
train_labels = mnist['train_labels'][0][0] # 60000*1
test_images = mnist['test_images'][0][0] # 28*28*10000
test_labels = mnist['test_labels'][0][0] # 10000*1
fig1 = pl.figure(1)
fig2 = pl.figure(2)
np.random.seed(seed=10)
for i in range(10):
img = test_images[:, :, i]
ax1 = fig1.add_subplot(3, 3, i)
ax1.imshow(img)
ax1.set_xticks(())
ax1.set_yticks(())
ax1.set_title('true class = %s' % test_labels[i])
img_shuffled = img.copy()
# np.shuffle only along the first index, ravel it first
np.random.shuffle(img_shuffled.ravel())
img_shuffled = img_shuffled.reshape(img.shape)
ax2 = fig2.add_subplot(3, 3, i)
ax2.imshow(img_shuffled)
ax2.set_xticks(())
import utils
import scipy.io
import numpy as np
from linear_classifier import LinearSVM_twoclass
import sys
from sklearn.metrics.pairwise import rbf_kernel
#############################################################################
# load the SPAM email training and test dataset #
#############################################################################
print "-------GAUSSIAN/RBF KERNEL-------"
print "Reading the data..."
sys.stdout.flush()
X, y = utils.load_mat("data/spamTrain.mat")
yy = np.ones(y.shape)
yy[y == 0] = -1
X, Xval, yy, yyval = cross_validation.train_test_split(X, yy, test_size=0.1)
test_data = scipy.io.loadmat("data/spamTest.mat")
X_test = test_data["Xtest"]
y_test = test_data["ytest"].flatten()
yy_test = np.ones(y_test.shape)
yy_test[y_test == 0] = -1
print "Done!"
sys.stdout.flush()
#############################################################################
# your code for setting up the best SVM classifier for this dataset #
# Design the training parameters for the SVM. #
from reg_linear_regressor_multi import RegularizedLinearReg_SquaredLoss
########################################################################
## =========== Part 1: Loading and Visualizing Data ===================#
########################################################################
# We start the exercise by first loading and visualizing the dataset. #
# The following code will load the dataset into your environment and #
# plot the data. #
########################################################################
# Load Training Data
print 'Loading and Visualizing Data ...'
X, y, Xtest, ytest, Xval, yval = utils.load_mat('ex2data1.mat')
# Plot training data
plot_utils.plot_data(X,y,'Change in water level (x)','Water flowing out of the dam (y)')
plt.savefig('fig6.pdf')
########################################################################
## =========== Part 2: Regularized Linear Regression ==================#
########################################################################
# You should now implement the loss function and gradient of the
# loss function for regularized linear regression in reg_linear_regression_multi.py
# append a column of ones to matrix X
XX = np.vstack([np.ones((X.shape[0],)),X]).T
#!/usr/bin/env python
from utils import load_mat
from matplotlib import pylab as pl
import numpy as np
data = load_mat("mnistAll")
mnist = data["mnist"]
train_images = mnist["train_images"][0][0] # 28*28*60000
train_labels = mnist["train_labels"][0][0] # 60000*1
test_images = mnist["test_images"][0][0] # 28*28*10000
test_labels = mnist["test_labels"][0][0] # 10000*1
fig1 = pl.figure(1)
fig2 = pl.figure(2)
np.random.seed(seed=10)
for i in range(10):
img = test_images[:, :, i]
ax1 = fig1.add_subplot(3, 3, i)
ax1.imshow(img)
ax1.set_xticks(())
ax1.set_yticks(())
ax1.set_title("true class = %s" % test_labels[i])
img_shuffled = img.copy()
# np.shuffle only along the first index, ravel it first
np.random.shuffle(img_shuffled.ravel())
img_shuffled = img_shuffled.reshape(img.shape)
ax2 = fig2.add_subplot(3, 3, i)
ax2.imshow(img_shuffled)
from sklearn import preprocessing, metrics
import utils
import scipy.io
import numpy as np
from linear_classifier import LinearSVM_twoclass
from sklearn.cross_validation import train_test_split
#############################################################################
# load the SPAM email training and test dataset #
#############################################################################
X, y = utils.load_mat('data/spamTrain.mat')
yy = np.ones(y.shape)
yy[y == 0] = -1
test_data = scipy.io.loadmat('data/spamTest.mat')
X_test = test_data['Xtest']
y_test = test_data['ytest'].flatten()
#############################################################################
# your code for setting up the best SVM classifier for this dataset #
# Design the training parameters for the SVM. #
# What should the learning_rate be? What should C be? #
# What should num_iters be? Should X be scaled? Should X be kernelized? #
#############################################################################
# your experiments below
X_train, X_val, y_train, y_val = train_test_split(X,
y,
test_size=0.8,
random_state=42)
if __name__ == "__main__":
arg = parse_args()
print("========Call with Arguments========")
print(arg)
if not os.path.exists(RESULTS_PATH):
os.mkdir(RESULTS_PATH)
print(">>> Directory {} created.".format(RESULTS_PATH))
if not os.path.exists(BCM_PATH):
os.mkdir(BCM_PATH)
print(">>> Directory {} created.".format(BCM_PATH))
print("\n========Reading Data========")
data, _ = load_mat(arg.data_path, False, 1, 1, ',', True, False, None,
None)
label = load_label(arg.label_path, ',', '0')
data = data["data"]
k_means_logger = Logger(LOG_PATH,
"Benchmark_K_MEANS.log",
benchmark_logger=True)
dbscan_logger = Logger(LOG_PATH,
"Benchmark_DBSCAN.log",
benchmark_logger=True)
k_means_results = {}
dbscan_results = {}
print("\n========Benchmarking========")
for dim in DR_DIM:
#!/usr/bin/env python
from utils import load_mat
import numpy as np
import matplotlib.pylab as pl
from scipy import ndimage
data = load_mat('20news_w100')
documents = data['documents']
documents = documents.toarray().T
newsgroups = data['newsgroups'][0]
#sort documents by number of words and choose the first 1000
chosen_docs_arg = np.argsort(np.sum(documents, axis=1))
chosen_docs_arg = chosen_docs_arg[-1000:][::-1] # descend
documents = documents[chosen_docs_arg]
newsgroups = newsgroups[chosen_docs_arg]
#sort by newsgroups label
sorted_arg = np.argsort(newsgroups)
documents = documents[sorted_arg]
newsgroups = newsgroups[sorted_arg]
#zoom the image to show it
image = ndimage.zoom(documents, (1, 10))
pl.imshow(image, cmap=pl.cm.gray, interpolation='none')
#draw a red line betweent different newsgroups
groups_label = np.unique(newsgroups)
for i in range(len(groups_label) - 1):
y, = np.where(newsgroups == groups_label[i + 1])
y = y[0]
save_point = torch.load(model_path)
model_param = save_point['state_dict']
model = resblock(conv_bn_relu_res_block, 10, 3, 1)
model.load_state_dict(model_param)
model = model.cuda()
model.eval()
for img_name in sorted(os.listdir(img_path)):
img_path_name = os.path.join(img_path, img_name)
rgb = imread(img_path_name)
rgb = rgb / 255
rgb = np.expand_dims(np.transpose(rgb, [2, 1, 0]), axis=0).copy()
img_res1 = reconstruction(rgb, model)
img_res2 = np.flip(reconstruction(np.flip(rgb, 2).copy(), model), 1)
img_res3 = (img_res1 + img_res2) / 2
mat_name = img_name[:-4] + '.mat'
mat_dir = os.path.join(result_path, mat_name)
save_matv73(mat_dir, var_name, img_res3)
gt_name = img_name[12:-4] + '.mat'
gt_dir = os.path.join(gt_path, gt_name)
gt = load_mat(gt_dir, var_name)
mrae_error = mrae(img_res3, gt['rad'][:, :, 1])
rrmse_error = rmse(img_res3, gt['rad'][:, :, 1])
print("[%s] MRAE=%0.9f RRMSE=%0.9f" % (img_name, mrae_error, rrmse_error))
mat[i, row] = factor
plus = -1 * factor * mat[row, row + 1:-1]
mat[i, row + 1:-1] += plus
temp = mat.copy()
# print_mat(mat,m,n)
U = np.triu(mat[:, :-1], 0)
for i in range(m):
temp[i, i] = 1
L = np.tril(temp[:, :-1], 0)
P = np.zeros(shape=(m, n - 1))
for j in range(m):
row_idx = int(mat[j, -1])
P[j, row_idx - 1] = 1
return P, L, U
if __name__ == "__main__":
path = r"data.txt"
matrix = load_mat(path, "LU")
if matrix.size == 0:
print("input Error!")
sys.exit()
P, L, U = LU_factorization(matrix)
m, n = P.shape
print("L=")
print_mat(L, m, m)
print("U=")
print_mat(U, m, m)
print("P=")
print_mat(P, m, m)
for col in range(n):
cur_col = mat[:, col]
if col == 0: #a1=||a1||*q1
R[0, 0] = math.sqrt(np.sum(np.square(cur_col)))
q = cur_col / R[0, 0]
Q[:, col] = q
else:
q = cur_col.copy()
for i in range(col):
R[i, col] = np.matmul(Q[:, i], mat[:, col])
for j in range(col): #qi=ai- <q1|ak>q1-<q2|ai>q2- <qi-1|ai>qi-1
q -= R[j, col] * Q[:, j]
R[col, col] = math.sqrt(np.sum(np.square(q)))
q = q / R[col, col]
Q[:, col] = q
return Q, R
if __name__ == "__main__":
path = r'data.txt'
matrix = load_mat(path, "QR")
if matrix.size == 0:
print("input Error!")
sys.exit()
Q, R = QR(matrix)
m, n = Q.shape
print("Q=")
print_mat(Q, m, m)
print("R=")
print_mat(R, m, n)
#!/usr/bin/env python
from utils import load_mat
import numpy as np
import matplotlib.pylab as pl
from scipy import ndimage
data = load_mat('20news_w100')
documents = data['documents']
documents = documents.toarray().T
newsgroups = data['newsgroups'][0]
#sort documents by number of words and choose the first 1000
chosen_docs_arg = np.argsort(np.sum(documents, axis=1))
chosen_docs_arg = chosen_docs_arg[-1000:][::-1] # descend
documents = documents[chosen_docs_arg]
newsgroups = newsgroups[chosen_docs_arg]
#sort by newsgroups label
sorted_arg = np.argsort(newsgroups)
documents = documents[sorted_arg]
newsgroups = newsgroups[sorted_arg]
#zoom the image to show it
image = ndimage.zoom(documents, (1, 10))
pl.imshow(image, cmap=pl.cm.gray, interpolation='none')
#draw a red line betweent different newsgroups
groups_label = np.unique(newsgroups)
for i in range(len(groups_label) - 1):
y, = np.where(newsgroups == groups_label[i + 1])
y = y[0]
def merge_mat():
mat_dir = "/media/2T/data/data_40/benchmarkData/metadata/classMapping40.mat"
f = utils.load_mat(mat_dir)
lut = f["mapClass"][0]
lut = np.concatenate((np.array([40]), lut))
print lut
#!/usr/bin/env python
from utils import load_mat
import numpy as np
import matplotlib.pylab as pl
from matplotlib.patches import Ellipse
data = load_mat('heightWeight')
data = data['heightWeightData']
sex = data[:, 0]
x = data[:, 1]
y = data[:, 2]
male_arg = (sex == 1)
female_arg = (sex == 2)
x_male = x[male_arg]
y_male = y[male_arg]
x_female = x[female_arg]
y_female = y[female_arg]
fig = pl.figure()
ax = fig.add_subplot(111)
ax.plot(x_male, y_male, 'bx')
ax.plot(x_female, y_female, 'ro')
pl.savefig('gaussHeightWeight_1.png')
def draw_ell(cov, xy, color):
u, v = np.linalg.eigh(cov)
angle = np.arctan2(v[0][1], v[0][0])
angle = (180 * angle / np.pi)
# here we time u2 with 5, assume 95% are in this ellipse
from sklearn import preprocessing, metrics, cross_validation
import utils
import scipy.io
import numpy as np
from linear_classifier import LinearSVM_twoclass
import sys
#############################################################################
# load the SPAM email training and test dataset #
#############################################################################
print "-------3RD DEGREE POLYNOMIAL KERNEL-------"
print "Reading the data..."
sys.stdout.flush()
X,y = utils.load_mat('data/spamTrain.mat')
yy = np.ones(y.shape)
yy[y==0] = -1
X, Xval, yy, yyval = cross_validation.train_test_split(X, yy, test_size=0.1)
test_data = scipy.io.loadmat('data/spamTest.mat')
X_test = test_data['Xtest']
y_test = test_data['ytest'].flatten()
yy_test = np.ones(y_test.shape)
yy_test[y_test==0] = -1
print "Done!"
sys.stdout.flush()
#############################################################################
# your code for setting up the best SVM classifier for this dataset #
# Design the training parameters for the SVM. #
import linear_svm
import matplotlib.pyplot as plt
import utils
from sklearn import preprocessing, metrics
from linear_classifier import LinearSVM_twoclass
############################################################################
# Part 0: Loading and Visualizing Data #
# We start the exercise by first loading and visualizing the dataset. #
# The following code will load the dataset into your environment and plot #
# the data. #
############################################################################
# load ex6data1.mat
X, y = utils.load_mat('data/ex4data1.mat')
utils.plot_twoclass_data(X, y, 'x1', 'x2', ['neg', 'pos'])
plt.savefig('fig1.pdf')
############################################################################
# Part 1: Hinge loss function and gradient #
############################################################################
C = 1
theta = np.zeros((X.shape[1], ))
J, grad = linear_svm.svm_loss_twoclass(theta, X, y, C)
print "J = ", J, " grad = ", grad
############################################################################
def main(args):
path = args.files
matrix = load_mat(path, args.mode)
if matrix.size == 0:
print("input Matrix Error!")
sys.exit()
m, n = matrix.shape
if args.mode == "LU":
print("LU Factorization, the input should be a square matrix.\n")
elif args.mode == "QR":
r = np.linalg.matrix_rank(matrix)
if r < n:
print(
"Error!\n QR Factorization, The matrix has linearly dependent columns can not be uniquely factored as A=QR!\n"
)
print("=" * 50, "\norigin matrix type: {m} * {n}".format(m=m, n=n),
"\nOrigin Matrix A = ")
print_mat(matrix, m, n)
print("\nThe factorization is processing!\n ")
if args.mode == "LU":
P, L, U = LU_factorization(matrix)
m, n = P.shape
print("L=")
print_mat(L, m, m)
print("U=")
print_mat(U, m, m)
print("P=")
print_mat(P, m, m)
elif args.mode == "QR":
Q, R = QR(matrix)
m, n = Q.shape
m1, n1 = R.shape
print("Q=")
print_mat(Q, m, n)
print("R=")
print_mat(R, m1, n1)
elif args.mode == "Householder":
Q, R = Householder_Reduction(matrix)
m, n = Q.shape
m1, n1 = R.shape
print("Q=")
print_mat(Q, m, n)
print("R=")
print_mat(R, m1, n1)
elif args.mode == "Givens":
Q, R = Givens_Reduction(matrix)
m, n = Q.shape
m1, n1 = R.shape
print("Q=")
print_mat(Q, m, n)
print("R=")
print_mat(R, m1, n1)
elif args.mode == "URV":
U, R, V = URV(matrix)
m, n = U.shape
m1, n1 = R.shape
m2, n2 = V.shape
print("U=")
print_mat(U, m, n)
print("R=")
print_mat(R, m1, n1)
print("V=")
print_mat(V, m2, n2)
