Godeyes查看:2 回复:8 评论:2 创建时间:2020-05-08T07:23:26用户:Godeyes查看:2 回复:8 评论:2 创建时间:2020-05-08T07:23:26
哈喽，大家好，我是敲击小萌新----Godeyes!!!!!!!!
今天我们继续来学习java，话不多说，直接开锤
浮点型数据实际上在内存中存储的时候大部分情况下都是存储了数据的近似值，为什么呢？这是因为在现实世界中存在无穷的数，例如3.333333333333333333..，数据是无穷的，但是内存是有限的，所以只能存储近似值，float 单精度占 4 个字节，double 双精度占 8 个字节，相对来说 double 精度要高一些。由于浮点型数据存储的是近似值，所以一般判断两个浮点型数据是否相等的操作很少。
在 java 语言中有这样的一条规定：只要是浮点型的字面量，例如 1.0、3.14 等默认会被当做 double 类型来处理，如果想让程序将其当做 float 类型来处理，需要在字面量后面添加 f/F。请看以下代码：
public class DoubleTest {
public static void main(String[] args) {
float f = 3.0;
}
}
编译报错了：
为什么会编译报错呢？那是因为 3.0 默认被当做 double 类型来处理，占用 8 个字节，前面的 f 变量是 float 类型占用 4 个字节，大容量无法直接赋值给小容量。怎么修改呢？请看代码：
public class DoubleTest {
public static void main(String[] args) {
//float f = 3.0;
//第一种方案
float f = 3.0F;
System.out.println("f = " + f);
//第二种方案
float f1 = (float)3.0;
System.out.println("f1 = " + f1);
}
}运行结果如下图所示：
以上程序的第一种方案在 3.0 后面添加了 F，3.0F 被当做 float 类型来处理。第二种方案是进行了强制类型转换，第二种方案可能会存在精度损失。
今天的课程就到此为止了，咋们明天再见
星空之忆
package bpAutoEncode.multi;
import java.util.ArrayList;
import bpAutoEncode.base.IbpBase;
import tool.Function;
public class BPEncodeMulti implements IbpBase{
private double[][] layer;
private double[][][] weight;
private double[][] error;
private double rate;
public BPEncodeMulti(int features,int feaAfterEncode,double r) {
int layerNum=3;
int[] numberOfLayer=new int[layerNum];
numberOfLayer[0]=numberOfLayer[layerNum-1]=features;
numberOfLayer[layerNum/2]=feaAfterEncode;
init(numberOfLayer, r);
}
public BPEncodeMulti(ArrayList<BPEncodeMulti> models,double r) {
int[] numberOfLayer=new int[models.size()*2+1];
numberOfLayer[models.size()]=models.get(models.size()-1).getMinNodeNum();
int n=numberOfLayer.length;
rate=r;
layer=new double[n][];
weight=new double[n-1][][];
error=new double[n][];
for(int i=0;i<models.size();++i) {
numberOfLayer[i]=numberOfLayer[n-1-i]=models.get(i).getMaxNodeNum();
weight[i]=models.get(i).getZoomOutWeight();
weight[weight.length-1-i]=models.get(i).getZoomInWeight();
}
for(int i=0;i<n;++i) {
layer[i]=new double[numberOfLayer[i]];
error[i]=new double[numberOfLayer[i]];
}
}
public double[][] getZoomInWeight() {
return weight[1];
}
public double[][] getZoomOutWeight() {
return weight[0];
}
public int getMinNodeNum() {
return layer[1].length;
}
public int getMaxNodeNum() {
return layer[0].length;
}
@Override
public void init(int[] numberOfLayer,double r) {
rate=r;
int n=numberOfLayer.length;
layer=new double[n][];
weight=new double[n-1][][];
error=new double[n][];
for(int i=0;i<n;++i) {
layer[i]=new double[numberOfLayer[i]];
error[i]=new double[numberOfLayer[i]];
if(i<n-1) {
weight[i]=new double[numberOfLayer[i]+1][numberOfLayer[i+1]];
for(int j=0;j<numberOfLayer[i]+1;++j)
for(int k=0;k<numberOfLayer[i+1];++k)
weight[i][j][k]=Math.random();
}
}
}
@Override
public double[] computeOut(double[] inp) {
for(int i=1;i<layer.length;++i) {
for(int k=0;k<layer[i].length;++k) {
double z=weight[i-1][layer[i-1].length][k];
for(int j=0;j<layer[i-1].length;++j) {
layer[i-1][j]=i==1?inp[j]:layer[i-1][j];
z+=weight[i-1][j][k]*layer[i-1][j];
}
layer[i][k]=Function.sigmoid(z);
}
}
return layer[layer.length-1];
}
public double[][] computeOut(double[][] inp) {
double[][] result=new double[inp.length][];
for(int i=0;i<inp.length;++i) result[i]=computeOut(inp[i]);
return result;
}
@Override
public void backPropagation(double[] target) {
int i=layer.length-1;
for(int j=0;j<layer[i].length;++j)
error[i][j]=layer[i][j]*(1-layer[i][j])*(target[j]-layer[i][j]);
while(i-->0){
for(int j=0;j<layer[i].length;++j) {
double err=0.0;
for(int k=0;k<layer[i+1].length;++k) {
err+=weight[i][j][k]*error[i+1][k];
weight[i][j][k]+=rate*error[i+1][k]*layer[i][j];
if(j==layer[i].length-1)
weight[i][j+1][k]+=rate*error[i+1][k];
}
error[i][j]=err*layer[i][j]*(1.0-layer[i][j]);
}
}
}
public void trainModel(double[][] inp,double p) {
int xn=0;
double tmp;
while(true) {
for(int i=0;i<inp.length;++i) {
computeOut(inp[i]);
backPropagation(inp[i]);
}
tmp=reportModel(inp, p);
++xn;
if(tmp>1.0-p) return;
if(xn%10000==0) p+=0.01;
}
}
public static ArrayList<BPEncodeMulti> getTrainModel(double[][] inp,double rate,double p) {
ArrayList<BPEncodeMulti> result=new ArrayList<BPEncodeMulti>();
int max=inp[0].length;
int min=(int) Math.sqrt(max);
min+=(max-min)%4;
int n=(max-min)/4;
System.out.println(n);
double[][] in=inp;
for(int i=0;i<n;++i) {
BPEncodeMulti bpEncodeMulti=new BPEncodeMulti(max-4*i, max-4*(i+1), rate);
bpEncodeMulti.trainModel(in, p);
System.out.print(bpEncodeMulti.reportModel(in喵uteEncodeDataSet(in, tmp);
in=tmp;
result.add(bpEncodeMulti);
System.out.println("\t第"+(i+1)+"个子模型*.");
}
return result;
}
public static double repModel(ArrayList<BPEncodeMulti> model,double[][] inp,double p) {
System.out.println(model.size());
int count=0;
for(double[] in : inp) {
double[] a=in;
for(int i=0;i<model.size();++i) {
double[] tmp=new double[model.get(i).getMinNodeNum()];
model.get(i).computeEncodeData(a, tmp);
a=tmp;
}
for(int i=model.size()-1;i>=0;--i)
a=model.get(i).computeDecodeData(a);
if(compare(a, in, p)) ++count;
}
return count/(double)inp.length;
}
public void computeEncodeData(double[] inp,double[] result) {
computeOut(inp);
for(int i=0;i<result.length;++i) result[i]=layer[layer.length/2][i];
}
public void computeEncodeDataSet(double[][] inp,double[][] dataSet) {
for(int i=0;i<inp.length;++i)
computeEncodeData(inp[i], dataSet[i]);
}
public double[] computeDecodeData(double[] inp) {
for(int i=layer.length/2+1;i<layer.length;++i) {
for(int k=0;k<layer[i].length;++k) {
double z=weight[i-1][layer[i-1].length][k];
for(int j=0;j<layer[i-1].length;++j) {
layer[i-1][j]=i==2?inp[j]:layer[i-1][j];
z+=weight[i-1][j][k]*layer[i-1][j];
}
layer[i][k]=Function.sigmoid(z);
}
}
return layer[layer.length-1];
}
public double[][] computeDecodeDataSet(double[][] inp) {
double[][] result=new double[inp.length][];
for(int i=0;i<result.length;++i) result[i]=computeDecodeData(inp[i]);
return result;
}
public double reportModel(double[][] inp,double p) {
int count=0;
for(int i=0;i<inp.length;++i) {
double[] result=computeOut(inp[i]);
//System.out.println(Arrays.toString(inp[i])+"\t"+Arrays.toString(result));
//System.out.println(Arrays.toString(result));
if(compare(result, inp[i], p)) ++count;
}
return count/(double)inp.length;
}
public static boolean compare(double[] a1,double[] a2,double p) {
double err=0.0;
for(int i=0;i<a1.length;++i)
err+=Math.pow(a1[i]-a2[i],2.0);
err/=a1.length;
if(err<p) return true;
else return false;
}
}
点赞0
评论
GodeyesJava学习教程（第一章）[介绍java]：https://shequ.codemao.cn/community/281707
java学习教程（第二章）[java的注释]：https://shequ.codemao.cn/community/281722
Java（第三章）[编写第一个java程序]：https://shequ.codemao.cn/community/281753
Java（特殊篇）[运行和编译java程序]：https://shequ.codemao.cn/community/281785
Java学习教程（第四章）[标识符与关键字]：https://shequ.codemao.cn/community/282020
Java学习教程（第五章）[变量]{1.字面量}:https://shequ.codemao.cn/community/282531
Java学习教程（第五章）[变量]{变量概述}:https://shequ.codemao.cn/community/283059
Java学习教程（第五章）[变量]{使用变量}：https://shequ.codemao.cn/community/283194
[教程帖]Java学习教程第五章[变量]{变量分类}：https://shequ.codemao.cn/community/283732
[教程帖]Java学习教程（第五章）[变量]{变量作用域和章节总结}:https://shequ.codemao.cn/community/283745
[教程帖]Java学习教程（第六章）[数据类型]{数据类型概述}:https://shequ.codemao.cn/community/284512
[教程帖]Java学习教程（第六章）[数据类型]{字符编码}:https://shequ.codemao.cn/community/285286
[教程帖]Java学习教程（第六章）[数据类型]{字符型详解 理解}：https://shequ.codemao.cn/community/286136
[教程帖]Java学习教程（第六章）[数据类型]{整数型详解（理解）}:https://shequ.codemao.cn/community/289851
[教程帖]Java学习教程（第六章）[数据类型]{布尔型详解（理解）}:https://shequ.codemao.cn/community/290606
[教程帖]Java学习教程（第六章）[数据类型]{ 浮点型详解（理解）}:https://shequ.codemao.cn/community/291409
点赞0
评论
