详解用TensorFlow实现逻辑回归算法,手把手教你使用Git

前言

本文将实现逻辑回归算法,预测低出生体重的概率。

Git使用教程

在go语言中,自身已经集成了一定log模块,开发者可以使用go语言自身的log包(import “log”)。也有不少对自身log的开源封装。对于一些简单的开发,自身的log模块就已经足够应付。但是对一些大型,复杂的开发,log需要分门别类的输出,或者通过网络进行输出,自身log模块将难以应对。

# Logistic Regression
# 逻辑回归
#----------------------------------
#
# This function shows how to use TensorFlow to
# solve logistic regression.
# y = sigmoid(Ax + b)
#
# We will use the low birth weight data, specifically:
# y = 0 or 1 = low birth weight
# x = demographic and medical history data

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
import requests
from tensorflow.python.framework import ops
import os.path
import csv


ops.reset_default_graph()

# Create graph
sess = tf.Session()

###
# Obtain and prepare data for modeling
###

# name of data file
birth_weight_file = 'birth_weight.csv'

# download data and create data file if file does not exist in current directory
if not os.path.exists(birth_weight_file):
  birthdata_url = 'https://github.com/nfmcclure/tensorflow_cookbook/raw/master/01_Introduction/07_Working_with_Data_Sources/birthweight_data/birthweight.dat'
  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.writerow(birth_header)
    writer.writerows(birth_data)
    f.close()

# 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:
     birth_data.append(row)

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

# Pull out target variable
y_vals = np.array([x[0] for x in birth_data])
# Pull out predictor variables (not id, not target, and not birthweight)
x_vals = np.array([x[1:8] for x in birth_data])

# set for reproducible results
seed = 99
np.random.seed(seed)
tf.set_random_seed(seed)

# Split data into train/test = 80%/20%
# 分割数据集为测试集和训练集
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]

# Normalize by column (min-max norm)
# 将所有特征缩放到0和1区间(min-max缩放),逻辑回归收敛的效果更好
# 归一化特征
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))

###
# Define Tensorflow computational graph¶
###

# Declare batch size
batch_size = 25

# Initialize placeholders
x_data = tf.placeholder(shape=[None, 7], dtype=tf.float32)
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)

# Create variables for linear regression
A = tf.Variable(tf.random_normal(shape=[7,1]))
b = tf.Variable(tf.random_normal(shape=[1,1]))

# Declare model operations
model_output = tf.add(tf.matmul(x_data, A), b)

# Declare loss function (Cross Entropy loss)
loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=model_output, labels=y_target))

# Declare optimizer
my_opt = tf.train.GradientDescentOptimizer(0.01)
train_step = my_opt.minimize(loss)

###
# Train model
###

# Initialize variables
init = tf.global_variables_initializer()
sess.run(init)

# Actual Prediction
# 除记录损失函数外,也需要记录分类器在训练集和测试集上的准确度。
# 所以创建一个返回准确度的预测函数
prediction = tf.round(tf.sigmoid(model_output))
predictions_correct = tf.cast(tf.equal(prediction, y_target), tf.float32)
accuracy = tf.reduce_mean(predictions_correct)

# Training loop
# 开始遍历迭代训练,记录损失值和准确度
loss_vec = []
train_acc = []
test_acc = []
for i in range(1500):
  rand_index = np.random.choice(len(x_vals_train), size=batch_size)
  rand_x = x_vals_train[rand_index]
  rand_y = np.transpose([y_vals_train[rand_index]])
  sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})

  temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_target: rand_y})
  loss_vec.append(temp_loss)
  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)
  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)%300==0:
    print('Loss = ' + str(temp_loss))


###
# Display model performance
###

# 绘制损失和准确度
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()

一:Git是什么?

当前也有一些比较重量级的log模块,比如logrus,可以实现比较复杂的功能。这里介绍一个轻量级的log模块——log4go

数据结果:

Git是目前世界上最先进的分布式版本控制系统。

最近又看了一些golang的日志包和相关的文章,仔细阅读了go
1.9.2系统提供的log和go-log,产生了对log4go的日志输出进行优化的想法。

Loss = 0.845124
Loss = 0.658061
Loss = 0.471852
Loss = 0.643469
Loss = 0.672077

二:SVN与Git的最主要的区别?

结构化与multiwriter

图片 1

