一维数据集上的神经网络

# 1 引入包，创建会话

import tensorflow as tf

import numpy as np

sess = tf.Session()

# 2 初始化数据

data_size = 25

data_1d = np.random.normal(size=data_size)

x_input_1d = tf.placeholder(dtype=tf.float32, shape=[data_size])

# 3 定义卷积层

def conv_layer_1d(input_1d, my_filter):

    # Make 1d input 4d

    input_2d = tf.expand_dims(input_1d, 0)

    input_3d = tf.expand_dims(input_2d, 0)

    input_4d = tf.expand_dims(input_3d, 3)

    # Perform convolution

    convolution_output = tf.nn.conv2d(input_4d, filter=my_filter,

                                      strides=[1,1,1,1], padding='VALID')

    conv_output_1d = tf.squeeze(convolution_output)

    return conv_output_1d

    # Now drop extra dimensions

my_filter = tf.Variable(tf.random_normal(shape=[1,5,1,1]))

my_convolution_output = conv_layer_1d(x_input_1d, my_filter)

# 4 激励函数

def activation(input_1d):

    return tf.nn.relu(input_1d)

my_activation_output = activation(my_convolution_output)

# 池化

def max_pool(input_1d, width):

    # First we make the 1d input into 4d.

    input_2d = tf.expand_dims(input_1d, 0)

    input_3d = tf.expand_dims(input_2d, 0)

    input_4d = tf.expand_dims(input_3d, 3)

    # Perform the max pool operation

    pool_output = tf.nn.max_pool(input_4d, ksize=[1, 1, width, 1], strides=[1, 1, 1, 1],

                                 padding='VALID')

    pool_output_1d = tf.squeeze(pool_output)

    return pool_output_1d

my_maxpool_output = max_pool(my_activation_output, width=5)

# 全连接层

def fully_connected(input_layer, num_outputs):

    # Create weights

    weight_shape = tf.squeeze(tf.stack([tf.shape(input_layer), [num_outputs]]))

    weight = tf.random_normal(weight_shape, stddev=0.1)

    bias = tf.random_normal(shape=[num_outputs])

    # make input into 2d

    input_layer_2d = tf.expand_dims(input_layer, 0)

    # perform fully connected operations

    full_output = tf.add(tf.matmul(input_layer_2d, weight), bias)

    # Drop extra dimmensions

    full_output_1d = tf.squeeze(full_output)

    return full_output_1d

my_full_output = fully_connected(my_maxpool_output, 5)

# 初始化变量，运行计算图大阴每层输出结果

init = tf.global_variables_initializer()

sess.run(init)

feed_dict = {x_input_1d:data_1d}

# Convolution Output

print("Input = array of length 25")

print("Convolution w/filter length = 5, stride size = 1, results in an array of legth 21:")

print(sess.run(my_convolution_output, feed_dict = feed_dict))

# Activation Output

print('\nInput = the above array of length 21')

print('Relu element wise returns the array of length 21:')

print(sess.run(my_activation_output, feed_dict=feed_dict))

# Maxpool output

print('\nInput = the above array of length 21')

print('MaxPool, window length = 5, stride size = 1, results in the array of length 17')

print(sess.run(my_maxpool_output, feed_dict=feed_dict))

# Fully Connected Output

print('Input = the above array of length 17')

print('Fully connected layer on all four rows with five outputs')

print(sess.run(my_full_output, feed_dict=feed_dict))

# 关闭会话

sess.close()

输出结果如下：

Input = array of length 25

Convolution w/filter length = 5, stride size = 1, results in an array of legth 21:

[ 0.7306204   0.09220226 -0.8647339  -1.7677759   3.0679996  -0.42977548

 -1.4834487   2.084762   -0.63769084 -1.6181873   0.8859257   0.94589835

 -2.3447719   1.4659762   0.86647564 -0.5625909   0.02268941  1.3069543

 -1.5059514   3.0157318  -2.7027912 ]

Input = the above array of length 21

Relu element wise returns the array of length 21:

