精华内容
下载资源
问答
  • 他在演讲中简要讨论了一系列实施微服务的先决条件,这些先决条件是每个组织在考虑大规模采用微服务架构之前应该要具备的。在这篇文章里,Phil详细地解释了这些先决条件。当你决定采用微服务,你将经历从单一应用到一...
  • J ava基础复习一、理解new ...如果出现这种情况,就会发生运行时异常(你将在第10章学习如何处理这种异常以及其他异常情况)。对于本书中示例程序,你不必担心内存不足情况,但是在实际编程中你必须考虑这种...

    J ava基础复习

    一、理解new 运算符:

    理解new运算符是在运行期间为对象分配内存的是很重要的。这样做的好处是你的程

    序在运行期间可以创建它所需要的内存。但是,内存是有限的,因此new有可能由于内存不足而无法给一个对象分配内存。如果出现这种情况,就会发生运行时异常(你将在第10

    章学习如何处理这种异常以及其他异常情况)。对于本书中的示例程序,你不必担心内存

    不足的情况,但是在实际的编程中你必须考虑这种可能性。

    二、类和对象之间的区别:

    让我们再次复习类和对象之间的区别。类创建一种新的数据类型,该种类型能被用来

    创建对象。也就是,类创建了一个逻辑的框架,该框架定义了它的成员之间的关系。当你声明类的对象时,你正在创造该类的实例。因此,类是一个逻辑构造,对象有物理的真实性(也就是对象占用内存空间)。弄清楚这个区别是很重要的。

    三、区分自变量和参数两个术语:

    区分自变量(parameter)和参数(argument)这两个术语是很重要的。自变量是方法

    定义的一个变量,当方法被调用时,它接收一个值。例如在square()中,i就是一个自变量。参数是当一个方法被调用时,传递给该方法的值。例如,square(100)把100作为参数传递。在square()中,自变量i接收该值。

    四、构造函数的理解

    构造函数(constructor)在对象创建时初始化。它与它的类同名,它的语法与方法类似。一旦定义了构造函数,在对象创建后,在new运算符完成前,构造函数立即自动调用。构造函数看起来有点奇怪,因为它没有任何返回值,即使是void型的值也不返回。这是因为一个类的构造函数内隐藏的类型是它自己类的类型。构造函数的任务就是初始化一个对象的内部状态,以便使创建的实例变量能够完全初始化,可以被对象马上使用。

    五、this关键字的理解:

    你知道,在同一个范围或一个封装范围内,定义二个重名的局部变量在Java中是不合法的。有趣的是,局部变量,包括传递到方法的正式的自变量,可以与类的实例变量的名

    展开全文
  • 先决条件 Python3.6 Django MVC框架 HTML,CSS和Bootstrap PostgreSQL 设置/安装 $ git clone $ cd hoodApp $ source virtual / bin / activate $通过运行命令pip3 install -r requirements.txt安装所有将为应用...
  • 修改汉诺塔的规则,从左到右或者从右到做必须经过中间,也就是说实际动作只有4个...例如如果是7层塔,最初所有的塔都在LS上,LS从栈顶到栈底依次是1-7,一个动作能发生的先决条件是不违反小压大的原则。那么,form栈弹

    修改汉诺塔的规则,从左到右或者从右到做必须经过中间,也就是说实际动作只有4个:左到中、中到右、右到中和中到左。现在我们把左中右三个地点抽象成栈,依次记为LS、MS和RS。假设最初所有的塔都在LS上,4个动作其实是将一个栈的栈顶元素弹出然后压入到另一个栈的过程。

    例如如果是7层塔,最初所有的塔都在LS上,LS从栈顶到栈底依次是1-7,一个动作能发生的先决条件是不违反小压大的原则。那么,form栈弹出的元素num如果想压入到to栈中,那么num的值必须小于当前to栈的栈顶。还有一个原则为相邻不可逆原则,解释如下:

    1.我们把四个动作依次定义为L->M、M->L、M->R、R->M;

    2.很明显,L->M和M->L为可逆过程。

    3.在这个修改过的汉诺塔游戏中,如果想走出最少的步数,那么两个相邻动作绝不可以是互逆过程。

    根据以上两个原则可以退出两个结论:

    1.游戏的第一步动作一定是L->M

    2.在整个过程中为了不违反以上两个原则,四个动作只有一个合适,另外三个都会违反以上两个原则。

    综上所述,每一步只有一个动作达标,那么只要每一步都根据这两个原则来动就行了。

    实现代码:

    package algorithm_6_2;
    
    import java.util.Stack;
    
    public class algorithm_6_2 {
    	public enum Action{
    		No, LToM,MToL,MToR,RToM
    	}
    	static public int hanoiProblem2(int num, String left, String mid, String right){
    		Stack<Integer> lS = new Stack<Integer>();
    		Stack<Integer> mS = new Stack<Integer>();
    		Stack<Integer> rS = new Stack<Integer>();
    		lS.push(Integer.MAX_VALUE);
    		mS.push(Integer.MAX_VALUE);
    		rS.push(Integer.MAX_VALUE);
    		for (int i =num; i>0;i--){
    			lS.push(i);
    		}
    		Action[] record = { Action.No };
    		int step = 0;
    		while(rS.size() != num +1){
    			step += fStackToStack(record, Action.MToL, Action.LToM, lS, mS, left, mid);
    			step += fStackToStack(record, Action.LToM, Action.MToL, mS, lS, mid, left);
    			step += fStackToStack(record, Action.RToM, Action.MToR, mS, rS, mid, right);
    			step += fStackToStack(record, Action.MToR, Action.RToM, rS, mS, right, mid);
    		}
    		return step;
    	
    	}
    	private static int fStackToStack(Action[] record, Action preNoAct, Action nowAct, Stack<Integer> fstack, Stack<Integer> tstack,
    			String from, String to) {
    		if(record[0] !=preNoAct && fstack.peek() < tstack.peek()){
    			tstack.push(fstack.pop());
    			System.out.println("Move " + tstack.peek() + " from " + from + " to " + to);
    			record[0] = nowAct;
    			return 1;
    		}
    		return 0;
    	}
    	public static void main(String[] args) {
    		String str1 = "left";
    		String str2 = "mid";
    		String str3 = "right";
    		hanoiProblem2(3, str1, str2, str3);
    	}
    }
    

    结果:

    Move 1 from left to mid
    Move 1 from mid to right
    Move 2 from left to mid
    Move 1 from right to mid
    Move 1 from mid to left
    Move 2 from mid to right
    Move 1 from left to mid
    Move 1 from mid to right
    Move 3 from left to mid
    Move 1 from right to mid
    Move 1 from mid to left
    Move 2 from right to mid
    Move 1 from left to mid
    Move 1 from mid to right
    Move 2 from mid to left
    Move 1 from right to mid
    Move 1 from mid to left
    Move 3 from mid to right
    Move 1 from left to mid
    Move 1 from mid to right
    Move 2 from left to mid
    Move 1 from right to mid
    Move 1 from mid to left
    Move 2 from mid to right
    Move 1 from left to mid
    Move 1 from mid to right

    展开全文
  • 先决条件 本节概述了收集使用此软件所需令牌,密钥和凭据过程。 它分为两部分:Twitch设置和Philips Hue设置。 抽搐设置 为了运行服务器并连接到Twitch,您将需要一些凭证。 使用以下属性创建一个新: 姓名 ...
  • 在API容器方面提供冗余:如果容器发生故障,传入请求将被重定向到另一个正在运行实例。 容器之间协调:Swarm将在API之间进行协调,并选择其中一个以监听传入请求。 扩展推理服务,以便获得更快预测,...
  • 在API容器方面提供冗余:如果容器发生故障,传入请求将被重定向到另一个正在运行实例。 容器之间协调:Swarm将在API之间进行协调,并选择其中一个以监听传入请求。 扩展推理服务,以便获得更快预测,...
  • 在API容器方面提供冗余:如果容器发生故障,传入请求将被重定向到另一个正在运行实例。 容器之间协调:Swarm将在API之间进行协调,并选择其中一个以监听传入请求。 扩展推理服务,以便获得更快预测,...
  • 食品商店 使用Ionic和Firebase,这是一个实时美食广场应用程序...先决条件 Node.js 科尔多瓦 离子性 凉亭 安装 克隆此存储库 $ git clone https://github.com/mjunaidsalaat/TheFoodShop.git $ cd TheFoodShop $ bowe
  • 不了解应用程序技术框架,目前演示了完全相同的管道定义中发生的aspnetcore和nodejs构建。 AWS中的部署架构 ,具有用于运行Jenkins的受管节点池和用于在无服务器节点池中运行应用程序。 用于存储Jenkins主目录。 ...
  • 随着社会信息化进程步伐加快,人们对现代建筑观念和要求也发生了变化,智能大楼出现为传统建筑注入了全新概念,并成为现代建筑发展方向,而结构化综合布线系统是实现大楼智能化基础和先决条件
  • 随着社会信息化进程步伐加快,人们对现代建筑观念和要求也发生了变化,智能大楼出现为传统建筑注入了全新概念,并成为现代建筑发展方向,而结构化综合布线系统是实现大楼智能化基础和先决条件
  • 随着社会信息化进程步伐加快,人们对现代建筑观念和要求也发生了变化,智能大楼出现为传统建筑注入了全新概念,并成为现代建筑发展方向,而结构化布线">综合布线系统是实现大楼智能化基础和先决条件
  • 贝叶斯公式理解

    2017-12-10 21:41:04
    1.贝叶斯应用的先决条件 结果是独立事件并且是互斥事件; 2. 条件贝叶斯的适用范围 根据先验概率和已知的信息求后验概率, 3. 贝叶斯的知识预备 3.1 条件概率 在条件B发生的情况下,得出事件A发生的概率; 根据...

    刚学习贝叶斯时,不太理解,看了视频和2本书籍后完全理解了,分享你,看是否有帮助,

    条件贝叶斯

    1.贝叶斯应用的先决条件

    结果是独立事件并且是互斥事件;

    2. 条件贝叶斯的适用范围

    根据先验概率和已知的信息求后验概率,

    3. 贝叶斯的知识预备

    3.1 条件概率

    在条件B发生的情况下,得出事件A发生的概率;
    根据集合图知道;
    贝叶斯公式的理解

    P(A|B)=P(A∩B) / P(B)

    3.2 全概率公式

    全概率的公式
    A={面试成功}
    B1={到A公司面试}
    B2={到B公司面试}
    B3={到C公司面试}
    P(B1)=0.7; P(A|B1)=0.5; [小明有0.7的概率选择A公司面试,成功率为0.5]
    P(B2)=0.2; P(A|B2)=0.7
    P(B3)=0.1, P(A|B3)=0.3
    P(A)=P(A|B1)P(B1)+P(A|B2)P(B2)+P(A|B3)P(B3)
    =0.70.5+0.20.7+0.1*0.3=0.52

    4. 贝叶斯公式

    4.1 贝叶斯公式

    P(A|B) = P(A|B1)P(B1) / [P(A|B1)P(B1)+ P(A|B2)+P(B2)+...]
    其中:
    P(A|B1) 和P(A|B2) 是先验概率;
    P(B1), P(B2) 是已知的信息;
    分母本质就是一个全概率公式;

    4.2 贝叶斯公式的推导

    P(A|B)=P(A∩B)/P(B)
    根据加法公式的推导得到: P(A∩B)= P(A|B1)P(B1)
    P(B) = P(A∩B1)+ P(A∩B2)
    P(A|B) = P(A|B1)
    P(B1) / [P(A|B1)*P(B1)+ P(A|B2)+P(B2)]

    4.3 贝叶斯的难点

    就是把文字和描述转换成贝叶斯公式;

    4.4 贝叶斯的举例

    例1: 学生的试卷是否及格

    根据学生考试成绩来统计, 事件A 表示成绩来自男生; 事件B表示成绩来自于女生; P(A)=60%, P(B)=40%, 另外: S表示成绩合格, F表示成不合格;
    给出的条件概率:
    P(S|A)=3/4, P(F|A) = 1/4;
    P(S|B)=5/6, P(F|B) = 1/6;
    求:假设某次考试, 一个同学未写名字和学号, 考试结果是不及格;
    那么请问这份考试是男生和女生的概率分别是多少?
    P(A|F) = [P(A∩F)]/ P(F) = [0.61/4 ] / [0.61/4 + 0.41/6] =0.6923
    P(B|F) = [P(B∩F)]/ P(F) =P(F|B
    P(B) /[ P(F|BP(B) + P(F|AP(B)) ]
    = (1/60.4) / (1/60.4 + 1/4*0.4)
    = 0.3077
    说明: 该成绩是男生的概率是 69.23%, 是女生的概率是 30.77%;

    转载于:https://blog.51cto.com/emars/2049203

    展开全文
  • 先决条件 Python 3(在完全支持之前,Apache Beam可能仍会记录警告) 用于转换Doc(x)文件 管道 例如,转换管道可能如下所示: 有关当前示例实现,请参见下文。 简单管道 存在一个简单非Apache Beam特定管道...
  • YOLOv4-v3 Darknet GPU推理API 这是使用Yolov4 Darknet框架对象检测推理API存储库。 该存储库还与Yolov3 darknet模型具有交叉兼容性。 该存储库还支持最新Yolov4模型 ...先决条件 Ubuntu 18
  • 为了开发和构建“ My Dapp”,必须安装以下先决条件: (或任何用于编辑JavascriptIDE) (DappStarter使用) 安装 使用终端(或命令提示符),转到包含项目文件文件夹,然后键入: yarn这将获取所有必需...
  • 系统管理员工具 ... 审核O365用户帐户是否存在HaveIBeenPwned数据库中违规行为,如果最近30天内发生违规行为,则发送电子邮件。 先决条件 HaveIBeenPwned订阅,每月3.5美元,可访问API O365_Licen
  • 为了开发和构建“ My Dapp”,必须安装以下先决条件: (或任何用于编辑JavascriptIDE) (DappStarter使用) ( )(安装后运行flow cadence install-vscode-extension以启用Cadence源文件代码高亮显示) ...
  • 为了开发和构建“ My Dapp”,必须安装以下先决条件: (或任何用于编辑JavascriptIDE) (DappStarter使用) ( )(安装后运行flow cadence install-vscode-extension以启用Cadence源文件代码高亮显示) ...
  • 为了开发和构建“ My Dapp”,必须安装以下先决条件: (或任何用于编辑JavascriptIDE) (DappStarter使用) ( )(安装后运行flow cadence install-vscode-extension以启用Cadence源文件代码高亮显示) ...
  • 需求或先决条件 虽然我会尽量少用数学术语,但这篇文章希望读者熟悉一些概念,比如用户—项目交互矩阵、矩阵分解、嵌入空间,以及基本机器学习术语。这个故事不是介绍推荐系统。这是对它们增量变换介绍。无论...

    2020-04-18 10:06:17

    作者:Dimitris Poulopoulos

    编译:ronghuaiyang

    导读

    推荐系统应该要可以适应发生的变化。

    构建一个增量推荐系统

     

    需求或先决条件

    虽然我会尽量少用数学术语,但这篇文章希望读者熟悉一些概念,比如用户—项目交互矩阵、矩阵分解、嵌入空间,以及基本的机器学习术语。这个故事不是介绍推荐系统。这是对它们的增量变换的介绍。无论如何,这个故事都是针对机器学习和推荐系统领域的初学者的。

    介绍

    启动一个机器学习项目,数据科学家收集数据,处理它们,训练一个模型并将其部署到生产中。当模型的性能开始变差时,数据科学家通常会从头开始重复这个循环。只是这一次,他们有了新的数据来更新模型并提高其性能。然而,这通常是一种反生产实践,也是一种低效的实践,特别是在对当前数据做出决策是至关重要的业务领域。

    现在,进入推荐系统的世界,用户的偏好经常根据季节、预算、时尚趋势等变化。此外,到达的客户和新的库存产生了所谓的冷启动问题,即系统没有足够的信息来匹配消费者与产品或服务。一个推荐系统应该在这些变化发生的时候理想地适应这些变化,修改它的模型以始终代表当前状态,同时需要一次数据传递。这就是增量学习的概念。

    这个故事是这个系列的第一部分,在这个系列中,我们将探索如何将增量学习的思想应用到推荐系统中,并使用实际操作的方法。在第一部分中,我们使用一个基于Pytorch的python库CF Step,重现了Joao Vinagre等人发表的*“Fast incremental matrix factorization for recommendation with positive-only feedback”*中的结果。接下来,我们将通过应用一些技巧来达到更高的目标。

    快速增量矩阵分解

    我们将要实现的算法将使用隐式的、只有正的反馈。让我们试着揭开这两个关键词的神秘面纱。“隐性反馈”指的是,用户从未对他们接触过的内容表达过直接的意见(如评分)。隐式反馈的一个例子是客户购买产品的次数,或者他们看电影的时间。顾客购买产品或使用服务越多,我们就越有信心认为这是一种偏好。只有正的反馈通常与隐式反馈一起出现。这是因为,在隐式反馈的情况下,我们很少知道什么构成了消极的交互。一个用户不与一个项目交互没有什么意义。想象一个超市里的消费者。如果客户还没有购买特定的产品,我们无法确定原因。

    回到我们的实现中,仅为正数意味着用户—物品交互矩阵R只包含布尔值,其中true表示默认值,false表示缺失值。这个假设有两个主要含义,保持R的稀疏性,因为在训练期间只使用正反馈,对于任意的用户—物品交互,false值的地方都是完全有效的推荐候选。

    算法&方案

    现在让我们进一步研究一下本文提出的增量随机梯度下降(ISGD)算法。

    构建一个增量推荐系统

    ISGD — 增量 SGD

    我们拥有的数据是元组或者说用户—物品交互。记住这些都是正的交互。算法的输入是三个数字,feat这是用户或物品嵌入空间的维度,λ,即正则化系数,还有η,学习率。算法的输出是两个嵌入矩阵:用户矩阵A和物品矩阵B。这些矩阵的维数,A是number_of_users x feat,B是number_of_items x feat 。然后我们有几个步骤:

    • 检查活跃用户是否已知。如果不是,则创建一个具有随机潜在特征的新用户,该用户来自均值为0、标准差为1的正态分布。对活跃物品执行相同的操作。
    • 计算损失。因为我们只需要处理正反馈,所以目标总是“1”。因此,我们只需要从“1”中减去我们的预测。
    • 使用通用的更新规则更新活跃用户的潜在特征(用户嵌入矩阵中的参数)。对活跃物品执行相同的操作。
    • 转到下一个数据点。这样,我们就可以处理任意长度的流数据。

    实现&评估

    对于这个实现,我们将使用CF Step Python库和著名的Movielens数据集。CF Step是一个开源的库,用python编写,以Pytorch为基础,支持实现快速增量式学习推荐系统。该库是欧洲研究项目CloudDBAppliance的副产品。你可以很容易地运行以下命令安装库:

    pip install cf-step

    接下来,下载movielens 1m数据集并提取ratings.dat文件放到一个方便的位置,例如,Linux中的tmp文件夹。对于这个实现,我们只需要这个文件。其余的文件(users.dat和movies.dat)包含了用户和电影的元数据。我们使用pandas加载的文件到内存:

    # load the data
    col_names = ['user_id', 'movie_id', 'rating', 'timestamp']
    ratings_df = pd.read_csv('/tmp/ratings.dat', delimiter='::', names=col_names, engine='python')
    
    # transform users and movies to categorical features
    ratings_df['user_id'] = ratings_df['user_id'].astype('category')
    ratings_df['movie_id'] = ratings_df['movie_id'].astype('category')
    
    # use the category codes to avoid creating separate vocabularies
    ratings_df['user_code'] = ratings_df['user_id'].cat.codes.astype(int)
    ratings_df['movie_code'] = ratings_df['movie_id'].cat.codes.astype(int)
    
    ratings_df.head()

    构建一个增量推荐系统

     

    如你所见,我们将用户和电影IDs转换为类别,以便提取类别编码。现在,我们不必为嵌入矩阵的生成创建单独的词汇表。我们只需要处理用户和电影编码,而不是IDs。最后,我们通过这个dataframe在编码和IDs之间建立连接,以查找原始用户和电影。现在,让我们看看我们正在处理的用户和电影的数量。

    n_users = ratings_df['user_code'].max() + 1
    n_movies = ratings_df['movie_code'].max() + 1

    如果我们打印这些数字,我们将看到我们有6040个用户和3706个电影。接下来,我们将按照timestamp对数据进行排序,以模拟流事件。

    data_df = ratings_df.sort_values(by='timestamp')

    如前所述,该算法只支持正反馈。因此,我们将把5的评分视为积极的反馈,并丢弃其他的评分。我们想用1表示喜欢,用0表示不喜欢,并创建一个名为preference的新列来保存它们。然后,我们可以只过滤preference == 1。

    # more than 4 -> 1, less than 5 -> 0
    data_df['preference'] = np.where(data_df['rating'] > 4, 1, 0)
    
    # keep only ones and discard the others
    data_df_cleaned = data_df[(data_df['preference'] == 1)]
    data_df_cleaned.head()

    构建一个增量推荐系统

     

    接下来,让我们初始化我们的模型。为此,我们需要一个模型架构、一个目标函数(即损失函数)和一个优化器。我们将使用SimpleCF网络作为模型架构,这是CF Step提供的内置神经网络架构。对于目标函数,我们将使用一个简单的lambda函数,它接受一个prediction和一个target,并从target中减去prediction。在我们的例子中,target总是1。对于优化器,我们将使用Pytorch的SGD实现。我们选择的因子数为128,学习率为0.06。现在我们准备初始化Step模型。

    net = SimpleCF(n_users, n_movies, factors=128, init=torch.nn.init.normal_, mean=0., std=.1)
    objective = lambda pred, target: target - pred
    optimizer = SGD(net.parameters(), lr=6e-2)
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    
    model = Step(net, objective, optimizer, device=device)

    评估方法如下:

    • 通过对前20%的数据进行训练来提升模型。
    • 模拟数据流,并使用recall@k 作为度量来评估模型的性能。
    • 如果用户是已知的,作出预测,并为这个预测计算recall@k 。然后,使用这种用户—物品交互逐步地训练增量算法。
    • 如果用户未知,使用这种用户—物品交互,训练增量算法,。

    为此,让我们取前20%的数据,创建数据加载器和批次来拟合模型。

    pct = int(data_df_cleaned.shape[0] * .2)
    bootstrapping_data = data_df_cleaned[:pct]
    
    features = ['user_code', 'movie_code', 'rating']
    target = ['preference']
    data_set = TensorDataset(torch.tensor(bootstrapping_data[features].values), torch.tensor(bootstrapping_data[target].values))
    data_loader = DataLoader(data_set, batch_size=BATCH_SIZE, shuffle=False)
    
    model.batch_fit(data_loader)

    然后,我们获取剩余的数据并创建一个不同的数据集。

    # get the remaining data
    data_df_step = data_df_cleaned.drop(bootstrapping_data.index)
    data_df_step = data_df_step.reset_index(drop=True)
    
    # create the DataLoader
    stream_data_set = TensorDataset(torch.tensor(data_df_step[features].values), torch.tensor(data_df_step[target].values))
    stream_data_loader = DataLoader(stream_data_set, batch_size=1, shuffle=False)

    最后,模拟流并使用recall@10对模型进行评估。这个步骤在GPU上需要5到6分钟。

    k = 10  # we keep only the top 10 recommendations
    recalls = []
    known_users = []
    
    with tqdm(total=len(stream_data_loader)) as pbar:
        for idx, (features, preferences) in enumerate(stream_data_loader):
            itr = idx + 1
            
            user = features[:, 0]
            item = features[:, 1]
            rtng = features[:, 2]
            pref = preferences
    
            if user.item() in known_users and rtng.item() == 5:
                predictions = model.predict(user, k)
                recall = recall_at_k(predictions.tolist(), item.tolist(), k)
                recalls.append(recall)
                model.step(user, item, rtng, pref)
            else:
                model.step(user, item, rtng, pref)
                
            known_users.append(user.item())
            pbar.update(1)
    

    我们可以可视化我们的训练结果。为此,我们将使用一个5k滑动窗口的移动平均值,就像他们在发布的论文中所做的那样。我们可以看到,对于movielens数据集,下图与论文中给出的结果一致。要保存模型,使用model.save()内置方法并传递一个有效的路径。

    构建一个增量推荐系统

     

    总结

    在这个故事中,我们展示了增量学习在推荐系统中的重要性,并重现了Joao Vinagre等人发表的*“Fast incremental matrix factorization for recommendation with positive-only feedback”*的结果。我们介绍了CF Step python库,这是一个开源库,可以快速实现增量学习推荐系统。在下一章,我们将进一步讨论这个问题,并尝试提高算法的准确性。

     

    英文原文:https://towardsdatascience.com/building-an-incremental-recommender-system-8836e30afaef

    展开全文
  • 为了开发和构建“ My Dapp”,必须安装以下先决条件: (或任何用于编辑JavascriptIDE) (DappStarter使用) ( )(安装后,请运行flow cadence install-vscode-extension来启用Cadence源文件代码高亮显示...
  • 为了开发和构建“ My Dapp”,必须安装以下先决条件: (或任何用于编辑JavascriptIDE) (DappStarter使用) ( )(安装后,请运行flow cadence install-vscode-extension来启用Cadence源文件代码高亮显示...
  • 为了开发和构建“ My Dapp”,必须安装以下先决条件: (或任何用于编辑JavascriptIDE) (DappStarter使用) ( )(安装后,请运行flow cadence install-vscode-extension来启用Cadence源文件代码高亮显示...
  • 为了开发和构建“ My Dapp”,必须安装以下先决条件: (或任何用于编辑JavascriptIDE) (DappStarter使用) ( )(安装后,请运行flow cadence install-vscode-extension来启用Cadence源文件代码高亮显示...
  • 为了开发和构建“ My Dapp”,必须安装以下先决条件: (或任何用于编辑JavascriptIDE) (DappStarter使用) ( )(安装后,请运行flow cadence install-vscode-extension来启用Cadence源文件代码高亮显示...
  • 为了开发和构建“ My Dapp”,必须安装以下先决条件: (或任何用于编辑JavascriptIDE) (DappStarter使用) ( )(安装后,请运行flow cadence install-vscode-extension来启用Cadence源文件代码高亮显示...
  • 为了开发和构建“ My Dapp”,必须安装以下先决条件: (或任何用于编辑JavascriptIDE) (DappStarter使用) ( )(安装后,请运行flow cadence install-vscode-extension以启用Cadence源文件代码高亮显示...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 211
精华内容 84
关键字:

发生的先决条件是