text: # Copyright 2019 IBM Corporation
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  # http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  
  import unittest
  import warnings
  import random
  import sys
  import lale.operators as Ops
  from lale.lib.lale import ConcatFeatures
  from lale.lib.lale import NoOp
  from lale.lib.sklearn import KNeighborsClassifier
  from lale.lib.sklearn import LinearSVC
  from lale.lib.sklearn import LogisticRegression
  from lale.lib.sklearn import MinMaxScaler
  from lale.lib.sklearn import MLPClassifier
  from lale.lib.sklearn import Nystroem
  from lale.lib.sklearn import OneHotEncoder
  from lale.lib.sklearn import PCA
  from lale.lib.sklearn import TfidfVectorizer
  from lale.lib.sklearn import MultinomialNB
  from lale.lib.sklearn import SimpleImputer
  from lale.lib.sklearn import SVC
  from lale.lib.xgboost import XGBClassifier
  from lale.lib.sklearn import PassiveAggressiveClassifier
  from lale.lib.sklearn import StandardScaler
  from lale.lib.sklearn import FeatureAgglomeration
  from typing import List
  import lale.type_checking
  
  import sklearn.datasets
  
  from lale.sklearn_compat import make_sklearn_compat
  from lale.search.lale_smac import get_smac_space, lale_trainable_op_from_config
  from lale.search.op2hp import hyperopt_search_space
  
  @unittest.skip("Skipping here because travis-ci fails to allocate memory. This runs on internal travis.")
  class TestResNet50(unittest.TestCase):
      def test_init_fit_predict(self):
          import torchvision.datasets as datasets
          import torchvision.transforms as transforms
          from lale.lib.pytorch import ResNet50
  
          transform = transforms.Compose([transforms.ToTensor()])
  
          data_train = datasets.FakeData(size = 50, num_classes=2 , transform = transform)#, target_transform = transform)
          clf = ResNet50(num_classes=2,num_epochs = 1)
          clf.fit(data_train)
          predicted = clf.predict(data_train)
  
  
  class TestResamplers(unittest.TestCase):
  
      def setUp(self):
          from sklearn.datasets import make_classification
          from sklearn.model_selection import train_test_split
          X, y = make_classification(n_classes=2, class_sep=2,
              weights=[0.1, 0.9], n_informative=3, n_redundant=1, flip_y=0,
              n_features=20, n_clusters_per_class=1, n_samples=1000, random_state=10)
          self.X_train, self.X_test, self.y_train, self.y_test =  train_test_split(X, y)    
  
  def create_function_test_resampler(res_name):
      def test_resampler(self):
          from lale.lib.sklearn import PCA, Nystroem, LogisticRegression, RandomForestClassifier
          from lale.lib.lale import NoOp, ConcatFeatures
          X_train, y_train = self.X_train, self.y_train
          X_test, y_test = self.X_test, self.y_test
          import importlib
          module_name = ".".join(res_name.split('.')[0:-1])
          class_name = res_name.split('.')[-1]
          module = importlib.import_module(module_name)
  
          class_ = getattr(module, class_name)
          with self.assertRaises(ValueError):
              res = class_()
  
          #test_schemas_are_schemas
          lale.type_checking.validate_is_schema(class_.input_schema_fit())
          lale.type_checking.validate_is_schema(class_.input_schema_predict())
          lale.type_checking.validate_is_schema(class_.output_schema_predict())
          lale.type_checking.validate_is_schema(class_.hyperparam_schema())
  
          #test_init_fit_predict
          from lale.operators import make_pipeline
          pipeline1 = PCA() >> class_(operator=make_pipeline(LogisticRegression()))
          trained = pipeline1.fit(X_train, y_train)
          predictions = trained.predict(X_test)
  
          pipeline2 = class_(operator=make_pipeline(PCA(), LogisticRegression()))
          trained = pipeline2.fit(X_train, y_train)
          predictions = trained.predict(X_test)
  
          #test_with_hyperopt
          from lale.lib.lale import Hyperopt
          optimizer = Hyperopt(estimator=PCA >> class_(operator=make_pipeline(LogisticRegression())), max_evals = 1, show_progressbar=False)
          trained_optimizer = optimizer.fit(X_train, y_train)
          predictions = trained_optimizer.predict(X_test)
  
          pipeline3 = class_(operator= PCA() >> (Nystroem & NoOp) >> ConcatFeatures >> LogisticRegression())
          optimizer = Hyperopt(estimator=pipeline3, max_evals = 1, show_progressbar=False)
          trained_optimizer = optimizer.fit(X_train, y_train)
          predictions = trained_optimizer.predict(X_test)
  
          pipeline4 = (PCA >> class_(operator=make_pipeline(Nystroem())) & class_(operator=make_pipeline(Nystroem()))) >> ConcatFeatures >> LogisticRegression()
          optimizer = Hyperopt(estimator=pipeline4, max_evals = 1, scoring='roc_auc', show_progressbar=False)
          trained_optimizer = optimizer.fit(X_train, y_train)
          predictions = trained_optimizer.predict(X_test)
  
          #test_cross_validation
          from lale.helpers import cross_val_score
          cv_results = cross_val_score(pipeline1, X_train, y_train, cv = 2)
          self.assertEqual(len(cv_results), 2)
  
          #test_to_json
          pipeline1.to_json()
  
      test_resampler.__name__ = 'test_{0}'.format(res_name.split('.')[-1])
      return test_resampler
  
  resamplers = ['lale.lib.imblearn.SMOTE',
                'lale.lib.imblearn.SMOTEENN',
                'lale.lib.imblearn.ADASYN',
                'lale.lib.imblearn.BorderlineSMOTE',
                'lale.lib.imblearn.SVMSMOTE',
                'lale.lib.imblearn.RandomOverSampler',
                'lale.lib.imblearn.CondensedNearestNeighbour',
                'lale.lib.imblearn.EditedNearestNeighbours',
                'lale.lib.imblearn.RepeatedEditedNearestNeighbours',
                'lale.lib.imblearn.AllKNN',
                'lale.lib.imblearn.InstanceHardnessThreshold']
  
  for res in resamplers:
      setattr(
          TestResamplers,
          'test_{0}'.format(res.split('.')[-1]),
          create_function_test_resampler(res)
      )
  
  class TestImblearn(unittest.TestCase):
      def setUp(self):
          from sklearn.datasets import make_classification
          from sklearn.model_selection import train_test_split
          X, y = make_classification(n_classes=2, class_sep=2,
              weights=[0.1, 0.9], n_informative=3, n_redundant=1, flip_y=0,
              n_features=20, n_clusters_per_class=1, n_samples=1000, random_state=10)
          self.X_train, self.X_test, self.y_train, self.y_test =  train_test_split(X, y)    
  
      def test_decision_function(self):
          from lale.lib.imblearn import SMOTE
          from lale.operators import make_pipeline
          from lale.lib.sklearn import RandomForestClassifier
          smote = SMOTE(operator=make_pipeline(RandomForestClassifier()))
          trained = smote.fit(self.X_train, self.y_train)
          trained.predict(self.X_test)
          with self.assertRaises(AttributeError):
              trained.decision_function(self.X_test)
      
      def test_string_labels(self):
          from lale.lib.imblearn import CondensedNearestNeighbour
          print(type(CondensedNearestNeighbour))
          from lale.operators import make_pipeline
          y_train = ['low' if label==0 else 'high' for label in self.y_train]
          pipeline = CondensedNearestNeighbour(operator=make_pipeline(PCA(), LogisticRegression()), sampling_strategy=['high'])
          trained = pipeline.fit(self.X_train, y_train)
          predictions = trained.predict(self.X_test)
  