SVN是集中式版本控制系统,版本库是集中放在中央服务器的,而干活的时候,用的都是自己的电脑,所以首先要从中央服务器哪里得到最新的版本,然后干活,干完后,需要把自己做完的活推送到中央服务器。集中式版本控制系统是必须联网才能工作,如果在局域网还可以,带宽够大,速度够快,如果在互联网下,如果网速慢的话,就纳闷了。

log使用multiwriter支持多个日志输出,用 Mutex
加锁解决多线程日志输出的冲突。log4go 则采用结构化编程用 channel 传递
LogRecord 日志记录。

迭代1500次的交叉熵损失图

Git是分布式版本控制系统,那么它就没有中央服务器的,每个人的电脑就是一个完整的版本库,这样,工作的时候就不需要联网了,因为版本都是在自己的电脑上。既然每个人的电脑都有一个完整的版本库,那多个人如何协作呢?比如说自己在电脑上改了文件A,其他人也在电脑上改了文件A,这时,你们两之间只需把各自的修改推送给对方,就可以互相看到对方的修改了。

原来以为 channel 的效率比较高……其实这是一个伪命题。channel
是一个全局加锁的队列,可以用来加锁,但效率比较低。因为它多了传递数据、协调顺序处理、timout等功能,并不仅仅是加锁。跟Mutex不是一回事儿。

图片 2

三:在windows上如何安装Git?

log4go 将屏幕日志输出 termlog
放在了结构里,这带来一个小问题。当我们用log4go调试小程序时,运行的太快,termlog
的 goroutine
还没有运行起来,程序就退出了。结果屏幕上没有显示日志。这个问题只能通过在
Close()时加延时,等待 goroutine 启动来解决。然后还要检查 channel ……

迭代1500次的测试集和训练集的准确度图

msysgit是 windows版的Git,如下:

func (f *Filter) Close() {
 if f.closed {
  return
 }
 // sleep at most one second and let go routine running
 // drain the log channel before closing
 for i := 10; i > 0; i-- {
  // Must call Sleep here, otherwise, may panic send on closed channel
  time.Sleep(100 * time.Millisecond)
  if len(f.rec) <= 0 {
   break
  }
 }
 // block write channel
 f.closed = true
 defer f.LogWriter.Close()
 close(f.rec)
 if len(f.rec) <= 0 {
  return
 }
 // drain the log channel and write driect
 for rec := range f.rec {
  f.LogWrite(rec)
 }
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

图片 3

log直接将格式化日志信息输出到屏幕,简单多了。

您可能感兴趣的文章:

  • 用TensorFlow实现lasso回归和岭回归算法的示例
  • TensorFlow实现Softmax回归模型
  • 运用TensorFlow进行简单实现线性回归、梯度下降示例
  • 用tensorflow构建线性回归模型的示例代码
  • 用tensorflow实现弹性网络回归算法
  • 用TensorFlow实现戴明回归算法的示例

需要从网上下载一个,然后进行默认安装即可。安装完成后,在开始菜单里面找到
“Git –> Git Bash”,如下:

试着兼顾两者,在 log4go 中增加了
writer,直接输出到屏幕。拟将FileLog,SocketLog作为backend,仍然放在结构里。这样,调试小程序和生产程序可以使用同一个日志库。实测效率略有降低。不知道
windows 下的 ColorLog 如何,以后再说。

图片 4

在log4go中可以通过调用 SetOutput(nil),使out = nil来关闭屏幕输出。

会弹出一个类似的命令窗口的东西,就说明Git安装成功。如下:

Determine caller func – it’s
expensive

图片 5

这句话注释在 log
源文件中,log4go也要调用runtime.Caller(skip int)函数来获取源文件名和行号。它是昂贵的——消耗了CPU。建议在生产环境中关闭,log.SetSkip(-1)
。如果要对log4go进行封装,设置log.SetSkip(log.GetSkip()+1)

安装完成后,还需要最后一步设置,在命令行输入如下:

format优化

图片 6

其实,这才是文章的主题。

因为Git是分布式版本控制系统,所以需要填写用户名和邮箱作为一个标识。

日志输出避免不了打印日期和时间,linux
环境下还要打印微秒,说不定还要打印时区。log4go的pattlog.go就是完成这些工作的。

注意:git config –global
参数,有了这个参数,表示你这台机器上所有的Git仓库都会使用这个配置,当然你也可以对某个仓库指定的不同的用户名和邮箱。

  • 有一个1秒更新一次的cache机制。很漂亮。
  • 大量使用字符串格式化函数——fmt.Sprintf。
  • 返回字符串。而writer一般支持的是[]byte。多做一次转换。
  • 每次都bytes.Splite讲format字符串以%字符分解成[][]byte。

四:如何操作?

在log里边自备了一个cheap的itoa函数。

一:创建版本库。

// Cheap integer to fixed-width decimal ASCII. Give a negative width to avoid zero-padding.
func itoa(buf *[]byte, i int, wid int) {
 // Assemble decimal in reverse order.
 var b [20]byte
 bp := len(b) - 1
 for i >= 10 || wid > 1 {
  wid--
  q := i / 10
  b[bp] = byte('0' + i - q*10)
  bp--
  i = q
 }
 // i < 10
 b[bp] = byte('0' + i)
 *buf = append(*buf, b[bp:]...)
}

什么是版本库?版本库又名仓库,英文名repository,你可以简单的理解一个目录,这个目录里面的所有文件都可以被Git管理起来,每个文件的修改,删除,Git都能跟踪,以便任何时刻都可以追踪历史,或者在将来某个时刻还可以将文件”还原”。

用这个函数替换日期和时间的字符串格式化函数。用[]byte代替string。

所以创建一个版本库也非常简单,如下我是D盘 –> www下
目录下新建一个testgit版本库。

优化前,log4go 的 benchmark。

图片 7

BenchmarkFormatLogRecord-4    300000    4480 ns/op
BenchmarkConsoleLog-4     1000000    1748 ns/op
BenchmarkConsoleNotLogged-4    20000000    97.5 ns/op
BenchmarkConsoleUtilLog-4     300000    3496 ns/op
BenchmarkConsoleUtilNotLog-4   20000000    104 ns/op

pwd 命令是用于显示当前的目录。

优化后:

  1. 通过命令 git init 把这个目录变成git可以管理的仓库,如下:
BenchmarkFormatLogRecord-4  1000000    1443 ns/op
BenchmarkConsoleLog-4   2000000    982 ns/op
BenchmarkConsoleUtilLog-4   500000    3242 ns/op
BenchmarkConsoleUtilNotLog-4 30000000    48.4 ns/op

图片 8

格式化日期时间所花的时间是原来的1/3。

这时候你当前testgit目录下会多了一个.git的目录,这个目录是Git来跟踪管理版本的,没事千万不要手动乱改这个目录里面的文件,否则,会把git仓库给破坏了。如下:

打印无格式化信息所花的时间是原来的1/2。

图片 9

BenchmarkConsoleUtilLog调用了runtime.Caller,格式化信息,且新增了输出信息到屏幕的时间。

  1. 把文件添加到版本库中。

字符串格式化——比较昂贵。

首先要明确下,所有的版本控制系统,只能跟踪文本文件的改动,比如txt文件,网页,所有程序的代码等,Git也不列外,版本控制系统可以告诉你每次的改动,但是图片,视频这些二进制文件,虽能也能由版本控制系统管理,但没法跟踪文件的变化,只能把二进制文件每次改动串起来,也就是知道图片从1kb变成2kb,但是到底改了啥,版本控制也不知道。

总结

下面先看下demo如下演示:

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对脚本之家的支持。

我在版本库testgit目录下新建一个记事本文件 readme.txt 内容如下:11111111

第一步:使用命令 git add readme.txt添加到暂存区里面去。如下:

图片 10

如果和上面一样,没有任何提示,说明已经添加成功了。

第二步:用命令 git commit告诉Git,把文件提交到仓库。

图片 11

现在我们已经提交了一个readme.txt文件了,我们下面可以通过命令git
status来查看是否还有文件未提交,如下:

图片 12

说明没有任何文件未提交,但是我现在继续来改下readme.txt内容,比如我在下面添加一行2222222222内容,继续使用git
status来查看下结果,如下:

图片 13

上面的命令告诉我们 readme.txt文件已被修改,但是未被提交的修改。

接下来我想看下readme.txt文件到底改了什么内容,如何查看呢?可以使用如下命令:

git diff readme.txt 如下:

图片 14

如上可以看到,readme.txt文件内容从一行11111111改成 二行
添加了一行22222222内容。

知道了对readme.txt文件做了什么修改后,我们可以放心的提交到仓库了,提交修改和提交文件是一样的2步(第一步是git
add 第二步是:git commit)。

如下:

图片 15

二:版本回退:

如上,我们已经学会了修改文件,现在我继续对readme.txt文件进行修改,再增加一行

内容为33333333333333.继续执行命令如下:

图片 16

现在我已经对readme.txt文件做了三次修改了,那么我现在想查看下历史记录,如何查呢?我们现在可以使用命令
git log 演示如下所示:

图片 17

git
log命令显示从最近到最远的显示日志,我们可以看到最近三次提交,最近的一次是,增加内容为333333.上一次是添加内容222222,第一次默认是
111111.如果嫌上面显示的信息太多的话,我们可以使用命令 git log
–pretty=oneline 演示如下:

图片 18

现在我想使用版本回退操作,我想把当前的版本回退到上一个版本,要使用什么命令呢?可以使用如下2种命令,第一种是:git
reset –hard HEAD^ 那么如果要回退到上上个版本只需把HEAD^ 改成 HEAD^^
以此类推。那如果要回退到前100个版本的话,使用上面的方法肯定不方便,我们可以使用下面的简便命令操作:git
reset –hard HEAD~100 即可。未回退之前的readme.txt内容如下:

图片 19

如果想回退到上一个版本的命令如下操作:

图片 20

再来查看下 readme.txt内容如下:通过命令cat readme.txt查看

图片 21

可以看到,内容已经回退到上一个版本了。我们可以继续使用git log
来查看下历史记录信息,如下:

图片 22

我们看到 增加333333
内容我们没有看到了,但是现在我想回退到最新的版本,如:有333333的内容要如何恢复呢?我们可以通过版本号回退,使用命令方法如下:

git reset –hard 版本号
,但是现在的问题假如我已经关掉过一次命令行或者333内容的版本号我并不知道呢?要如何知道增加3333内容的版本号呢?可以通过如下命令即可获取到版本号:git
reflog 演示如下:

图片 23

通过上面的显示我们可以知道,增加内容3333的版本号是
6fcfc89.我们现在可以命令

git reset –hard 6fcfc89来恢复了。演示如下:

图片 24

可以看到 目前已经是最新的版本了。

三:理解工作区与暂存区的区别?

工作区:就是你在电脑上看到的目录,比如目录下testgit里的文件(.git隐藏目录版本库除外)。或者以后需要再新建的目录文件等等都属于工作区范畴。

版本库(Repository):工作区有一个隐藏目录.git,这个不属于工作区,这是版本库。其中版本库里面存了很多东西,其中最重要的就是stage(暂存区),还有Git为我们自动创建了第一个分支master,以及指向master的一个指针HEAD。

我们前面说过使用Git提交文件到版本库有两步:

第一步:是使用 git add 把文件添加进去,实际上就是把文件添加到暂存区。

第二步:使用git
commit提交更改,实际上就是把暂存区的所有内容提交到当前分支上。

我们继续使用demo来演示下:

我们在readme.txt再添加一行内容为4444444,接着在目录下新建一个文件为test.txt
内容为test,我们先用命令 git status来查看下状态,如下:

图片 25

现在我们先使用git add 命令把2个文件都添加到暂存区中,再使用git
status来查看下状态,如下:

图片 26

接着我们可以使用git commit一次性提交到分支上,如下:

图片 27

四:Git撤销修改和删除文件操作。

一:撤销修改:

比如我现在在readme.txt文件里面增加一行
内容为555555555555,我们先通过命令查看如下:

图片 28

在我未提交之前,我发现添加5555555555555内容有误,所以我得马上恢复以前的版本,现在我可以有如下几种方法可以做修改:

第一:如果我知道要删掉那些内容的话,直接手动更改去掉那些需要的文件,然后add添加到暂存区,最后commit掉。

第二:我可以按以前的方法直接恢复到上一个版本。使用 git reset –hard
HEAD^

但是现在我不想使用上面的2种方法,我想直接想使用撤销命令该如何操作呢?首先在做撤销之前,我们可以先用
git status 查看下当前的状态。如下所示:

图片 29

可以发现,Git会告诉你,git checkout — file
可以丢弃工作区的修改,如下命令:

git checkout — readme.txt,如下所示:

图片 30

发表评论

电子邮件地址不会被公开。 必填项已用*标注

标签:
网站地图xml地图