ZHUNH

hi there, my friend

0%

发表于 更新于 分类于 本文字数： 124 阅读时长 ≈ 1 分钟

1.安装

1
yum install nginx

安装目录：/usr/sbin 配置目录：/etc/nginx

阅读全文 »

发表于 更新于 分类于 本文字数： 189 阅读时长 ≈ 1 分钟

关于docker使用，每个image可以去docker官网查看使用说明，包括环境变量等配置。 例如https://hub.docker.com/_/zookeeper/。 docker-compose安装https://docs.docker.com/compose/install/

1.查看网络

1
2
docker network ls
docker network inspect [网络id]

发表于 更新于 分类于 本文字数： 397 阅读时长 ≈ 1 分钟

1.Session对象

  • run(fetched, feed_dict=None, options=None, run_metadata=None)

    fetches: 表示数据流图中能接收的任意数据流图元素，各类Op/Tensor对象

    feed_dict:可选。给数据流图提供运行时数据。feed_dict的数据结构为python中的字典，其元素为各种键值对。

    options: ## 2. 常用 tf 函数

1
result = tf.equal(tf.sign(p - 0.5), tf.sign(t - 0.5))
  1. tf.equal 判断两个参数的值是否相等
  2. tf.sign 用于取出正负符号 
    1
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
  3. tf.cast 把布尔值转换为1或0。
  4. tf.reduce_mean 是对向量(更多的是多维数组)的各个组成元素求平均值的函数。

发表于 更新于 分类于 本文字数： 5.8k 阅读时长 ≈ 5 分钟

[toc]

1.vue中组件之间的通讯方式

1.父 -> 子 使用prop

子组件Pack.vue

1
2
3
4
5
6
7
8
9
10
11
12
<template>
  <div>
    <el-card>
      <p>{{ k }}</p>
    </el-card>
  </div>
</template>
<script>
export default {
    props:['k']
}
</script>

父组件

1
<bike k="你好" />

2.子 -> 父 使用$emit 触发自定义事件

子组件 Pack.vue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<template>
  <div>
    <el-card>
      <el-button @click="childMethod">点击触发父组件事件</el-button>
    </el-card>
  </div>
</template>
<script>
export default {
  data() {
    return {
      name: "Mok"
    };
  },
  methods: {
    childMethod() {
      this.$emit("tmpMethodParam", this.name);
    },
  },
};
</script>

父组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<template>
  <div>
    <el-row>
      <el-card title="子组件->父组件">
        <p><small>name：</small>{{ name }}</p>
        <pack @tmpMethodParam="parentMethod" />
      </el-card>
    </el-row>
  </div>
</template>
<script>
import pack from "./components/Pack";
export default {
  data() {
    return {
        name:"default name."
    };
  },
  components: {
    pack
  },
  methods: {
    parentMethod(name) {
      this.name = name
    },
  }
};
</script>

3.其他方式 中央事件管理器vuex

见第二节。

4.如果是页面路由组件 ？ Vue

5.eventBus

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 定义eventBus    ./eventBus/index.js
import Vue from 'vue'
export const eventBus = new Vue()
//或者在main.js直接定义：
Vue.prototype.$EventBus = new Vue()
// 在一个组件中调用
import {eventBus} from "@/eventBus"
export default {
    methods: {
        eventBusTest(){
            eventBus.$emit("changeName", {
                msg:"组件2发送事件"
            })
        }
    }
}
//在另一个组件中监听执行
import {eventBus} from "@/eventBus"
export default {
  mounted(){
      eventBus.$on("changeName",({msg})=>{
          alert(msg)
      })
  }
};

2.vuex 的简介

vue 官方提供的 状态管理器 整个项目中需要在多个地方共享的数据存放在同一的位置进行管理

vuex定义使用

（1）state：存放状态

1
2
3
4
5
6
7
8
9
10
11
12
//定义
const state = {
  personName: 'Rick',
}
//调用
this.$store.state.personName
//使用mapState辅助函数调用
import { mapState } from 'vuex'
computed: {
	...mapState(["personName"])
	//作为子模块...mapState(["orange"]) =》使用 orange.personName
}

（2）getters：加工states成员给外界