[0.7306204  0.09220226 0.         0.         3.0679996  0.

 0.         2.084762   0.         0.         0.8859257  0.94589835

 0.         1.4659762  0.86647564 0.         0.02268941 1.3069543

 0.         3.0157318  0.        ]

Input = the above array of length 21

MaxPool, window length = 5, stride size = 1, results in the array of length 17

[3.0679996  3.0679996  3.0679996  3.0679996  3.0679996  2.084762

 2.084762   2.084762   0.94589835 1.4659762  1.4659762  1.4659762

 1.4659762  1.4659762  1.3069543  3.0157318  3.0157318 ]

Input = the above array of length 17

Fully connected layer on all four rows with five outputs

[ 1.8550391  -1.1319994   0.44229037 -1.3700286  -1.7920521 ]

卷积层

首先，卷积层输入序列是25个元素的一维数组。卷积层的功能是相邻5个元素与过滤器（长度为5的向量）内积。因为移动步长为1，所以25个元素的序列中一共有21个相邻为5的序列，最终输出也是5。

激励函数

将卷积成的输出，21个元素的向量通过relu函数逐元素转化。输出仍是21个元素的向量。

池化层，最大值池化

取相邻5个元素的最大值。输入21个元素的序列，输出17个元素的序列。

全连接层

上述17个元素通过全连接层，有5个输出。
注意上述过程的输出都做了维度的裁剪。但在每一步的过程中都是扩充成4维张量操作的。

二维数据上的神经网络

# 1 引入包，创建会话

import tensorflow as tf

import numpy as np

sess = tf.Session()

# 2 创建数据和占位符

data_size = [10, 10]

data_2d = np.random.normal(size=data_size)

x_input_2d = tf.placeholder(dtype=tf.float32, shape=data_size)

# 3 卷积层：2x2过滤器

def conv_layer_2d(input_2d, my_filter):

    # First, change 2d input to 4d

    input_3d = tf.expand_dims(input_2d, 0)

    input_4d = tf.expand_dims(input_3d, 3)

    # Perform convolution

    convolution_output = tf.nn.conv2d(input_4d, filter=my_filter, strides=[1,2,2,1], padding='VALID')

    # Drop extra dimensions

    conv_output_2d = tf.squeeze(convolution_output)

    return conv_output_2d

my_filter = tf.Variable(tf.random_normal(shape=[2,2,1,1]))

my_convolution_output = conv_layer_2d(x_input_2d, my_filter)

# 4 激励函数

def activation(input_2d):

    return tf.nn.relu(input_2d)

my_activation_output = activation(my_convolution_output)

# 5 池化层

def max_pool(input_2d, width, height):

    # Make 2d input into 4d

    input_3d = tf.expand_dims(input_2d, 0)

    input_4d = tf.expand_dims(input_3d, 3)

    # Perform max pool

    pool_output = tf.nn.max_pool(input_4d, ksize=[1, height, width, 1], strides=[1,1,1,1], padding='VALID')

    # Drop extra dimensions

    pool_output_2d = tf.squeeze(pool_output)

    return pool_output_2d

my_maxpool_output = max_pool(my_activation_output, width=2, height=2)

# 6 全连接层

def fully_connected(input_layer, num_outputs):

    # Flatten into 1d

    flat_input = tf.reshape(input_layer, [-1])

    # Create weights

    weight_shape = tf.squeeze(tf.stack([tf.shape(flat_input), [num_outputs]]))

    weight = tf.random_normal(weight_shape, stddev=0.1)

    bias = tf.random_normal(shape=[num_outputs])

    # Change into 2d

    input_2d = tf.expand_dims(flat_input, 0)

    # Perform fully connected operations

    full_output = tf.add(tf.matmul(input_2d, weight), bias)

    # Drop extra dimensions

    full_output_2d = tf.squeeze(full_output)

    return full_output_2d

my_full_output = fully_connected(my_maxpool_output, 5)

# 7 初始化变量

init = tf.initialize_all_variables()

sess.run(init)

feed_dict = {x_input_2d: data_2d}

# 8 打印每层输出结果

# Convolution Output

print('Input = [10 x 10] array')

print('2x2 Convolution, stride size = [2x2], results in the [5x5] array:')

