def get_params(): W_xh = nd.random_normal(scale=std, shape=(input_dim, hidden_dim), ctx=ctx) W_hh = nd.random_normal(scale=std, shape=(hidden_dim, hidden_dim), ctx=ctx) b_h = nd.zeros(hidden_dim, ctx=ctx) W_hy = nd.random_normal(scale=std, shape=(hidden_dim, output_dim), ctx=ctx) b_y = nd.zeros(output_dim, ctx=ctx) params = [W_xh, W_hh, b_h, W_hy, b_y] for param in params: param.attach_grad() return params
def get_parameters(): W_xh = nd.random_normal(scale=config.std, shape=(config.input_dim, config.hidden_dim)) W_hh = nd.random_normal(scale=config.std, shape=(config.hidden_dim, config.hidden_dim)) b_h = nd.zeros(config.hidden_dim) W_hy = nd.random_normal(scale=config.std, shape=(config.hidden_dim, config.output_dim)) b_y = nd.zeros(config.output_dim) parameters = [W_xh, W_hh, b_h, W_hy, b_y] for parameter in parameters: parameter.attach_grad() return parameters
def init_params(): w = nd.random_normal(scale=1, shape=(num_inputs, 1)) b = nd.zeros(shape=(1,)) params = [w, b] for param in params: param.attach_grad()#自动求导 需要创建它们的梯度 return params
def test_optimizer(optimizer, optimizer_params): # Weights index = 0 weight = nd.zeros(shape=(8,)) # Optimizer from registry optimizer = opt.create(optimizer, **optimizer_params) state = optimizer.create_state(index, weight) # Run a few updates for i in range(1, 13): grad = nd.random_normal(shape=(8,)) if isinstance(optimizer, SockeyeOptimizer): batch_state = BatchState(metric_val=random()) optimizer.pre_update_batch(batch_state) optimizer.update(index, weight, grad, state) # Checkpoint if i % 3 == 0: if isinstance(optimizer, SockeyeOptimizer): checkpoint_state = CheckpointState(checkpoint=(i % 3 + 1), metric_val=random()) optimizer.pre_update_checkpoint(checkpoint_state)
def __init__(self, vocab_size, tag2idx, embedding_dim, hidden_dim): super(BiLSTM_CRF, self).__init__() with self.name_scope(): self.embedding_dim = embedding_dim self.hidden_dim = hidden_dim self.vocab_size = vocab_size self.tag2idx = tag2idx self.tagset_size = len(tag2idx) self.word_embeds = nn.Embedding(vocab_size, embedding_dim) self.lstm = rnn.LSTM(hidden_dim // 2, num_layers=1, bidirectional=True) # Maps the output of the LSTM into tag space. self.hidden2tag = nn.Dense(self.tagset_size) # Matrix of transition parameters. Entry i,j is the score of # transitioning *to* i *from* j. self.transitions = nd.random_normal(shape=(self.tagset_size, self.tagset_size)) self.hidden = self.init_hidden()
def test_optimizer(optimizer, optimizer_params): # Weights index = 0 weight = nd.zeros(shape=(8, )) # Optimizer from registry optimizer = opt.create(optimizer, **optimizer_params) state = optimizer.create_state(index, weight) # Run a few updates for i in range(1, 13): grad = nd.random_normal(shape=(8, )) if isinstance(optimizer, SockeyeOptimizer): batch_state = BatchState(metric_val=random()) optimizer.pre_update_batch(batch_state) optimizer.update(index, weight, grad, state) # Checkpoint if i % 3 == 0: if isinstance(optimizer, SockeyeOptimizer): checkpoint_state = CheckpointState(checkpoint=(i % 3 + 1), metric_val=random()) optimizer.pre_update_checkpoint(checkpoint_state)
def get_params(): # 隐含层 W_xz = nd.random_normal(scale=std, shape=(input_dim, hidden_dim), ctx=ctx) W_hz = nd.random_normal(scale=std, shape=(hidden_dim, hidden_dim), ctx=ctx) b_z = nd.zeros(hidden_dim, ctx=ctx) W_xr = nd.random_normal(scale=std, shape=(input_dim, hidden_dim), ctx=ctx) W_hr = nd.random_normal(scale=std, shape=(hidden_dim, hidden_dim), ctx=ctx) b_r = nd.zeros(hidden_dim, ctx=ctx) W_xh = nd.random_normal(scale=std, shape=(input_dim, hidden_dim), ctx=ctx) W_hh = nd.random_normal(scale=std, shape=(hidden_dim, hidden_dim), ctx=ctx) b_h = nd.zeros(hidden_dim, ctx=ctx) W_hy = nd.random_normal(scale=std, shape=(hidden_dim, output_dim), ctx=ctx) b_y = nd.zeros(output_dim, ctx=ctx) params = [W_xz, W_hz, b_z, W_xr, W_hr, b_r, W_xh, W_hh, b_h, W_hy, b_y] for param in params: param.attach_grad() return params
def __init__(self, vocab_size, tag2idx, embedding_dim, hidden_dim): super(BiLSTM_CRF, self).__init__() with self.name_scope(): self.embedding_dim = embedding_dim self.hidden_dim = hidden_dim self.vocab_size = vocab_size self.tag2idx = tag2idx self.tagset_size = len(tag2idx) self.word_embeds = nn.Embedding(vocab_size, embedding_dim) self.lstm = rnn.LSTM(hidden_dim // 2, num_layers=1, bidirectional=True) # Maps the output of the LSTM into tag space. self.hidden2tag = nn.Dense(self.tagset_size) # Matrix of transition parameters. Entry i,j is the score of # transitioning *to* i *from* j. self.transitions = nd.random_normal(shape=(self.tagset_size, self.tagset_size)) self.hidden = self.init_hidden()
from mxnet import ndarray as nd import numpy as np x = nd.zeros((3, 4)) print(x) x = nd.ones((3, 4)) print(x) x = nd.array([[1, 2], [3, 4]]) print(x) # 创建随机数组,每个元素的值都是随机采样而来,经常被用于初始化模型参数 y = nd.random_normal(0, 1, shape=(3, 4)) print(y) print(y.shape) print(y.size) x = nd.random_normal(0, 1, shape=(3, 4)) print(x) print(x + y) print(x * y) # 指数运算. print(nd.exp(y)) # 转置 print(nd.dot(x, y.T)) # 广播 a = nd.arange(3).reshape((3, 1)) b = nd.arange(2).reshape((1, 2)) print('a:', a)
# 显式记录要求求导的函数 with ag.record(): y = x * 2 z = y * x # 对函数进行求导 z.backward() print('x.grad:',x.grad) ''' 对控制流进行求导 ''' def f(a): b = a * 2 while nd.norm(b).asscalar() < 1000: b = b * 2 if nd.sum(b).asscalar() > 0: c = b else: c = 100 * b return c a = nd.random_normal(shape=3) a.attach_grad() with ag.record(): c = f(a) c.backward() print('c.grad = ',a.grad)
for batch_i, data, label in data_iter(batch_size): with autograd.record(): output = net(data, w, b) loss = square_loss(output, label) loss.backward() adagrad([w, b], sqrs, lr, batch_size) if batch_i * batch_size % period == 0: total_loss.append( np.mean(square_loss(net(X, w, b), y).asnumpy())) print("Batch size %d, Learning rate %f, Epoch %d, loss %.4e" % (batch_size, lr, epoch, total_loss[-1])) print('w:', np.reshape(w.asnumpy(), (1, -1)), 'b:', b.asnumpy()[0], '\n') x_axis = np.linspace(0, epochs, len(total_loss), endpoint=True) plt.semilogy(x_axis, total_loss) plt.xlabel('epoch') plt.ylabel('loss') plt.show() if __name__ == '__main__': # 生成数据集。 num_inputs = 2 num_examples = 1000 true_w = [2, -3.4] true_b = 4.2 X = nd.random_normal(scale=1, shape=(num_examples, num_inputs)) y = true_w[0] * X[:, 0] + true_w[1] * X[:, 1] + true_b y += .01 * nd.random_normal(scale=1, shape=y.shape) dataset = gluon.data.ArrayDataset(X, y) train(batch_size=10, lr=0.9, epochs=3, period=10)
# 配置训练参数 trainer_g = gluon.Trainer(generator.collect_params(), 'Adam', {'learning_rate': learning_rate}) trainer_d = gluon.Trainer(discriminator.collect_params(), 'Adam', {'learning_rate': learning_rate}) print('Begin to train') for epoch in range(151): loss_Dis = 0. loss_Gen = 0. for real, _ in data: # 加载到指定设备内存(gpu/cpu) real = real.as_in_context(ctx) Z_dim = nd.random_normal(0, 1, shape=(len(real), 100), ctx=ctx) # 训练判别器 fake = generator(Z_dim) with autograd.record(): real_res = discriminator(real) fake_res = discriminator(fake) loss_d = net.loss_d(real_res, fake_res) loss_d.backward() trainer_d.step(batch_size) # 训练生成器 with autograd.record(): fake = generator(Z_dim) fake_res = discriminator(fake) loss_g = net.loss_g(fake_res)
from mxnet import ndarray as nd from mxnet import autograd import numpy as np import matplotlib.pyplot as plt import random num_input = 2 # 每个样本的特征数 num_example = 1000 # 样本数量 true_w = [2, -3.4] true_b = 4.2 X = nd.random_normal(shape=(num_example, num_input)) # 随机生成数据集 y = true_w[0] * X[:, 0] + true_w[1] * X[:, 1] + true_b y += 0.01 * nd.random_normal(shape=y.shape) #plt.scatter(X[:,1].asnumpy(),y.asnumpy()) #plt.show() # 数据读取,data_iter函数返回batch_size个随机的样本和对应的目标 # 由yield构造一个迭代器 batch_size = 10 def data_iter(): # 产生一个随机索引 idx = list(range(num_example)) random.shuffle(idx) # 遍历所有样本 for i in range(0, num_example, batch_size): j = nd.array(idx[i:min(i + batch_size, num_example)])
def init_hidden(self): return [nd.random_normal(shape=(2, 1, self.hidden_dim // 2)), nd.random_normal(shape=(2, 1, self.hidden_dim // 2))]
return [text_labels[int(i)] for i in label] # data, label = minist_train[0:9] # show_image(data) # print(get_text_labels(label)) # load data batch_size = 256 train_data = gluon.data.DataLoader(minist_train, batch_size, shuffle = True) test_data = gluon.data.DataLoader(minist_test, batch_size, shuffle = False) # initialize parameters num_inputs = 784 # 28*28 num of features num_outputs = 10 # num of class W = nd.random_normal(shape=(num_inputs, num_outputs)) b = nd.random_normal(shape=num_outputs) # row vec params = [W, b] for param in params: param.attach_grad() def softmax(X): exp = nd.exp(X) partition = exp.sum(axis = 1, keepdims=True) # return (nrows, 1) matrix return exp / partition def net(X): return softmax(nd.dot(X.reshape((-1, num_inputs)), W) + b) # the second dim is num_inputs, the first dim will be automatically calculated
class Config: def __init__(self): self.num_inputs = 3 self.training_size = 1000 self.batch_size = 10 self.learning_rate = 1e-2 self.num_epochs = 5 config = Config() true_w = [2.5, 4.7, -3.2] true_b = 2.9 X = nd.random_normal(shape=(config.training_size, config.num_inputs)) y = nd.dot(X, nd.array(true_w)) + true_b y += 0.01 * nd.random_normal(shape=y.shape) def data_generator(batch_size): index = list(range(config.training_size)) random.shuffle(index) for i in range(0, config.training_size, batch_size): j = nd.array(index[i:min(i + batch_size, config.training_size)]) yield nd.take(X, j), nd.take(y, j) w = nd.random_normal(shape=(config.num_inputs, 1)) b = nd.zeros((1,))
sys.path.append('..') from utils import utils batch_size = 256 train_data, test_data = utils.load_data_fashion_mnist(batch_size) # 定义一个只有一层的隐藏层模型 from mxnet import ndarray as nd num_inputs = 28 * 28 num_outputs = 10 num_hidden = 255 weight_scale = 0.01 W1 = nd.random_normal(shape=(num_inputs, num_hidden), scale=weight_scale) b1 = nd.zeros(num_hidden) W2 = nd.random_normal(shape=(num_hidden, num_outputs), scale=weight_scale) b2 = nd.zeros(num_outputs) params = [W1, b1, W2, b2] for param in params: param.attach_grad() # 定义非线性激活函数 def relu(X): # 先广播,然后对应的取两者之间的最大值组成返回矩阵 return nd.maximum(X, 0)
mnist_train = gluon.data.vision.FashionMNIST(train=True, transform=transform) mnist_test = gluon.data.vision.FashionMNIST(train=False, transform=transform) data, label = mnist_train[0] print('shape:', data.shape, 'label:', label) batch_size = 50 train_data = gluon.data.DataLoader(mnist_train, batch_size, shuffle=True) test_data = gluon.data.DataLoader(mnist_test, batch_size, shuffle=False) num_inputs = 28 * 28 num_hidden1 = 256 num_hidden2 = 128 num_outputs = 10 weight_scale = .01 w1 = nd.random_normal(shape=(num_inputs, num_hidden1), scale=weight_scale) b1 = nd.random_normal(shape=(num_hidden1)) w2 = nd.random_normal(shape=(num_hidden1, num_hidden2), scale=weight_scale) b2 = nd.random_normal(shape=(num_hidden2)) w3 = nd.random_normal(shape=(num_hidden2, num_outputs), scale=weight_scale) b3 = nd.random_normal(shape=(num_outputs)) params = [w1, b1, w2, b2, w3, b3] for param in params: param.attach_grad() def softmax(X): exp = nd.exp(X) partition = exp.sum(axis=1, keepdims=True) return exp / partition def relu(X):
H = nd.tanh(nd.dot(X, W_xh) + nd.dot(H, W_hh) + b_h) # compute output from hidden state Y = nd.dot(H, W_hy) + b_y _outputs.append(Y) return _outputs, H # gradient clipping to avoid gradient explosion def gradient_clipping(parameters, threshold, ctx): if threshold is not None: norm = nd.array([0.0], ctx) for parameter in parameters: norm += nd.sum(parameter.grad ** 2) norm = nd.sqrt(norm).asscalar() if norm > threshold: for parameter in parameters: parameter.grad[:] *= (threshold / norm) if __name__ == '__main__': initial_state = nd.zeros(shape=(config.batch_size, config.hidden_dim)) dump_data = [nd.random_normal(shape=(config.batch_size, config.input_dim)) for _ in range(config.num_steps)] parameters = get_parameters() _outputs, final_state = rnn(dump_data, initial_state, *parameters) print(_outputs, final_state)
def databalanceGenerator(workQueue, maxdatabalance): conn = pymysql.Connect(host="localhost", port=3306, user="******", password="******", database="stock", charset="utf8") cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) featureNames = [ 'DateString', 'Date', 'Code', 'Day1OpenPrice', 'Day1ClosePrice', 'Day1Diff', 'Day1Percent', 'Day1LowPrice', 'Day1HighPrice', 'Day1Volume', 'Day1Amount', 'Day1Exchange', 'Day2OpenPrice', 'Day2ClosePrice', 'Day2Diff', 'Day2Percent', 'Day2LowPrice', 'Day2HighPrice', 'Day2Volume', 'Day2Amount', 'Day2Exchange', 'Day3OpenPrice', 'Day3ClosePrice', 'Day3Diff', 'Day3Percent', 'Day3LowPrice', 'Day3HighPrice', 'Day3Volume', 'Day3Amount', 'Day3Exchange', 'Day4OpenPrice', 'Day4ClosePrice', 'Day4Diff', 'Day4Percent', 'Day4LowPrice', 'Day4HighPrice', 'Day4Volume', 'Day4Amount', 'Day4Exchange', 'Day5OpenPrice', 'Day5ClosePrice', 'Day5Diff', 'Day5Percent', 'Day5LowPrice', 'Day5HighPrice', 'Day5Volume', 'Day5Amount', 'Day5Exchange', 'Day6OpenPrice', 'Day6ClosePrice', 'Day6Diff', 'Day6Percent', 'Day6LowPrice', 'Day6HighPrice', 'Day6Volume', 'Day6Amount', 'Day6Exchange', 'Day7OpenPrice', 'Day7ClosePrice', 'Day7Diff', 'Day7Percent', 'Day7LowPrice', 'Day7HighPrice', 'Day7Volume', 'Day7Amount', 'Day7Exchange', 'Day8OpenPrice', 'Day8ClosePrice', 'Day8Diff', 'Day8Percent', 'Day8LowPrice', 'Day8HighPrice', 'Day8Volume', 'Day8Amount', 'Day8Exchange', 'Day9OpenPrice', 'Day9ClosePrice', 'Day9Diff', 'Day9Percent', 'Day9LowPrice', 'Day9HighPrice', 'Day9Volume', 'Day9Amount', 'Day9Exchange', 'Day10OpenPrice', 'Day10ClosePrice', 'Day10Diff', 'Day10Percent', 'Day10LowPrice', 'Day10HighPrice', 'Day10Volume', 'Day10Amount', 'Day10Exchange', 'Day11OpenPrice', 'Day11ClosePrice', 'Day11Diff', 'Day11Percent', 'Day11LowPrice', 'Day11HighPrice', 'Day11Volume', 'Day11Amount', 'Day11Exchange', 'Day12OpenPrice', 'Day12ClosePrice', 'Day12Diff', 'Day12Percent', 'Day12LowPrice', 'Day12HighPrice', 'Day12Volume', 'Day12Amount', 'Day12Exchange', 'Day13OpenPrice', 'Day13ClosePrice', 'Day13Diff', 'Day13Percent', 'Day13LowPrice', 'Day13HighPrice', 'Day13Volume', 'Day13Amount', 'Day13Exchange', 'Day14OpenPrice', 'Day14ClosePrice', 'Day14Diff', 'Day14Percent', 'Day14LowPrice', 'Day14HighPrice', 'Day14Volume', 'Day14Amount', 'Day14Exchange', 'Day15OpenPrice', 'Day15ClosePrice', 'Day15Diff', 'Day15Percent', 'Day15LowPrice', 'Day15HighPrice', 'Day15Volume', 'Day15Amount', 'Day15Exchange', 'Day16OpenPrice', 'Day16ClosePrice', 'Day16Diff', 'Day16Percent', 'Day16LowPrice', 'Day16HighPrice', 'Day16Volume', 'Day16Amount', 'Day16Exchange', 'Day17OpenPrice', 'Day17ClosePrice', 'Day17Diff', 'Day17Percent', 'Day17LowPrice', 'Day17HighPrice', 'Day17Volume', 'Day17Amount', 'Day17Exchange', 'Day18OpenPrice', 'Day18ClosePrice', 'Day18Diff', 'Day18Percent', 'Day18LowPrice', 'Day18HighPrice', 'Day18Volume', 'Day18Amount', 'Day18Exchange', 'Day19OpenPrice', 'Day19ClosePrice', 'Day19Diff', 'Day19Percent', 'Day19LowPrice', 'Day19HighPrice', 'Day19Volume', 'Day19Amount', 'Day19Exchange', 'Day20OpenPrice', 'Day20ClosePrice', 'Day20Diff', 'Day20Percent', 'Day20LowPrice', 'Day20HighPrice', 'Day20Volume', 'Day20Amount', 'Day20Exchange', 'Day21OpenPrice', 'Day21ClosePrice', 'Day21Diff', 'Day21Percent', 'Day21LowPrice', 'Day21HighPrice', 'Day21Volume', 'Day21Amount', 'Day21Exchange', 'Day22OpenPrice', 'Day22ClosePrice', 'Day22Diff', 'Day22Percent', 'Day22LowPrice', 'Day22HighPrice', 'Day22Volume', 'Day22Amount', 'Day22Exchange', 'Day23OpenPrice', 'Day23ClosePrice', 'Day23Diff', 'Day23Percent', 'Day23LowPrice', 'Day23HighPrice', 'Day23Volume', 'Day23Amount', 'Day23Exchange', 'Day24OpenPrice', 'Day24ClosePrice', 'Day24Diff', 'Day24Percent', 'Day24LowPrice', 'Day24HighPrice', 'Day24Volume', 'Day24Amount', 'Day24Exchange', 'Day25OpenPrice', 'Day25ClosePrice', 'Day25Diff', 'Day25Percent', 'Day25LowPrice', 'Day25HighPrice', 'Day25Volume', 'Day25Amount', 'Day25Exchange', 'Day26OpenPrice', 'Day26ClosePrice', 'Day26Diff', 'Day26Percent', 'Day26LowPrice', 'Day26HighPrice', 'Day26Volume', 'Day26Amount', 'Day26Exchange', 'Day27OpenPrice', 'Day27ClosePrice', 'Day27Diff', 'Day27Percent', 'Day27LowPrice', 'Day27HighPrice', 'Day27Volume', 'Day27Amount', 'Day27Exchange', 'Day28OpenPrice', 'Day28ClosePrice', 'Day28Diff', 'Day28Percent', 'Day28LowPrice', 'Day28HighPrice', 'Day28Volume', 'Day28Amount', 'Day28Exchange', 'Day29OpenPrice', 'Day29ClosePrice', 'Day29Diff', 'Day29Percent', 'Day29LowPrice', 'Day29HighPrice', 'Day29Volume', 'Day29Amount', 'Day29Exchange', 'Day30OpenPrice', 'Day30ClosePrice', 'Day30Diff', 'Day30Percent', 'Day30LowPrice', 'Day30HighPrice', 'Day30Volume', 'Day30Amount', 'Day30Exchange', 'Day31OpenPrice', 'Day31ClosePrice', 'Day31Diff', 'Day31Percent', 'Day31LowPrice', 'Day31HighPrice', 'Day31Volume', 'Day31Amount', 'Day31Exchange', 'Day32OpenPrice', 'Day32ClosePrice', 'Day32Diff', 'Day32Percent', 'Day32LowPrice', 'Day32HighPrice', 'Day32Volume', 'Day32Amount', 'Day32Exchange', 'Day33OpenPrice', 'Day33ClosePrice', 'Day33Diff', 'Day33Percent', 'Day33LowPrice', 'Day33HighPrice', 'Day33Volume', 'Day33Amount', 'Day33Exchange', 'Day34OpenPrice', 'Day34ClosePrice', 'Day34Diff', 'Day34Percent', 'Day34LowPrice', 'Day34HighPrice', 'Day34Volume', 'Day34Amount', 'Day34Exchange', 'Day35OpenPrice', 'Day35ClosePrice', 'Day35Diff', 'Day35Percent', 'Day35LowPrice', 'Day35HighPrice', 'Day35Volume', 'Day35Amount', 'Day35Exchange', 'Day36OpenPrice', 'Day36ClosePrice', 'Day36Diff', 'Day36Percent', 'Day36LowPrice', 'Day36HighPrice', 'Day36Volume', 'Day36Amount', 'Day36Exchange', 'Day37OpenPrice', 'Day37ClosePrice', 'Day37Diff', 'Day37Percent', 'Day37LowPrice', 'Day37HighPrice', 'Day37Volume', 'Day37Amount', 'Day37Exchange', 'Day38OpenPrice', 'Day38ClosePrice', 'Day38Diff', 'Day38Percent', 'Day38LowPrice', 'Day38HighPrice', 'Day38Volume', 'Day38Amount', 'Day38Exchange', 'Day39OpenPrice', 'Day39ClosePrice', 'Day39Diff', 'Day39Percent', 'Day39LowPrice', 'Day39HighPrice', 'Day39Volume', 'Day39Amount', 'Day39Exchange', 'Day40OpenPrice', 'Day40ClosePrice', 'Day40Diff', 'Day40Percent', 'Day40LowPrice', 'Day40HighPrice', 'Day40Volume', 'Day40Amount', 'Day40Exchange', 'Week1OpenPrice', 'Week1ClosePrice', 'Week1LowPrice', 'Week1HighPrice', 'Week1Volume', 'Week1Amount', 'Week1Diff', 'Week1Percent', 'Week1Exchange', 'Week2OpenPrice', 'Week2ClosePrice', 'Week2LowPrice', 'Week2HighPrice', 'Week2Volume', 'Week2Amount', 'Week2Diff', 'Week2Percent', 'Week2Exchange', 'Week3OpenPrice', 'Week3ClosePrice', 'Week3LowPrice', 'Week3HighPrice', 'Week3Volume', 'Week3Amount', 'Week3Diff', 'Week3Percent', 'Week3Exchange', 'Week4OpenPrice', 'Week4ClosePrice', 'Week4LowPrice', 'Week4HighPrice', 'Week4Volume', 'Week4Amount', 'Week4Diff', 'Week4Percent', 'Week4Exchange' ] predictNames = [ 'NextDayIncrease', 'NextDayIncrease1', 'NextDayIncrease2', 'NextDayIncrease3', 'NextDayIncrease4', 'NextDayIncrease5', 'NextDayIncrease6', 'NextDayIncrease7', 'NextDayIncrease8', 'NextDayIncrease9', 'NextDayIncrease10', 'NextDayDecrease1', 'NextDayDecrease2', 'NextDayDecrease3', 'NextDayDecrease4', 'NextDayDecrease5', 'NextDayDecrease6', 'NextDayDecrease7', 'NextDayDecrease8', 'NextDayDecrease9', 'NextDayDecrease10' ] while (not workQueue.empty()): code = workQueue.get() df = pd.read_sql( "SELECT {} from {} where code = {} and DATABALANCE = -1 and {} = true " .format(getSQLColumnString(featureNames + predictNames), tableName, code, predictCategory), conn, columns=featureNames + predictNames) dfless = df[df[predictCategory] == 1] #unbalaced class data enhance, add more data through giving a random_normal to the real data enhanceIter = copyNumbers #len(df) // len(dfless) for i in range(enhanceIter): dflessCopy = dfless.copy(True) dflessCopy['DATABALANCE'] = (i + maxdatabalance + 1) for columnName in dfless.iloc[0].index: if not columnName.startswith('Next'): normalarr = None if columnName.__contains__( 'Percent') or columnName.__contains__( 'Exchange') or columnName.__contains__('Diff'): normalarr = nd.random_normal(shape=(len(dfless), 1), scale=0.01).asnumpy() elif columnName.__contains__('Price'): normalarr = nd.random_normal(shape=(len(dfless), 1), scale=1).asnumpy() # elif isinstance( df[columnName].iloc[0], str) or columnName.__contains__( 'Code') or columnName.__contains__('CODELONG'): #columnName.__contains__('Date') or columnName.__contains__('Code') or columnName.__contains__('CODELONG') continue else: normalarr = nd.random_normal(shape=(len(dfless), 1), scale=100).asnumpy() dflessCopy[ columnName] = dflessCopy[columnName].values.reshape( len(dfless), 1) + normalarr dflessCopy['DATABALANCE'] = (i + maxdatabalance + 1) for index, row in dflessCopy.iterrows(): insertAExample(row, cursor, conn) #ignore_index true, otherwise duplicate index will happen #df = df.append(dflessCopy,ignore_index=True) cursor.close() conn.close()
transform=transform) batch_size = 256 # Read Data train_data = gluon.data.DataLoader(dataset=mnist_train, batch_size=batch_size, shuffle=True) test_data = gluon.data.DataLoader(dataset=mnist_test, batch_size=batch_size, shuffle=False) # Initialize Params num_inputs = 28 * 28 num_outputs = 10 w = nd.random_normal(shape=[num_inputs, num_outputs]) b = nd.random_normal(shape=(num_outputs)) params = [w, b] for param in params: param.attach_grad() # Define Model def softmax(X): exp = nd.exp(X) partition = exp.sum(axis=1, keepdims=True) return exp / partition def net(X):
## 测试 ##所以我们的第一个教程是如何只利用ndarray和autograd来实现一个线性回归的训练。 from mxnet import ndarray as nd from mxnet import autograd import random from mxnet import gluon #### 准备输入数据 ### num_inputs = 2##数据维度 num_examples = 1000##样例大小 ## 真实的需要估计的参数 true_w = [2, -3.4]##权重 true_b = 4.2##偏置 X = nd.random_normal(shape=(num_examples, num_inputs))## 1000*2 y = true_w[0] * X[:, 0] + true_w[1] * X[:, 1] + true_b## 1000*1 y += .01 * nd.random_normal(shape=y.shape)##加入 噪声 服从均值0和标准差为0.01的正态分布 ## 读取数据 ''' batch_size = 10 def data_iter(): # 产生一个随机索引 idx = list(range(num_examples)) random.shuffle(idx)##打乱 for i in range(0, num_examples, batch_size):##0 10 20 ... j = nd.array(idx[i:min(i+batch_size,num_examples)])##随机抽取10个样例 yield nd.take(X, j), nd.take(y, j)##样例和标签 我们通过python的yield来构造一个迭代器。 ''' batch_size = 10
## 测试 python 0_linear_regression_dis2_with_bis.py ##所以我们的第一个教程是如何只利用ndarray和autograd来实现一个线性回归的训练。 ## 两维 线性回归 带 偏置 # y = a*x1 + b*x2 + c from mxnet import ndarray as nd from mxnet import autograd #反向传播自动求梯度 import random #### 准备输入数据 ########################### ############################################## num_inputs = 2 ##数据维度 num_examples = 1000 ##样例大小 ## 真实的需要估计的参数 true_w = [2, -3.4] ##权重 true_b = 4.2 ##偏置 X = nd.random_normal(shape=(num_examples, num_inputs)) ## 1000*2 y = true_w[0] * X[:, 0] + true_w[1] * X[:, 1] + true_b ## 1000*1 y += .01 * nd.random_normal(shape=y.shape) ##加入 噪声 服从均值0和标准差为0.01的正态分布 ## 读取数据 batch_size = 10 #每次训练输入 10个样本数据 def data_iter(): # 产生一个随机索引 idx = list(range(num_examples)) random.shuffle(idx) ##打乱 for i in range(0, num_examples, batch_size): ##0 10 20 ... j = nd.array(idx[i:min(i + batch_size, num_examples)]) ##随机抽取10个样例 yield nd.take(X, j), nd.take(y, j) ##样例和标签 我们通过python的yield来构造一个迭代器。
import matplotlib as mpl mpl.rcParams['figure.dpi'] = 120 import matplotlib.pyplot as plt mx.random.seed(1) random.seed(1) num_inputs = 2 num_examples = 1000 true_w = [2, -3.4] true_b = 4.2 X = nd.random.normal(scale=1, shape=(num_examples, num_inputs)) y = true_w[0] * X[:, 0] + true_w[1] * X[:, 1] + true_b y += .01 * nd.random_normal(scale=1, shape=y.shape) dataset = gluon.data.ArrayDataset(X, y) # define model net = gluon.nn.Sequential() net.add(gluon.nn.Dense(1)) square_loss = gluon.loss.L2Loss() # initialize model # net.initialize() # begin train def train(batch_size, lr, mom, epochs, period): assert period >= batch_size and batch_size % period == 0
#一个稍微复杂点的数据集,它跟MNIST非常像,但是内容不再是分类数字,而是服饰 ## 准备 训练和测试数据集 batch_size = 256#每次训练 输入的图片数量 train_data, test_data = utils.load_data_fashion_mnist(batch_size) ########################################################### ### 定义模型 ################## #@@@@初始化模型参数 权重和偏置@@@@ num_inputs = 28*28##输入为图像尺寸 28*28 num_outputs = 10#输出10个标签 num_hidden = 256#定义一个只有一个隐含层的模型,这个隐含层输出256个节点 weight_scale = .01#初始化权重参数的 均匀分布均值 #输入到隐含层 权重 + 偏置 W1 = nd.random_normal(shape=(num_inputs, num_hidden), scale=weight_scale) b1 = nd.zeros(num_hidden) #隐含层到输出层 权重 + 偏置 W2 = nd.random_normal(shape=(num_hidden, num_outputs), scale=weight_scale) b2 = nd.zeros(num_outputs) params = [W1, b1, W2, b2]#所有参数 for param in params:#参数添加自动求导 param.attach_grad() ##非线性激活函数 #为了让我们的模型可以拟合非线性函数,我们需要在层之间插入非线性的激活函数。 def relu(X): return nd.maximum(X, 0) ### 定义模型 def net(X): X = X.reshape((-1, num_inputs))
def get_params(): w = nd.random_normal(shape=(num_inputs, 1)) * 0.01 b = nd.zeros((1, )) for param in (w, b): param.attach_grad() return (w, b)
from mxnet import ndarray as nd from mxnet import autograd from mxnet import gluon import random num_inputs = 2; num_examples = 1000 true_w = [2, -3.4]; true_b = 4.2; X = nd.random_normal(shape = (num_examples, num_inputs)) # design matrix with 2 features y = true_w[0] * X[:, 0] + true_w[1]*X[:, 1] + true_b y += 0.01 * nd.random_normal(shape=y.shape) # noise batch_size = 10 dataset = gluon.data.ArrayDataset(X, y) data_iter = gluon.data.DataLoader(dataset, batch_size, shuffle=True) # define model net = gluon.nn.Sequential() net.add(gluon.nn.Dense(1)) # initial parameters net.initialize() # default randomly initialize # loss square_loss = gluon.loss.L2Loss() # optimization trainer = gluon.Trainer(
# # CKPT = "/home/jiancheng/code/segmentation/deeplabv3p_gluon/workspace/tmptf/xception/model.ckpt" # FLAG = "imagenet_pretrain_for_pascal" # CLASSES = 21 set_gpu_usage() output_folder = os.path.join(BASE, FLAG, "TF2NPY") extract_tensors_from_checkpoint_file(CKPT, output_folder=output_folder) keras_model = npy_to_keras(classes=CLASSES, load_from=output_folder, save_to=os.path.join(BASE, FLAG, "%s.h5" % FLAG)) print("Keras model setup. Output shape: ", keras_model.output.get_shape()) weight_converter = WeightConverter(keras_model=keras_model) gluon_model = DeepLabv3p_gluon(classes=CLASSES) gluon_model.initialize(ctx=mx.gpu()) inputs = nd.random_normal(shape=(1, 3, 512, 512), ctx=mx.gpu()) outputs = gluon_model(inputs) print("Gluon model setup. Output shape: ", outputs.shape) weight_converter.set_parameters(gluon_model) gluon_model.save_params(os.path.join(BASE, FLAG, "%s.params" % FLAG)) print("Clear.")
def train(pool_size, epochs, train_data, val_data, ctx, netEn, netDe, netD, netD2, trainerEn, trainerDe, trainerD, trainerD2, lambda1, batch_size, expname, append=True, useAE = False): tp_file = open(expname + "_trainloss.txt", "w") tp_file.close() text_file = open(expname + "_validtest.txt", "w") text_file.close() #netGT, netDT, _, _ = set_test_network(opt.depth, ctx, opt.lr, opt.beta1,opt.ndf, opt.ngf, opt.append) GAN_loss = gluon.loss.SigmoidBinaryCrossEntropyLoss() L1_loss = gluon.loss.L2Loss() image_pool = imagePool.ImagePool(pool_size) metric = mx.metric.CustomMetric(facc) metric2 = mx.metric.CustomMetric(facc) metricMSE = mx.metric.MSE() loss_rec_G = [] loss_rec_D = [] loss_rec_R = [] acc_rec = [] acc2_rec = [] loss_rec_D2 = [] loss_rec_G2 = [] lr = 0.002 #mu = nd.random_normal(loc=0, scale=1, shape=(batch_size/2,64,1,1), ctx=ctx) mu = nd.random.uniform(low= -1, high=1, shape=(batch_size/2,64,1,1),ctx=ctx) #mu = nd.zeros((batch_size/2,64,1,1),ctx=ctx) sigma = nd.ones((64,1,1),ctx=ctx) mu.attach_grad() sigma.attach_grad() stamp = datetime.now().strftime('%Y_%m_%d-%H_%M') logging.basicConfig(level=logging.DEBUG) for epoch in range(epochs): tic = time.time() btic = time.time() train_data.reset() iter = 0 #print('learning rate : '+str(trainerD.learning_rate )) for batch in train_data: ############################ # (1) Update D network: maximize log(D(x, y)) + log(1 - D(x, G(x, z))) ########################### real_in = batch.data[0].as_in_context(ctx) real_out = batch.data[1].as_in_context(ctx) fake_latent= netEn(real_in) #real_latent = nd.random_normal(loc=0, scale=1, shape=fake_latent.shape, ctx=ctx) real_latent = nd.multiply(nd.power(sigma,2),nd.random_normal(loc=0, scale=1, shape=fake_latent.shape, ctx=ctx)) #nd.random.uniform( low=-1, high=1, shape=fake_latent.shape, ctx=ctx) fake_out = netDe(fake_latent) fake_concat = nd.concat(real_in, fake_out, dim=1) if append else fake_out with autograd.record(): # Train with fake image # Use image pooling to utilize history imagesi output = netD(fake_concat) output2 = netD2(fake_latent) fake_label = nd.zeros(output.shape, ctx=ctx) fake_latent_label = nd.zeros(output2.shape, ctx=ctx) noiseshape = (fake_latent.shape[0]/2,fake_latent.shape[1],fake_latent.shape[2],fake_latent.shape[3]) eps2 = nd.multiply(nd.power(sigma,2),nd.random_normal(loc=0, scale=1, shape=fake_latent.shape, ctx=ctx)) #eps2 = nd.random_normal(loc=0, scale=sigma.asscalar(), shape=fake_latent.shape, ctx=ctx) # #eps = nd.random.uniform( low=-1, high=1, shape=noiseshape, ctx=ctx) rec_output = netD(netDe(eps2)) errD_fake = GAN_loss(rec_output, fake_label) errD_fake2 = GAN_loss(output, fake_label) errD2_fake = GAN_loss(output2, fake_latent_label) metric.update([fake_label, ], [output, ]) metric2.update([fake_latent_label, ], [output2, ]) real_concat = nd.concat(real_in, real_out, dim=1) if append else real_out output = netD(real_concat) output2 = netD2(real_latent) real_label = nd.ones(output.shape, ctx=ctx) real_latent_label = nd.ones(output2.shape, ctx=ctx) errD_real = GAN_loss(output, real_label) errD2_real = GAN_loss(output2, real_latent_label) #errD = (errD_real + 0.5*(errD_fake+errD_fake2)) * 0.5 errD = (errD_real + errD_fake) * 0.5 errD2 = (errD2_real + errD2_fake) * 0.5 totalerrD = errD+errD2 totalerrD.backward() #errD2.backward() metric.update([real_label, ], [output, ]) metric2.update([real_latent_label, ], [output2, ]) trainerD.step(batch.data[0].shape[0]) trainerD2.step(batch.data[0].shape[0]) ############################ # (2) Update G network: maximize log(D(x, G(x, z))) - lambda1 * L1(y, G(x, z)) ########################### with autograd.record(): sh = fake_latent.shape eps2 = nd.multiply(nd.power(sigma,2),nd.random_normal(loc=0, scale=1, shape=fake_latent.shape, ctx=ctx)) #eps2 = nd.random_normal(loc=0, scale=sigma.asscalar(), shape=fake_latent.shape, ctx=ctx) # #eps = nd.random.uniform( low=-1, high=1, shape=noiseshape, ctx=ctx) rec_output = netD(netDe(eps2)) fake_latent= (netEn(real_in)) output2 = netD2(fake_latent) fake_out = netDe(fake_latent) fake_concat = nd.concat(real_in, fake_out, dim=1) if append else fake_out output = netD(fake_concat) real_label = nd.ones(output.shape, ctx=ctx) real_latent_label = nd.ones(output2.shape, ctx=ctx) errG2 = GAN_loss(rec_output, real_label) errR = L1_loss(real_out, fake_out) * lambda1 errG = 10.0*GAN_loss(output2, real_latent_label)+errG2+errR+nd.mean(nd.power(sigma,2)) errG.backward() if epoch>50: sigma -= lr / sigma.shape[0] * sigma.grad print(sigma) trainerDe.step(batch.data[0].shape[0]) trainerEn.step(batch.data[0].shape[0]) loss_rec_G2.append(nd.mean(errG2).asscalar()) loss_rec_G.append(nd.mean(nd.mean(errG)).asscalar()-nd.mean(errG2).asscalar()-nd.mean(errR).asscalar()) loss_rec_D.append(nd.mean(errD).asscalar()) loss_rec_R.append(nd.mean(errR).asscalar()) loss_rec_D2.append(nd.mean(errD2).asscalar()) _, acc2 = metric2.get() name, acc = metric.get() acc_rec.append(acc) acc2_rec.append(acc2) # Print log infomation every ten batches if iter % 10 == 0: _, acc2 = metric2.get() name, acc = metric.get() logging.info('speed: {} samples/s'.format(batch_size / (time.time() - btic))) #print(errD) logging.info('discriminator loss = %f, D2 loss = %f, generator loss = %f, G2 loss = %f, binary training acc = %f , D2 acc = %f, reconstruction error= %f at iter %d epoch %d' % (nd.mean(errD).asscalar(),nd.mean(errD2).asscalar(), nd.mean(errG-errG2-errR).asscalar(),nd.mean(errG2).asscalar(), acc,acc2,nd.mean(errR).asscalar() ,iter, epoch)) iter = iter + 1 btic = time.time() name, acc = metric.get() _, acc2 = metric2.get() tp_file = open(expname + "_trainloss.txt", "a") tp_file.write(str(nd.mean(errG2).asscalar()) + " " + str( nd.mean(nd.mean(errG)).asscalar() - nd.mean(errG2).asscalar() - nd.mean(errR).asscalar()) + " " + str( nd.mean(errD).asscalar()) + " " + str(nd.mean(errD2).asscalar()) + " " + str(nd.mean(errR).asscalar()) +" "+str(acc) + " " + str(acc2)+"\n") tp_file.close() metric.reset() metric2.reset() train_data.reset() logging.info('\nbinary training acc at epoch %d: %s=%f' % (epoch, name, acc)) logging.info('time: %f' % (time.time() - tic)) if epoch%10 ==0:# and epoch>0: text_file = open(expname + "_validtest.txt", "a") filename = "checkpoints/"+expname+"_"+str(epoch)+"_D.params" netD.save_params(filename) filename = "checkpoints/"+expname+"_"+str(epoch)+"_D2.params" netD2.save_params(filename) filename = "checkpoints/"+expname+"_"+str(epoch)+"_En.params" netEn.save_params(filename) filename = "checkpoints/"+expname+"_"+str(epoch)+"_De.params" netDe.save_params(filename) fake_img1 = nd.concat(real_in[0],real_out[0], fake_out[0], dim=1) fake_img2 = nd.concat(real_in[1],real_out[1], fake_out[1], dim=1) fake_img3 = nd.concat(real_in[2],real_out[2], fake_out[2], dim=1) fake_img4 = nd.concat(real_in[3],real_out[3], fake_out[3], dim=1) val_data.reset() text_file = open(expname + "_validtest.txt", "a") for vbatch in val_data: real_in = vbatch.data[0].as_in_context(ctx) real_out = vbatch.data[1].as_in_context(ctx) fake_latent= netEn(real_in) y = netDe(fake_latent) fake_out = y metricMSE.update([fake_out, ], [real_out, ]) _, acc2 = metricMSE.get() text_file.write("%s %s %s\n" % (str(epoch), nd.mean(errR).asscalar(), str(acc2))) metricMSE.reset() images = netDe(eps2) fake_img1T = nd.concat(images[0],images[1], images[2], dim=1) fake_img2T = nd.concat(images[3],images[4], images[5], dim=1) fake_img3T = nd.concat(images[6],images[7], images[8], dim=1) fake_img = nd.concat(fake_img1T,fake_img2T, fake_img3T,dim=2) visual.visualize(fake_img) plt.savefig('outputs/'+expname+'_fakes_'+str(epoch)+'.png') text_file.close() # Do 10 iterations of sampler update fake_img1T = nd.concat(real_in[0],real_out[0], fake_out[0], dim=1) fake_img2T = nd.concat(real_in[1],real_out[1], fake_out[1], dim=1) fake_img3T = nd.concat(real_in[2],real_out[2], fake_out[2], dim=1) #fake_img4T = nd.concat(real_in[3],real_out[3], fake_out[3], dim=1) fake_img = nd.concat(fake_img1,fake_img2, fake_img3,fake_img1T,fake_img2T, fake_img3T,dim=2) visual.visualize(fake_img) plt.savefig('outputs/'+expname+'_'+str(epoch)+'.png') '''if epoch > 100: for ep2 in range(10): with autograd.record(): #eps = nd.random_normal(loc=0, scale=1, shape=noiseshape, ctx=ctx) # eps = nd.random.uniform( low=-1, high=1, shape=noiseshape, ctx=ctx) eps2 = nd.random_normal(loc=0, scale=0.02, shape=noiseshape, ctx=ctx) eps2 = nd.tanh(eps2*sigma+mu) eps2 = nd.concat(eps,eps2,dim=0) rec_output = netD(netDe(eps2)) fake_label = nd.zeros(rec_output.shape, ctx=ctx) errGS = GAN_loss(rec_output, fake_label) errGS.backward() mu -= lr / mu.shape[0] * mu.grad sigma -= lr / sigma.shape[0] * sigma.grad print('mu ' + str(mu[0,0,0,0].asnumpy())+ ' sigma '+ str(sigma[0,0,0,0].asnumpy())) ''' images = netDe(eps2) fake_img1T = nd.concat(images[0],images[1], images[2], dim=1) fake_img2T = nd.concat(images[3],images[4], images[5], dim=1) fake_img3T = nd.concat(images[6],images[7], images[8], dim=1) fake_img = nd.concat(fake_img1T,fake_img2T, fake_img3T,dim=2) visual.visualize(fake_img) plt.savefig('outputs/'+expname+'_fakespost_'+str(epoch)+'.png') return([loss_rec_D,loss_rec_G, loss_rec_R, acc_rec, loss_rec_D2, loss_rec_G2, acc2_rec])
import random import matplotlib as mpl mpl.rcParams['figure.dpi'] = 120 import matplotlib.pyplot as plt # regression with regularization num_train = 20 num_test = 100 num_inputs = 200 true_w = nd.ones((num_inputs, 1)) * 0.01 true_b = 0.05 X = nd.random_normal(shape=(num_train + num_test, num_inputs)) y = nd.dot(X, true_w) y += .01 * nd.random_normal(shape=y.shape) batch_size = 1 # split into test and train sets X_train, X_test = X[:num_train, :], X[:num_test, :] y_train, y_test = y[:num_train], y[num_train:] dataset_train = gluon.data.ArrayDataset(X_train, y_train) data_iter_train = gluon.data.DataLoader(dataset_train, batch_size, shuffle=True) square_loss = gluon.loss.L2Loss()
def main(opt): ctx = mx.gpu() if opt.use_gpu else mx.cpu() testclasspaths = [] testclasslabels = [] print('loading test files') filename = '_testlist.txt' with open(opt.dataset + "_" + opt.expname + filename, 'r') as f: for line in f: testclasspaths.append(line.split(' ')[0]) if int(line.split(' ')[1]) == -1: testclasslabels.append(0) else: testclasslabels.append(1) neworder = range(len(testclasslabels)) neworder = shuffle(neworder) c = list(zip(testclasslabels, testclasspaths)) print('shuffling') random.shuffle(c) #testclasslabels, testclasspaths = zip(*c) #testclasslabels = testclasslabels[1:5000] #testclasspaths = testclasspaths[1:5000] ltnt = 512 print('loading pictures') test_data = load_image.load_test_images(testclasspaths, testclasslabels, opt.batch_size, opt.img_wd, opt.img_ht, ctx, opt.noisevar) print('picture loading done') netEn, netDe, netD, netD2, netDS = set_network(opt.depth, ctx, 0, 0, opt.ndf, opt.ngf, opt.append) netEn.load_params('checkpoints/' + opt.expname + '_' + str(opt.epochs) + '_En.params', ctx=ctx) netDe.load_params('checkpoints/' + opt.expname + '_' + str(opt.epochs) + '_De.params', ctx=ctx) netD.load_params('checkpoints/' + opt.expname + '_' + str(opt.epochs) + '_D.params', ctx=ctx) netD2.load_params('checkpoints/' + opt.expname + '_' + str(opt.epochs) + '_D2.params', ctx=ctx) netDS.load_params('checkpoints/' + opt.expname + '_' + str(opt.epochs) + '_SD.params', ctx=ctx) print('Model loading done') lbllist = [] scorelist1 = [] scorelist2 = [] scorelist3 = [] scorelist4 = [] test_data.reset() count = 0 for batch in (test_data): count += 1 print(str(count)) #, end="\r") real_in = batch.data[0].as_in_context(ctx) real_out = batch.data[1].as_in_context(ctx) lbls = batch.label[0].as_in_context(ctx) code = netEn((real_out)) code = code + nd.random.normal( loc=0, scale=0.002, shape=code.shape, ctx=ctx) outnn = (netDe(code)) out_concat = nd.concat(real_out, outnn, dim=1) if opt.append else outnn output4 = nd.mean((netD(out_concat)), (1, 3, 2)).asnumpy() code = netEn(real_in) #code=codet+nd.random.normal(loc=0, scale=0.0000001, shape=code.shape,ctx=ctx) #code2=codet+nd.random.normal(loc=0, scale=0.000001, shape=code.shape,ctx=ctx) #eq_code = heq(code.asnumpy(),2) #code = nd.array(eq_code, ctx=ctx) out = netDe(code) #out2 = netDe(code2) out_concat = nd.concat(real_in, out, dim=1) if opt.append else out output = netD(out_concat) #Denoised image output3 = nd.mean((out - real_out)**2, (1, 3, 2)).asnumpy() #denoised-real output = nd.mean(output, (1, 3, 2)).asnumpy() out_concat = nd.concat(real_out, real_out, dim=1) if opt.append else real_out output2 = netDS(netDe(code)) #Image with no noise output2 = nd.mean(output2, (1, 3, 2)).asnumpy() lbllist = lbllist + list(lbls.asnumpy()) scorelist1 = scorelist1 + list(output) scorelist2 = scorelist2 + list(output2) scorelist3 = scorelist3 + list(output3) scorelist4 = scorelist4 + list(output4) fake_img1 = nd.concat(real_in[0], real_out[0], out[0], outnn[0], dim=1) fake_img2 = nd.concat(real_in[1], real_out[1], out[1], outnn[1], dim=1) fake_img3 = nd.concat(real_in[2], real_out[2], out[2], outnn[2], dim=1) fake_img4 = nd.concat(real_in[3], real_out[3], out[3], outnn[3], dim=1) fake_img = nd.concat(fake_img1, fake_img2, fake_img3, fake_img4, dim=2) #print(np.shape(fake_img)) visual.visualize(fake_img) plt.savefig('outputs/T_' + opt.expname + '_' + str(count) + '.png') if not opt.isvalidation: fpr, tpr, _ = roc_curve(lbllist, scorelist1, 1) roc_auc1 = auc(fpr, tpr) fpr, tpr, _ = roc_curve(lbllist, scorelist2, 1) roc_auc2 = auc(fpr, tpr) fpr, tpr, _ = roc_curve(lbllist, scorelist3, 1) roc_auc3 = auc(fpr, tpr) fpr, tpr, _ = roc_curve(lbllist, scorelist4, 1) roc_auc4 = auc(fpr, tpr) plt.gcf().clear() plt.clf() sns.set(color_codes=True) posscores = [ scorelist3[i] for i, v in enumerate(lbllist) if int(v) == 1 ] negscores = [ scorelist3[i] for i, v in enumerate(lbllist) if int(v) == 0 ] #sns.distplot(posscores, hist=False, label="Known Classes" ,rug=True) sns.kdeplot(posscores, label="Known Classes") sns.kdeplot(negscores, label="Unnown Classes") #plt.hold() #sns.distplot(negscores, hist=False, label = "Unknown Classes", rug=True); plt.legend() plt.savefig('outputs/matdist_' + opt.expname + '_.png') plt.gcf().clear() inputT = nd.zeros((ltnt, ltnt, 1, 1), ctx=ctx) for i in range(0, ltnt): inputT[i, i, :, :] = -1 out = netDe(inputT) count = 0 for i in range(int(math.ceil(math.sqrt(ltnt)))): for j in range(int(math.ceil(math.sqrt(ltnt)))): if count < ltnt: plt.subplot(math.ceil(math.sqrt(ltnt)), math.ceil(math.sqrt(ltnt)), count + 1) plt.imshow( ((out[count].asnumpy().transpose(1, 2, 0) + 1.0) * 127.5).astype(np.uint8)) plt.axis('off') count += 1 plt.savefig('outputs/atoms_' + opt.expname + '_.png') plt.gcf().clear() plt.clf() return ([roc_auc1, roc_auc2, roc_auc3, roc_auc4]) else: return ([0, 0, 0, 0]) fakecode = nd.random_normal(loc=0, scale=1, shape=(16, 4096, 1, 1), ctx=ctx) out = netDe(fakecode) fake_img1 = nd.concat(out[0], out[1], out[2], out[3], dim=1) fake_img2 = nd.concat(out[7], out[6], out[5], out[4], dim=1) fake_img3 = nd.concat(out[8], out[9], out[10], out[11], dim=1) fake_img4 = nd.concat(out[15], out[14], out[13], out[12], dim=1) fake_img = nd.concat(fake_img1, fake_img2, fake_img3, fake_img4, dim=2) #print(np.shape(fake_img)) visual.visualize(fake_img) plt.savefig('outputs/fakes_' + opt.expname + '_.png')
] return [text_labels[int(i)] for i in label] data, label = mnist_train[0:9] show_images(data) print(get_text_labels(label)) batch_size = 256 train_data = gluon.data.DataLoader(mnist_train, batch_size, shuffle=True) test_data = gluon.data.DataLoader(mnist_test, batch_size, shuffle=False) num_inputs = 784 num_outputs = 10 W = nd.random_normal(shape=(num_inputs, num_outputs)) b = nd.random_normal(shape=num_outputs) params = [W, b] for param in params: param.attach_grad() def softmax(X): exp = nd.exp(X) partition = exp.sum(axis=1, keepdims=True) return exp / partition X = nd.random_normal(shape=(2, 5))
# 使用 record() 要求 MXNet 记录需要求导的程序 with ag.record(): y = x * 2 z = y * x # 求导 z.backward() print('x.grad:', x.grad) # ############### 对控制流求导 ############### def f(a): b = a * 2 while nd.norm(b).asscalar() < 1000: b = b * 2 if nd.sum(b).asscalar() > 0: c = b else: c = 100 * b return c a = nd.random_normal(shape=(3, 4)) a.attach_grad() with ag.record(): c = f(a) c.backward() print(a.grad == c / a)
return nd.stack(dx1, dx2, axis=1) if __name__ == "__main__": import seaborn as sns import matplotlib.pyplot as plt np.random.seed(123) mx.random.seed(123) ctx = mx.cpu() model = Model1(0.3, 0.3, ctx=ctx) start = nd.array([0.0, 0.0], ctx=ctx) sampler = Langevin(start.shape, ctx=ctx) res = sampler.sample(model, start, step_size=0.1, num=1000, burnin=200) plt.scatter(res[:, 0].asnumpy(), res[:, 1].asnumpy()) sns.jointplot(res[:, 0].asnumpy(), res[:, 1].asnumpy(), stat_func=None) np.random.seed(123) mx.random.seed(123) model = Model2(0.3, 0.3, ctx=ctx) nchain = 1000 start = nd.random_normal(shape=(nchain, 2), ctx=ctx) sampler = LangevinMultiChain(start.shape[1:], nchain, ctx=ctx) res = sampler.sample(model, start, step_size=0.1, burnin=200) plt.scatter(res[:, 0].asnumpy(), res[:, 1].asnumpy()) sns.jointplot(res[:, 0].asnumpy(), res[:, 1].asnumpy(), stat_func=None)
import mxnet as mx #GPU import sys sys.path.append('..') import utils ctx = utils.try_gpu() print('Will use ', ctx) num_hidden = 256 weight_scale = .01 # ??? Wxh = nd.random_normal(shape=(vocab_size, num_hidden), ctx=ctx) * weight_scale Whh = nd.random_normal(shape=(num_hidden, num_hidden), ctx=ctx) * weight_scale bh = nd.zeros(num_hidden, ctx=ctx) # ??? Why = nd.random_normal(shape=(num_hidden, vocab_size), ctx=ctx) * weight_scale by = nd.zeros(vocab_size, ctx=ctx) params = [Wxh, Whh, bh, Why, by] for param in params: param.attach_grad() def get_inputs(data): return [nd.one_hot(X, vocab_size) for X in data.T]
# 定义模型 import mxnet as mx try: ctx = mx.gpu() nd.zeros((1,), ctx=ctx) except: ctx = mx.cpu() ctx weight_scale = 0.01 num_output = 10 # output channels = 20,kernel = (5,5) W1 = nd.random_normal(shape=(20, 1, 5, 5), scale=weight_scale, ctx=ctx) b1 = nd.zeros(W1.shape[0], ctx=ctx) # output channels = 50 ,kernel = (3,3) W2 = nd.random_normal(shape=(50, 20, 3, 3), scale=weight_scale, ctx=ctx) b2 = nd.zeros(W2.shape[0], ctx=ctx) # output dim = 128 W3 = nd.random_normal(shape=(1250, 128), scale=weight_scale, ctx=ctx) b3 = nd.zeros(W3.shape[1], ctx=ctx) # output dim = 10 W4 = nd.random_normal(shape=(W3.shape[1], 10), scale=weight_scale, ctx=ctx) b4 = nd.zeros(W4.shape[1], ctx=ctx) params = [W1, b1, W2, b2, W3, b3, W4, b4]
def make_noise(bs, nz, ctx): return random_normal(0, 1, shape=(bs, nz, 1, 1), ctx=ctx, dtype='float32')
# 优化求解(梯度下降) def SGD(params_p, lr_p): for param_p in params_p: # 必须是param_p[:] = ... param = ...会重新创建新param,这个是没有attach_grad的 param_p[:] = param_p - lr_p * param_p.grad if __name__ == '__main__': # genData() num_inputs = 2 num_examples = 1000 X, y = common.genData(num_inputs, num_examples) # 1.数据 # 2.模型 (初始化) W = nd.random_normal(shape=(num_inputs, 1)) b = nd.zeros((1, )) params = [W, b] for param in params: param.attach_grad() # 3.参数 + 训练 batch_size = 10 learning_rate = 0.001 epoch = 10 niter = 0 smoothing_constant = 0.01 losses = [] moving_loss = 0
yield nd.take(test_img_nd, j).as_in_context(ctx), nd.take(test_lab_nd, j).as_in_context(ctx) else: idx = list(range(len(train_labels))) for i in range(0, len(train_labels), batch_size): j = nd.array(idx[i:min(i + batch_size, len(train_labels))]) yield nd.take(train_img_nd, j).as_in_context(ctx), nd.take(train_lab_nd, j).as_in_context(ctx) num_input = 28 * 28 num_output = 10 W = nd.random_normal(shape=(num_input, num_output), ctx=ctx) b = nd.random_normal(shape=(num_output), ctx=ctx) wb_params = [W, b] for p in wb_params: p.attach_grad() def net_wb(X): return nd.dot(X, W) + b def relu(X): return nd.maximum(X, 0)
from mxnet import ndarray as nd from mxnet import autograd import matplotlib.pyplot as plt import random # data set num_inputs = 2 num_examples = 1000 true_w = [2, -3.4] true_b = 4.2 X = nd.random_normal(shape=(num_examples, num_inputs)) y = true_w[0] * X[:, 0] + true_w[1] * X[:, 1] + true_b y += .01 * nd.random_normal(shape=y.shape) plt.scatter(X[:, 0].asnumpy(), y.asnumpy()) plt.show() # generate random training data set batch_size = 10 def data_iter(): idx = list(range(num_examples)) random.shuffle(idx) for i in range(0, num_examples, batch_size): j = nd.array(idx[i: min(i+batch_size, num_examples)]) yield nd.take(X, j), nd.take(y, j) for data, label in data_iter(): print(data, label)
data, label = mnist_train[0:10] show_images(data)#图像 print(get_text_labels(label))##标号 ## 准备 训练和测试数据集 # 这个DataLoader是一个iterator对象类(每次只载入一个banch的数据进入内存),非常适合处理规模较大的数据集 batch_size = 256#每次训练 输入的图片数量 train_data = gluon.data.DataLoader(mnist_train, batch_size, shuffle=True)#按照 batch_size 分割成 每次训练时的数据 test_data = gluon.data.DataLoader(mnist_test, batch_size, shuffle=False) #测试数据 ########################################################### ### 定义模型 ################## #@@@@初始化模型参数 权重和偏置@@@@ num_inputs = 784#输入数据维度 1*784 num_outputs = 10#输出标签维度 1*10 W = nd.random_normal(shape=(num_inputs, num_outputs)) # 256*784 × 784*10 ——————> 256*10 每张图像预测10个类别的概率 每次共256张图片 b = nd.random_normal(shape=num_outputs)#偏置 params = [W, b]#权重和偏置 参数 # 模型参数附上梯度 自动微分时 会计算梯度信息 for param in params: param.attach_grad() #@@@@@定义模型@@@@@@ ## softmax 回归实现 exp(Xi)/(sum(exp(Xi))) 归一化概率 使得 10类概率之和为1 def softmax(X): exp = nd.exp(X) # 假设exp是矩阵,这里对行进行求和,并要求保留axis 1, # 就是返回 (nrows, 1) 形状的矩阵 partition = exp.sum(axis=1, keepdims=True) return exp / partition
transform=transform) batch_size = 256 train_data = gluon.data.DataLoader(mnist_train, batch_size, shuffle=True) test_data = gluon.data.DataLoader(mnist_test, batch_size, shuffle=False) num_inputs = 28 * 28 num_outputs = 10 num_hidden = 256 num_hidden10 = 512 weight_scale1 = 0.2 weight_scale10 = 0.4 weight_scale2 = 0.6 w1 = nd.random_normal(shape=(num_inputs, num_hidden), scale=weight_scale1) b1 = nd.zeros(num_hidden) w10 = nd.random_normal(shape=(num_hidden, num_hidden10), scale=weight_scale10) b10 = nd.zeros(num_hidden10) w2 = nd.random_normal(shape=(num_hidden10, num_outputs), scale=weight_scale2) b2 = nd.zeros(num_outputs) params = [w1, b1, w10, b10, w2, b2] for p in params: p.attach_grad() def relu(x):
def gaussian(shape): return nd.random_normal(shape=shape).as_in_context(context)