本文目录一览：
- 如何用神经网络实现连续型变量的回归预测？
- 计算机python的实现方式都有哪些？
- python 常用的系统函数有哪些
- 如何利用python语言实现机器学习算法
- python把一个字符串列表写入txt文件，并保证每个字符串占用一行且没有其他符号（例如[]‘’空格）
- 怎样用python构建一个卷积神经网络模型
如何用神经网络实现连续型变量的回归预测？
神经网络最开始是机器学习的一种模型，但其训练的时间和其他几种模型相比不占优势，且结果也不尽人意，所以一直没有被广泛使用。但随着数学的深入研究以及计算机硬件质量的提高，尤其是GPU的出现，给深度学习的广泛应用提供了基础。GPU最初是为了给游戏玩家带来高质量的视觉体验，由于其处理矩阵运算的能力特别优秀，也被用于深度学习中模型的训练，以往数十天才能训练好的模型在GPU上训练几天就可以训练好，大大减少了深度学习的训练时间，因而深度学习的应用越来越多。 神经网络作为深度学习最主要的模型，人工神经网络ANN是最基础的神经网络结构，其工作原理很像人类大脑中的神经。神经元是ANN的工作单元，每个神经元含有权重和偏置，神经元将上一层神经元传递过来的值通过权重和偏置的运算，得到新的结果，将该结果传递给下一层神经元，通过不断的传递，最终获得输出结果。 要想用神经网络实现连续型变量的回归预测，需要将该N维变量的数据作为输入，中间再设置隐藏层和每一层的神经元个数，至于隐藏层的层数则需要多次训练才能得出较准确的层数。而最后输出层的值和实际变量的值会有误差，神经网络会通过不断地训练，更改权重和偏置的值来使误差尽可能的小，当误差小到一定程度，该神经网络的回归预测就算成功了。 通常使用Python来搭建神经网络，Python自带深度学习的一些库，在进行回归预测时，我们只需用调用函数，设定几个参数，如隐藏层层数和神经元个数等，剩下的就是等模型自行训练，最终便能完成回归预测，非常的方便。
计算机python的实现方式都有哪些？
虽然官方 Python 实现差不多得到最广泛的欢迎，但也有一些其他实现对特定领域的用户来说更具吸引力。 知名的实现包括:
- CPython
这最早出现并持续维护的 Python 实现，以 C 语言编写。新的语言特性通常在此率先添加。 - Jython
以 Java 语言编写的 Python 实现。此实现可以作为 Java 应用的一个脚本语言，或者可以用来创建需要 Java 类库支持的应用。想了解更多信息可访问 Jython 网站。 - Python for .NET
此实现实际上使用了 CPython 实现，但是属于 .NET 托管应用并且可以引入 .NET 类库。它的创造者是 Brian Lloyd。想了解详情可访问 Python for .NET 主页。 - IronPython
另一个 .NET 的 Python 实现，与 Python.NET 不同点在于它是生成 IL 的完全 Python 实现，并且将 Python 代码直接编译为 .NET 程序集。它的创造者就是当初创造 Jython 的 Jim Hugunin。想了解详情可访问 IronPython 网站。 - PyPy
完全使用 Python 语言编写的 Python 实现。它支持多个其他实现所没有的高级特性，例如非栈式支持和 JIT 编译器等。此项目的目标之一是通过允许方便地修改解释器 (因为它是用 Python 编写的)，鼓励该对语言本身进行试验。想了解详情可访问 PyPy 项目主页。 以上这些实现都可能在某些方面与此参考文档手册的描述有所差异，或是引入了超出标准 Python 文档范围的特定信息。请参考它们各自的专门文档，以确定你正在使用的这个实现有哪些你需要了解的东西。
python 常用的系统函数有哪些
- 常用内置函数：(不用import就可以直接使用)
help(obj)在线帮助, obj可是任何类型callable(obj)查看一个obj是不是可以像函数一样调用repr(obj)得到obj的表示字符串，可以利用这个字符串eval重建该对象的一个拷贝eval_r(str)表示合法的python表达式，返回这个表达式dir(obj)查看obj的name space中可见的namehasattr(obj,name)查看一个obj的name space中是否有namegetattr(obj,name)得到一个obj的name space中的一个namesetattr(obj,name,value)为一个obj的name space中的一个name指向vale这个objectdelattr(obj,name)从obj的name space中删除一个namevars(obj)返回一个object的name space。用dictionary表示locals()返回一个局部name space,用dictionary表示globals()返回一个全局name space,用dictionary表示type(obj)查看一个obj的类型isinstance(obj,cls)查看obj是不是cls的instanceissubclass(subcls,supcls)查看subcls是不是supcls的子类
- 类型转换函数
chr(i)把一个ASCII数值,变成字符ord(i)把一个字符或者unicode字符,变成ASCII数值oct(x)把整数x变成八进制表示的字符串hex(x)把整数x变成十六进制表示的字符串str(obj)得到obj的字符串描述list(seq)把一个sequence转换成一个listtuple(seq)把一个sequence转换成一个tupledict(),dict(list)转换成一个dictionaryint(x)转换成一个integerlong(x)转换成一个long intergerfloat(x)转换成一个浮点数complex(x)转换成复数max(...)求最大值min(...)求最小值
- 用于执行程序的内置函数
complile如果一段代码经常要使用,那么先编译,再运行会更快。
- 和操作系统相关的调用
- 系统相关的信息模块 import sys
sys.argv是一个list,包含所有的命令行参数.sys.stdout,sys.stdin,sys.stderr分别表示标准输入输出,错误输出的文件对象.sys.stdin.readline()从标准输入读一行sys.stdout.write("a")屏幕输出asys.exit(exit_code)退出程序sys.modules是一个dictionary，表示系统中所有可用的modulesys.platform得到运行的操作系统环境sys.path是一个list,指明所有查找module，package的路径.
- 操作系统相关的调用和操作 import os
os.environ一个dictionary 包含环境变量的映射关系os.environ["HOME"]可以得到环境变量HOME的值os.chdir(dir)改变当前目录os.chdir('d:\\outlook')注意windows下用到转义os.getcwd()得到当前目录os.getegid()得到有效组idos.getgid()得到组idos.getuid()得到用户idos.geteuid()得到有效用户idos.setegid,os.setegid(),os.seteuid(),os.setuid()os.getgruops()得到用户组名称列表os.getlogin()得到用户登录名称os.getenv得到环境变量os.putenv设置环境变量os.umask设置umaskos.system(cmd)利用系统调用，运行cmd命令
- 操作举例：
os.mkdir('/tmp/xx') os.system("echo 'hello' /tmp/xx/a.txt") os.listdir('/tmp/xx') os.rename('/tmp/xx/a.txt','/tmp/xx/b.txt') os.remove('/tmp/xx/b.txt') os.rmdir('/tmp/xx') - 用python编写一个简单的shell
#!/usr/bin/python import os, sys cmd = sys.stdin.readline() while cmd: os.system(cmd) cmd = sys.stdin.readline() - 用os.path编写平台无关的程序
os.path.abspath("1.txt") == os.path.join(os.getcwd(), "1.txt") os.path.split(os.getcwd()) # 用于分开一个目录名称中的目录部分和文件名称部分。 os.path.join(os.getcwd(), os.pardir, 'a', 'a.doc') # 全成路径名称. os.pardir # 表示当前平台下上一级目录的字符 .. os.path.getctime("/root/1.txt") # 返回1.txt的ctime(创建时间)时间戳 os.path.exists(os.getcwd()) # 判断文件是否存在 os.path.expanduser('~/dir') # 把~扩展成用户根目录 os.path.expandvars('$PATH') # 扩展环境变量PATH os.path.isfile(os.getcwd()) # 判断是否是文件名，1是0否 os.path.isdir('c:\Python26\temp') # 判断是否是目录,1是0否 os.path.islink('/home/huaying/111.sql') # 是否是符号连接 windows下不可用 os.path.ismout(os.getcwd()) # 是否是文件系统安装点 windows下不可用 os.path.samefile(os.getcwd(), '/home/huaying') # 看看两个文件名是不是指的是同一个文件 os.path.walk('/home/huaying', test_fun, "a.c") - 遍历/home/huaying下所有子目录包括本目录,对于每个目录都会调用函数test_fun.
def test_fun(filename, dirname, names): # filename即是walk中的a.c dirname是访问的目录名称 if filename in names: # names是一个list,包含dirname目录下的所有内容 print os.path.join(dirname, filename) os.path.walk('/home/huaying', test_fun, "a.c")
- 系统相关的信息模块 import sys
- 文件操作
- 打开文件
f = open("filename", "r") # r只读 w写 rw读写 rb读二进制 wb写二进制 w+写追加 - 读写文件
f.write("a") # f.write(str) 写一字符串 f.writeline() # f.readlines() 与下read类同 f.read() # 全读出来 f.read(size) # 表示从文件中读取size个字符 f.readline() # 读一行,到文件结尾,返回空串. f.readlines() # 读取全部，返回一个list. list每个元素表示一行，包含"\n" f.tell() # 返回当前文件读取位置 f.seek(off, where) # 定位文件读写位置. off表示偏移量，正数向文件尾移动，负数表示向开头移动。 f.flush() # 刷新缓存 - 关闭文件
f.close()
- 打开文件
- regular expression 正则表达式 import re
- 简单的regexp
p = re.compile("abc") if p.match("abc") : print "match" - 字符集合(用[]表示)
列出字符,如[abc]表示匹配a或b或c,大多数metacharacter在[]中只表示和本身匹配。例：a = ".^$*+?{\\|()" p = re.compile("["+a+"]") for i in a: if p.match(i): print "[%s] is match" %i else: print "[%s] is not match" %i - ^出现在[]的开头,表示取反。
[^abc]表示除了a,b,c之外的所有字符。^没有出现在开头，即于身身匹配。 - -可表示范围。
[a-zA-Z]匹配任何一个英文字母。[0-9]匹配任何数字。 - \在[]中的妙用。
- \d [0-9]
- \D [^0-9]
- \s [ \t\n\r\f\v]
- \S [^ \t\n\r\f\v]
- \w [a-zA-Z0-9_]
- \W [^a-zA-Z0-9_]
- \t 表示和tab匹配, 其他的都和字符串的表示法一致
- \x20 表示和十六进制ascii 0x20匹配
- 有了\，可以在[]中表示任何字符。注：单独的一个"."如果没有出现[]中，表示出了换行\n以外的匹配任何字符,类似[^\n].
- regexp的重复
- {m,n}表示出现m个以上(含m个),n个以下(含n个). 如ab{1,3}c和abc,abbc,abbbc匹配，不会与ac,abbbc匹配。
- m是下界，n是上界。m省略表下界是0,n省略，表上界无限大。
- *表示{,} +表示{1,} ?表示{0,1}
- 最大匹配和最小匹配 python都是最大匹配，如果要最小匹配，在*,+,?,{m,n}后面加一个?.
- match object的end可以得到匹配的最后一个字符的位置。
re.compile("a*").match('aaaa').end() # 4 最大匹配 re.compile("a*?").match('aaaa').end() # 0 最小匹配 - 使用原始字符串
字符串表示方法中用\表示字符.大量使用影响可读性。
解决方法：在字符串前面加一个r表示raw格式。a = r"\a" print a # 结果是\a a = r"\"a" print a # 结果是\"a - 使用re模块
- 先用re.compile得到一个RegexObject 表示一个regexp
- 后用pattern的match,search的方法,得到MatchObject
- 再用match object得到匹配的位置,匹配的字符串等信息
- RegxObject常用函数:
re.compile("a").match("abab") # 如果abab的开头和re.compile("a")匹配，得到MatchObject _sre.SRE_Match object at 0x81d43c8 re.compile("a").match("bbab") # None 注：从str的开头开始匹配 re.compile("a").search("abab") # 在abab中搜索第一个和re_obj匹配的部分 _sre.SRE_Match object at 0x81d43c8 re.compile("a").search("bbab") # _sre.SRE_Match object at 0x8184e18 和match()不同,不必从开头匹配 re_obj.findall(str) # 返回str中搜索所有和re_obj匹配的部分.返回一个tuple,其中元素是匹配的字符串. - MatchObject的常用函数
m.start()返回起始位置m.end()返回结束位置(不包含该位置的字符)m.span()返回一个tuple表示(m.start(), m.end())m.pos(),m.endpos(),m.re(),m.string()m.re().search(m.string(), m.pos(), m.endpos())会得到m本身m.finditer()可以返回一个iterator,用来遍历所有找到的MatchObject.for m in re.compile("[ab]").finditer("tatbxaxb"): print m.span()
- 高级regexp
|表示联合多个regexp. A B两个regexp，A|B表示和A匹配或者跟B匹配.^表示只匹配一行的开始行首,^只有在开头才有此特殊意义。$表示只匹配一行的结尾\A表示只匹配第一行字符串的开头 ^匹配每一行的行首\Z表示只匹配行一行字符串的结尾 $匹配第一行的行尾\b只匹配词的边界 例：\binfo\b 只会匹配"info" 不会匹配information\B表示匹配非单词边界
- 示例如下：
print re.compile(r"\binfo\b").match("info ") # 使用raw格式 \b表示单词边界 _sre.SRE_Match object at 0x817aa98 print re.compile("\binfo\b").match("info ") # 没有使用raw \b表示退格符号 None print re.compile("\binfo\b").match("\binfo\b ") _sre.SRE_Match object at 0x8174948 - 分组(Group) 示例：
re.compile("(a(b)c)d").match("abcd").groups() # ('abc', 'b')#!/usr/local/bin/python import re x = """ name: Charles Address: BUPT name: Ann Address: BUPT """ #p = re.compile(r"^name:(.*)\n^Address:(.*)\n", re.M) p = re.compile(r"^name:(?P<name>.*)\n^Address:(?P<address>.*)\n", re.M) for m in p.finditer(x): print m.span() print "here is your friends list" print "%s, %s"%m.groups() - Compile Flag
用re.compile得到RegxObject时，可以有一些flag用来调整RegxObject的详细特征.DOTALL, S让.匹配任意字符,包括换行符\nIGNORECASE, I忽略大小写LOCALES, L让\w \W \b \B和当前的locale一致MULTILINE, M多行模式，只影响^和$ (参见上例)VERBOSE, Xverbose模式
- 简单的regexp
如何利用python语言实现机器学习算法
基于以下三个原因，我们选择Python作为实现机器学习算法的编程语言：
- Python的语法清晰；
- 易于操作纯文本文件；
- 使用广泛，存在大量的开发文档。
可执行伪代码
Python具有清晰的语法结构，大家也把它称作可执行伪代码（executable pseudo-code）。默认安装的Python开发环境已经附带了很多高级数据类型，如列表、元组、字典、集合、队列等，无需进一步编程就可以使用这些数据类型的操作。使用这些数据类型使得实现抽象的数学概念非常简单。此外，读者还可以使用自己熟悉的编程风格，如面向对象编程、面向过程编程、或者函数式编程。不熟悉Python的读者可以参阅附录A，该附录详细介绍了Python语言、Python使用的数据类型以及安装指南。 Python语言处理和操作文本文件非常简单
非常易于处理非数值型数据。Python语言提供了丰富的正则表达式函数以及很多访问Web页面的函数库，使得从HTML中提取数据变得非常简单直观。 Python比较流行
Python语言使用广泛，代码范例也很多，便于读者快速学习和掌握。此外，在开发实际应用程序时，也可以利用丰富的模块库缩短开发周期。 在科学和金融领域，Python语言得到了广泛应用。SciPy和NumPy等许多科学函数库都实现了向量和矩阵操作，这些函数库增加了代码的可读性，学过线性代数的人都可以看懂代码的实际功能。另外，科学函数库SciPy和NumPy使用底层语言（C和Fortran）编写，提高了相关应用程序的计算性能。本书将大量使用Python的NumPy。 Python的科学工具可以与绘图工具Matplotlib协同工作。Matplotlib可以绘制二D、三D图形，也可以处理科学研究中经常使用到的图形，所以本书也将大量使用Matplotlib。 Python开发环境还提供了交互式shell环境，允许用户开发程序时查看和检测程序内容。 Python开发环境将来还会集成Pylab模块，它将NumPy、SciPy和Matplotlib合并为一个开发环境。在本书写作时，Pylab还没有并入Python环境，但是不远的将来我们肯定可以在Python开发环境找到它。 Python语言的特色
诸如MATLAB和Mathematica等高级程序语言也允许用户执行矩阵操作，MATLAB甚至还有许多内嵌的特征可以轻松地构造机器学习应用，而且MATLAB的运算速度也很快。然而MATLAB的不足之处是软件费用太高，单个软件授权就要花费数千美元。虽然也有适合MATLAB的第三方插件，但是没有一个有影响力的大型开源项目。 Java和C等强类型程序设计语言也有矩阵数学库，然而对于这些程序设计语言来说，最大的问题是即使完成简单的操作也要编写大量的代码。程序员首先需要定义变量的类型，对于Java来说，每次封装属性时还需要实现getter和setter方法。另外还要记着实现子类，即使并不想使用子类，也必须实现子类方法。为了完成一个简单的工作，我们必须花费大量时间编写了很多无用冗长的代码。Python语言则与Java和C完全不同，它清晰简练，而且易于理解，即使不是编程人员也能够理解程序的含义，而Java和C对于非编程人员则像天书一样难于理解。 所有人在小学二年级已经学会了写作，然而大多数人必须从事其他更重要的工作。
——鲍比·奈特
也许某一天，我们可以在这句话中将“写作”替代为“编写代码”，虽然有些人对于编写代码很感兴趣，但是对于大多数人来说，编程仅是完成其他任务的工具而已。Python语言是高级编程语言，我们可以花费更多的时间处理数据的内在含义，而无须花费太多精力解决计算机如何得到数据结果。Python语言使得我们很容易表达自己的目的。 Python语言的缺点
Python程序运行的效率不如Java或者C代码高，但是我们可以使用Python调用C编译的代码。这样，我们就可以同时利用C和Python的优点，逐步地开发机器学习应用程序。我们可以首先使用Python编写实验程序，如果进一步想要在产品中实现机器学习，转换成C代码也不困难。如果程序是按照模块化原则组织的，我们可以先构造可运行的Python程序，然后再逐步使用C代码替换核心代码以改进程序的性能。C++ Boost库就适合完成这个任务，其他类似于Cython和PyPy的工具也可以编写强类型的Python代码，改进一般Python程序的性能。 如果程序的算法或者思想有缺陷，则无论程序的性能如何，都无法得到正确的结果。如果解决问题的思想存在问题，那么单纯通过提高程序的运行效率，扩展用户规模都无法解决这个核心问题。从这个角度来看，Python快速实现系统的优势就更加明显了，我们可以快速地检验算法或者思想是否正确，如果需要，再进一步优化代码。
python把一个字符串列表写入txt文件，并保证每个字符串占用一行且没有其他符号（例如[]‘’空格）
代码如下：
# coding=utf-8
a = ['zali','sili','ann']
with open('test.txt', 'w') as f:
for i in a:
f.write(i + '\n')
运行结果
怎样用python构建一个卷积神经网络模型
上周末利用python简单实现了一个卷积神经网络，只包含一个卷积层和一个maxpooling层，pooling层后面的多层神经网络采用了softmax形式的输出。实验输入仍然采用MNIST图像使用10个feature map时，卷积和pooling的结果分别如下所示。 部分源码如下：
# coding=utf-8
'''
Created on 2014年11月30日
@author: Wangliaofan
'''
import numpy
import struct
import matplotlib.pyplot as plt
import math
import random
import copy
# test
from BasicMultilayerNeuralNetwork import BMNN2
def sigmoid(inX):
if 1.0 + numpy.exp(-inX) == 0.0:
return 999999999.999999999
return 1.0 / (1.0 + numpy.exp(-inX))
def difsigmoid(inX):
return sigmoid(inX) * (1.0 - sigmoid(inX))
def tangenth(inX):
return (1.0 * math.exp(inX) - 1.0 * math.exp(-inX)) / (1.0 * math.exp(inX) + 1.0 * math.exp(-inX))
def cnn_conv(in_image, filter_map, B, type_func='sigmoid'):
# in_image[num,feature map,row,col]=in_image[Irow,Icol]
# features map[k filter,row,col]
# type_func['sigmoid','tangenth']
# out_feature[k filter,Irow-row+1,Icol-col+1]
shape_image = numpy.shape(in_image) # [row,col]
shape_filter = numpy.shape(filter_map) # [k filter,row,col]
if shape_filter[1] > shape_image[0] or shape_filter[2] > shape_image[1]:
raise Exception
shape_out = (shape_filter[0], shape_image[0] - shape_filter[1] + 1, shape_image[1] - shape_filter[2] + 1)
out_feature = numpy.zeros(shape_out)
k, m, n = numpy.shape(out_feature)
for k_idx in range(0, k):
# rotate 180 to calculate conv
c_filter = numpy.rot90(filter_map[k_idx, :, :], 2)
for r_idx in range(0, m):
for c_idx in range(0, n):
# conv_temp=numpy.zeros((shape_filter[1],shape_filter[2]))
conv_temp = numpy.dot(in_image[r_idx:r_idx + shape_filter[1], c_idx:c_idx + shape_filter[2]], c_filter)
sum_temp = numpy.sum(conv_temp)
if type_func == 'sigmoid':
out_feature[k_idx, r_idx, c_idx] = sigmoid(sum_temp + B[k_idx])
elif type_func == 'tangenth':
out_feature[k_idx, r_idx, c_idx] = tangenth(sum_temp + B[k_idx])
else:
raise Exception
return out_feature
def cnn_maxpooling(out_feature, pooling_size=2, type_pooling="max"):
k, row, col = numpy.shape(out_feature)
max_index_Matirx = numpy.zeros((k, row, col))
out_row = int(numpy.floor(row / pooling_size))
out_col = int(numpy.floor(col / pooling_size))
out_pooling = numpy.zeros((k, out_row, out_col))
for k_idx in range(0, k):
for r_idx in range(0, out_row):
for c_idx in range(0, out_col):
temp_matrix = out_feature[k_idx, pooling_size * r_idx:pooling_size * r_idx + pooling_size, pooling_size * c_idx:pooling_size * c_idx + pooling_size]
out_pooling[k_idx, r_idx, c_idx] = numpy.amax(temp_matrix)
max_index = numpy.argmax(temp_matrix)
# print max_index
# print max_index/pooling_size, max_index%pooling_size
max_index_Matirx[k_idx, pooling_size * r_idx + max_index / pooling_size, pooling_size * c_idx + max_index % pooling_size] = 1
return out_pooling, max_index_Matirx
def poolwithfunc(in_pooling, W, B, type_func='sigmoid'):
k, row, col = numpy.shape(in_pooling)
out_pooling = numpy.zeros((k, row, col))
for k_idx in range(0, k):
for r_idx in range(0, row):
for c_idx in range(0, col):
out_pooling[k_idx, r_idx, c_idx] = sigmoid(W[k_idx] * in_pooling[k_idx, r_idx, c_idx] + B[k_idx])
return out_pooling
# out_feature is the out put of conv
def backErrorfromPoolToConv(theta, max_index_Matirx, out_feature, pooling_size=2):
k1, row, col = numpy.shape(out_feature)
error_conv = numpy.zeros((k1, row, col))
k2, theta_row, theta_col = numpy.shape(theta)
if k1 != k2:
raise Exception
for idx_k in range(0, k1):
for idx_row in range(0, row):
for idx_col in range(0, col):
error_conv[idx_k, idx_row, idx_col] = \
max_index_Matirx[idx_k, idx_row, idx_col] * \
float(theta[idx_k, idx_row / pooling_size, idx_col / pooling_size]) * \
difsigmoid(out_feature[idx_k, idx_row, idx_col])
return error_conv
def backErrorfromConvToInput(theta, inputImage):
k1, row, col = numpy.shape(theta)
# print "theta",k1,row,col
i_row, i_col = numpy.shape(inputImage)
if row > i_row or col > i_col:
raise Exception
filter_row = i_row - row + 1
filter_col = i_col - col + 1
detaW = numpy.zeros((k1, filter_row, filter_col))
# the same with conv valid in matlab
for k_idx in range(0, k1):
for idx_row in range(0, filter_row):
for idx_col in range(0, filter_col):
subInputMatrix = inputImage[idx_row:idx_row + row, idx_col:idx_col + col]
# print "subInputMatrix",numpy.shape(subInputMatrix)
# rotate theta 180
# print numpy.shape(theta)
theta_rotate = numpy.rot90(theta[k_idx, :, :], 2)
# print "theta_rotate",theta_rotate
dotMatrix = numpy.dot(subInputMatrix, theta_rotate)
detaW[k_idx, idx_row, idx_col] = numpy.sum(dotMatrix)
detaB = numpy.zeros((k1, 1))
for k_idx in range(0, k1):
detaB[k_idx] = numpy.sum(theta[k_idx, :, :])
return detaW, detaB
def loadMNISTimage(absFilePathandName, datanum=60000):
images = open(absFilePathandName, 'rb')
buf = images.read()
index = 0
magic, numImages, numRows, numColumns = struct.unpack_from('IIII', buf, index)
print magic, numImages, numRows, numColumns
index += struct.calcsize('IIII')
if magic != 2051:
raise Exception
datasize = int(784 * datanum)
datablock = "" + str(datasize) + "B"
# nextmatrix=struct.unpack_from('47040000B' ,buf, index)
nextmatrix = struct.unpack_from(datablock, buf, index)
nextmatrix = numpy.array(nextmatrix) / 255.0
# nextmatrix=nextmatrix.reshape(numImages,numRows,numColumns)
# nextmatrix=nextmatrix.reshape(datanum,1,numRows*numColumns)
nextmatrix = nextmatrix.reshape(datanum, 1, numRows, numColumns)
return nextmatrix, numImages
def loadMNISTlabels(absFilePathandName, datanum=60000):
labels = open(absFilePathandName, 'rb')
buf = labels.read()
index = 0
magic, numLabels = struct.unpack_from('II', buf, index)
print magic, numLabels
index += struct.calcsize('II')
if magic != 2049:
raise Exception
datablock = "" + str(datanum) + "B"
# nextmatrix=struct.unpack_from('60000B' ,buf, index)
nextmatrix = struct.unpack_from(datablock, buf, index)
nextmatrix = numpy.array(nextmatrix)
return nextmatrix, numLabels
def simpleCNN(numofFilter, filter_size, pooling_size=2, maxIter=1000, imageNum=500):
decayRate = 0.01
MNISTimage, num1 = loadMNISTimage("F:\Machine Learning\UFLDL\data\common\\train-images-idx3-ubyte", imageNum)
print num1
row, col = numpy.shape(MNISTimage[0, 0, :, :])
out_Di = numofFilter * ((row - filter_size + 1) / pooling_size) * ((col - filter_size + 1) / pooling_size)
MLP = BMNN2.MuiltilayerANN(1, [128], out_Di, 10, maxIter)
MLP.setTrainDataNum(imageNum)
MLP.loadtrainlabel("F:\Machine Learning\UFLDL\data\common\\train-labels-idx1-ubyte")
MLP.initialweights()
rng = numpy.random.RandomState(23455)
W_shp = (numofFilter, filter_size, filter_size)
W_bound = numpy.sqrt(numofFilter * filter_size * filter_size)
W_k = rng.uniform(low=-1.0 / W_bound, high=1.0 / W_bound, size=W_shp)
B_shp = (numofFilter,)
B = numpy.asarray(rng.uniform(low=-.5, high=.5, size=B_shp))
cIter = 0
while cIter < maxIter:
cIter += 1
ImageNum = random.randint(0, imageNum - 1)
conv_out_map = cnn_conv(MNISTimage[ImageNum, 0, :, :], W_k, B, "sigmoid")
out_pooling, max_index_Matrix = cnn_maxpooling(conv_out_map, 2, "max")
pool_shape = numpy.shape(out_pooling)
MLP_input = out_pooling.reshape(1, 1, out_Di)
# print numpy.shape(MLP_input)
DetaW, DetaB, temperror = MLP.backwardPropogation(MLP_input, ImageNum)
if cIter % 50 == 0:
print cIter, "Temp error: ", temperror
# print numpy.shape(MLP.Theta[MLP.Nl-2])
# print numpy.shape(MLP.Ztemp[0])
# print numpy.shape(MLP.weightMatrix[0])
theta_pool = MLP.Theta[MLP.Nl-2] * MLP.weightMatrix[0].transpose()
# print numpy.shape(theta_pool)
# print "theta_pool",theta_pool
temp = numpy.zeros((1, 1, out_Di))
temp[0, :, :] = theta_pool
back_theta_pool = temp.reshape(pool_shape)
# print "back_theta_pool",numpy.shape(back_theta_pool)
# print "back_theta_pool",back_theta_pool
error_conv = backErrorfromPoolToConv(back_theta_pool, max_index_Matrix, conv_out_map, 2)
# print "error_conv",numpy.shape(error_conv)
# print error_conv
conv_DetaW, conv_DetaB = backErrorfromConvToInput(error_conv, MNISTimage[ImageNum, 0, :, :])
# print "W_k",W_k
# print "conv_DetaW",conv_DetaW