1
2
3
4
5
6
//定义
const getters = {
  personName: state => state.orange.personName + " today."
}
//调用
this.$store.getters.personName

（3）mutations： state成员操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//定义
const mutations = {
    setPersonName: (state, payload) => {
    state.personName = payload.newName
  }
}
//调用
this.$store.commit("setPersonName", { newName: "Happy" });
//如果定义了子模块，orange为子模块名
this.$store.commit("orange/setPersonName", { newName: "Happy" });
//或者这样，没试过
store.commit({
  type: 'increment',
  amount: 10
})

​ mutations必须是同步函数。提交 mutation 是更改状态的唯一方法。

（4）actions：异步操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//注册
actions: {
  setPersonName (context) {
    context.commit('setPersonName')
  }
}
//通常参数解构context，以下模拟一个异步操作
const actions = {
    setPersonNameAsync: ({commit, state})=>{
        setTimeout(()=>{
            // 获取数据
            let data = { newName: "HAHAH" }
            // 执行mutations
            commit('setPersonName', data)
        },1000)
    }
}
// 分发，Action 通过 store.dispatch 方法触发：
store.dispatch('setPersonName')

​ Action 函数接受一个与 store 实例具有相同方法和属性的 context 对象，因此你可以调用 context.commit 提交一个 mutation，或者通过 context.state 和 context.getters 来获取 state 和 getters。

​ Action 提交的是 mutation，而不是直接变更状态，异步逻辑都应该封装到 action 里面。

（5）modules：模块化状态管理

./store/modules/orange.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
const state = {
  personName: 'Rick',
}

const mutations = {
    setPersonName: (state, payload) => {
    state.personName = payload.newName
  }
}

const actions = {
    setPersonNameAsync: ({commit, state})=>{
        setTimeout(()=>{
            // 获取数据
            let data = { newName: "HAHAH" }
            // 执行mutations
            commit('setPersonName', data)
        },1000)
    }
}

export default {
  namespaced: true,
  state,
  mutations,
  actions
}

./store/getters.js

1
2
3
4
const getters = {
  personName: state => state.orange.personName + " today."
}
export default getters

./store/index.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import Vue from 'vue'
import Vuex from 'vuex'
import getters from './getters'
import orange from './modules/orange'

Vue.use(Vuex)

const store = new Vuex.Store({
  modules: {
    app,
    settings,
    user,
    orange
  },
  getters
})

export default store

main.js

1
2
3
4
5
6
7
8
9
import Vue from 'vue'
import store from './store'
...
new Vue({
  el: '#app',
  router,
  store,
  render: h => h(App)
})

什么时候需要用vuex

1.使用了 vue- router,并且多个路由之间需要共享数据的时候

2.页面数据太多难以管理

使用vuex

（1）安装 vuex npm install --save vuex

（2）在 src 目录下创建一个 store/index.js 文件

​ 思考项目的哪些数据要放到仓库中；

（3）需要在 main.js 中，也就是 new Vue 的时候，配置 store 这个选项，选项的值就是 store 的实例对象

（4）如何使用仓库的数据

​ 使用 mapState 辅助函数；

（5）如何在组件中修改仓库的数据

​ 首先在仓库的 mutations 中定义一个修改 state 的方法；

​ 组件中使用 mapMutations 辅助函数；

3.特殊情况

1
2
3
4
1. $root 获取到根组件的实例对象
2. $parent	获取父组件的实例对象
3. $children	获取子组件的实例对象

ref调用子组件方法

子组件方法定义 使用\(refs 获取具体某个子组件的实例或者具体html元素的真实dom（常用） （1）首先需要标记。你想要获取的组件或者html元素，在他们身上定义一个 ref="xxx" （2）然后 this.\)refs.xxx （3）如果 ref 标记的是普通html元素，那么到通过 $refs.xxx 得到的将是这个html元素的dom对象 （4）如果 ref 标记的是一个子组件。那么通过 $refs.xxx 得到的将是这个子组件的实例对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<template>
  <div>
      <span>子组件2</span>
  </div>
</template>
<script>
export default {
    methods: {
        sayHi(){
            alert("bike组件哈哈")
        }
    }
}
</script>

