def output_curves_folds(results: ModelCVResult, y: Series):
return {
'label': "Recall precision folds",
'type': 'PlotRecord',
'key': 'recal_precision_folds',
'data': {
'labels': {
'x': 'Recall',
'y': 'Precision',
},
'lines':
pipeline(results['y_scores'], [
map(lambda y_score: compute_curves(
get_1_class_y_score(y_score), y)),
enumerate,
map(
lambda index__result: {
'x': index__result[1].curve_horizontal,
'y': index__result[1].curve_vertical_recall_precision,
'label': index__result[0],
}),
list,
]),
'plotProps': {
'yDomain': [0, 1],
'width': 450,
'height': 375
},
},
'width': 700,
}
def output_feature_importance(result: ModelCVResult):
try:
return {
'label': "Feature importance",
'type': 'featureImportance',
'key': 'correlation_table',
'data': {
"features":
list(
pipeline(
enumerate(result['feature_importance']),
[
map(
lambda item: {
"name":
result['feature_importance'].index[item[0]
],
"name_detailed":
format_feature_detailed(result[
'feature_importance'].index[item[0]]),
"importance":
item[1]
}),
list,
partial(sorted,
key=itemgetter("importance"),
reverse=True),
],
)),
},
'width': 700,
}
except (ValueError, TypeError):
pass
def compute_classification_metrics_from_results_with_statistics(
y_true: Series,
results: List[ModelCVResult],
threshold: Optional[float] = None,
target_variable: str = 'y_scores',
ignore_warning: bool = False,
) -> ClassificationMetricsWithStatistics:
chosen_threshold = threshold if threshold is not None else get_best_threshold_from_results(
y_true, results)
return pipeline(
results,
[
partial(
mapl,
partial(
compute_classification_metrics_from_result,
y_true,
threshold=chosen_threshold,
target_variable=target_variable,
ignore_warning=ignore_warning,
)),
flatten,
list,
compute_ci_for_metrics_collection,
],
)
def dict_configuration_to_params(configuration):
parameters = pipeline(
configuration,
[
instantiate_configuration,
get('pipeline'),
configuration_to_params,
],
)
return parameters
def compute_regression_metrics_from_results_with_statistics(
y_true: Series,
results: List[ModelCVResult],
) -> RegressionMetricsWithStatistics:
return pipeline(
results,
[
partial(mapl,
partial(compute_regression_metrics_from_result, y_true)),
flatten, list, compute_ci_for_metrics_collection,
lambda item: RegressionMetricsWithStatistics(**item)
],
)
def compute_regression_metrics_folds(
y_scores: List[Series],
y: Series,
) -> Optional[ClassificationMetricsWithSTD]:
return pipeline(
y_scores,
[
map(lambda y_score: compute_regression_metrics(y_score, y)),
list,
average_list_dicts,
lambda item: RegressionMetrics(**item),
],
)
def compute_metrics_from_result_ci(y_true: Series,
result: ModelCVResult,
threshold: Optional[float] = None
) -> ClassificationMetricsWithStatistics:
chosen_threshold = threshold if threshold is not None else get_best_threshold_from_results(
y_true, [result])
return pipeline(
result,
[
compute_classification_metrics_from_result(
y_true, threshold=chosen_threshold),
compute_ci_for_metrics_collection,
],
)
def compute_classification_metrics_folds(
y_scores: List[Series],
y: Series,
threshold: float = DEFAULT_THRESHOLD,
) -> Optional[ClassificationMetricsWithSTD]:
return pipeline(
y_scores,
[
map(lambda y_score: compute_classification_metrics(
get_1_class_y_score(y_score), y, threshold)),
list,
average_list_dicts_metric_std,
],
)
def coil_color_setting(total_expect_coil):
coil_color_list = [
["Ain", ["NAME:Color", "R:=", 255, "G:=", 0, "B:=", 0]],
["Aout", ["NAME:Color", "R:=", 255, "G:=", 0, "B:=", 128]],
["Bin", ["NAME:Color", "R:=", 0, "G:=", 0, "B:=", 255]],
["Bout", ["NAME:Color", "R:=", 0, "G:=", 128, "B:=", 255]],
["Cin", ["NAME:Color", "R:=", 0, "G:=", 128, "B:=", 0]],
["Cout", ["NAME:Color", "R:=", 0, "G:=", 64, "B:=", 64]]
]
def set_color(coil_name):
oEditor.ChangeProperty([
"NAME:AllTabs",
[
"NAME:Geometry3DAttributeTab",
["NAME:PropServers", coil_name],
["NAME:ChangedProps", color_no]
]
])
for coil_name, color_no in coil_color_list:
pipeline(total_expect_coil,
[(filter, String.startswith(coil_name)), list,
(map, set_color), list])
def _(dictionary):
try:
parameters = pipeline(
dictionary,
[
keyfilter(lambda k: k != '__type'),
valmap(json_deserialize_types),
],
)
Class = get_member_by_path(dictionary['__type'])
instance = make_instance(Class)
for key, value in parameters.items():
setattr(instance, key, json_deserialize_types(value))
return instance
except KeyError:
return valmap(json_deserialize_types, dictionary)
def json_serialize_types(value):
try:
value.__dict__
except AttributeError:
return value
return {
'__type': type(value).__module__ + "." + type(value).__name__,
**pipeline(
value.__dict__,
[
keyfilter(lambda l: not l.startswith("_")),
json_serialize_types,
],
),
}
def result_from_fold_results(results: Iterable[ModelResult]) -> ModelCVResult:
results = list(results)
return ModelCVResult(feature_importance=pipeline(
results,
[
map(get('feature_importance')),
list,
],
),
y_scores=pipeline(
results,
[
map(get('y_test_score')),
list,
],
),
y_train_scores=pipeline(
results,
[
map(get('y_train_score')),
list,
],
),
y_predicts=pipeline(
results,
[
map(get('y_test_predict')),
list,
],
),
y_train_predicts=pipeline(
results,
[
map(get('y_train_predict')),
list,
],
),
models=pipeline(
results,
[
map(get('model')),
list,
],
),
elapsed=pipeline(results, [
map(get('elapsed')),
max,
]))
def current_excitation_setting(ctx):
print('Set coil excitation')
oModule = ctx["ansys_object"]["oDesign"].GetModule("BoundarySetup")
coil_name_list = ctx["data"]["coil_name_list"]
excitation_name = ctx["params"]["name_params"]["excitation"]
N, I_ph_A, I_ph_B, I_ph_C = excitation_name[
"conductor_number"], excitation_name["phase_I_A"], excitation_name[
"phase_I_B"], excitation_name["phase_I_C"]
def Add_winding_group(winding_name, phase_current):
return oModule.AssignWindingGroup([
"NAME:" + winding_name, "Type:=", "Current", "IsSolid:=", False,
"Current:=", phase_current, "Resistance:=", "0ohm", "Inductance:=",
"0nH", "Voltage:=", "0mV", "ParallelBranchesNum:=", "1"
])
def assign_coil_group(polarity, coil_group):
oModule.AssignCoilGroup(coil_group, [
"NAME:" + coil_group[0], "Objects:=", coil_group,
"Conductor number:=", N, "PolarityType:=", polarity
])
def add_coil_to_winding(winding, polarity, coil_group):
def boundary_list(winding, polarity, coil):
return [
"NAME:" + coil, "Objects:=", [coil], "ParentBndID:=", winding,
"Conductor number:=", N, "Winding:=", winding,
"PolarityType:=", polarity
]
boundary_polarity_winding = partial(boundary_list, winding, polarity)
oModule.AddCoilstoWinding([
"NAME:AddTerminalsToWinding", ["NAME:BoundaryList"] +
list(map(boundary_polarity_winding, coil_group))
])
###
# variable
winding_group = [
"Winding_A",
"Winding_B",
"Winding_C",
]
current_ph_group = [I_ph_A, I_ph_B, I_ph_C]
winding_coil_polarity_group = [["Winding_A", "Negative", "Ain"],
["Winding_A", "Positive", "Aout"],
["Winding_B", "Negative", "Bin"],
["Winding_B", "Positive", "Bout"],
["Winding_C", "Negative", "Cin"],
["Winding_C", "Positive", "Cout"]]
# setting winding_A, B, C
list(map(Add_winding_group, winding_group, current_ph_group))
for winding, polarity, coil in winding_coil_polarity_group:
# settting assign_coil_group
pipeline(coil_name_list, [
(filter, String.startswith(coil)),
list,
partial(assign_coil_group, polarity),
])
# settting add_coil_to_winding
pipeline(coil_name_list,
[(filter, String.startswith(coil)), list,
partial(add_coil_to_winding, winding, polarity)])
return ctx