print(sess.run(my_convolution_output, feed_dict=feed_dict))

# Activation Output

print('\nInput = the above [5x5] array')

print('Relu element wise returns the [5x5] array:')

print(sess.run(my_activation_output, feed_dict=feed_dict))

# Max Pool Output

print('\nInput = the above [5x5] array')

print('[2x2] MaxPool, stride size = [1x1] results in the [4x4] array:')

print(sess.run(my_maxpool_output, feed_dict = feed_dict))

# Fully connected output

print('\nInput = the above [4x4] array')

print('Fully connected layer on all four rows with five outputs:')

print(sess.run(my_full_output, feed_dict=feed_dict))

输出结果如下：

Input = [10 x 10] array

2x2 Convolution, stride size = [2x2], results in the [5x5] array:

[[ 0.80993664 -1.2700474   0.27375805  0.54493535 -1.0037322 ]

 [-1.2054954   2.7807589  -0.9015032  -0.24516574  2.126141  ]

 [ 0.19843565 -0.3517378   2.624067   -3.2827137   1.0169035 ]

 [-1.3321284  -0.98290706  0.7477172   1.655221    1.5588429 ]

 [ 1.2763401   0.88586557 -2.230918   -1.5759512   1.1120629 ]]

Input = the above [5x5] array

Relu element wise returns the [5x5] array:

[[0.80993664 0.         0.27375805 0.54493535 0.        ]

 [0.         2.7807589  0.         0.         2.126141  ]

 [0.19843565 0.         2.624067   0.         1.0169035 ]

 [0.         0.         0.7477172  1.655221   1.5588429 ]

 [1.2763401  0.88586557 0.         0.         1.1120629 ]]

Input = the above [5x5] array

[2x2] MaxPool, stride size = [1x1] results in the [4x4] array:

[[2.7807589  2.7807589  0.54493535 2.126141  ]

 [2.7807589  2.7807589  2.624067   2.126141  ]

 [0.19843565 2.624067   2.624067   1.655221  ]

 [1.2763401  0.88586557 1.655221   1.655221  ]]

Input = the above [4x4] array

Fully connected layer on all four rows with five outputs:

[ 0.7709798  -0.2126801  -0.7047844   0.89408153 -0.46939346]

TensorFlow 实现多层神经网络

# 1 引入包

import tensorflow as tf

import matplotlib.pyplot as plt

import requests

import numpy as np

import os

import csv

sess = tf.Session()

# 2 导入数据

# name of data file

birth_weight_file = 'birth_weight.csv'

birthdata_url = 'https://github.com/nfmcclure/tensorflow_cookbook/raw/master' \

                '/01_Introduction/07_Working_with_Data_Sources/birthweight_data/birthweight.dat'

# Download data and create data file if file does not exist in current directory

if not os.path.exists(birth_weight_file):

    birth_file = requests.get(birthdata_url)

    birth_data = birth_file.text.split('\r\n')

    birth_header = birth_data[0].split('\t')

    birth_data = [[float(x) for x in y.split('\t') if len(x) >= 1]

                  for y in birth_data[1:] if len(y) >= 1]

    with open(birth_weight_file, "w") as f:

        writer = csv.writer(f)

        writer.writerows([birth_header])

        writer.writerows(birth_data)

# read birth weight data into memory

birth_data = []

with open(birth_weight_file, newline='') as csvfile:

    csv_reader = csv.reader(csvfile)

    birth_header = next(csv_reader)

    for row in csv_reader:

        if len(row)>0:

            birth_data.append(row)

birth_data = [[float(x) for x in row] for row in birth_data]

# Extract y-target (birth weight)

y_vals = np.array([x[8] for x in birth_data])

# Filter for features of interest

cols_of_interest = ['AGE', 'LWT', 'RACE', 'SMOKE', 'PTL', 'HT', 'UI']

x_vals = np.array([[x[ix] for ix, feature in enumerate(birth_header) if feature in cols_of_interest]

                   for x in birth_data])

# 3 设置种子

seed = 4

tf.set_random_seed(seed)

np.random.seed(seed)

batch_size = 100

# 4 划分训练集和测试集