父组件调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//定义ref
<bike ref="bike"/>
import bike from "./components/Bike";
export default {
  components: {
    bike
  },
  methods: {
    refTest(){
        // 在父组件调用子组件方法
        this.$refs['bike'].sayHi()
    }
  }
};

发表于 更新于 分类于 本文字数： 4k 阅读时长 ≈ 4 分钟

  1. 定义proto文件text1.proto

    定义消息类型：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    syntax = "proto3" ;

    message Test{
        //姓名
        string name = 1;
        //体重
        repeated int32 weight = 2 ;
        //身高
        int32 height =3 ;
        //性别
        string sex = 4 ;
    }

  2. 使用protocol buffer编译器执行以下命令来运行.proto文件，编译器将生成所选语言的代码，这些代码可以操作在.proto文件中定义的消息类型，包括获取、设置字段值，将消息序列化到一个输出流中，以及从一个输入流中解析消息。对go来说，编译器会为每个消息类型生成一个.pb.go文件。

    1
    2
    $ protoc --go_out=./ *.proto  #不添加grpc插件
    $ protoc --go_out=plugins=grpc:./ *.proto #添加grpc插件

    执行以上命令会将text1.proto文件编译生成以文件text1.pb.go，内容如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    // Code generated by protoc-gen-go. DO NOT EDIT.
    // source: text1.proto

    package text1

    import (
    	fmt "fmt"
    	proto "github.com/golang/protobuf/proto"
    	math "math"
    )

    // Reference imports to suppress errors if they are not otherwise used.
    var _ = proto.Marshal
    var _ = fmt.Errorf
    var _ = math.Inf

    // This is a compile-time assertion to ensure that this generated file
    // is compatible with the proto package it is being compiled against.
    // A compilation error at this line likely means your copy of the
    // proto package needs to be updated.
    const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

    type Test struct {
    	//姓名
    	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
    	//体重
    	Weight []int32 `protobuf:"varint,2,rep,packed,name=weight,proto3" json:"weight,omitempty"`
    	//身高
    	Height int32 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
    	//性别
    	Sex                  string   `protobuf:"bytes,4,opt,name=sex,proto3" json:"sex,omitempty"`
    	XXX_NoUnkeyedLiteral struct{} `json:"-"`
    	XXX_unrecognized     []byte   `json:"-"`
    	XXX_sizecache        int32    `json:"-"`
    }

    func (m *Test) Reset()         { *m = Test{} }
    func (m *Test) String() string { return proto.CompactTextString(m) }
    func (*Test) ProtoMessage()    {}
    func (*Test) Descriptor() ([]byte, []int) {
    	return fileDescriptor_c52d883d2746fb54, []int{0}
    }

    func (m *Test) XXX_Unmarshal(b []byte) error {
    	return xxx_messageInfo_Test.Unmarshal(m, b)
    }
    func (m *Test) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    	return xxx_messageInfo_Test.Marshal(b, m, deterministic)
    }
    func (m *Test) XXX_Merge(src proto.Message) {
    	xxx_messageInfo_Test.Merge(m, src)
    }
    func (m *Test) XXX_Size() int {
    	return xxx_messageInfo_Test.Size(m)
    }
    func (m *Test) XXX_DiscardUnknown() {
    	xxx_messageInfo_Test.DiscardUnknown(m)
    }

    var xxx_messageInfo_Test proto.InternalMessageInfo

    func (m *Test) GetName() string {
    	if m != nil {
    		return m.Name
    	}
    	return ""
    }

    func (m *Test) GetWeight() []int32 {
    	if m != nil {
    		return m.Weight
    	}
    	return nil
    }

    func (m *Test) GetHeight() int32 {
    	if m != nil {
    		return m.Height
    	}
    	return 0
    }

    func (m *Test) GetSex() string {
    	if m != nil {
    		return m.Sex
    	}
    	return ""
    }

    func init() {
    	proto.RegisterType((*Test)(nil), "Test")
    }

    func init() { proto.RegisterFile("text1.proto", fileDescriptor_c52d883d2746fb54) }

    var fileDescriptor_c52d883d2746fb54 = []byte{
    	// 110 bytes of a gzipped FileDescriptorProto
    	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2e, 0x49, 0xad, 0x28,
    	0x31, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x57, 0x8a, 0xe1, 0x62, 0x09, 0x49, 0x2d, 0x2e, 0x11,
    	0x12, 0xe2, 0x62, 0xc9, 0x4b, 0xcc, 0x4d, 0x95, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x02, 0xb3,
    	0x85, 0xc4, 0xb8, 0xd8, 0xca, 0x53, 0x33, 0xd3, 0x33, 0x4a, 0x24, 0x98, 0x14, 0x98, 0x35, 0x58,
    	0x83, 0xa0, 0x3c, 0x90, 0x78, 0x06, 0x44, 0x9c, 0x59, 0x81, 0x11, 0x24, 0x0e, 0xe1, 0x09, 0x09,
    	0x70, 0x31, 0x17, 0xa7, 0x56, 0x48, 0xb0, 0x80, 0x8d, 0x00, 0x31, 0x93, 0xd8, 0xc0, 0x96, 0x18,
    	0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xa5, 0x53, 0x6d, 0x33, 0x73, 0x00, 0x00, 0x00,
    }

  3. 定义服务（Service）

    如果想要将消息类型用在 RPC（远程过程调用）系统中，可以在.proto文件中定义一个RPC服务接口，protocol buffe 编译器将会根据所选择的不同语言生成服务接口代码及存根。如想要定义一个RPC服务并具有一个方法，该方法能够接收SearchRequest并返回一个SearchResponse，此时可在.proto文件中进行如下定义：

    1
    2
    3
    4
    service SearchService {
    	//rpc 服务的函数名 （传入参数） 返回 （返回参数）
    	rpc Search (SearchRequest) returns (SearchResponse);
    }

