深度学习笔记（二）：基于tensorflow gpu版本的深度神经网络程序总览_tf.contrib.layers.xavier_initializer()-程序员宅基地
技术标签： Andrew Ng python 机器学习 深度学习 神经网络 deeplearning.ai
在第一篇笔记深度学习笔记（一）：基于numpy的深度神经网络程序总览之后，又用tensorflow的gpu版本实现了一遍，果然封装很好，写起来很舒服，速度也快很多，100次epoch分分钟就结束了，效果和第一篇笔记中基于numpy的效果差不多，以下是代码，比基于numpy的代码少了一多半，后续笔记就开始记录程序结构和算法步骤了，有时间就更新。
源代码和数据：点击打开链接
# -*- coding: utf-8 -*-
"""
Created on Sat Sep 30 18:45:47 2017
@author: 董玮
"""
import argparse
import time
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
from tensorflow.python.framework import ops
"""
类型：抽象类
说明：规则化数据接口，一般用于数据预处理中。
"""
class interface_normalize_data(object):
"""
类型：公有成员变量
说明：规则化数据过程中，定义一个无穷小精度，用来防止数据计算中的非法操作。
"""
epsilon = 1e-8
"""
类型：抽象公有成员函数
说明：用来规则化数据。
参数：
data -- 待处理的数据。
返回值：
data -- 处理后的数据。
"""
def normalize_data(self, data):
pass
"""
类型：实体类，继承自抽象类interface_normalize_data
说明：用于中心化数据，使数据中心在坐标原点上。
"""
class mean_normalization(interface_normalize_data):
def normalize_data(self, data):
#计算数据每个维度的期望，并用每一条数据减去期望。
center = data - tf.reduce_mean(data, axis = 0, keep_dims = True)
return center
"""
类型：实体类，继承自抽象类interface_normalize_data
说明：用于中心化数据，并除以方差，使数据中心在坐标原点上，并且使每个维度之间的跨度相似。
"""
class variance_normalization(interface_normalize_data):
def normalize_data(self, data):
center = data - tf.reduce_mean(data, axis = 0, keep_dims = True)
#计算数据每个维度的方差。
variance = tf.reduce_mean(tf.square(center), axis = 0, keep_dims = True)
#除以方差并在除数上加上无穷小精度。
vscore = center / (variance + self.epsilon)
return vscore
"""
类型：实体类，继承自抽象类interface_normalize_data
说明：用于Z-Score统计，与上述实体类的区别是除以标准差而不是方差。
"""
class zscore_normalization(interface_normalize_data):
def normalize_data(self, data):
center = data - tf.reduce_mean(data, axis = 0, keep_dims = True)
variance = tf.reduce_mean(tf.square(center), axis = 0, keep_dims = True)
#除以标准差并在除数上加上无穷小精度。
zscore = center / tf.sqrt(variance + self.epsilon)
return zscore
"""
类型：抽象类
说明：神经网络初始化参数接口。
"""
class interface_initialize_parameters(object):
"""
类型：公有成员变量
说明：定义输入层、隐藏层、输出层每层的神经元个数。
"""
structure = None
"""
类型：公有成员变量
说明：定义规则化功能。
"""
regularizer = None
"""
类型：公有成员变量
说明：随机种子，用来产生随机数。
"""
seed = 1
"""
类型：抽象公有成员函数
说明：用来初始化参数。
"""
def initialize_parameters(self):
pass
"""
类型：实体类
说明：标准的x-avier参数初始化，继承自抽象类interface_initialize_parameters
"""
class xavier_initialize_parameters(interface_initialize_parameters):
"""
类型：公有成员函数
说明：用来初始化参数。
参数：无
返回值：
parameters -- 返回初始化后的参数。
"""
def initialize_parameters(self):
tf.set_random_seed(self.seed)
parameters = {}
#初始化两类参数，一种是W1、W2、W3……，另一种是b1、b2、b3……。其中数字代表层数。
#W的维度为(当前层神经元数，前一层神经元数)。b的维度为(当前层神经元数，1)。
for l in range(1, len(self.structure)):
parameters["W" + str(l)] = tf.get_variable("W" + str(l), [self.structure[l-1], self.structure[l]],
initializer = tf.contrib.layers.xavier_initializer(self.seed), regularizer = self.regularizer)
parameters["b" + str(l)] = tf.get_variable("b" + str(l), [1, self.structure[l]],
initializer = tf.zeros_initializer())
return parameters
"""
类型：实体类
说明：具有batch normalization功能的x-avier参数初始化，继承自抽象类interface_initialize_parameters
"""
class xavier_initialize_parameters_BN(interface_initialize_parameters):
"""
类型：公有成员函数
说明：用来初始化参数。
参数：无
返回值：
parameters -- 返回初始化后的参数。
"""
def initialize_parameters(self):
tf.set_random_seed(self.seed)
parameters = {}
#因batch normalization需要，初始化三类参数，W1、W2、W3……，gamma1、gamma2、gamma3……，beta1、beta2、beta3……。其中数字代表层数。
#W的维度为(当前层神经元数，前一层神经元数)。gamma与beta的维度均为(当前层神经元数，1)。
for l in range(1, len(self.structure)):
parameters["W" + str(l)] = tf.get_variable("W" + str(l), [self.structure[l-1], self.structure[l]],
initializer = tf.contrib.layers.xavier_initializer(self.seed), regularizer = self.regularizer)
parameters["gamma" + str(l)] = tf.get_variable("gamma" + str(l), [1, self.structure[l]],
initializer = tf.ones_initializer())
parameters["beta" + str(l)] = tf.get_variable("beta" + str(l), [1, self.structure[l]],
initializer = tf.zeros_initializer())
return parameters
"""
类型：抽象类
说明：定义向前向后算法。
"""
class interface_propagation(object):
"""
类型：公有成员变量
说明：规则化数据过程中，定义一个无穷小精度，用来防止数据计算中的非法操作。
"""
epsilon = 1e-8
"""
类型：公有成员变量
说明：是否进行dropout规则化操作。
"""
is_dropout = False
"""
类型：公有成员变量
说明：如果is_dropout为真，那么此变量存储每一层保持神经元个数的概率。
"""
keep_prob = 1.
"""
类型：公有成员变量
说明：定义激活函数。
"""
act_func = None
"""
类型：抽象公有函数
说明：向前算法。
参数：
training_set -- 训练集。
training_label -- 训练标签。
parameters -- 训练参数。
"""
def forward_propagation(self, training_set, training_label, parameters):
pass
"""
类型：具体类
说明：标准的向前算法，继承自interface_propagation。
"""
class propagation_standard(interface_propagation):
def forward_propagation(self, training_set, training_label, parameters):
if(len(parameters) < 2):
return None
#向前算法
A = training_set
layer_number = len(parameters) // 2
for l in range(1, layer_number):
Z = tf.matmul(A, parameters["W"+str(l)]) + parameters["b" + str(l)]
#激活函数
A = self.act_func(Z)
#添加dropout正则化功能
if(self.is_dropout == True):
A = tf.nn.dropout(A, self.keep_prob)
Z = tf.matmul(A, parameters["W"+str(layer_number)]) + parameters["b" + str(layer_number)]
#计算代价函数
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels = training_label, logits = Z)) + tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))
return cross_entropy, Z
"""
类型：具体类
说明：带有Batch normalization的向前算法，继承自interface_propagation。
"""
class propagation_BN(interface_propagation):
def forward_propagation(self, training_set, training_label, parameters):
if(len(parameters) < 2):
return None
#向前算法
A = training_set
#注意，因为Batch normalization有三个学习参数，这里要除以3取整。
layer_number = len(parameters) // 3
for l in range(1, layer_number):
Z = tf.matmul(A, parameters["W"+str(l)])
#向前算法中的Batch normalization步骤。
Zmean = tf.reduce_mean(Z, axis = 0, keep_dims = True)
Zcenter = Z - Zmean
Zvariance = tf.reduce_mean(tf.square(Zcenter), axis = 0, keep_dims = True)
Ztilde = Zcenter / tf.sqrt(Zvariance + self.epsilon)
Z = tf.multiply(Ztilde, parameters["gamma" + str(l)]) + parameters["beta" + str(l)]
#激活函数
A = self.act_func(Z)
if(self.is_dropout == True):
A = tf.nn.dropout(A, self.keep_prob)
#向前算法中输出层的Batch normalization步骤。
Z = tf.matmul(A, parameters["W"+str(layer_number)])
Zmean = tf.reduce_mean(Z, axis = 0, keep_dims = True)
Zcenter = Z - Zmean
Zvariance = tf.reduce_mean(tf.square(Zcenter), axis = 0, keep_dims = True)
Ztilde = Zcenter / tf.sqrt(Zvariance + self.epsilon)
Z = tf.multiply(Ztilde, parameters["gamma" + str(layer_number)]) + parameters["beta" + str(layer_number)]
#计算代价函数
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels = training_label, logits = Z)) + tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))
return cross_entropy, Z
"""
类型：抽象类
说明：定义一个工厂类，用来生产学习模型过程中所需要的模块。
"""
class interface_factory(object):
"""
类型：公有成员变量
说明：数据预处理规则化模块。
"""
normalizer = None
"""
类型：公有成员变量
说明：学习参数初始化模块。
"""
initializer = None
"""
类型：公有成员变量
说明：向前学习算法模块。
"""
propagator = None
"""
类型：公有成员变量
说明：规则化数据过程中，定义一个无穷小精度，用来防止数据计算中的非法操作。
"""
epsilon = 1e-8
"""
类型：公有成员变量
说明：定义优化算法的学习率。
"""
learning_rate = 1e-3
"""
类型：公有成员变量
说明：Batch normalization超参数。
"""
beta1 = 0.9
"""
类型：公有成员变量
说明：Batch normalization超参数。
"""
beta2 = 0.999
"""
类型：公有成员变量
说明：数据批量优化算法说需要的batch大小，即每次训练从训练集里抽样的个数。
"""
minibatch_size = 512
"""
类型：公有成员变量
说明：epoch个数，即需要训练整个数据集多少遍。
"""
num_epochs = 100
"""
类型：公有成员变量
说明：定义每几步衰减一次。
"""
epoch_step = 5
"""
类型：公有成员变量
说明：衰退比率。
"""
k = 0.09
"""
类型：抽象公有成员函数
说明：创建一个工厂，该工厂生产训练和测试数据过程中所需要的模块。
"""
def create_workpiece(self, *arguments):
pass
"""
类型：具体类
说明：工厂版本v1，不带Batch normalization功能，激活函数为relu，最后一层激活函数为softmax，代价函数用的是交叉熵损失函数，优化算法为adam，学习率为指数衰减。
"""
class factory_v1(interface_factory):
"""
类型：公有成员函数
说明：创建一个工厂，该工厂生产训练和测试数据过程中所需要的模块。
参数：
arguments[0] -- 数值计算精度 - epsilon
arguments[1] -- 网络结构 - structure
arguments[2] -- 随机种子 - seed
arguments[3] -- 学习率 - learning_rate
arguments[4] -- adam参数 - beta1
arguments[5] -- adam参数 - beta2
arguments[6] -- batch的大小 - minibatch_size
arguments[7] -- epoch个数 - num_epochs
arguments[8] -- 衰减步数 - epoch_step
arguments[9] -- 衰减率 - k
"""
def create_workpiece(self, *arguments):
self.epsilon = arguments[0]
self.normalizer = zscore_normalization()
self.normalizer.epsilon = self.epsilon
structure = arguments[1]
seed = arguments[2]
self.initializer = xavier_initialize_parameters()
self.initializer.structure = structure
self.initializer.seed = seed
self.propagator = propagation_standard()
self.propagator.epsilon = self.epsilon
self.propagator.act_func = tf.nn.relu
self.learning_rate = arguments[3]
self.beta1 = arguments[4]
self.beta2 = arguments[5]
self.minibatch_size = arguments[6]
self.num_epochs = arguments[7]
self.epoch_step = arguments[8]
self.k = arguments[9]
return self
"""
类型：具体类
说明：工厂版本v3，带Batch normalization功能，带dropout规则化，激活函数为relu，最后一层激活函数为softmax，代价函数用的是交叉熵损失函数，优化算法为adam，学习率为指数衰减。
"""
class factory_v2(interface_factory):
"""
类型：公有成员函数
说明：创建一个工厂，该工厂生产训练和测试数据过程中所需要的模块。
参数：
arguments[0] -- 数值计算精度 - epsilon
arguments[1] -- 网络结构 - structure
arguments[2] -- 随机种子 - seed
arguments[3] -- 学习率 - learning_rate
arguments[4] -- adam参数 - beta1
arguments[5] -- adam参数 - beta2
arguments[6] -- batch的大小 - minibatch_size
arguments[7] -- epoch个数 - num_epochs
arguments[8] -- 衰减步数 - epoch_step
arguments[9] -- 衰减率 - k
arguments[10] -- 是否进行dropout步骤 - is_dropout
arguments[11] -- dropout保持概率 - keep_prob
"""
def create_workpiece(self, *arguments):
self.epsilon = arguments[0]
#tf_epsilon = tf.Variable(epsilon)
self.normalizer = zscore_normalization()
self.normalizer.epsilon = self.epsilon
structure = arguments[1]
seed = arguments[2]
self.initializer = xavier_initialize_parameters_BN()
self.initializer.structure = structure
self.initializer.seed = seed
self.propagator = propagation_BN()
self.propagator.epsilon = self.epsilon
self.propagator.act_func = tf.nn.relu
self.learning_rate = arguments[3]
self.beta1 = arguments[4]
self.beta2 = arguments[5]
self.minibatch_size = arguments[6]
self.num_epochs = arguments[7]
self.epoch_step = arguments[8]
self.k = arguments[9]
is_dropout = arguments[10]
keep_prob = arguments[11]
self.propagator.is_dropout = is_dropout
self.propagator.keep_prob = keep_prob
return self
"""
类型：抽象类
说明：定义一个工厂类，用来生产学习模型过程中所需要的模块。
"""
class interface_train_model(object):
"""
类型：公有成员变量
说明：学习参数。
"""
parameters = None
"""
类型：公有成员变量
说明：训练集。
"""
training_set = None
"""
类型：公有成员变量
说明：训练标签。
"""
training_label = None
"""
类型：公有成员变量
说明：验证集。
"""
validation_set = None
"""
类型：公有成员变量
说明：验证标签。
"""
validation_label = None
"""
类型：公有成员变量
说明：测试集。
"""
test_set = None
"""
类型：公有成员变量
说明：测试标签。
"""
test_label = None
"""
类型：公有成员变量
说明：工厂对象。
"""
factory = None
"""
类型：抽象公有成员函数
说明：训练模型方法。
"""
def training_model(self, *arguments):
pass
"""
类型：具体类
说明：定义深度神经网络。
"""
class deep_neural_networks(interface_train_model):
"""
类型：初始化函数
说明：初始化工厂对象。
"""
def __init__(self, factory):
self.factory = factory
def training_model(self, *arguments):
#重置图计算步骤，恢复默认状态。
ops.reset_default_graph()
#定义占位符，用来输入数据
X = tf.placeholder(tf.float32, shape=(None, self.training_set.shape[1]))
Y = tf.placeholder(tf.float32, shape=(None, self.training_label.shape[1]))
#定义深度神经网络结构
self.factory.initializer.structure = np.append(np.array([self.training_set.shape[1]]), self.factory.initializer.structure)
num_minibatches = int(self.training_set.shape[0] / self.factory.minibatch_size) + 1
#定义数据预处理步骤
if(self.factory.normalizer != None):
normalize_result = self.factory.normalizer.normalize_data(X)
#定义学习参数及超参数初始化步骤
self.parameters = self.factory.initializer.initialize_parameters()
seed = self.factory.initializer.seed
#定义向前算法步骤
cross_entropy, ZL = self.factory.propagator.forward_propagation(X, Y, self.parameters)
global_step = tf.Variable(0, trainable = False)
#定义学习率衰减
learning_rate_target = tf.train.natural_exp_decay(self.factory.learning_rate, global_step, self.factory.epoch_step * self.training_set.shape[0], self.factory.k, staircase=True)
#定义优化算法
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate_target, beta1 = self.factory.beta1, beta2 = self.factory.beta2, epsilon = self.factory.epsilon).minimize(cross_entropy, global_step = global_step)
#定义计算精度
correct_prediction = tf.equal(tf.argmax(ZL, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
costs = []
training_accuracies = []
validation_accuracies = []
#在验证集上表现最好的学习参数
best_parameters = {}
#最好学习参数时，训练集的精度
best_training_acc = 0.
#最好学习参数时，验证集的精度
best_validation_acc = 0.
init = tf.global_variables_initializer()
#执行计算图
with tf.Session() as sess:
start = time.clock()
sess.run(init)
#数据在计算图中的预处理步骤
if(self.factory.normalizer != None):
self.training_set = sess.run(normalize_result, feed_dict={X: self.training_set})
self.validation_set = sess.run(normalize_result, feed_dict={X: self.validation_set})
#epoch学习过程
for iter_epoch in range(1, self.factory.num_epochs + 1):
cost = 0
#minibatch学习过程
for iter_batch in range(1, num_minibatches + 1):
seed += 1
(minibatch_X, minibatch_Y) = self.__random_mini_batches(self.factory.minibatch_size, seed)
_ , minibatch_cost = sess.run([optimizer, cross_entropy], feed_dict={X: minibatch_X, Y: minibatch_Y})
cost += minibatch_cost
cost /= num_minibatches
costs.append(cost)
training_acc = accuracy.eval(feed_dict={X: self.training_set, Y: self.training_label})
training_accuracies.append(training_acc)
validation_acc = accuracy.eval(feed_dict={X: self.validation_set, Y: self.validation_label})
validation_accuracies.append(validation_acc)
if(validation_acc > best_validation_acc):
best_training_acc = training_acc
best_validation_acc = validation_acc
best_parameters = sess.run(self.parameters)
print ("Cost after epoch %i: %f" % (iter_epoch, cost))
print ("Training accuracy after epoch %i: %f" % (iter_epoch, training_acc))
print ("Validation accuracy after epoch %i: %f" % (iter_epoch, validation_acc))
end = time.clock()
self.factory.initializer.seed = seed
self.parameters = best_parameters
plt.plot(np.squeeze(costs))
plt.ylabel('cost')
plt.xlabel('epochs')
plt.title("Learning rate of Start step =" + str(self.factory.learning_rate))
plt.show()
plt.plot(np.squeeze(training_accuracies))
plt.ylabel('training accracy')
plt.xlabel('epochs')
plt.title("Learning rate of Start step =" + str(self.factory.learning_rate))
plt.show()
plt.plot(np.squeeze(validation_accuracies))
plt.ylabel('validation accracy')
plt.xlabel('epochs')
plt.title("Learning rate of Start step =" + str(self.factory.learning_rate))
plt.show()
print ("Accuracy of total Training set: %f%%" % (best_training_acc * 100))
print ("Accuracy of total Validation set: %f%%" % (best_validation_acc * 100))
print ("Training of total Time: %f Minutes" % ((end - start) / 60))
"""
从训练数据集和标签集中随机抽取minibatch。
参数：
X_train -- 训练数据集。
Y_train -- 训练标签集。
minibatch_size -- minibatch尺寸。
seed -- 随机种子。
返回值：
元组 -- 返回一个minibatch，包括训练数据和对应的标签数据。
"""
def __random_mini_batches(self, minibatch_size, seed):
np.random.seed(seed)
shuffle_array = np.random.randint(0, self.training_set.shape[0], minibatch_size)
return (self.training_set[shuffle_array, :], self.training_label[shuffle_array, :])
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--data_dir', type=str, default='/tmp/tensorflow/mnist/input_data',
help='Directory for storing input data')
FLAGS, unparsed = parser.parse_known_args()
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
struct = [512, 256, 128, 64, 32, 16, 10]
factory = factory_v2()
factory.create_workpiece(1e-8, struct, 1, 1e-3, 0.9, 0.999, 512, 100, 5, 0.009, False, 0.8)
dnn = deep_neural_networks(factory)
dnn.training_set = mnist.train.images
dnn.training_label = mnist.train.labels
dnn.validation_set = mnist.test.images
dnn.validation_label = mnist.test.labels
dnn.training_model()
main()运行结果：
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
智能推荐
分布式光纤传感器的全球与中国市场2022-2028年：技术、参与者、趋势、市场规模及占有率研究报告_预计2026年中国分布式传感器市场规模有多大-程序员宅基地
文章浏览阅读3.2k次。本文研究全球与中国市场分布式光纤传感器的发展现状及未来发展趋势，分别从生产和消费的角度分析分布式光纤传感器的主要生产地区、主要消费地区以及主要的生产商。重点分析全球与中国市场的主要厂商产品特点、产品规格、不同规格产品的价格、产量、产值及全球和中国市场主要生产商的市场份额。主要生产商包括：FISO TechnologiesBrugg KabelSensor HighwayOmnisensAFL GlobalQinetiQ GroupLockheed MartinOSENSA Innovati_预计2026年中国分布式传感器市场规模有多大
07_08 常用组合逻辑电路结构——为IC设计的延时估计铺垫_基4布斯算法代码-程序员宅基地
文章浏览阅读1.1k次，点赞2次，收藏12次。常用组合逻辑电路结构——为IC设计的延时估计铺垫学习目的：估计模块间的delay，确保写的代码的timing 综合能给到多少HZ，以满足需求！_基4布斯算法代码
OpenAI Manager助手（基于SpringBoot和Vue）_chatgpt网页版-程序员宅基地
文章浏览阅读3.3k次，点赞3次，收藏5次。OpenAI Manager助手（基于SpringBoot和Vue）_chatgpt网页版
关于美国计算机奥赛USACO，你想知道的都在这_usaco可以多次提交吗-程序员宅基地
文章浏览阅读2.2k次。USACO自1992年举办，到目前为止已经举办了27届，目的是为了帮助美国信息学国家队选拔IOI的队员，目前逐渐发展为全球热门的线上赛事，成为美国大学申请条件下，含金量相当高的官方竞赛。USACO的比赛成绩可以助力计算机专业留学，越来越多的学生进入了康奈尔，麻省理工，普林斯顿，哈佛和耶鲁等大学，这些同学的共同点是他们都参加了美国计算机科学竞赛（USACO)，并且取得过非常好的成绩。适合参赛人群USACO适合国内在读学生有意向申请美国大学的或者想锻炼自己编程能力的同学，高三学生也可以参加12月的第_usaco可以多次提交吗
MySQL存储过程和自定义函数_mysql自定义函数和存储过程-程序员宅基地
文章浏览阅读394次。1.1 存储程序1.2 创建存储过程1.3 创建自定义函数1.3.1 示例1.4 自定义函数和存储过程的区别1.5 变量的使用1.6 定义条件和处理程序1.6.1 定义条件1.6.1.1 示例1.6.2 定义处理程序1.6.2.1 示例1.7 光标的使用1.7.1 声明光标1.7.2 打开光标1.7.3 使用光标1.7.4 关闭光标1.8 流程控制的使用1.8.1 IF语句1.8.2 CASE语句1.8.3 LOOP语句1.8.4 LEAVE语句1.8.5 ITERATE语句1.8.6 REPEAT语句。_mysql自定义函数和存储过程
半导体基础知识与PN结_本征半导体电流为0-程序员宅基地
文章浏览阅读188次。半导体二极管——集成电路最小组成单元。_本征半导体电流为0
随便推点
【Unity3d Shader】水面和岩浆效果_unity 岩浆shader-程序员宅基地
文章浏览阅读2.8k次，点赞3次，收藏18次。游戏水面特效实现方式太多。咱们这边介绍的是一最简单的UV动画（无顶点位移），整个mesh由4个顶点构成。实现了水面效果（左图），不动代码稍微修改下参数和贴图可以实现岩浆效果（右图）。有要思路是1，uv按时间去做正弦波移动2，在1的基础上加个凹凸图混合uv3，在1、2的基础上加个水流方向4，加上对雾效的支持，如没必要请自行删除雾效代码(把包含fog的几行代码删除)S..._unity 岩浆shader
广义线性模型——Logistic回归模型（1）_广义线性回归模型-程序员宅基地
文章浏览阅读5k次。广义线性模型是线性模型的扩展，它通过连接函数建立响应变量的数学期望值与线性组合的预测变量之间的关系。广义线性模型拟合的形式为：其中g(μY)是条件均值的函数（称为连接函数）。另外，你可放松Y为正态分布的假设，改为Y 服从指数分布族中的一种分布即可。设定好连接函数和概率分布后，便可以通过最大似然估计的多次迭代推导出各参数值。在大部分情况下，线性模型就可以通过一系列连续型或类别型预测变量来预测正态分布的响应变量的工作。但是，有时候我们要进行非正态因变量的分析，例如：（1）类别型.._广义线性回归模型
HTML+CSS大作业 环境网页设计与实现(垃圾分类) web前端开发技术 web课程设计 网页规划与设计_垃圾分类网页设计目标怎么写-程序员宅基地
文章浏览阅读69次。环境保护、 保护地球、 校园环保、垃圾分类、绿色家园、等网站的设计与制作。 总结了一些学生网页制作的经验：一般的网页需要融入以下知识点：div+css布局、浮动、定位、高级css、表格、表单及验证、js轮播图、音频 视频 Flash的应用、ul li、下拉导航栏、鼠标划过效果等知识点，网页的风格主题也很全面：如爱好、风景、校园、美食、动漫、游戏、咖啡、音乐、家乡、电影、名人、商城以及个人主页等主题，学生、新手可参考下方页面的布局和设计和HTML源码（有用点赞△） 一套A+的网_垃圾分类网页设计目标怎么写
C# .Net 发布后,把dll全部放在一个文件夹中,让软件目录更整洁_.net dll 全局目录-程序员宅基地
文章浏览阅读614次，点赞7次，收藏11次。之前找到一个修改 exe 中 DLL地址 的方法, 不太好使,虽然能正确启动, 但无法改变 exe 的工作目录,这就影响了.Net 中很多获取 exe 执行目录来拼接的地址 ( 相对路径 ),比如 wwwroot 和 代码中相对目录还有一些复制到目录的普通文件 等等,它们的地址都会指向原来 exe 的目录, 而不是自定义的 “lib” 目录,根本原因就是没有修改 exe 的工作目录这次来搞一个启动程序,把 .net 的所有东西都放在一个文件夹,在文件夹同级的目录制作一个 exe._.net dll 全局目录
BRIEF特征点描述算法_breif description calculation 特征点-程序员宅基地
文章浏览阅读1.5k次。本文为转载，原博客地址：http://blog.csdn.net/hujingshuang/article/details/46910259简介 BRIEF是2010年的一篇名为《BRIEF:Binary Robust Independent Elementary Features》的文章中提出，BRIEF是对已检测到的特征点进行描述，它是一种二进制编码的描述子，摈弃了利用区域灰度..._breif description calculation 特征点
房屋租赁管理系统的设计和实现，SpringBoot计算机毕业设计论文_基于spring boot的房屋租赁系统论文-程序员宅基地
文章浏览阅读4.1k次，点赞21次，收藏79次。本文是《基于SpringBoot的房屋租赁管理系统》的配套原创说明文档，可以给应届毕业生提供格式撰写参考，也可以给开发类似系统的朋友们提供功能业务设计思路。_基于spring boot的房屋租赁系统论文