train_indices = np.random.choice(len(x_vals), round(len(x_vals)*0.8), replace=False)

test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices)))

x_vals_train = x_vals[train_indices]

x_vals_test = x_vals[test_indices]

y_vals_train = y_vals[train_indices]

y_vals_test = y_vals[test_indices]

def normalize_cols(m):

    col_max = m.max(axis=0)

    col_min = m.min(axis=0)

    return (m - col_min) /(col_max - col_min)

x_vals_train = np.nan_to_num(normalize_cols(x_vals_train))

x_vals_test = np.nan_to_num(normalize_cols(x_vals_test))

# 5 定义一个设置变量和bias的函数

def init_weight(shape, st_dev):

    weight = tf.Variable(tf.random_normal(shape, stddev=st_dev))

    return weight

def init_bias(shape, st_dev):

    bias = tf.Variable(tf.random_normal(shape, stddev=st_dev))

    return bias

# 6 初始化占位符

x_data = tf.placeholder(shape=[None, 7], dtype=tf.float32)

y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

# 7 创建全连接层函数，方便重复使用

def fully_connected(input_layer, weights, biases):

    layer = tf.add(tf.matmul(input_layer, weights), biases)

    return tf.nn.relu(layer)

# 8 创建算法模型

# Create second layer (25 hidden nodes)

weight_1 = init_weight(shape=[7, 25], st_dev=10.0)

bias_1 = init_weight(shape=[25], st_dev=10.0)

layer_1 = fully_connected(x_data, weight_1, bias_1)

# Create second layer (10 hidden nodes)

weight_2 = init_weight(shape=[25, 10], st_dev=10.0)

bias_2 = init_weight(shape=[10], st_dev=10.0)

layer_2 = fully_connected(layer_1, weight_2, bias_2)

# Create third layer (3 hidden nodes)

weight_3 = init_weight(shape=[10, 3], st_dev=10.0)

bias_3 = init_weight(shape=[3], st_dev=10.0)

layer_3 = fully_connected(layer_2, weight_3, bias_3)

# Create output layer (1 output value)

weight_4 = init_weight(shape=[3, 1], st_dev=10.0)

bias_4 = init_bias(shape=[1], st_dev=10.0)

final_output = fully_connected(layer_3, weight_4, bias_4)

# 9 L1损失函数

loss = tf.reduce_mean(tf.abs(y_target - final_output))

my_opt = tf.train.AdamOptimizer(0.05)

train_step = my_opt.minimize(loss)

init = tf.global_variables_initializer()

sess.run(init)

# 10 迭代200

# Initialize the loss vectors

loss_vec = []

test_loss = []

for i in range(200):

    # Choose random indices for batch selection

    rand_index = np.random.choice(len(x_vals_train), size=batch_size)

    # Get random batch

    rand_x = x_vals_train[rand_index]

    rand_y = np.transpose([y_vals_train[rand_index]])

    # Run the training step

    sess.run(train_step, feed_dict={x_data: rand_x, y_target:rand_y})

    # Get and store the train loss

    temp_loss = sess.run(loss, feed_dict = {x_data:rand_x, y_target:rand_y})

    loss_vec.append(temp_loss)

    # get and store the test loss

    test_temp_loss = sess.run(loss, feed_dict = {x_data:x_vals_test, y_target:np.transpose([y_vals_test])})

    test_loss.append(test_temp_loss)

    if (i+1)% 25 == 0:

        print('Generation: ' + str(i+1)+'.Loss = ' + str(temp_loss))

# 12 绘图

plt.plot(loss_vec, 'k-', label='Train Loss')

plt.plot(test_loss, 'r--', label='Test Loss')

plt.title('Loss per Generation')

plt.xlabel('Generation')

plt.ylabel('Loss')

plt.legend(loc='upper right')

plt.show()

# Model Accuracy

actuals = np.array([x[0] for x in birth_data])

test_actuals = actuals[test_indices]

train_actuals = actuals[train_indices]

test_preds = [x[0] for x in sess.run(final_output, feed_dict={x_data: x_vals_test})]

train_preds = [x[0] for x in sess.run(final_output, feed_dict={x_data: x_vals_train})]