发表于 更新于 分类于 本文字数： 1.6k 阅读时长 ≈ 1 分钟

1.PoW 工作量证明算法

矿工根据难度系数值，进行随机数运算找到符合条件的解，找到解的旷工即获得记账权。

特点：耗费巨大计算资源，最终体现为电力资源的浪费。

2.POS 股权证明算法

根据股权占比来决定记账权，即股权占比最高的节点获得记账权 。

PoS基于网络参与者目前所持有的数字货币的数量和时间进行利益分配，是一种对货币所有权的证明，PoS依赖于其区块链自身的代币，在不同的代币系统，PoS算法往往有不同的表达形式。

###2.DPOS 股权授权证明算法

授权股份证明算法(Delegated proof-of-stake, DPoS).DPoS共识的基本思路类似于“董事会决策”,即系统中每个节点可以将其持有的股份权益作为选票授予一个代表,获得票数最多且愿意成为代表的前N个节点将进入“董事会”,按照既定的时间表轮流对交易进行打包结算、并且签署(即生产)新区块.如果说 PoW 和 PoS 共识分别是 “算力为王” 和 “权益为王” 的记账方式 的话, DPoS 则可以认为是 “民主集中式” 的记账方式, 其不仅能够很好地解决 PoW 浪费能源和联合挖 矿对系统的去中心化构成威胁的问题, 也能够弥补 PoS 中拥有记账权益的参与者未必希望参与记账的缺点, 其设计者认为 DPoS 是当时最快速、最高效、最去中心化和最灵活的共识算法.

股份授权证明机制(DPOS,Delegated Proof of stake)又称为“股东代表机制”，将拥有一定数量的 代币的每个节点看作为股东，各个节点根据持有的代币的数量做出定量的投票，最后选出定量的节点。这些节点作为代表，轮流生成区块，同时其代表们 也会收到等同于一个平均水平的 区块所包含交易费的10%作为报酬。如果一些代表在生成区块的过程中发现了问题，股东将会重新投票，并选取新 的代表进行替换。

代表EOS。

3.PBFT 实用拜占庭容错算法

参考博客：https://blog.csdn.net/jfkidear/article/details/81275974

PBFT算法由于每个副本节点都需要和其他节点进行P2P的共识同步，因此随着节点的增多，性能会下降的很快，但是在较少节点的情况下可以有不错的性能，并且分叉的几率很低。PBFT主要用于联盟链，但是如果能够结合类似DPOS这样的节点代表选举规则的话也可以应用于公联，并且可以在一个不可信的网络里解决拜占庭容错问题，TPS应该是远大于POW的。

