Coverage for mlprodict/onnxrt/validate/validate_problems.py: 99%

1# pylint: disable=E1101 

2""" 

3@file 

4@brief Validates runtime for many :scikit-learn: operators. 

5The submodule relies on :epkg:`onnxconverter_common`, 

6:epkg:`sklearn-onnx`. 

7""" 

8import numpy 

9from sklearn.base import ( 

10 ClusterMixin, BiclusterMixin, OutlierMixin, 

11 RegressorMixin, ClassifierMixin) 

12from sklearn.calibration import CalibratedClassifierCV 

13from sklearn.cross_decomposition import PLSSVD 

14from sklearn.datasets import load_iris 

15from sklearn.decomposition import LatentDirichletAllocation, NMF 

16from sklearn.discriminant_analysis import LinearDiscriminantAnalysis, QuadraticDiscriminantAnalysis 

17from sklearn.ensemble import ( 

18 AdaBoostRegressor, GradientBoostingRegressor, AdaBoostClassifier, 

19 BaggingClassifier, VotingClassifier, GradientBoostingClassifier, 

20 RandomForestClassifier) 

21try: 

22 from sklearn.ensemble import StackingClassifier, StackingRegressor 

23except ImportError: # pragma: no cover 

24 # new in 0.22 

25 StackingClassifier, StackingRegressor = None, None 

26from sklearn.feature_extraction import DictVectorizer, FeatureHasher 

27from sklearn.feature_extraction.text import ( 

28 CountVectorizer, TfidfVectorizer, TfidfTransformer) 

29from sklearn.ensemble import ( 

30 HistGradientBoostingRegressor, 

31 HistGradientBoostingClassifier) 

32from sklearn.feature_selection import ( 

33 RFE, RFECV, GenericUnivariateSelect, 

34 SelectPercentile, SelectFwe, SelectKBest, 

35 SelectFdr, SelectFpr, SelectFromModel) 

36from sklearn.gaussian_process import GaussianProcessClassifier, GaussianProcessRegressor 

37from sklearn.isotonic import IsotonicRegression 

38from sklearn.linear_model import ( 

39 ARDRegression, ElasticNetCV, 

40 LarsCV, LassoCV, LassoLarsCV, LassoLarsIC, 

41 SGDRegressor, OrthogonalMatchingPursuitCV, 

42 TheilSenRegressor, BayesianRidge, MultiTaskElasticNet, 

43 MultiTaskElasticNetCV, MultiTaskLassoCV, MultiTaskLasso, 

44 PassiveAggressiveClassifier, RidgeClassifier, 

45 RidgeClassifierCV, PassiveAggressiveRegressor, 

46 HuberRegressor, LogisticRegression, SGDClassifier, 

47 LogisticRegressionCV, Perceptron) 

48from sklearn.mixture._base import BaseMixture 

49from sklearn.model_selection import GridSearchCV, RandomizedSearchCV 

50from sklearn.multiclass import ( 

51 OneVsRestClassifier, OneVsOneClassifier, OutputCodeClassifier) 

52from sklearn.multioutput import MultiOutputRegressor, MultiOutputClassifier 

53from sklearn.naive_bayes import BernoulliNB, GaussianNB, MultinomialNB, ComplementNB 

54from sklearn.neighbors import ( 

55 NearestCentroid, RadiusNeighborsClassifier, 

56 NeighborhoodComponentsAnalysis) 

57from sklearn.preprocessing import ( 

58 LabelBinarizer, LabelEncoder, 

59 OneHotEncoder, PowerTransformer) 

60from sklearn.semi_supervised import LabelPropagation, LabelSpreading 

61from sklearn.svm import LinearSVC, LinearSVR, NuSVR, SVR, SVC, NuSVC 

62from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier, ExtraTreeClassifier 

63from sklearn.utils import shuffle 

64from ._validate_problems_helper import ( 

65 _noshapevar, _1d_problem, text_alpha_num) 

66 

67 

68def _modify_dimension(X, n_features, seed=19): 

69 """ 

70 Modifies the number of features to increase 

71 or reduce the number of features. 

72 

73 @param X features matrix 

74 @param n_features number of features 

75 @param seed random seed (to get the same 

76 dataset at each call) 

77 @return new featurs matrix 

78 """ 

79 if n_features is None or n_features == X.shape[1]: 

80 return X 