test_preds = np.array([0.0 if x < 2500.0 else 1.0 for x in test_preds])

train_preds = np.array([0.0 if x < 2500.0 else 1.0 for x in train_preds])

# Print out accuracies

test_acc = np.mean([x == y for x, y in zip(test_preds, test_actuals)])

train_acc = np.mean([x == y for x, y in zip(train_preds, train_actuals)])

print('On predicting the category of low birthweight from regression output (<2500g):')

print('Test Accuracy: {}'.format(test_acc))

print('Train Accuracy: {}'.format(train_acc))

实现了一个含有三层隐藏层的全连接神经网络。

线性预测模型的优化

# 1 导入必要的库

import matplotlib.pyplot as plt

import numpy as np

import tensorflow as tf

import requests

import os

import csv

sess = tf.Session()

# 加载数据集，进行数据抽取和归一化

# name of data file

birth_weight_file = 'birth_weight.csv'

birthdata_url = 'https://github.com/nfmcclure/tensorflow_cookbook/raw/master' \

                '/01_Introduction/07_Working_with_Data_Sources/birthweight_data/birthweight.dat'

# Download data and create data file if file does not exist in current directory

if not os.path.exists(birth_weight_file):

    birth_file = requests.get(birthdata_url)

    birth_data = birth_file.text.split('\r\n')

    birth_header = birth_data[0].split('\t')

    birth_data = [[float(x) for x in y.split('\t') if len(x) >= 1]

                  for y in birth_data[1:] if len(y) >= 1]

    with open(birth_weight_file, "w") as f:

        writer = csv.writer(f)

        writer.writerows([birth_header])

        writer.writerows(birth_data)

# read birth weight data into memory

birth_data = []

with open(birth_weight_file, newline='') as csvfile:

    csv_reader = csv.reader(csvfile)

    birth_header = next(csv_reader)

    for row in csv_reader:

        if len(row)>0:

            birth_data.append(row)

birth_data = [[float(x) for x in row] for row in birth_data]

# Extract y-target (birth weight)

y_vals = np.array([x[0] for x in birth_data])

# Filter for features of interest

cols_of_interest = ['AGE', 'LWT', 'RACE', 'SMOKE', 'PTL', 'HT', 'UI']

x_vals = np.array([[x[ix] for ix, feature in enumerate(birth_header) if feature in cols_of_interest]

                   for x in birth_data])

# 4 划分训练集和测试集

train_indices = np.random.choice(len(x_vals), round(len(x_vals)*0.8), replace=False)

test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices)))

x_vals_train = x_vals[train_indices]

x_vals_test = x_vals[test_indices]

y_vals_train = y_vals[train_indices]

y_vals_test = y_vals[test_indices]

def normalize_cols(m):

    col_max = m.max(axis=0)

    col_min = m.min(axis=0)

    return (m - col_min) /(col_max - col_min)

x_vals_train = np.nan_to_num(normalize_cols(x_vals_train))

x_vals_test = np.nan_to_num(normalize_cols(x_vals_test))

# 3 声明批量大小和占位符

batch_size = 90

x_data = tf.placeholder(shape=[None, 7], dtype=tf.float32)

y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

# 4 声明函数来初始化变量和层

def init_variable(shape):

    return tf.Variable(tf.random_normal(shape=shape))

# Create a logistic layer definition

def logistic(input_layer, multiplication_weight, bias_weight, activation=True):

    linear_layer = tf.add(tf.matmul(input_layer, multiplication_weight), bias_weight)

    if activation :

        return tf.nn.sigmoid(linear_layer)

    else :

        return linear_layer

# 5 声明神经网络的两个隐藏层和输出层

# First logistic layer (7 inputs to 14 hidden nodes)

A1 = init_variable(shape=[7, 14])

b1 = init_variable(shape=[14])

logistic_layer1 = logistic(x_data, A1, b1)

# Second logistic layer (14 inputs to 5 hidden nodes)

A2 = init_variable(shape=[14, 5])

b2 = init_variable(shape=[5])

logistic_layer2 = logistic(logistic_layer1, A2, b2)

