一维数据集上的神经网络

# 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. Spring Beans 自动装配 简介

    Beans 自动装配 Spring 容器可以在不使用<constructor-arg>和<property> 元素的情况下自动装配相互协作的 bean 之间的关系,这有助于减少 ...

  2. Java——删除Map集合中key-value值

    通过迭代器删除Map集合中的key-value值 Iterator<String> iter = map.keySet().iterator(); while(iter.hasNext() ...

  3. 【解决办法】IIS环境中，打开网站后就直接列出了所有文件

    有时候访问一个不应当被访问的网站目录时网站会列出该目录下的所有文件,这很不安全,尤其是我们希望我们自己的网站不出现这种情况,如下图所示. 解决办法,在网站根目录新建web.config文件,内容如下: ...

  4. Git-Jenkins-代码的上线

    第一章:自动化上线代码基本介绍 1.软件开发生命周期 老板的创意---产品经理---立项---开发团队---测试团队---运维上线 产品经理---加需求---开发团队---测试----更新代码,上线 ...

  5. 百度地图结合ECharts实现复杂覆盖物(Overlay)

    先来看效果图 一 前置知识 官方Overlay-覆盖物的抽象基类 方法 返回值 描述 initialize(map: Map) HTMLElement 抽象方法,用于初始化覆盖物,当调用map.add ...

  6. 子串 NOIP2015 D2T2 luoguP2679 字符串处理+DP

    AC通道! 题目大意: 给定两个长度分别为 n 和 m 的字符串 A 和 B,选取 A 中的 k 个子串,使这 k 个子串按照先后顺序连接起来后等于 B 子串.   输入输出样例 输入 #1 6 3 ...

  7. [PHP自动化－进阶]005.Snoopy采集框架介绍

    引言:Snoopy是一个php类,用来模仿web浏览器的功能,它能完成获取网页内容和发送表单的任务. **官方网址:http://snoopy.sourceforge.net/** 简单一句话表达:& ...

  8. [JavaWeb基础] 013.Struts2 自定义类型转换器

    很多时候,我们在做web开发的时候经常要用到时间的转换器,Struts2给我们提供了一种类型转换器的接口.下面我们讲讲怎么实现吧. 1.首先我们要定义一个类型转换的类,继承自com.babybus.s ...

  9. burpsuite 2.0beta体验

    这里有破解版:http://ximcx.cn/post-110.html 一直再用1.7x版本,2.0的还没怎么用过 移除了 Scanner 和spider 选项卡,全部整理到Dashboard里 代 ...

  10. jQuery-简单理解

    1.概念 jQuery是js的一个类库,主要封装的是js中DOM操作部分,使用和原生js一样 2.代码展示 HTML部分 封装原理 test测试 JS部分 //声明对象 var bjsxt = {}; ...