def main(): tf.compat.v1.disable_eager_execution() # data = tf.keras.datasets.mnist # (x_train, y_train), (x_test, y_test) = data.load_data() mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # plt.imshow(x_train[1], cmap="binary") # plt.show() sess = tfc.InteractiveSession() x = tfc.placeholder("float", shape=[None, 784]) y_ = tfc.placeholder("float", shape=[None, 10]) W = tf.Variable(tf.zeros([784, 10])) b = tf.Variable(tf.zeros([10])) sess.run(tfc.initialize_all_variables()) y = tf.nn.softmax(tf.matmul(x, W) + b) cross_entropy = -tf.reduce_sum(y_ * tfc.log(y)) train_step = tfc.train.GradientDescentOptimizer(0.01).minimize( cross_entropy) for i in range(1000): batch = mnist.train.next_batch(50) train_step.run(feed_dict={x: batch[0], y_: batch[1]}) correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print( "测试集的正确率为", accuracy.eval(feed_dict={ x: mnist.test.images, y_: mnist.test.labels }))
def main(): acl_resource = AclResource() acl_resource.init() mnist = input_data.read_data_sets('MNIST_data/', one_hot=True) #load model model = Model(model_path) images = mnist.test.images labels = mnist.test.labels total = len(images) correct = 0.0 start = time.time() for i in range(len(images)): result = model.execute([images[i]]) label = labels[i] if np.argmax(result[0])==np.argmax(label): correct+=1.0 if i%1000==0: print(f'infer {i+1} pics...') end = time.time() print(f'infer finished, acc is {correct/total}, use time {(end-start)*1000}ms')
def mst(): mnist = input_data.read_data_sets("./ST_data/", one_hot=True) # 获取图片的特征值 train_images_data = mnist.train.images # []可查看某个图的数据 train_labels_data = mnist.train.labels # print(train_images_data) # print(train_labels_data) # 批次获取50张图片的数据 特征值 + 目标值 data = mnist.train.next_batch(50)
def conv_fc(): # setting data path fileName = './2020-01-03/acsset' # get data mnist = input_data.read_data_sets(fileName, one_hot=True) # defining model and get conclusion x, y_ture, y_predict = model() # 进行交叉熵运算计算损失 with tf.compat.v1.variable_scope("sotf_cross"): # 求平均交叉熵损失 loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=y_predict, labels=y_ture)) # 梯度下降,求出损失 with tf.compat.v1.variable_scope("optimizer"): train_op = tf.compat.v1.train.GradientDescentOptimizer(0.1).minimize( loss) # 计算准确率 with tf.compat.v1.variable_scope("acc"): equal_list = tf.equal(tf.argmax(y_ture, 1), tf.argmax(y_predict, 1)) accuracy = tf.reduce_mean(tf.cast(equal_list, tf.float32)) # 定义一个初始化变量 op init_op = tf.compat.v1.global_variables_initializer() # 开启会话运行 with tf.compat.v1.Session() as sess: sess.run(init_op) # 循环训练 for i in range(100): # 取出真实的数据 mnist_x, mnist_y = mnist.train.next_batch(50) # run train_op 训练 sess.run(train_op, feed_dict={x: mnist_x, y_ture: mnist_y}) print( "训练第%d部, 准确率为%f" % (i, sess.run(accuracy, feed_dict={ x: mnist_x, y_ture: mnist_y })))
def main(): # 将obs的训练数据拷贝到modelarts mox.file.copy_parallel(src_url="obs://canncamps-hw38939615/MNIST_data/", dst_url="MNIST_data") mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) config = tf.ConfigProto() custom_op = config.graph_options.rewrite_options.custom_optimizers.add() custom_op.name = "NpuOptimizer" config.graph_options.rewrite_options.remapping = RewriterConfig.OFF # 必须显式关闭remap sess = tf.Session(config=config) batch_size = cfg.BATCH_SIZE parameter_path = cfg.PARAMETER_FILE lenet = Lenet() max_iter = cfg.MAX_ITER saver = tf.train.Saver() if os.path.exists(parameter_path): saver.restore(parameter_path) else: sess.run(tf.initialize_all_variables()) for i in range(max_iter): batch = mnist.train.next_batch(batch_size) if i % 100 == 0: train_accuracy, train_loss = sess.run( [lenet.train_accuracy, lenet.loss], feed_dict={ lenet.raw_input_image: batch[0], lenet.raw_input_label: batch[1] }) print("step %d, training accuracy %g, loss is %g" % (i, train_accuracy, train_loss)) sess.run(lenet.train_op, feed_dict={ lenet.raw_input_image: batch[0], lenet.raw_input_label: batch[1] }) save_path = saver.save(sess, parameter_path) print("save model in {}".format(save_path)) # 将训练好的权重拷回到obs mox.file.copy_parallel(src_url="checkpoint/", dst_url="obs://canncamps-hw38939615/ckpt")
def train(): # load data(mnist手写数据集) mnist = input_data.read_data_sets('MNIST_data', one_hot=True) x_data = tf.placeholder(tf.float32, [batch_size, img_size], name="x_data") z_prior = tf.placeholder(tf.float32, [batch_size, z_size], name="z_prior") keep_prob = tf.placeholder(tf.float32, name="keep_prob") global_step = tf.Variable(0, name="global_step", trainable=False) # 创建生成模型 x_generated, g_params = build_generator(z_prior) # 创建判别模型 y_data, y_generated, d_params = build_discriminator( x_data, x_generated, keep_prob) # 损失函数的设置 d_loss = -(tf.log(y_data) + tf.log(1 - y_generated)) g_loss = -tf.log(y_generated) optimizer = tf.train.AdamOptimizer(0.0001) # 两个模型的优化函数 d_trainer = optimizer.minimize(d_loss, var_list=d_params) g_trainer = optimizer.minimize(g_loss, var_list=g_params) init = tf.global_variables_initializer() saver = tf.train.Saver() # 启动默认图 sess = tf.Session() # 初始化 sess.run(init) if to_restore: chkpt_fname = tf.train.latest_checkpoint(output_path) saver.restore(sess, chkpt_fname) else: if os.path.exists(output_path): shutil.rmtree(output_path) os.mkdir(output_path) z_sample_val = np.random.normal(0, 1, size=(batch_size, z_size)).astype(np.float32) steps = 60000 / batch_size for i in range(sess.run(global_step), max_epoch): for j in np.arange(steps): # for j in range(steps): print("epoch:%s, iter:%s" % (i, j)) # 每一步迭代,我们都会加载256个训练样本,然后执行一次train_step x_value, _ = mnist.train.next_batch(batch_size) x_value = 2 * x_value.astype(np.float32) - 1 z_value = np.random.normal(0, 1, size=(batch_size, z_size)).astype(np.float32) # 执行生成 sess.run(d_trainer, feed_dict={ x_data: x_value, z_prior: z_value, keep_prob: np.sum(0.7).astype(np.float32) }) # 执行判别 if j % 1 == 0: sess.run(g_trainer, feed_dict={ x_data: x_value, z_prior: z_value, keep_prob: np.sum(0.7).astype(np.float32) }) x_gen_val = sess.run(x_generated, feed_dict={z_prior: z_sample_val}) show_result(x_gen_val, "output/sample{0}.jpg".format(i)) z_random_sample_val = np.random.normal( 0, 1, size=(batch_size, z_size)).astype(np.float32) x_gen_val = sess.run(x_generated, feed_dict={z_prior: z_random_sample_val}) show_result(x_gen_val, "output/random_sample{0}.jpg".format(i)) sess.run(tf.assign(global_step, i + 1)) saver.save(sess, os.path.join(output_path, "model"), global_step=global_step)
from __future__ import print_function import numpy as np # import tensorflow as tf import tensorflow.compat.v1 as tf tf.disable_v2_behavior() # Import MNIST data from tensorflow_core.examples.tutorials.mnist import input_data K = 4 mnist = input_data.read_data_sets("/tmp/data/", one_hot=True) # In this example, we limit mnist data Xtr, Ytr = mnist.train.next_batch(55000) # whole training set Xte, Yte = mnist.test.next_batch(100) # whole test set # tf Graph Input xtr = tf.placeholder("float", [None, 784]) ytr = tf.placeholder("float", [None, 10]) xte = tf.placeholder("float", [784]) # Euclidean Distance distance = tf.negative( tf.sqrt( tf.reduce_sum(tf.square(tf.subtract(xtr, xte)), reduction_indices=1))) # Prediction: Get min distance neighbors values, indices = tf.nn.top_k(distance, k=K, sorted=False) nearest_neighbors = [] for i in range(K):
def reduce(self, n_dimensions=None, keep_info=None): if keep_info: normalized_singular_values = self._singular_values / sum( self._singular_values) info = np.cumsum(normalized_singular_values) index = next(idx for idx, value in enumerate(info) if value >= keep_info) + 1 n_dimensions = index with self._graph.as_default(): sigma = tf.slice(self._sigma, [0, 0], [self._data.shape[1], n_dimensions]) pca = tf.matmul(self._u, sigma) with tf.Session(graph=self._graph) as session: return session.run(pca, feed_dict={self._X: self._data}) minist = input_data.read_data_sets('MNIST_data/') tf_pca = TF_PCA(minist.train.images) tf_pca.fit() pca = tf_pca.reduce(keep_info=0.1) # 保存的信息占比 print('original data shape', minist.train.images.shape) print('reduced data shape ', pca.shape) Set = sns.color_palette('Set2', 10) color_mapping = {key: value for (key, value) in enumerate(Set)} colors = list(map(lambda x: color_mapping[x], minist.train.labels)) fig = plt.figure() ax = Axes3D(fig) ax.scatter(pca[:, 0], pca[:, 1], pca[:, 2], c=colors) plt.show()
self.tensors.x: xs, self.tensors.y: ys }) return precise def save(self): self.saver.save(self.session, self.save_path) def close(self): self.session.close() def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): self.close() if __name__ == '__main__': path = "MNIST_data" ds = read_data_sets(path) print(ds.train.num_examples) # 打印 训练集的数量 print(ds.test.num_examples) # 打印 测试集的数量 print(ds.validation.num_examples) # 打印 验证集的数量 save_path = "models/p31/mnist" app = MNISTApp(save_path) with app: app.train(ds) app.predict(ds)
self.saver.save(self.session, self.config.save_path) def predict(self, da): precise_totle = 0 batches = da.test.num_examples // self.config.batch_size for batch in range(batches): xs, ys = da.test.next_batch(self.config.batch_size) precise = self.session.run(self.ts.precise, { self.ts.xs: xs, self.ts.ys: ys }) precise_totle += precise print(f"precise = {precise_totle / batches}") def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): self.session.close() if __name__ == '__main__': tf.disable_eager_execution() config = Config() app = App(config) da = read_data_sets(config.data_path) with app: app.train(da) app.predict(da)
# knn # test 样本找K个最接近样本 # k(100)个样本中,概率最该的样本是?(50个1)那就是1了 import tensorflow as tf import numpy as np import random from tensorflow_core.examples.tutorials.mnist import input_data # load date # 数据装载 # input_data.read_data_sets('文件路径',one_hot=bool) # one_hot=bool 非0即1 fileName = '/Users/liupeng/PycharmProjects/MachineLearning/2020-01-01/acsset' mnist = input_data.read_data_sets(fileName, one_hot=True) # 属性设置 # 训练集图片数量 trainNumber = 55000 # 测试集图片数量 testNumber = 10000 # 训练用的图片数量 trainSize = 5000 # 训练用的图片数量 testSize = 5 # k = ? k = 4 # 数据分解 # 在【0-trainNumber】范围内选取trainSize个数据,不可以重复
# 导入包 import tensorflow as tf from tensorflow_core.examples.tutorials.mnist import input_data from tensorflow.python.framework import graph_util from npu_bridge.npu_init import * # 引入minist数据集 mnist = input_data.read_data_sets('MNIST_data', one_hot=True) # 每个批次的大小 batch_size = 100 # 计算需要多少批次 n_batch = mnist.train.num_examples // batch_size output_node_names = "Sigmoid" output_graph = '/home/ma-user/AscendProjects/MyTraining/models/lenet.pb' def config(): session_config = tf.ConfigProto( allow_soft_placement=True, log_device_placement=False,) custom_op = session_config.graph_options.rewrite_options.custom_optimizers.add() custom_op.name = "NpuOptimizer" custom_op.parameter_map["use_off_line"].b = True # True表示在昇腾AI处理器上执行训练 session_config.graph_options.rewrite_options.remapping = RewriterConfig.OFF # 必须显式关闭 session_config.graph_options.rewrite_options.memory_optimization = RewriterConfig.OFF # 必须显式关闭 return session_config #定义初始化函数 # 初始化权值 def weight_variable(shape):
def get_feed_dict(self, ds): values = ds.next_batch(self.config.batch_size) # xs,ys return {tensor: value for tensor, value in zip(self.ts.inputs, values)} def save(self): self.saver.save(self.session, save_path=self.config.save_path) def test(self, ds_test): pass def close(self): self.session.close() def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): self.close() if __name__ == '__main__': cfg = Config() cfg.from_cmd() print(cfg) ds = read_data_sets(cfg.simple_path) app = cfg.get_app() with app: app.train(ds_train=ds.train, ds_validation=ds.validation) app.test(ds_test=ds.test)
def full_connected(): mnist = input_data.read_data_sets("./MNIST_data/", one_hot=True) # 1. 建立数据占位符 with tf.variable_scope("data"): x = tf.placeholder(tf.float32, [None, 784]) y_true = tf.placeholder(tf.int32, [None, 10]) # 2. 建立一个全链接层的神经网络 with tf.variable_scope("fc_model"): # 随机初始化权重和偏置 weight = tf.Variable(tf.random_normal([784, 10], mean=0.0, stddev=1.0), name="w") bias = tf.Variable(tf.constant(0.0, shape=[10])) # 预测None个样本的输出结果 matrix [None, 784] * [784, 10] + [10] = [None, 10} y_predict = tf.matmul(x, weight) + bias # 3. 求出所以样本的损失值 然后求平均值 with tf.variable_scope("soft_cross"): # 求平均交叉熵损失 loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=y_predict)) # 4. 梯度下降求出损失 with tf.variable_scope("optimizer"): train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss) # 5. 计算准确率 with tf.variable_scope("acc"): equal_list = tf.equal(tf.argmax(y_true, 1), tf.argmax(y_predict, 1)) # equal_list None个样本 [1, 0, 0, 1, 1, ...] accuracy = tf.reduce_mean(tf.cast(equal_list, tf.float32)) # 收集变量 单个数字值收集 tf.summary.scalar("losses", loss) tf.summary.scalar("acc", accuracy) # 高维度变量收集 tf.summary.histogram("weights", weight) tf.summary.histogram("biases", bias) # 定义一个初始化变量的op init_op = tf.global_variables_initializer() # 定义一个合并变量的op merged = tf.summary.merge_all() # 开启会话 去训练 with tf.compat.v1.Session() as sess: # 初始化变量 sess.run(init_op) # 建立events文件 然后写入 file_writer = tf.summary.FileWriter("./tmp/", graph=sess.graph) # 迭代步数去训练 更新参数预测 for i in range(2000): # 取出真实存在的特征值和目标值 mnist_x, mnist_y = mnist.train.next_batch(50) # 运行train_op训练 sess.run(train_op, feed_dict={x: mnist_x, y_true: mnist_y}) # 写入每步训练的值 summary = sess.run(merged, feed_dict={x: mnist_x, y_true: mnist_y}) file_writer.add_summary(summary, i) print("训练第{}步, 准确率为:{}".format( i, sess.run(accuracy, feed_dict={ x: mnist_x, y_true: mnist_y })))
mean = app.session.run(app.ts.final_mean) print(mean) msd = app.session.run(app.ts.final_msd) print(msd) std = np.sqrt(msd - mean**2) print(std) vec = np.random.normal(mean, std, [sample, len(std)]) images = app.session.run(app.ts.y, {app.ts.vec: vec}) # [-1, 28, 28] # 将所有图片做成一张图片,每行20张小图 images = np.reshape(images, [-1, col, 28, 28]) # [-1, 20, 28, 28] images = np.transpose(images, [0, 2, 1, 3]) # [-1, 28, 20, 28] images = np.reshape(images, [-1, col * 28]) # [-1, 28, 20 * 28] # images = np.transpose(images, [2, 0, 1]) # [20 * 28, -1, 28] # images = np.reshape(images, [col * 28, -1]) # [20 * 28, -1] # images = np.transpose(images, [1, 0]) # [-1, 20 * 28] cv2.imwrite(path, images * 255) if __name__ == '__main__': tf.disable_eager_execution() tf.reset_default_graph() config = MyConfig() ds = read_data_sets(config.simple_path) app = myf.App(config) with app: app.train(ds_train=MyDS(ds.train, config), ds_validation=MyDS(ds.validation, config)) # predict(app, config.batch_size, config.image_path, config.col)
def mnist(): mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) nb_classes = 10 X = tf.placeholder(tf.float32, [None, 784]) Y = tf.placeholder(tf.float32, [None, nb_classes]) W = tf.Variable(tf.random_normal([784, nb_classes])) b = tf.Variable(tf.random_normal([nb_classes])) hypothesis = tf.nn.softmax(tf.matmul(X, W) + b) cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1)) train = tf.train.GradientDescentOptimizer( learning_rate=0.1).minimize(cost) is_correct = tf.equal(tf.argmax(hypothesis, 1), tf.argmax(Y, 1)) accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32)) num_epochs = 15 batch_size = 100 num_iterations = int(mnist.train.num_examples / batch_size) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for epoch in range(num_epochs): avg_cost = 0 for i in range(num_iterations): batch_xs, batch_ys = mnist.train.next_batch(batch_size) _, cost_val = sess.run([train, cost], feed_dict={ X: batch_xs, Y: batch_ys }) avg_cost += cost_val / num_iterations print("Epoch: {:04d}, Cost: {:.9f}".format( epoch + 1, avg_cost)) print("Learning finished") print( "Accuracy: ", accuracy.eval(session=sess, feed_dict={ X: mnist.test.images, Y: mnist.test.labels }), ) r = random.randint(0, mnist.test.num_examples - 1) print("Label: ", sess.run(tf.argmax(mnist.test.labels[r:r + 1], 1))) print( "Prediction: ", sess.run(tf.argmax(hypothesis, 1), feed_dict={X: mnist.test.images[r:r + 1]}), ) plt.imshow( mnist.test.images[r:r + 1].reshape(28, 28), cmap="Greys", interpolation="nearest", ) plt.show()
#!/usr/bin/python3.6 """ @Author: xiaxianyi<*****@*****.**> @Time: 2021/4/5 9:11 @File: test.py Description: """ import tensorflow as tf from Inference import inference import tensorflow_core.examples.tutorials.mnist.input_data as input_data if __name__ == '__main__': mnist = input_data.read_data_sets("MNIST_data/", one_hot=False) infer = inference() test_data = mnist.test num_examples = test_data._num_examples count = 0 for i in range(num_examples): batch = mnist.train.next_batch(1) pred = infer.predict(batch[0]) label = batch[1] if pred[0] == label[0]: count += 1 print("test data accuracy: ", count / 10000)
import tensorflow as tf from tensorflow_core.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets("MNIST_data", one_hot=True) batch_size = 200 n_batch = mnist.train.num_examples // batch_size x = tf.placeholder(tf.float32, [None, 784]) y = tf.placeholder(tf.float32, [None, 10]) keep_prob = tf.placeholder(tf.float32) lr = tf.Variable(0.001, dtype=tf.float32) """ W = tf.Variable(tf.zeros([784, 10])) b = tf.Variable(tf.zeros([10])) prediction = tf.nn.softmax(tf.matmul(x, W)+b) """ W1 = tf.Variable(tf.truncated_normal([784, 500], stddev=0.1)) b1 = tf.Variable(tf.zeros([500])+0.1) prediction1 = tf.nn.tanh(tf.matmul(x, W1)+b1) prediction1_drop = tf.nn.dropout(prediction1, keep_prob) W2 = tf.Variable(tf.truncated_normal([500, 250], stddev=0.1)) b2 = tf.Variable(tf.zeros([250])+0.1) prediction2 = tf.nn.tanh(tf.matmul(prediction1_drop, W2)+b2) prediction2_drop = tf.nn.dropout(prediction2, keep_prob) W3 = tf.Variable(tf.truncated_normal([250, 10], stddev=0.1)) b3 = tf.Variable(tf.zeros([10])+0.1) prediction = tf.nn.softmax(tf.matmul(prediction2_drop, W3)+b3)
import tensorflow as tf import numpy as np from scipy import stats from tensorflow_core.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets("./data", one_hot=True) X_train, y_train = mnist.train.next_batch(5000) # [5000,784],[5000,10] X_test, y_test = mnist.test.next_batch(100) # [100,784], [100,10] k = 3 with tf.name_scope("Inputs"): target_x = tf.placeholder("float", [1, 784], name='test_x') # target vector X = tf.placeholder( "float", [None, 784]) # matrix of observations to compare to target y = tf.placeholder("float", [None, 10]) # matrix of one-hot class vectors with tf.name_scope("Distance_layer"): with tf.name_scope("L1-distace"): l1_dist = tf.reduce_sum( tf.abs(tf.subtract(X, target_x)), 1 ) # euclidean distance. the sum of squared differences between elements, row-wise. with tf.name_scope("L2-distance"): l2_dist = tf.sqrt( tf.reduce_sum(tf.square(tf.subtract(X, target_x)), 1) ) # euclidean distance. the sum of squared differences between elements, row-wise. # nn = tf.argmin(l1_dist, 0) with tf.name_scope("k-nearest"):