# Final output layer (5 hidden nodes to 1 output)

A3 = init_variable(shape=[5, 1])

b3 = init_variable(shape=[1])

final_output = logistic(logistic_layer2, A3, b3, activation=False)

# 6 声明损失函数和优化方法

# Create loss function

loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(

        labels = y_target, logits=final_output))

# Declare optimizer

my_opt = tf.train.AdamOptimizer(learning_rate = 0.002)

train_step = my_opt.minimize(loss)

# Initialize variables

init = tf.global_variables_initializer()

sess.run(init)

# 7 评估精度

prediction = tf.round(tf.nn.sigmoid(final_output))

predictions_correct = tf.cast(tf.equal(prediction, y_target), tf.float32)

accuracy = tf.reduce_mean(predictions_correct)

# 8 迭代训练模型

# Initialize loss and accuracy vectors

loss_vec = []

train_acc = []

test_acc = []

for i in range(1500):

    # Select random indicies for batch selection

    rand_index = np.random.choice(len(x_vals_train), size=batch_size)

    # Select batch

    rand_x = x_vals_train[rand_index]

    rand_y = np.transpose([y_vals_train[rand_index]])

    # Run training step

    sess.run(train_step, feed_dict={x_data:rand_x, y_target:rand_y})

    # Get training loss

    temp_loss = sess.run(loss, feed_dict={x_data:rand_x, y_target:rand_y})

    loss_vec.append(temp_loss)

    # Get training accuracy

    temp_acc_train = sess.run(accuracy, feed_dict = {x_data:x_vals_train, y_target:np.transpose([y_vals_train])})

    train_acc.append(temp_acc_train)

    # Get test accuracy

    temp_acc_test = sess.run(accuracy, feed_dict = {x_data:x_vals_test, y_target:np.transpose([y_vals_test])})

    test_acc.append(temp_acc_test)

    if (i+1)%150==0:

        print('Loss = ' + str(temp_loss))

# 9 绘图

# Plot loss over time

plt.plot(loss_vec, 'k-')

plt.title('Cross Entropy Loss per Generation')

plt.xlabel('Generation')

plt.ylabel('Cross Entropy Loss')

plt.show()

# Plot train and test accuracy

plt.plot(train_acc, 'k-', label='Train Set Accuracy')

plt.plot(test_acc, 'r--', label='Test Set Accuracy')

plt.title('Train and Test Accuracy')

plt.xlabel('Generation')

plt.ylabel('Accuracy')

plt.legend(loc='lower right')

plt.show()

这一个仍然是全连接，只是只有两层隐藏层，节点数也减少了。

