598 lines
22 KiB
JavaScript
598 lines
22 KiB
JavaScript
'use strict';
|
|
|
|
//sklearn 生成分类样本
|
|
pbc.globalFunctionD['make_classification'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
|
if (args.length === 0 && keywords.length === 8) {
|
|
var key1block = py2block.convert(keywords[0].value);
|
|
var key2block = py2block.convert(keywords[1].value);
|
|
var key3block = py2block.convert(keywords[2].value);
|
|
var key4block = py2block.convert(keywords[3].value);
|
|
var key5block = py2block.convert(keywords[4].value);
|
|
var key6block = py2block.convert(keywords[5].value);
|
|
var key7block = py2block.convert(keywords[6].value);
|
|
var key8block = py2block.convert(keywords[7].value);
|
|
return block("sklearn_make_classification", func.lineno, {}, {
|
|
"n_samples": key1block,
|
|
"n_features": key2block,
|
|
"n_informative": key3block,
|
|
"n_redundant": key4block,
|
|
"n_repeated": key5block,
|
|
"n_classes": key6block,
|
|
"n_clusters_per_class": key7block,
|
|
"random_state": key8block
|
|
}, {
|
|
"inline": "false"
|
|
});
|
|
}
|
|
else
|
|
{
|
|
throw new Error("Incorrect number of arguments");
|
|
}
|
|
|
|
}
|
|
|
|
//sklearn 生成回归样本
|
|
pbc.globalFunctionD['make_regression'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
|
if (args.length === 0 && keywords.length === 7) {
|
|
var key1block = py2block.convert(keywords[0].value);
|
|
var key2block = py2block.convert(keywords[1].value);
|
|
var key3block = py2block.convert(keywords[2].value);
|
|
var key4block = py2block.convert(keywords[3].value);
|
|
var key5block = py2block.convert(keywords[4].value);
|
|
var key6block = py2block.convert(keywords[5].value);
|
|
var key7block = py2block.convert(keywords[6].value);
|
|
return block("sklearn_make_regression", func.lineno, {}, {
|
|
"n_samples": key1block,
|
|
"n_features": key2block,
|
|
"n_informative": key3block,
|
|
"n_targets": key4block,
|
|
"bias": key5block,
|
|
"noise": key6block,
|
|
"random_state": key7block
|
|
}, {
|
|
"inline": "false"
|
|
});
|
|
}
|
|
else
|
|
{
|
|
throw new Error("Incorrect number of arguments");
|
|
}
|
|
|
|
}
|
|
|
|
//sklearn 生成聚类样本
|
|
pbc.globalFunctionD['make_blobs'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
|
if (args.length === 0 && keywords.length === 7) {
|
|
var key1block = py2block.convert(keywords[0].value);
|
|
var key2block = py2block.convert(keywords[1].value);
|
|
var key3block = py2block.convert(keywords[2].value);
|
|
var key4block = py2block.convert(keywords[3].value);
|
|
var key5block = py2block.convert(keywords[4].value);
|
|
var key6block = py2block.convert(keywords[5].value);
|
|
var key7block = py2block.convert(keywords[6].value);
|
|
return block("sklearn_make_blobs", func.lineno, {}, {
|
|
"n_samples": key1block,
|
|
"n_features": key2block,
|
|
"centers": key3block,
|
|
"cluster_std": key4block,
|
|
"center_box": key5block,
|
|
"shuffle": key6block,
|
|
"random_state": key7block
|
|
}, {
|
|
"inline": "false"
|
|
});
|
|
}
|
|
else
|
|
{
|
|
throw new Error("Incorrect number of arguments");
|
|
}
|
|
|
|
}
|
|
|
|
//sklearn 加载数据集
|
|
function sklearn_load_check_assign(mode){
|
|
function converter(py2block, node, targets, value) {
|
|
if(value.func._astname != "Attribute" || value.func.value._astname != "Name"){
|
|
return false;
|
|
}
|
|
var moduleName = py2block.Name_str(value.func.value);
|
|
var funcName = py2block.identifier(value.func.attr);
|
|
value.args = value.args || [];
|
|
if (value._astname === "Call" && moduleName === "datasets"
|
|
&& funcName === mode && !value.args.length)
|
|
return true;
|
|
return false;
|
|
}
|
|
return converter;
|
|
}
|
|
|
|
function sklearn_load_create_block(){
|
|
function converter(py2block, node, targets, value) {
|
|
var name = py2block.Name_str(node.targets[0]);
|
|
var type = py2block.identifier(value.func.attr);
|
|
//注意：赋值语句里，即使图形块上下可接，也不需要加[]
|
|
return block('sklearn_load', node.lineno, {
|
|
"name": name,
|
|
"type": type
|
|
}, {});
|
|
}
|
|
return converter;
|
|
}
|
|
|
|
pbc.assignD.get('load_iris')['check_assign'] = sklearn_load_check_assign('load_iris');
|
|
pbc.assignD.get('load_boston')['check_assign'] = sklearn_load_check_assign('load_boston');
|
|
pbc.assignD.get('load_diabetes')['check_assign'] = sklearn_load_check_assign('load_diabetes');
|
|
pbc.assignD.get('load_breast_cancer')['check_assign'] = sklearn_load_check_assign('load_breast_cancer');
|
|
pbc.assignD.get('load_linnerud')['check_assign'] = sklearn_load_check_assign('load_linnerud');
|
|
pbc.assignD.get('load_digits')['check_assign'] = sklearn_load_check_assign('load_digits');
|
|
|
|
pbc.assignD.get('load_iris')['create_block'] = sklearn_load_create_block();
|
|
pbc.assignD.get('load_boston')['create_block'] = sklearn_load_create_block();
|
|
pbc.assignD.get('load_diabetes')['create_block'] = sklearn_load_create_block();
|
|
pbc.assignD.get('load_breast_cancer')['create_block'] = sklearn_load_create_block();
|
|
pbc.assignD.get('load_linnerud')['create_block'] = sklearn_load_create_block();
|
|
pbc.assignD.get('load_digits')['create_block'] = sklearn_load_create_block();
|
|
|
|
//sklearn 获取特征值/标签值/标签/特征
|
|
function sklearn_data_target(py2block, node, value, attr) {
|
|
return block('sklearn_data_target', node.lineno, {
|
|
"type": py2block.identifier(attr)
|
|
}, {
|
|
"name": py2block.convert(value)
|
|
});
|
|
}
|
|
pbc.objectAttrD.get('data')['sklearn.datasets'] = sklearn_data_target;
|
|
pbc.objectAttrD.get('target')['sklearn.datasets'] = sklearn_data_target;
|
|
pbc.objectAttrD.get('target_names')['sklearn.datasets'] = sklearn_data_target;
|
|
pbc.objectAttrD.get('feature_names')['sklearn.datasets'] = sklearn_data_target;
|
|
|
|
//sklearn 数据集分割
|
|
pbc.globalFunctionD['train_test_split'] = function (py2block, func, args, keywords, starargs, kwargs, node) {
|
|
if (args.length === 2) {
|
|
var arg1block = py2block.convert(args[0]);
|
|
var arg2block = py2block.convert(args[1]);
|
|
var key1block = py2block.convert(keywords[0].value);
|
|
var key2block = py2block.convert(keywords[1].value);
|
|
return block("sklearn_train_test_split", func.lineno, {}, {
|
|
"train_data": arg1block,
|
|
"train_target": arg2block,
|
|
"test_size": key1block,
|
|
"rondom_state": key2block,
|
|
}, {
|
|
"inline": "false"
|
|
});
|
|
}
|
|
else if(args.length === 1)
|
|
{
|
|
var arg1block = py2block.convert(args[0]);
|
|
var key1block = py2block.convert(keywords[0].value);
|
|
var key2block = py2block.convert(keywords[1].value);
|
|
return block("sklearn_train_test_split_no_target", func.lineno, {}, {
|
|
"train_data": arg1block,
|
|
"test_size": key1block,
|
|
"rondom_state": key2block,
|
|
}, {
|
|
"inline": "false"
|
|
});
|
|
}
|
|
else
|
|
{
|
|
throw new Error("Incorrect number of arguments");
|
|
}
|
|
|
|
}
|
|
|
|
//sklearn 初始化线性回归
|
|
pbc.assignD.get('LinearRegression')['check_assign'] = function(py2block, node, targets, value) {
|
|
if(value._astname != "Call" || value.func._astname != "Name"){
|
|
return false;
|
|
}
|
|
var funcName = value.func.id.v;
|
|
value.args = value.args || [];
|
|
if(funcName === "LinearRegression" && !value.args.length)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
pbc.assignD.get('LinearRegression')['create_block'] = function(py2block, node, targets, value){
|
|
var name = py2block.convert(node.targets[0]);
|
|
var key1block = py2block.convert(value.keywords[0].value);
|
|
var key2block = py2block.convert(value.keywords[1].value);
|
|
var key3block = py2block.convert(value.keywords[2].value);
|
|
return block("sklearn_LinearRegression", node.lineno, {}, {
|
|
"model_name": name,
|
|
"fit_intercept": key1block,
|
|
"normalize": key2block,
|
|
"n_jobs": key3block
|
|
});
|
|
}
|
|
|
|
//sklearn 初始化岭回归
|
|
pbc.assignD.get('Ridge')['check_assign'] = function(py2block, node, targets, value) {
|
|
if(value._astname != "Call" || value.func._astname != "Name"){
|
|
return false;
|
|
}
|
|
var funcName = value.func.id.v;
|
|
value.args = value.args || [];
|
|
if(funcName === "Ridge" && !value.args.length)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
pbc.assignD.get('Ridge')['create_block'] = function(py2block, node, targets, value){
|
|
var name = py2block.convert(node.targets[0]);
|
|
var key1block = py2block.convert(value.keywords[0].value);
|
|
var key2block = py2block.convert(value.keywords[1].value);
|
|
var key3block = py2block.convert(value.keywords[2].value);
|
|
var key4block = py2block.convert(value.keywords[3].value);
|
|
var key5block = py2block.convert(value.keywords[4].value);
|
|
return block("sklearn_Ridge", node.lineno, {}, {
|
|
"model_name": name,
|
|
"alpha": key1block,
|
|
"fit_intercept": key2block,
|
|
"normalize": key3block,
|
|
"max_iter": key4block,
|
|
"random_state": key5block
|
|
});
|
|
}
|
|
|
|
//sklearn 初始化决策树 分类算法
|
|
pbc.assignD.get('DecisionTreeClassifier')['check_assign'] = function(py2block, node, targets, value) {
|
|
if(value._astname != "Call" || value.func._astname != "Name"){
|
|
return false;
|
|
}
|
|
var funcName = value.func.id.v;
|
|
value.args = value.args || [];
|
|
if(funcName === "DecisionTreeClassifier" && !value.args.length)
|
|
return true;
|
|
return false;
|
|
}
|
|
pbc.assignD.get('DecisionTreeClassifier')['create_block'] = function(py2block, node, targets, value){
|
|
var name = py2block.convert(node.targets[0]);
|
|
var key1block = py2block.convert(value.keywords[0].value);
|
|
var key2block = py2block.convert(value.keywords[1].value);
|
|
return block("sklearn_DecisionTreeClassifier_Regressor", node.lineno, {
|
|
"type": "DecisionTreeClassifier"
|
|
}, {
|
|
"model_name": name,
|
|
"max_depth": key1block,
|
|
"random_state": key2block
|
|
});
|
|
}
|
|
|
|
//sklearn 初始化决策树 回归算法
|
|
pbc.assignD.get('DecisionTreeRegressor')['check_assign'] = function(py2block, node, targets, value) {
|
|
if(value._astname != "Call" || value.func._astname != "Name"){
|
|
return false;
|
|
}
|
|
var funcName = value.func.id.v;
|
|
value.args = value.args || [];
|
|
if(funcName === "DecisionTreeRegressor" && !value.args.length)
|
|
return true;
|
|
return false;
|
|
}
|
|
pbc.assignD.get('DecisionTreeRegressor')['create_block'] = function(py2block, node, targets, value){
|
|
var name = py2block.convert(node.targets[0]);
|
|
var key1block = py2block.convert(value.keywords[0].value);
|
|
var key2block = py2block.convert(value.keywords[1].value);
|
|
return block("sklearn_DecisionTreeClassifier_Regressor", node.lineno, {
|
|
"type": "DecisionTreeRegressor"
|
|
}, {
|
|
"model_name": name,
|
|
"max_depth": key1block,
|
|
"random_state": key2block
|
|
});
|
|
}
|
|
|
|
//sklearn 初始化随机森林 分类算法
|
|
pbc.assignD.get('RandomForestClassifier')['check_assign'] = function(py2block, node, targets, value) {
|
|
if(value._astname != "Call" || value.func._astname != "Name"){
|
|
return false;
|
|
}
|
|
var funcName = value.func.id.v;
|
|
value.args = value.args || [];
|
|
if(funcName === "RandomForestClassifier" && !value.args.length)
|
|
return true;
|
|
return false;
|
|
}
|
|
pbc.assignD.get('RandomForestClassifier')['create_block'] = function(py2block, node, targets, value){
|
|
var name = py2block.convert(node.targets[0]);
|
|
var key1block = py2block.convert(value.keywords[0].value);
|
|
var key2block = py2block.convert(value.keywords[1].value);
|
|
var key3block = py2block.convert(value.keywords[2].value);
|
|
var key4block = py2block.convert(value.keywords[3].value);
|
|
return block("sklearn_RandomForestClassifier_Regressor", node.lineno, {
|
|
"type": "RandomForestClassifier"
|
|
}, {
|
|
"model_name": name,
|
|
"n_estimators": key1block,
|
|
"max_depth": key2block,
|
|
"n_jobs": key3block,
|
|
"random_state": key4block
|
|
});
|
|
}
|
|
|
|
//sklearn 初始化随机森林 回归算法
|
|
pbc.assignD.get('RandomForestRegressor')['check_assign'] = function(py2block, node, targets, value) {
|
|
if(value._astname != "Call" || value.func._astname != "Name"){
|
|
return false;
|
|
}
|
|
var funcName = value.func.id.v;
|
|
value.args = value.args || [];
|
|
if(funcName === "RandomForestRegressor" && !value.args.length)
|
|
return true;
|
|
return false;
|
|
}
|
|
pbc.assignD.get('RandomForestRegressor')['create_block'] = function(py2block, node, targets, value){
|
|
var name = py2block.convert(node.targets[0]);
|
|
var key1block = py2block.convert(value.keywords[0].value);
|
|
var key2block = py2block.convert(value.keywords[1].value);
|
|
var key3block = py2block.convert(value.keywords[2].value);
|
|
var key4block = py2block.convert(value.keywords[3].value);
|
|
return block("sklearn_RandomForestClassifier_Regressor", node.lineno, {
|
|
"type": "RandomForestRegressor"
|
|
}, {
|
|
"model_name": name,
|
|
"n_estimators": key1block,
|
|
"max_depth": key2block,
|
|
"n_jobs": key3block,
|
|
"random_state": key4block
|
|
});
|
|
}
|
|
|
|
//sklearn 初始化K近邻 分类算法
|
|
pbc.assignD.get('KNeighborsClassifier')['check_assign'] = function(py2block, node, targets, value) {
|
|
if(value._astname != "Call" || value.func._astname != "Name"){
|
|
return false;
|
|
}
|
|
var funcName = value.func.id.v;
|
|
value.args = value.args || [];
|
|
if(funcName === "KNeighborsClassifier" && !value.args.length)
|
|
return true;
|
|
return false;
|
|
}
|
|
pbc.assignD.get('KNeighborsClassifier')['create_block'] = function(py2block, node, targets, value){
|
|
var name = py2block.convert(node.targets[0]);
|
|
var key1block = py2block.convert(value.keywords[0].value);
|
|
var key2block = py2block.convert(value.keywords[1].value);
|
|
return block("sklearn_KNeighborsClassifier_Regressor", node.lineno, {
|
|
"type": "KNeighborsClassifier"
|
|
}, {
|
|
"model_name": name,
|
|
"K": key1block,
|
|
"n_jobs": key2block
|
|
});
|
|
}
|
|
|
|
//sklearn 初始化K近邻 回归算法
|
|
pbc.assignD.get('KNeighborsRegressor')['check_assign'] = function(py2block, node, targets, value) {
|
|
if(value._astname != "Call" || value.func._astname != "Name"){
|
|
return false;
|
|
}
|
|
var funcName = value.func.id.v;
|
|
value.args = value.args || [];
|
|
if(funcName === "KNeighborsRegressor" && !value.args.length)
|
|
return true;
|
|
return false;
|
|
}
|
|
pbc.assignD.get('KNeighborsRegressor')['create_block'] = function(py2block, node, targets, value){
|
|
var name = py2block.convert(node.targets[0]);
|
|
var key1block = py2block.convert(value.keywords[0].value);
|
|
var key2block = py2block.convert(value.keywords[1].value);
|
|
return block("sklearn_KNeighborsClassifier_Regressor", node.lineno, {
|
|
"type": "KNeighborsRegressor"
|
|
}, {
|
|
"model_name": name,
|
|
"K": key1block,
|
|
"n_jobs": key2block
|
|
});
|
|
}
|
|
|
|
//sklearn 初始化高斯贝叶斯分类算法
|
|
pbc.assignD.get('GaussianNB')['check_assign'] = function(py2block, node, targets, value) {
|
|
if(value._astname != "Call" || value.func._astname != "Name"){
|
|
return false;
|
|
}
|
|
var funcName = value.func.id.v;
|
|
value.args = value.args || [];
|
|
if(funcName === "GaussianNB" && !value.args.length)
|
|
return true;
|
|
return false;
|
|
}
|
|
pbc.assignD.get('GaussianNB')['create_block'] = function(py2block, node, targets, value){
|
|
var name = py2block.convert(node.targets[0]);
|
|
return block("sklearn_GaussianNB", node.lineno, {}, {
|
|
"model_name": name
|
|
});
|
|
}
|
|
|
|
//sklearn 初始K-均值聚类
|
|
pbc.assignD.get('KMeans')['check_assign'] = function(py2block, node, targets, value) {
|
|
if(value._astname != "Call" || value.func._astname != "Name"){
|
|
return false;
|
|
}
|
|
var funcName = value.func.id.v;
|
|
value.args = value.args || [];
|
|
if(funcName === "KMeans" && !value.args.length)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
pbc.assignD.get('KMeans')['create_block'] = function(py2block, node, targets, value){
|
|
var name = py2block.convert(node.targets[0]);
|
|
var key1block = py2block.convert(value.keywords[0].value);
|
|
var key2block = py2block.convert(value.keywords[1].value);
|
|
var key3block = py2block.convert(value.keywords[2].value);
|
|
var key4block = py2block.convert(value.keywords[3].value);
|
|
return block("sklearn_KMeans", node.lineno, {}, {
|
|
"model_name": name,
|
|
"n_clusters": key1block,
|
|
"max_iter": key2block,
|
|
"random_state": key3block,
|
|
"n_jobs": key4block
|
|
});
|
|
}
|
|
|
|
//sklearn 训练模型
|
|
function sklearn_fit(){
|
|
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
|
if(args.length === 1) {
|
|
var objblock = py2block.convert(func.value);
|
|
var argblock1 = py2block.convert(args[0]);
|
|
return [block("sklearn_fit_no_target", func.lineno, {}, {
|
|
"model_name": objblock,
|
|
"train_data": argblock1
|
|
}, {
|
|
"inline": "true"
|
|
})];
|
|
}
|
|
else if(args.length === 2) {
|
|
var objblock = py2block.convert(func.value);
|
|
var argblock1 = py2block.convert(args[0]);
|
|
var argblock2 = py2block.convert(args[1]);
|
|
return [block("sklearn_fit", func.lineno, {
|
|
}, {
|
|
"model_name": objblock,
|
|
"train_data": argblock1,
|
|
"train_target": argblock2
|
|
}, {
|
|
"inline": "true"
|
|
})];
|
|
}
|
|
else
|
|
{
|
|
throw new Error("Incorrect number of arguments");
|
|
}
|
|
}
|
|
return converter;
|
|
}
|
|
pbc.objectFunctionD.get('fit')['sklearn.fit'] = sklearn_fit();
|
|
|
|
//sklearn 模型预测
|
|
function sklearn_predict(){
|
|
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
|
if(args.length === 1)
|
|
{
|
|
var objblock = py2block.convert(func.value);
|
|
var argblock1 = py2block.convert(args[0]);
|
|
return block("sklearn_predict", func.lineno, {
|
|
}, {
|
|
"model_name": objblock,
|
|
"train_data": argblock1
|
|
}, {
|
|
"inline": "true"
|
|
});
|
|
}
|
|
else
|
|
{
|
|
throw new Error("Incorrect number of arguments");
|
|
}
|
|
}
|
|
return converter;
|
|
}
|
|
pbc.objectFunctionD.get('predict')['sklearn'] = sklearn_predict();
|
|
|
|
//sklearn 计算模型得分
|
|
function sklearn_score(){
|
|
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
|
if (args.length === 2) {
|
|
var objblock = py2block.convert(func.value);
|
|
var argblock1 = py2block.convert(args[0]);
|
|
var argblock2 = py2block.convert(args[1]);
|
|
return block("sklearn_score", func.lineno, {}, {
|
|
"model_name": objblock,
|
|
"train_data": argblock1,
|
|
"train_target": argblock2
|
|
}, {
|
|
"inline": "true"
|
|
});
|
|
}
|
|
else if(args.length === 1)
|
|
{
|
|
var objblock = py2block.convert(func.value);
|
|
var argblock1 = py2block.convert(args[0]);
|
|
return block("sklearn_score_no_target", func.lineno, {}, {
|
|
"model_name": objblock,
|
|
"train_data": argblock1
|
|
}, {
|
|
"inline": "true"
|
|
});
|
|
}
|
|
else
|
|
{
|
|
throw new Error("Incorrect number of arguments");
|
|
}
|
|
}
|
|
return converter;
|
|
}
|
|
pbc.objectFunctionD.get('score')['sklearn'] = sklearn_score();
|
|
|
|
//sklearn 线性回归 模型获取 斜率/截距
|
|
function sklearn_coef_intercept(py2block, node, value, attr) {
|
|
return block('sklearn_coef_intercept', node.lineno, {
|
|
"type": py2block.identifier(attr)
|
|
}, {
|
|
"model_name": py2block.convert(value)
|
|
});
|
|
}
|
|
pbc.objectAttrD.get('coef_')['sklearn.linear_model'] = sklearn_coef_intercept;
|
|
pbc.objectAttrD.get('intercept_')['sklearn.linear_model'] = sklearn_coef_intercept;
|
|
|
|
//sklearn K-均值聚类 模型获取 簇中心坐标/聚类后的标签/所有点到对应簇中心的距离平方和
|
|
function sklearn_cluster_centers_labels_inertia(py2block, node, value, attr) {
|
|
return block('sklearn_cluster_centers_labels_inertia', node.lineno, {
|
|
"type": py2block.identifier(attr)
|
|
}, {
|
|
"model_name": py2block.convert(value)
|
|
});
|
|
}
|
|
pbc.objectAttrD.get('cluster_centers_')['sklearn.cluster'] = sklearn_cluster_centers_labels_inertia;
|
|
pbc.objectAttrD.get('labels_')['sklearn.cluster'] = sklearn_cluster_centers_labels_inertia;
|
|
pbc.objectAttrD.get('inertia_')['sklearn.cluster'] = sklearn_cluster_centers_labels_inertia;
|
|
|
|
//sklearn 保存模型
|
|
function sklearn_save_model(){
|
|
function converter(py2block, func, args, keywords, starargs, kwargs, node) {
|
|
if(args.length === 2) {
|
|
var argblock1 = py2block.convert(args[0]);
|
|
var argblock2 = py2block.convert(args[1]);
|
|
var funcName = func.attr.v;
|
|
return [block("sklearn_save_load_model", func.lineno, {
|
|
"type" : funcName
|
|
}, {
|
|
"model_name": argblock1,
|
|
"address": argblock2
|
|
}, {
|
|
"inline": "true"
|
|
})];
|
|
}
|
|
else
|
|
{
|
|
throw new Error("Incorrect number of arguments");
|
|
}
|
|
}
|
|
return converter;
|
|
}
|
|
pbc.objectFunctionD.get('dump')['sklearn.externals'] = sklearn_save_model();
|
|
|
|
//sklearn 加载模型
|
|
pbc.assignD.get('load')['check_assign'] = function(py2block, node, targets, value) {
|
|
if(value._astname != "Call" || value.func._astname != "Attribute"){
|
|
return false;
|
|
}
|
|
var funcName = value.func.attr.v;
|
|
if(funcName === "load" && value.args.length === 1)
|
|
return true;
|
|
return false;
|
|
}
|
|
pbc.assignD.get('load')['create_block'] = function(py2block, node, targets, value){
|
|
var name = py2block.convert(node.targets[0]);
|
|
var key1block = py2block.convert(value.args[0]);
|
|
var funcName = value.func.attr.v;
|
|
return block("sklearn_save_load_model", node.lineno, {
|
|
"type" : funcName
|
|
}, {
|
|
"model_name" : name,
|
|
"address" : key1block
|
|
});
|
|
} |