81 if n_features < X.shape[1]: 

82 return X[:, :n_features] 

83 rstate = numpy.random.RandomState(seed) # pylint: disable=E1101 

84 res = numpy.empty((X.shape[0], n_features), dtype=X.dtype) 

85 res[:, :X.shape[1]] = X[:, :] 

86 div = max((n_features // X.shape[1]) + 1, 2) 

87 for i in range(X.shape[1], res.shape[1]): 

88 j = i % X.shape[1] 

89 col = X[:, j] 

90 if X.dtype in (numpy.float32, numpy.float64): 

91 sigma = numpy.var(col) ** 0.5 

92 rnd = rstate.randn(len(col)) * sigma / div 

93 col2 = col + rnd 

94 res[:, j] -= col2 / div 

95 res[:, i] = col2 

96 elif X.dtype in (numpy.int32, numpy.int64): 

97 perm = rstate.permutation(col) 

98 h = rstate.randint(0, div) % X.shape[0] 

99 col2 = col.copy() 

100 col2[h::div] = perm[h::div] # pylint: disable=E1136 

101 res[:, i] = col2 

102 h = (h + 1) % X.shape[0] 

103 res[h, j] = perm[h] # pylint: disable=E1136 

104 else: # pragma: no cover 

105 raise NotImplementedError( # pragma: no cover 

106 f"Unable to add noise to a feature for this type {X.dtype}") 

107 return res 

108 

109 

110########### 

111# datasets 

112########### 

113 

114 

115def _problem_for_predictor_binary_classification( 

116 dtype=numpy.float32, n_features=None, add_nan=False): 

117 """ 

118 Returns *X, y, intial_types, method, node name, X runtime* for a 

119 binary classification problem. 

120 It is based on Iris dataset. 

121 """ 

122 data = load_iris() 

123 X = data.data 

124 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

125 rnd = state.randn(*X.shape) / 3 

126 X += rnd 

127 X = _modify_dimension(X, n_features) 

128 y = data.target 

129 y[y == 2] = 1 

130 if add_nan: 

131 rows = numpy.random.randint(0, X.shape[0] - 1, X.shape[0] // 3) 

132 cols = numpy.random.randint(0, X.shape[1] - 1, X.shape[0] // 3) 

133 X[rows, cols] = numpy.nan 

134 X = X.astype(dtype) 

135 y = y.astype(numpy.int64) 

136 return (X, y, [('X', X[:1].astype(dtype))], 

137 'predict_proba', 1, X.astype(dtype)) 

138 

139 

140def _problem_for_predictor_multi_classification(dtype=numpy.float32, n_features=None): 

141 """ 

142 Returns *X, y, intial_types, method, node name, X runtime* for a 

143 m-cl classification problem. 

144 It is based on Iris dataset. 

145 """ 

146 data = load_iris() 

147 X = data.data 

148 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

149 rnd = state.randn(*X.shape) / 3 

150 X += rnd 

151 X = _modify_dimension(X, n_features) 

152 y = data.target 

153 X = X.astype(dtype) 

154 y = y.astype(numpy.int64) 

155 return (X, y, [('X', X[:1].astype(dtype))], 

156 'predict_proba', 1, X.astype(dtype)) 

157 

158 

159def _problem_for_mixture(dtype=numpy.float32, n_features=None): 

160 """ 

161 Returns *X, y, intial_types, method, node name, X runtime* for a 

162 m-cl classification problem. 

163 It is based on Iris dataset. 

164 """ 

165 data = load_iris() 

166 X = data.data 

167 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

168 rnd = state.randn(*X.shape) / 3 

169 X += rnd 

170 X = _modify_dimension(X, n_features) 

171 y = data.target 

172 X = X.astype(dtype) 

173 y = y.astype(numpy.int64) 

174 return (X, None, [('X', X[:1].astype(dtype))], 

175 'predict_proba', 1, X.astype(dtype)) 

176 

177 

178def _problem_for_predictor_multi_classification_label(dtype=numpy.float32, n_features=None): 

179 """ 

180 Returns *X, y, intial_types, method, node name, X runtime* for a 

181 m-cl classification problem. 

182 It is based on Iris dataset. 

183 """ 

184 data = load_iris() 

185 X = data.data 

186 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

187 rnd = state.randn(*X.shape) / 3 

188 X += rnd 

189 X = _modify_dimension(X, n_features) 

190 y = data.target 

191 y2 = numpy.zeros((y.shape[0], 3), dtype=numpy.int64) 

192 for i, _ in enumerate(y): 

193 y2[i, _] = 1 

194 for i in range(0, y.shape[0], 5): 

195 y2[i, (y[i] + 1) % 3] = 1 

196 X = X.astype(dtype) 

197 y2 = y2.astype(numpy.int64) 

198 return (X, y2, [('X', X[:1].astype(dtype))], 

199 'predict_proba', 1, X.astype(dtype)) 

200 

201 

202def _problem_for_predictor_regression(many_output=False, options=None, 

203 n_features=None, nbrows=None, 

204 dtype=numpy.float32, add_nan=False, 

205 **kwargs): 

206 """ 

207 Returns *X, y, intial_types, method, name, X runtime* for a 

208 regression problem. 

209 It is based on Iris dataset. 

210 """ 

211 data = load_iris() 

212 X = data.data 

213 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

214 rnd = state.randn(*X.shape) / 3 

215 X += rnd 

216 X = _modify_dimension(X, n_features) 

217 y = data.target + numpy.arange(len(data.target)) / 100 

218 meth = 'predict' if kwargs is None else ('predict', kwargs) 

219 itt = [('X', X[:1].astype(dtype))] 

220 if n_features is not None: 

221 X = X[:, :n_features] 

222 itt = [('X', X[:1].astype(dtype))] 

223 if nbrows is not None: 

224 X = X[:nbrows, :] 

225 y = y[:nbrows] 

226 itt = [('X', X[:1].astype(dtype))] 

227 if options is not None: 

228 itt = itt, options 

229 if add_nan: 

230 rows = numpy.random.randint(0, X.shape[0] - 1, X.shape[0] // 3) 

231 cols = numpy.random.randint(0, X.shape[1] - 1, X.shape[0] // 3) 

232 X[rows, cols] = numpy.nan 

233 X = X.astype(dtype) 

234 y = y.astype(dtype) 

235 return (X, y, itt, 

236 meth, 'all' if many_output else 0, X.astype(dtype)) 

237 

238 

239def _problem_for_predictor_multi_regression(many_output=False, options=None, 

240 n_features=None, nbrows=None, 

241 dtype=numpy.float32, **kwargs): 

242 """ 

243 Returns *X, y, intial_types, method, name, X runtime* for a 

244 mregression problem. 

245 It is based on Iris dataset. 

246 """ 

247 data = load_iris() 

248 X = data.data 

249 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

250 rnd = state.randn(*X.shape) / 3 

251 X += rnd 

252 X = _modify_dimension(X, n_features) 

253 y = data.target.astype(float) + numpy.arange(len(data.target)) / 100 

254 meth = 'predict' if kwargs is None else ('predict', kwargs) 

255 itt = [('X', X[:1].astype(dtype))] 

256 if n_features is not None: 

257 X = X[:, :n_features] 

258 itt = [('X', X[:1].astype(dtype))] 

259 if nbrows is not None: 

260 X = X[:nbrows, :] 

261 y = y[:nbrows] 

262 itt = [('X', X[:1].astype(dtype))] 

263 if options is not None: 

264 itt = itt, options 

265 y2 = numpy.empty((y.shape[0], 2)) 

266 y2[:, 0] = y 

267 y2[:, 1] = y + 0.5 

268 X = X.astype(dtype) 

269 y2 = y2.astype(dtype) 

270 return (X, y2, itt, 

271 meth, 'all' if many_output else 0, X.astype(dtype)) 

272 

273 

274def _problem_for_numerical_transform(dtype=numpy.float32, n_features=None): 

275 """ 

276 Returns *X, intial_types, method, name, X runtime* for a 

277 transformation problem. 

278 It is based on Iris dataset. 

279 """ 

280 data = load_iris() 

281 X = data.data 

282 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

283 rnd = state.randn(*X.shape) / 3 

284 X += rnd 

285 X = _modify_dimension(X, n_features) 

286 X = X.astype(dtype) 

287 return (X, None, [('X', X[:1].astype(dtype))], 

288 'transform', 0, X.astype(dtype=numpy.float32)) 

289 

290 

291def _problem_for_numerical_transform_positive(dtype=numpy.float32, n_features=None): 

292 """ 

293 Returns *X, intial_types, method, name, X runtime* for a 

294 transformation problem. 

295 It is based on Iris dataset. 

296 """ 

297 data = load_iris() 

298 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

299 rnd = state.randn(*data.data.shape) / 3 

300 X = numpy.abs(data.data + rnd) 

301 X = _modify_dimension(X, n_features) 

302 X = X.astype(dtype) 

303 return (X, None, [('X', X[:1].astype(dtype))], 

304 'transform', 0, X.astype(dtype=numpy.float32)) 

305 

306 

307def _problem_for_numerical_trainable_transform(dtype=numpy.float32, n_features=None): 

308 """ 

309 Returns *X, intial_types, method, name, X runtime* for a 

310 transformation problem. 

311 It is based on Iris dataset. 

312 """ 

313 data = load_iris() 

314 X = data.data 

315 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

316 rnd = state.randn(*X.shape) / 3 

317 X += rnd 

318 X = _modify_dimension(X, n_features) 

319 y = data.target + numpy.arange(len(data.target)) / 100 

320 X = X.astype(dtype) 

321 y = y.astype(dtype) 

322 return (X, y, [('X', X[:1].astype(dtype))], 

323 'transform', 0, X.astype(dtype)) 

324 

325 

326def _problem_for_numerical_trainable_transform_cl(dtype=numpy.float32, n_features=None): 

327 """ 

328 Returns *X, intial_types, method, name, X runtime* for a 

329 transformation problem. 

330 It is based on Iris dataset. 

331 """ 

332 data = load_iris() 

333 X = data.data 

334 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

335 rnd = state.randn(*X.shape) / 3 

336 X += rnd 

337 X = _modify_dimension(X, n_features) 

338 y = data.target 

339 X = X.astype(dtype) 

340 y = y.astype(numpy.int64) 

341 return (X, y, [('X', X[:1].astype(dtype))], 

342 'transform', 0, X.astype(dtype)) 

343 

344 

345def _problem_for_clustering(dtype=numpy.float32, n_features=None): 

346 """ 

347 Returns *X, intial_types, method, name, X runtime* for a 

348 clustering problem. 

349 It is based on Iris dataset. 

350 """ 

351 data = load_iris() 

352 X = data.data 

353 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

354 rnd = state.randn(*X.shape) / 3 

355 X += rnd 

356 X = _modify_dimension(X, n_features) 

357 X = X.astype(dtype) 

358 return (X, None, [('X', X[:1].astype(dtype))], 

359 'predict', 0, X.astype(dtype)) 

360 

361 

362def _problem_for_clustering_scores(dtype=numpy.float32, n_features=None): 

363 """ 

364 Returns *X, intial_types, method, name, X runtime* for a 

365 clustering problem, the score part, not the cluster. 

366 It is based on Iris dataset. 

367 """ 

368 data = load_iris() 

369 X = data.data 

370 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

371 rnd = state.randn(*X.shape) / 3 

372 X += rnd 

373 X = _modify_dimension(X, n_features) 

374 X = X.astype(dtype) 

375 return (X, None, [('X', X[:1].astype(dtype))], 

376 'transform', 1, X.astype(dtype)) 

377 

378 

379def _problem_for_outlier(dtype=numpy.float32, n_features=None): 

380 """ 

381 Returns *X, intial_types, method, name, X runtime* for a 

382 transformation problem. 

383 It is based on Iris dataset. 

384 """ 

385 data = load_iris() 

386 X = data.data 

387 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

388 rnd = state.randn(*X.shape) / 3 

389 X += rnd 

390 X = _modify_dimension(X, n_features) 

391 X = X.astype(dtype) 

392 return (X, None, [('X', X[:1].astype(dtype))], 

393 'predict', 0, X.astype(dtype)) 

394 

395 

396def _problem_for_numerical_scoring(dtype=numpy.float32, n_features=None): 

397 """ 

398 Returns *X, y, intial_types, method, name, X runtime* for a 

399 scoring problem. 

400 It is based on Iris dataset. 

401 """ 

402 data = load_iris() 

403 X = data.data 

404 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

405 rnd = state.randn(*X.shape) / 3 

406 X += rnd 

407 y = data.target.astype(dtype) + numpy.arange(len(data.target)) / 100 

408 y /= numpy.max(y) 

409 X = X.astype(dtype) 

410 y = y.astype(dtype) 

411 return (X, y, [('X', X[:1].astype(dtype))], 

412 'score', 0, X.astype(dtype)) 

413 

414 

415def _problem_for_clnoproba(dtype=numpy.float32, n_features=None): 

416 """ 

417 Returns *X, y, intial_types, method, name, X runtime* for a 

418 scoring problem. 

419 It is based on Iris dataset. 

420 """ 

421 data = load_iris() 

422 X = data.data 

423 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

424 rnd = state.randn(*X.shape) / 3 

425 X += rnd 

426 X = _modify_dimension(X, n_features) 

427 y = data.target 

428 X = X.astype(dtype) 

429 y = y.astype(numpy.int64) 

430 return (X, y, [('X', X[:1].astype(dtype))], 

431 'predict', 0, X.astype(dtype)) 

432 

433 

434def _problem_for_clnoproba_binary(dtype=numpy.float32, n_features=None, add_nan=False): 

435 """ 

436 Returns *X, y, intial_types, method, name, X runtime* for a 

437 scoring problem. Binary classification. 

438 It is based on Iris dataset. 

439 """ 

440 data = load_iris() 

441 X = data.data 

442 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

443 rnd = state.randn(*X.shape) / 3 

444 X += rnd 

445 X = _modify_dimension(X, n_features) 

446 y = data.target 

447 y[y == 2] = 1 

448 if add_nan: 

449 rows = numpy.random.randint(0, X.shape[0] - 1, X.shape[0] // 3) 

450 cols = numpy.random.randint(0, X.shape[1] - 1, X.shape[0] // 3) 

451 X[rows, cols] = numpy.nan 

452 X = X.astype(dtype) 

453 y = y.astype(numpy.int64) 

454 return (X, y, [('X', X[:1].astype(dtype))], 

455 'predict', 0, X.astype(dtype)) 

456 

457 

458def _problem_for_cl_decision_function(dtype=numpy.float32, n_features=None): 

459 """ 

460 Returns *X, y, intial_types, method, name, X runtime* for a 

461 scoring problem. 

462 It is based on Iris dataset. 

463 """ 

464 data = load_iris() 

465 X = data.data 

466 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

467 rnd = state.randn(*X.shape) / 3 

468 X += rnd 

469 X = _modify_dimension(X, n_features) 

470 y = data.target 

471 X = X.astype(dtype) 

472 y = y.astype(numpy.int64) 

473 return (X, y, [('X', X[:1].astype(dtype))], 

474 'decision_function', 1, X.astype(dtype)) 

475 

476 

477def _problem_for_cl_decision_function_binary(dtype=numpy.float32, n_features=None): 

478 """ 

479 Returns *X, y, intial_types, method, name, X runtime* for a 

480 scoring problem. Binary classification. 

481 It is based on Iris dataset. 

482 """ 

483 data = load_iris() 

484 X = data.data 

485 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

486 rnd = state.randn(*X.shape) / 3 

487 X += rnd 

488 X = _modify_dimension(X, n_features) 

489 y = data.target 

490 y[y == 2] = 1 

491 X = X.astype(dtype) 

492 y = y.astype(numpy.int64) 

493 return (X, y, [('X', X[:1].astype(dtype))], 

494 'decision_function', 1, X.astype(dtype)) 

495 

496 

497def _problem_for_label_encoder(dtype=numpy.int64, n_features=None): 

498 """ 

499 Returns a problem for the :epkg:`sklearn:preprocessing:LabelEncoder`. 

500 """ 

501 data = load_iris() 

502 # X = data.data 

503 y = data.target.astype(dtype) 

504 itt = [('X', y[:1].astype(dtype))] 

505 y = y.astype(dtype) 

506 return (y, None, itt, 'transform', 0, y) 

507 

508 

509def _problem_for_dict_vectorizer(dtype=numpy.float32, n_features=None): 

510 """ 

511 Returns a problem for the :epkg:`sklearn:feature_extraction:DictVectorizer`. 

512 """ 

513 from skl2onnx.common.data_types import ( # delayed 

514 FloatTensorType, DoubleTensorType, StringTensorType, DictionaryType) 

515 data = load_iris() 

516 # X = data.data 

517 y = data.target 

518 y2 = [{_: dtype(1000 + i)} for i, _ in enumerate(y)] 

519 y2[0][2] = -2 

520 cltype = FloatTensorType if dtype == numpy.float32 else DoubleTensorType 

521 itt = [("X", DictionaryType(StringTensorType([1]), cltype([1])))] 

522 y2 = numpy.array(y2) 

523 y = y.astype(numpy.int64) 

524 return (y2, y, itt, 'transform', 0, y2) 

525 

526 

527def _problem_for_tfidf_vectorizer(dtype=numpy.float32, n_features=None): 

528 """ 

529 Returns a problem for the :epkg:`sklearn:feature_extraction:text:TfidfVectorizer`. 

530 """ 

531 from skl2onnx.common.data_types import ( # delayed 

532 StringTensorType) 

533 X = numpy.array([_[0] for _ in text_alpha_num]) 

534 y = numpy.array([_[1] for _ in text_alpha_num], dtype=dtype) 

535 itt = [("X", StringTensorType([None]))] 

536 return (X, y, itt, 'transform', 0, X) 

537 

538 

539def _problem_for_tfidf_transformer(dtype=numpy.float32, n_features=None): 

540 """ 

541 Returns a problem for the :epkg:`sklearn:feature_extraction:text:TfidfTransformer`. 

542 """ 

543 from skl2onnx.common.data_types import ( # delayed 

544 FloatTensorType, DoubleTensorType) 

545 X = numpy.array([_[0] for _ in text_alpha_num]) 

546 y = numpy.array([_[1] for _ in text_alpha_num], dtype=dtype) 

547 X2 = CountVectorizer().fit_transform(X).astype(dtype) 

548 cltype = FloatTensorType if dtype == numpy.float32 else DoubleTensorType 

549 itt = [("X", cltype([None, X2.shape[1]]))] 

550 return (X2, y, itt, 'transform', 0, X2) 

551 

552 

553def _problem_for_feature_hasher(dtype=numpy.float32, n_features=None): 

554 """ 

555 Returns a problem for the :epkg:`sklearn:feature_extraction:DictVectorizer`. 

556 """ 

557 from skl2onnx.common.data_types import ( # delayed 

558 FloatTensorType, DoubleTensorType, StringTensorType, DictionaryType) 

559 data = load_iris() 

560 # X = data.data 

561 y = data.target 

562 y2 = [{("cl%d" % _): dtype(1000 + i)} for i, _ in enumerate(y)] 

563 y2[0]["cl2"] = -2 

564 cltype = FloatTensorType if dtype == numpy.float32 else DoubleTensorType 

565 itt = [("X", DictionaryType(StringTensorType([1]), cltype([1])))] 

566 y2 = numpy.array(y2) 

567 return (y2, y, itt, 'transform', 0, y2) 

568 

569 

570def _problem_for_one_hot_encoder(dtype=numpy.float32, n_features=None): 

571 """ 

572 Returns a problem for the :epkg:`sklearn:preprocessing:OneHotEncoder`. 

573 """ 

574 data = load_iris() 

575 state = numpy.random.RandomState(seed=34) # pylint: disable=E1101 

576 rnd = state.randn(*data.data.shape) / 3 

577 X = _modify_dimension(data.data + rnd, n_features) 

578 X = X.astype(numpy.int32).astype(dtype) 

579 y = data.target 

580 X, y = shuffle(X, y, random_state=1) 

581 itt = [('X', X[:1].astype(dtype))] 

582 return (X[:, :1], y, itt, 'transform', 0, X[:, :1].astype(dtype)) 

583 

584 

585def find_suitable_problem(model): 

586 """ 

587 Determines problems suitable for a given 

588 :epkg:`scikit-learn` operator. It may be 

589 

590 * `b-cl`: binary classification 

591 * `m-cl`: m-cl classification 

592 * `m-label`: classification m-label 

593 (multiple labels possible at the same time) 

594 * `reg`: regression 

595 * `m-reg`: regression multi-output 

596 * `num-tr`: transform numerical features 

597 * `num-tr-pos`: transform numerical positive features 

598 * `scoring`: transform numerical features, target is usually needed 

599 * `outlier`: outlier prediction 

600 * `linearsvc`: classifier without *predict_proba* 

601 * `cluster`: similar to transform 

602 * `num+y-tr`: similar to transform with targets 

603 * `num+y-tr-cl`: similar to transform with classes 

604 * `num-tr-clu`: similar to cluster, but returns 

605 scores or distances instead of cluster 

606 * `key-col`: list of dictionaries 

607 * `text-col`: one column of text 

608 

609 Suffix `nofit` indicates the predictions happens 

610 without the model being fitted. This is the case 

611 for :epkg:`sklearn:gaussian_process:GaussianProcessRegressor`. 

612 The suffix `-cov` indicates the method `predict` was called 

613 with parameter ``return_cov=True``, `-std` tells 

614 method `predict` was called with parameter ``return_std=True``. 

615 The suffix ``-NSV`` creates an input variable 

616 like the following ``[('X', FloatTensorType([None, None]))]``. 

617 That's a way to bypass :epkg:`onnxruntime` shape checking 

618 as one part of the graph is designed to handle any 

619 kind of dimensions but apparently, if the input shape is 

620 precise, every part of the graph has to be precise. The strings 

621 used variables which means it is at the same time precise 

622 and unprecise. Suffix ``'-64'`` means the model will 

623 do double computations. Suffix ``-nop`` means the classifier 

624 does not implement method *predict_proba*. Suffix ``-1d`` 

625 means a one dimension problem (one feature). Suffix ``-dec`` 

626 checks method `decision_function`. 

627 

628 The following script gives the list of :epkg:`scikit-learn` 

629 models and the problem they can be fitted on. 

630 

631 .. runpython:: 

632 :showcode: 

633 :warningout: DeprecationWarning 

634 :rst: 

635 

636 from mlprodict.onnxrt.validate.validate import ( 

637 sklearn_operators, find_suitable_problem) 

638 from pyquickhelper.pandashelper import df2rst 

639 from pandas import DataFrame 

640 res = sklearn_operators() 

641 rows = [] 

642 for model in res[:20]: 

643 name = model['name'] 

644 row = dict(name=name) 

645 try: 

646 prob = find_suitable_problem(model['cl']) 

647 if prob is None: 

648 continue 

649 for p in prob: 

650 row[p] = 'X' 

651 except RuntimeError: 

652 pass 

653 rows.append(row) 

654 df = DataFrame(rows).set_index('name') 

655 df = df.sort_index() 

656 print(df2rst(df, index=True)) 

657 

658 The list is truncated. The full list can be found at 

659 :ref:`l-model-problem-list`. 

660 """ 

661 from ...onnx_conv.validate_scenarios import find_suitable_problem as ext_find_suitable_problem 

662 

663 def _internal(model): # pylint: disable=R0911 

664 

665 # checks that this model is not overwritten by this module 

666 ext = ext_find_suitable_problem(model) 

667 if ext is not None: 

668 return ext 

669 

670 # Exceptions 

671 if model in {GaussianProcessRegressor}: 

672 # m-reg causes MemoryError on some machine. 

673 return ['~b-reg-NF-64', # '~m-reg-NF-64', 

674 '~b-reg-NF-cov-64', # '~m-reg-NF-cov-64', 

675 '~b-reg-NF-std-64', # '~m-reg-NF-std-64', 

676 '~b-reg-NSV-64', # '~m-reg-NSV-64', 

677 '~b-reg-cov-64', # '~m-reg-cov-64', 

678 '~b-reg-std-NSV-64', # '~m-reg-std-NSV-64', 

679 'b-reg', '~b-reg-64', # 'm-reg' 

680 ] 

681 

682 if model in {DictVectorizer}: 

683 return ['key-int-col'] 

684 

685 if model in {TfidfVectorizer, CountVectorizer}: 

686 return ['text-col'] 

687 

688 if model in {TfidfTransformer}: 

689 return ['bow'] 

690 

691 if model in {FeatureHasher}: 

692 return ['key-str-col'] 

693 

694 if model in {OneHotEncoder}: 

695 return ['one-hot'] 

696 

697 if model in {LabelBinarizer, LabelEncoder}: 

698 return ['int-col'] 

699 

700 if model in {NuSVC, SVC, SGDClassifier, 

701 HistGradientBoostingClassifier}: 

702 return ['b-cl', 'm-cl', '~b-cl-64', '~b-cl-nan'] 

703 

704 if model in {GaussianProcessClassifier}: 

705 return ['b-cl', 'm-cl', '~b-cl-64'] 

706 

707 if model in {BaggingClassifier, BernoulliNB, CalibratedClassifierCV,