Tensorflow从0到1(4)之神经网络的更多相关文章

  1. 使用TensorFlow v2.0构建卷积神经网络

    使用TensorFlow v2.0构建卷积神经网络. 这个例子使用低级方法来更好地理解构建卷积神经网络和训练过程背后的所有机制. CNN 概述 MNIST 数据集概述 此示例使用手写数字的MNIST数 ...

  2. TensorFlow 2.0 深度学习实战 —— 浅谈卷积神经网络 CNN

    前言 上一章为大家介绍过深度学习的基础和多层感知机 MLP 的应用,本章开始将深入讲解卷积神经网络的实用场景.卷积神经网络 CNN(Convolutional Neural Networks,Conv ...

  3. Tensorflow学习：（二）搭建神经网络

    一.神经网络的实现过程 1.准备数据集,提取特征,作为输入喂给神经网络       2.搭建神经网络结构,从输入到输出       3.大量特征数据喂给 NN,迭代优化 NN 参数       4.使 ...

  4. TensorFlow学习笔记（二）深层神经网络

    一.深度学习与深层神经网络 深层神经网络是实现“多层非线性变换”的一种方法. 深层神经网络有两个非常重要的特性:深层和非线性. 1.1线性模型的局限性 线性模型:y =wx+b 线性模型的最大特点就是 ...

  5. TensorFlow 2.0 入门教程实战案例

    中文文档 TensorFlow 2 / 2.0 中文文档 知乎专栏 欢迎关注知乎专栏 https://zhuanlan.zhihu.com/geektutu 一.实战教程之强化学习 TensorFlo ...

  6. 三分钟快速上手TensorFlow 2.0 （后续）——扩展和附录

    TensorFlow Hub 模型复用 TF Hub 网站 打开主页 https://tfhub.dev/ ,在左侧有 Text.Image.Video 和 Publishers 等选项,可以选取关注 ...

  7. 三分钟快速上手TensorFlow 2.0 （下）——模型的部署 、大规模训练、加速

    前文:三分钟快速上手TensorFlow 2.0 (中)——常用模块和模型的部署 TensorFlow 模型导出 使用 SavedModel 完整导出模型 不仅包含参数的权值,还包含计算的流程(即计算 ...

  8. 三分钟快速上手TensorFlow 2.0 （上）——前置基础、模型建立与可视化

    本文学习笔记参照来源:https://tf.wiki/zh/basic/basic.html 学习笔记类似提纲,具体细节参照上文链接 一些前置的基础 随机数 tf.random uniform(sha ...

  9. 使用TensorFlow v2.0构建多层感知器

    使用TensorFlow v2.0构建一个两层隐藏层完全连接的神经网络(多层感知器). 这个例子使用低级方法来更好地理解构建神经网络和训练过程背后的所有机制. 神经网络概述 MNIST 数据集概述 此 ...

随机推荐

  1. 【Java】手把手理解CAS实现原理

    先来看看概念,[CAS] 全称“CompareAndSwap”,中文翻译即“比较并替换”. 定义:CAS操作包含三个操作数 —— 内存位置(V),期望值(A),和新值(B). 如果内存位置的值与期望值 ...

  2. Pyqt5_QMessageBox

    QMessageBox header:会话窗标题 info:会话窗内容 #弹出5种不同类型的消息框 reply1=QMessageBox.information(self,"title&qu ...

  3. Ajax长轮询(LongPoll)

    1)HTML HTTP是无状态.单向的协议,用户只能够通过客服端向服务器发送请求并由服务器处理发回一个响应.若要实现聊天室.WEBQQ.在线客服.邮箱等这些即时通讯的应用,就要用到“ 服务器推送技术( ...

  4. 基本sql语法

    SQL 语句主要可以划分为以下 3 个类别. DDL(Data Definition Languages)语句:数据定义语言,这些语句定义了不同的数据段.数据库.表.列.索引等数据库对象的定义.常用 ...

  5. JAVA POI替换EXCEL模板中自定义标签（XLSX版本）满足替换多个SHEET中自定义标签

    个人说明:为了简单实现导出数据较少的EXCEL(根据自定义书签模板) 一.替换Excel表格标签方法```/** * 替换Excel模板文件内容 * @param map * 需要替换的标签建筑队形式 ...

  6. [Python3]踩坑实录-优化技巧1

    选择合适的数据结构 考虑不同的应用场景,应选择不同的数据结构 比如在查找多于插入的场景中,考虑字典Dict是不是更适合; 因为在Python3中, 字典Dict 通过hash把key映射到hash t ...

  7. java中的垃圾处理机制

    1.何为垃圾在Java中,如果对象实体没有引用指向的话,存储该实体的内存便成为垃圾.JVM会有一个系统线程专门负责回收垃圾.垃圾同时包括分配对象内存间的碎片块 2.垃圾处理包含的算法 Java语言规范 ...

  8. Rocket - tilelink - Delayer

    https://mp.weixin.qq.com/s/pc8f_DOJ7w8k8BeM9gPzVw   简单介绍Delayer的实现.   1. 基本介绍   以一定的概率延迟消息的传递.   类参数 ...

  9. jchdl - GSL实例 - Concat

    https://mp.weixin.qq.com/s/oJY6Xj9_oM1gSmvH_dHkJg   Concat节点把多根输入线线组合成一排线输出.   参考链接 https://github.c ...

  10. 重装ArchLinux后修改GRUB配置不生效问题的解决

    重装ArchLinux后修改GRUB配置不生效问题的解决 mount指令看一下挂载,或者vim /etc/fstab看一下有没有/boot,看看fstab是不是没写进去.... 我特喵昨天重装完Arc ...