PBFT论文地址：http://pmg.csail.mit.edu/papers/osdi99.pdf

将拜占庭将军问题根据常见的工作上的问题进行简化：假设将军中没有叛军，信使的信息可靠但有可能被暗杀的情况下，将军们如何达成一致性决定？出现Paxos和Raft两种共识算法

4.Paxos

角色介绍

  • Client

    请求发起者。系统外部角色

  • Proposer

    接收client的请求，向集群提出提议。起到冲突调节的作用。

  • Acceptor

    提议投票和接受者，只在形成法定人数（多数派）时，提议才会最终被接受。

  • Learner

    提议接受者，备份，对集群一致性没有影响（不参与投票）

步骤和阶段

  • Prepare

    Proposer提出一个提案，编号为N，此N大于这个Proposer之前提出的提案编号，请求acceptors的quorum接受。

  • Promise

    如果N大于此proposer之前接收的任何提案的编号则接受，否则拒绝。

  • Accept

    如果达到了多数派，proposer会发出accept请求，此请求包含提案编号N，以及提案内容。

  • Accepted

    如果此proposer在此期间没有收到任何编号大于N的提案，则接受此提案内容，否则忽略。

###5.Raft

角色定义

  • Leader
  • Follower
  • Candidate

参考文章：https://www.jianshu.com/p/8e4bbe7e276c

###总结各共识算法的特点

算法 特点
PBFT 达成共识速度快，适用于节点少的分布式系统
DPOS 要求系统有代表权益的代币，而且由于权益的争夺，会极大减少代币的流动性

发表于 更新于 分类于 本文字数： 525 阅读时长 ≈ 1 分钟

1. 将caliper拉取到本地

1
git clone https://github.com/hyperledger/caliper.git

2.构建环境

1
2
3
4
5
6
7
cd caliper
npm install
#如果本机是Python3环境，换成Python2
npm run repoclean  
#备份当前目录下package.json
npm run bootstrap  
#这一步卡住的话ctr+c终止，将备份的package.json覆盖当前pakage.json再执行npm run bootstrap

3. benchmark环境构建，安装caliper-cli

1
2
3
4
5
6
7
8
cd ./packages/caliper-tests-integration
npm run start_verdaccio
#我的是macos，这一步会卡住，pm2启动不了verdaccio，那么直接执行以下命令：
pm2 start verdaccio -- -l 0.0.0.0:4873 -c scripts/config.yaml
此时启动成功，接着发布包：
npm run publish_packages
安装包：
npm run install_cli

4. 测试

1
BENCHMARK=fabric npm run run_tests

发表于 更新于 分类于 本文字数： 159 阅读时长 ≈ 1 分钟

集成算法

1.Bagging

​ 训练多个分类器取平均。 ​ 代表算法：随机森林，随机森林尽量使得所有决策树之间有差异性，通过两个随机选择来构造有差异的决策树：

  • 数据随机采样
  • 属性（特征）选择随机

2.Boosting

​ 对多个弱学习器加权训练

  • Adaboosting
  • Xgboosting

3.Stacking：分阶段聚合多个分类或回归模型

发表于 更新于 分类于 本文字数： 1.6k 阅读时长 ≈ 1 分钟

1.what？

  • etcd是CoreOS团队2013年6月发起的开源项目。
  • 它是一个强一致性的分布式键值数据库，基于go语言实现。
  • 用来存储需要由分布式系统或机器集群访问的数据。
  • 一个应用是将数据库连接详细信息或功能标志作为键值对存储在etcd中，并watch这些值，以便值改变时应用程序可以自行重新配置。
    阅读全文 »

发表于 更新于 分类于 本文字数： 1.9k 阅读时长 ≈ 2 分钟

1.zk客户端操作

在zk安装bin目录运行zkCli.sh脚本进入zk客户端

1
2
./bin/zkCli.sh -timeout 5000 -r -server zk1:2181
./bin/zkCli.sh -timeout 5000 -r -server zk2:2181
阅读全文 »