- Java锁的逻辑(结合对象头和ObjectMonitor)
- 还在用饼状图?来瞧瞧这些炫酷的百分比可视化新图形(附代码实现)⛵
- 自动注册实体类到EntityFrameworkCore上下文,并适配ABP及ABPVNext
- 基于Sklearn机器学习代码实战
学习文章: TPRE:分布式门限代理重加密 。
成方金科新技术实验室与隐语团队合作,构建了“ 基于国密的分布式门限代理重加密算法TPRE ”,为用户提供了一种安全、高效、自主可控的数据共享和授权管理方案。在 数据隐私保护 和 数据安全共享 方面具有广泛的应用前景.
⚠️:该算法由成方金科密码学研究员张曙光(知乎:六三)基于 隐语的密码库yacl 实现,其提供了易于开发的密码工具接口,TPRE算法目前已经贡献至yacl中。 https://github.com/secretflow/yacl/tree/main/yacl/crypto/primitives/tpre 。
TPRE算法具有以下优势:
代理重加密是一种公钥密码方案, 它允许代理将一个公钥加密成的密文转换到另一个公钥加密成的密文,而代理者不能了解关于原始消息的任何信息 ,要做到这一点,代理必须拥有一个 重加密密钥 .
一个代理重加密算法通常包含三种角色,即 数据拥有者Alice、数据接收者Bob和代理计算Proxy .
假设,数据 \(m\) 已经被Alice使用自己公钥加密为密文 \(c\) ,并存储在Proxy,具体算法具体步骤如下:
Alice作为数据拥有者,想要将数据授权给Bob使用,则为Proxy生成重加密密钥 \(rk\) .
Proxy在接收到 \(rk\) 后,对密文 \(c\) 重加密,得到新密文 \(c^‘\) ,并将其发送至Bob.
Bob使用自己的私钥 \(c^‘\) 对解密,即可得到明文数据 \(m\) .
这里想起来了一个基于NTRU的代理重加密方案: NTRUReEncrypt: An Efficient Proxy Re-Encryption Scheme Based on NTRU ,下面具体介绍一下方案:
代理重加密方案:NTRUReEncrypt 。
委托人为:A,被委托人为:B,代理者:proxy 。
代理重加密适合在云计算场景中使用,即 代理节点为计算性能较强的单节点 ,这与现有隐私计算体系架构不符,因为现在隐私计算架构通常是分布式架构。因此, 需要对传统代理重加密方案进行改造,使之能够适应分布式计算环境 .
分布式代理重加密是指将传统代理重加密中的单Proxy节点,拆分为多个Proxy节点 。因而 在对数据重加密时,需要多个Proxy节点参与合作计算 .
考虑到选取参与计算的Proxy节点的灵活性,需要 将分布式代理重加密重新设计为基于门限的分布式代理重加密 .
Shamir Secret Sharing是一种加密技术,可以将秘密信息分散成多个部分,并分配给不同的人,只有所有部分被汇集在一起才能重构出原来的秘密信息。它是由以色列密码学家Adi Shamir在1979年发明的,被广泛应用于保护机密信息,例如在密码学、数字签名、多方计算等领域。其基本思想是 通过多项式插值来实现信息的分散和重构 ,具有高度的安全性和可靠性.
Shamir密秘分享 :假设有一个秘密信息,例如一个密码或者一个私钥,需要将这个秘密信息分配给两个人,可以使用Shamir Secret Sharing算法来实现.
例如: 假设秘密信息是密码“5”,需要将它分配给两个人.
具体参考: https://www.cnblogs.com/pam-sh/p/17179097.html#shamir秘密分享 。
下图是我国商用密码 SM2选定的素数域椭圆曲线" sm2p256v1 "的参数选择:
更多可参考SM2国标:
使用的哈希算法构造如下:
\(h_x= (1 + Bignum(SM3(x)||SM3(SM3(x))) )mod n-1\) 。
其中 \(n\) 是椭圆曲线的阶, \(x\) 是函数的输入 。
SM3套wa?
由于 公钥密码是运行在代数计算上的密码算法,其计算效率远低于对称密码 ,因此,在待加密数据量较大时,使用公钥密码直接对数据加密不是一个良好选择。在该场景中,可使用 混合加密体制KEM/DEM :
这两个机制联合使用,可以提供数据的加解密效率,在密文需要传输时,也可降低通信开销。具体而言, DEM机制是用作保护原始数据,即使用对称加密算法,对原始数据进行加密保护 ; KEM是用作保护加密原始数据时所使用的对称密钥,使用公钥加密算法对对称密钥进行加密保护 .
关于更多密钥封装可参考: 密钥封装和公钥加密的联系和区别?
方案: https://github.com/nucypher/umbral-doc 。
UMBRAL是一个代理重加密方案(A THRESHOLD PROXY RE-ENCRYPTION SCHEME),根据一个密钥封装算法改进而来。Alice作为数据产生方,通过 \(N\) 个代理阶段的重加密机制可以将密文的解密权限委托给Bob,具体来说,Bob得到 \((t,N)\) 个节点重加密信息才能解密(恢复)出该明文.
代理重加密的使用场景:公共网络中任意数量的参与者实现私人数据共享,但不向中间实体(代理者)泄漏密钥信息.
UMBRAL是阈值代理重加密算法,是非交互式的、单向的,且在重加密后可以验证的,在阈值方面采用Shamir 秘密分享技术.
一个代理重加密【Proxy Re-Encryption,PRE】算法的简易框架如下:
算法中用户角色主要有:
代理重加密(PRE)由KEM(密钥封装)和DEM(分组加密)组成,其中DEM不涉及重加密,所以下图只讨论KEM部分.
下面对KEM的算法功能模块分别介绍:
1、密钥生成算法 。
Alice得到一对公私钥对 \((pk_A,sk_A)\) 。
输入: \(sk_A=a\) 、 \(pk_B=g^b\) 、片段 \(N\) 、阈值 \(t\) 。
输出: \(N\) 个重加密密钥片段 \(kFrag\) 。
2、封装和解封装算法 。
输入: \(pk_A\) 。
输出:对称加密密钥 \(K\) 和封装结果 \(capsule\) 。
输入: \(sk_A\) 和 \(capsule\) 。
输出:对称加密密钥 \(K\) 。
3、重封装和解封装片段算法 。
输入:重加密密钥片段 \(kFrag\) 和封装结果 \(capsule\) 。
输出:重新封装的片段(部分) \(cFrag\) 。
输入:Bob的私钥 \(sk_B=b\) 、 \(t\) 个重封装片段 \(cFrag\) 。
输出:对称加密密钥 \(K\) 。
下面详细介绍KDM算法流程:
1、参数设置 。
2、密钥生成算法 。
\(KeyGen()\) 。
\(ReKeyGen(sk_A,pk_B,N,t)\) 。
3、封装和解封装算法 。
\(Encapsulate(pk_A)\) 。
\(CheckCapsule(capsule)\) 。
\(Decapsulate(sk_A,capsule)\) 。
4、重封装和解封装片段算法 。
\(ReEncapsulation(kFrag,capsule)\) 。
\(DecapsulateFrags(sk_B,\left \{cFrag_i \right \}_{i=1}^{t},capsule)\) 。
结合上述KEM算法,加入 \(DEM\) 后,封装和解封装算法变为了加密和解密算法,另外需后续验证,所以DEM具体为认证加密算法(AEAD),下面给出 完整的KEM/DEM算法 :
\(Encrypt(pk_A,M)\) :
\(Decrypt(sk_A,C)\) :
\(ReEncrypt(kFrag,C)\) :
\(DecryptFrags(sk_B,\{C_i'\}_{i=1}^t)\) :
正确性和安全性参考原文.
源程序: https://github.com/nucypher/pyumbral 。
pyUmbral是 对门限代理重加密方案Umbral的实现 ,基于python,依赖 openssl 和 cryptography 库.
在该程序中,Alice(数据拥有者)通过一个重加密的代理节点,将解密权利授权给Bob。具体说,当有门限个代理节点参与重加密时,Bob能聚合这些重加密的密文,然后使用自己的私钥解密恢复出原始消息.
pyUmbral是 nucypher 背后的加密引擎,nucypher是一个代理重新加密网络,用于在去中心化系统中增强隐私.
pip3 install umbral
下面以一个例子证明方案功能的正确性(docs/examples/umbral_simple_api.py):
1、密钥生成 。
Alice生成:
Bob生成:
import random
from umbral import (
SecretKey, Signer, CapsuleFrag,
encrypt, generate_kfrags, reencrypt, decrypt_original, decrypt_reencrypted)
# Generate an Umbral key pair
# ---------------------------
# First, Let's generate two asymmetric key pairs for Alice:
# A delegating key pair and a Signing key pair.
alices_secret_key = SecretKey.random() #sk_A
alices_public_key = alices_secret_key.public_key() #pk_A
alices_signing_key = SecretKey.random() #签名私钥
alices_verifying_key = alices_signing_key.public_key() #签名公钥
alices_signer = Signer(alices_signing_key)
bobs_secret_key = SecretKey.random() #sk_B
bobs_public_key = bobs_secret_key.public_key() #pk_B
2、加解密 。
# Encrypt some data for Alice
# ---------------------------
# Now let's encrypt data with Alice's public key.
# Invocation of `pre.encrypt` returns both the `ciphertext`,
# and a `capsule`. Anyone with Alice's public key can perform
# this operation.
plaintext = b'Proxy Re-encryption is cool!'
capsule, ciphertext = encrypt(alices_public_key, plaintext)
print("ciphertext:",ciphertext)
# Decrypt data for Alice
# ----------------------
# Since data was encrypted with Alice's public key,
# Alice can open the capsule and decrypt the ciphertext with her private key.
cleartext = decrypt_original(alices_secret_key, capsule, ciphertext)
print("cleartext:",cleartext)
# Bob receives a capsule through a side channel (s3, ipfs, Google cloud, etc)
bob_capsule = capsule
# Attempt Bob's decryption (fail)
try:
fail_decrypted_data = decrypt_original(bobs_secret_key, bob_capsule, ciphertext)
except ValueError:
print("Decryption failed! Bob doesn't has access granted yet.")
3、重加密 。
# Alice grants access to Bob by generating kfrags
# -----------------------------------------------
# When Alice wants to grant Bob access to open her encrypted messages,
# she creates *threshold split re-encryption keys*, or *"kfrags"*,
# which are next sent to N proxies or *Ursulas*.
# She uses her private key, and Bob's public key, and she sets a minimum
# threshold of 10, for 20 total shares
kfrags = generate_kfrags(delegating_sk=alices_secret_key,
receiving_pk=bobs_public_key,
signer=alices_signer,
threshold=10,
shares=20) #Alice产生20个重加密密钥片段,给代理节点
# Ursulas perform re-encryption
# ------------------------------
# Bob asks several Ursulas to re-encrypt the capsule so he can open it.
# Each Ursula performs re-encryption on the capsule using the `kfrag`
# provided by Alice, obtaining this way a "capsule fragment", or `cfrag`.
# Let's mock a network or transport layer by sampling `threshold` random `kfrags`,
# one for each required Ursula.
kfrags = random.sample(kfrags, # All kfrags from above
10) # M - Threshold #从20个重加密密钥片段中,随机选出10个用作重加密
# Bob collects the resulting `cfrags` from several Ursulas.
# Bob must gather at least `threshold` `cfrags` in order to open the capsule.
cfrags = list() # Bob's cfrag collection
for kfrag in kfrags:
cfrag = reencrypt(kfrags=capsule, kfrag=kfrag)
cfrags.append(cfrag) # Bob collects a cfrag
assert len(cfrags) == 10
4、解密 。
# Bob checks the capsule fragments
# --------------------------------
# If Bob received the capsule fragments in serialized form,
# he can verify that they are valid and really originate from Alice,
# using Alice's public keys.
suspicious_cfrags = [CapsuleFrag.from_bytes(bytes(cfrag)) for cfrag in cfrags]
cfrags = [cfrag.verify(capsule,
verifying_pk=alices_verifying_key,
delegating_pk=alices_public_key,
receiving_pk=bobs_public_key,
)
for cfrag in suspicious_cfrags] #验证重加密后的密文
# Bob opens the capsule
# ------------------------------------
# Finally, Bob decrypts the re-encrypted ciphertext using his key.
bob_cleartext = decrypt_reencrypted(receiving_sk=bobs_secret_key,
delegating_pk=alices_public_key,
capsule=bob_capsule,
verified_cfrags=cfrags,
ciphertext=ciphertext) #Bob使用sk_B解密得到明文
print("bob_cleartext:",bob_cleartext)
assert bob_cleartext == plaintext
TPRELib共包含6个算法,分别为密钥对生成算法【GenerateTpreKeyPair】、重加密密钥生成【GenerateReKey】、加密【Encrypt】、解密算法【Decrypt】、重加密算法【ReEncrypt】、解密重加密密文算法【DecryptFrage】:
假设数据持有方为A,接收方为B,代理者(节点)为proxy 。
下面是门限代理重加密算法执行流程:
\(capsule\) :包含对称密钥信息 。
\(ct\) :使用对称加密的密文 。
假设Alice为数据所有方,Bob为数据需求方,代理者(代理节点)为proxy 。
设置参数,为了简单起见,我们将省略其余函数中的公共参数.
\(ReKeyGen(sk_A,pk_B,N,t)\) :输入 \((pk_A,sk_A)\) , \(pk_B\) ,代理节点数 \(N\) 和阈值 \(t\) ,重加密密钥生成算法计算出Alice和Bob之间的 \(N\) 个代理节点的重加密密钥
随机抽样 \(x_A\in Z_q\) 并计算 \(X_A=g^{x_A}\) 。
计算 \(d=H_3(X_A,pk_B,(pk_B)^{x_A})=H_3(g^{x_a},g^b,g^{bx_a})\) 。
在 \(f_i\in Z_q\) 中随机抽取 \(t-1\) 个元素,其中 \(i\in [1,t-1]\) ,并计算 \(f_0=(a*d^{-1}) mod q\) 。
【密秘分享】在 \(r-1\) 阶的 \(Z_q[x]\) 中构造一个多项式 \(f(x)\) ,使得 \(f(x)=f_0+f_1x+f_2x^2+...+f_{t-1}x^{t-1}\) 。
计算 \(D=H_6(pk_A,pk_B,pk_B^a)=H_6(g^a,g^b,g^{ba})\) 。
初始化集合 \(KF=0\) ,重复 \(N\) 次 。
封装算法 \(Encapsulate(pk_A)\) :输入公钥 \(pk_A=g^a\) 。
首先选择随机数 \(r,u\in Z_q\) ,并计算 \(E=g^r\) 和 \(V=g^u\) 。
计算 \(s=u+r*H_2(E,V)\) ,计算 \(K=KDF((pk_A)^{r+u})=KDF(g^{a(r+u)})\) , 该元组 \((E,V,s)\) 被称为胶囊(capsule) 。
最后输出 \((K,capsule)\) ,其中 \(K\) 为对称密钥 。
检查函数 \(CheckCapsule(capsule)\) :在输入一个 \(capsule=(E,V,s)\) 时,通过检查以下方程是否成立来检查该胶囊的有效性: \(g^{s}\overset{?}{=}V\cdot E^{H_{2}(E,V)}\) 。
解封算法 \(Decapsulate(sk_A,capsule)\) :输入密钥 \(sk_A=a\) 和原始胶囊 \(capsule=(E,V,s)\) 。
封装算法是根据公钥 \(pk_A\) 生成一个对称密钥 \(K\) 和一个capsule 。
解封装算法可以根据capsule还原出对称密钥 \(K\) 。
本算法可以选择任意素数域椭圆曲线,例如 Secp256k1 和s m2p256v1 ,其中sm2p256v1是我国国产密码学算法SM2使用的椭圆曲线【2.4】 。
源程序: https://github.com/secretflow/yacl/tree/main/yacl/crypto/primitives/tpre 。
TPRE是umbral的替代品,它是用C++实现的,用SM2、SM3和SM4取代了ECC和AES等算法.
可用于一下场景:
数据安全共享 。
数据安全授权 。
分布式密钥管理 。
模块功能:
由于tpre是放在隐语的yacl库中,安装编译参考“yacl使用” 。
1、密钥生成 。
std::unique_ptr<EcGroup> ecc_group = EcGroupFactory::Create("sm2"); //初始化参数,生成SM2对应的曲线参数
Keys keys;
std::pair<Keys::PublicKey, Keys::PrivateKey> key_pair_alice =
keys.GenerateKeyPair(ecc_group);
// According to the official SM2 document
// The hexadecimal of generator is:
// Gx = 32C4AE2C 1F198119 5F990446 6A39C994 8FE30BBF F2660BE1 715A4589
// 334C74C7
// Gy = BC3736A2 F4F6779C 59BDCEE3 6B692153 D0A9877C C62A4740 02DF32E5
// 2139F0A0
// When converting it to decimal, we have :
// "(2296314654723705055947953136255007457880
// 2567295341616970375194840604139615431,
// "85132369209828568825618990617112496413088
// 388631904505083283536607588877201568)";
std::string generator_str =
"(2296314654723705055947953136255007457880256729534161697037519"
"4840604139"
"615431, "
"85132369209828568825618990617112496413088388631904505083283536"
"6075888772"
"01568)";
EXPECT_EQ(ecc_group->GetAffinePoint(key_pair_alice.first.g).ToString(),
generator_str); //检测generator_str点是否在曲线上
std::pair<Keys::PublicKey, Keys::PrivateKey> key_pair_bob =
keys.GenerateKeyPair(ecc_group); //Bob生成一对公私钥
std::vector<Keys::KFrag> kfrags =
keys.GenerateReKey(ecc_group, key_pair_alice.second, key_pair_alice.first,
key_pair_bob.first, 5, 4); //生成5个重加密密钥
for (int i = 0; i < 5; i++) {
EXPECT_TRUE(kfrags[i].id > zero);
}
2、加解密 。
/************************* Phase 1 *************************/
// Start testing encryption and decryption functions
std::unique_ptr<EcGroup> ecc_group = EcGroupFactory::Create("sm2"); // 参数生成
std::pair<Keys::PublicKey, Keys::PrivateKey> key_pair_A =
keys.GenerateKeyPair(ecc_group); //Alice生成密钥对
// test tpre.Encrypt
std::string message = "hellooooooooooooo, I am 63, who are you?"; //明文消息
std::pair<Capsule::CapsuleStruct, std::vector<uint8_t>> ct_1 =
tpre.Encrypt(ecc_group, key_pair_A.first, iv, message); //使用Alice的公钥加密得到密文(Capsule,encdata)
// test tpre.Decrypt
std::string message_1 =
tpre.Decrypt(ecc_group, ct_1.first, iv, ct_1.second, key_pair_A.second); //使用Alice的私钥解密得到明文
// Determine if decryption was successful
EXPECT_EQ(message, message_1); //测试解密是否成功
// End testing encryption and decryption functions
3、重加密和解密 。
/************************* Phase 2 *************************/
// Start testing encryption, re-encryption, and decryption functions
// Second test tpre.Encrypt
std::string message_2 =
"If you were a teardrop;In my eye, For fear of losing you, I would never "
"cry. And if the golden sun, Should cease to shine its light, Just one "
"smile from you, Would make my whole world bright.";
std::pair<Capsule::CapsuleStruct, std::vector<uint8_t>> ct_2 =
tpre.Encrypt(ecc_group, key_pair_A.first, iv, message_2); //使用Alice的公钥加密明文消息
// test keys->GenerateReKey
std::pair<Keys::PublicKey, Keys::PrivateKey> key_pair_B =
keys.GenerateKeyPair(ecc_group); //Bob生成公私钥
int N = 5; // Number of all participants //代理节点数
int t = 4; // Threshold //阈值大小
std::vector<Keys::KFrag> kfrags = keys.GenerateReKey(
ecc_group, key_pair_A.second, key_pair_A.first, key_pair_B.first, N, t); //生成N个重加密密钥片段
// test tpre.ReEncrypt
std::pair<std::vector<Capsule::CFrag>, std::vector<uint8_t>> re_ct_set;
// You need to meet the number of participants to successfully decrypt,
// otherwise decryption will not be successful
for (int i = 0; i < t; i++) {
std::pair<Capsule::CapsuleStruct, std::vector<uint8_t>> ct_2_i = {
ct_2.first, ct_2.second};
std::pair<Capsule::CFrag, std::vector<uint8_t>> re_ct_i =
tpre.ReEncrypt(ecc_group, kfrags[i], ct_2_i); //使用重加密密钥片段 重新加密密文 得到re_ct_set
std::unique_ptr<Capsule::CFrag> cfrag_i_up(
new Capsule::CFrag(re_ct_i.first));
re_ct_set.first.push_back(re_ct_i.first);
re_ct_set.second = re_ct_i.second;
}
// test tpre.DecryptFrags
std::string message_3 =
tpre.DecryptFrags(ecc_group, key_pair_B.second, key_pair_A.first,
key_pair_B.first, iv, re_ct_set); //Bob使用私钥解密
// Determine whether decryption was successful after performing re-encryption
EXPECT_EQ(message_2, message_3);
为了适应数据要素化背景下数据流通需求场景,提出了 基于国密的分布式门限代理重加密算法TPRE ,该算法是由成方金科新技术实验室密码学研究员张曙光基于 隐语社区的基础密码学库yacl 实现。与传统的访问控制和权限管理方法相比,TPRE算法具有以下优点:
总之,基于国密的分布式门限代理重加密算法TPRE在数据隐私保护和数据安全共享方面具有广泛的应用前景和重要意义,为用户提供了一种安全、高效、自主可控的数据共享和授权管理方案.
最后此篇关于文章学习:TPRE:分布式门限代理重加密的文章就讲到这里了,如果你想了解更多关于文章学习:TPRE:分布式门限代理重加密的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
关闭。这个问题是opinion-based .它目前不接受答案。 想要改进这个问题? 更新问题,以便 editing this post 可以用事实和引用来回答它. 关闭 9 年前。 Improve
介绍篇 什么是MiniApis? MiniApis的特点和优势 MiniApis的应用场景 环境搭建 系统要求 安装MiniApis 配置开发环境 基础概念 MiniApis架构概述
我正在从“JavaScript 圣经”一书中学习 javascript,但我遇到了一些困难。我试图理解这段代码: function checkIt(evt) { evt = (evt) ? e
package com.fastone.www.javademo.stringintern; /** * * String.intern()是一个Native方法, * 它的作用是:如果字
您会推荐哪些资源来学习 AppleScript。我使用具有 Objective-C 背景的传统 C/C++。 我也在寻找有关如何更好地开发和从脚本编辑器获取更快文档的技巧。示例提示是“查找要编写脚本的
关闭。这个问题不满足Stack Overflow guidelines .它目前不接受答案。 想改善这个问题吗?更新问题,使其成为 on-topic对于堆栈溢出。 4年前关闭。 Improve thi
关闭。这个问题不满足Stack Overflow guidelines .它目前不接受答案。 想改善这个问题吗?更新问题,使其成为 on-topic对于堆栈溢出。 7年前关闭。 Improve thi
关闭。这个问题不符合 Stack Overflow guidelines 。它目前不接受答案。 想改善这个问题吗?更新问题,以便堆栈溢出为 on-topic。 6年前关闭。 Improve this
我是塞内加尔的阿里。我今年60岁(也许这是我真正的问题-笑脸!!!)。 我正在学习Flutter和Dart。今天,我想使用给定数据模型的列表(它的名称是Mortalite,请参见下面的代码)。 我尝试
关闭。这个问题是off-topic .它目前不接受答案。 想改进这个问题? Update the question所以它是on-topic对于堆栈溢出。 9年前关闭。 Improve this que
学习 Cappuccino 的最佳来源是什么?我从事“传统”网络开发,但我对这个新框架非常感兴趣。请注意,我对 Objective-C 毫无了解。 最佳答案 如上所述,该网站是一个好地方,但还有一些其
我正在学习如何使用 hashMap,有人可以检查我编写的这段代码并告诉我它是否正确吗?这个想法是有一个在公司工作的员工列表,我想从 hashMap 添加和删除员工。 public class Staf
我正在尝试将 jQuery 与 CoffeScript 一起使用。我按照博客中的说明操作,指示使用 $ -> 或 jQuery -> 而不是 .ready() 。我玩了一下代码,但我似乎无法理解我出错
还在学习,还有很多问题,所以这里有一些。我正在进行 javascript -> PHP 转换,并希望确保这些做法是正确的。是$dailyparams->$calories = $calories;一条
我目前正在学习 SQL,以便从我们的 Magento 数据库制作一个简单的 RFM 报告,我目前可以通过导出两个查询并将它们粘贴到 Excel 模板中来完成此操作,我想摆脱 Excel 模板。 我认为
我知道我很可能会因为这个问题而受到抨击,但没有人问,我求助于你。这是否是一个正确的 javascript > php 转换 - 在我开始不良做法之前,我想知道这是否是解决此问题的正确方法。 JavaS
除了 Ruby-Doc 之外,哪些来源最适合获取一些示例和教程,尤其是关于 Ruby 中的 Tk/Tile?我发现自己更正常了 http://www.tutorialspoint.com/ruby/r
我只在第一次收到警告。这正常吗? >>> cv=LassoCV(cv=10).fit(x,y) C:\Python27\lib\site-packages\scikit_learn-0.14.1-py
按照目前的情况,这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持,但这个问题可能会引发辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开,visit the
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be
我是一名优秀的程序员,十分优秀!