Remove Machine subclasses from SWIG (#5057)

* remove machine classes from swig

* remove multiclass classes

.ci/docker-steps.yml

@@ -112,7 +112,7 @@ steps:
  LD_LIBRARY_PATH=/build/src/shogun:$LD_LIBRARY_PATH
  workDir: '/src/doc/ipython-notebooks'
  containerCommand: |
- /bin/bash -c "export PYTHONPATH=/build/src/interfaces/python:$PYTHONPATH; pip3 install wheel; pip3 install Pillow scikit-learn networkx opencv-python opencv-contrib-python jupyter; /src/scripts/test_notebooks.sh . $(grep -c ^processor /proc/cpuinfo)"
+ /bin/bash -c "export PYTHONPATH=/build/src/interfaces/python:$PYTHONPATH; pip3 install wheel; pip3 install Pillow scikit-learn networkx opencv-python opencv-contrib-python jupyter; /src/scripts/test_notebooks.sh . 1"
  detached: false
 
 - ${{ if ne(parameters.swig, 'true') }}:

doc/ipython-notebooks/classification/SupportVectorMachines.ipynb

@@ -555,7 +555,7 @@
  " Y_.append(traindata[1][j])\n",
  " new_labels.append(trainlab[j])\n",
  " out1=svm1.apply(grid)\n",
- " z1=out1.get_labels().reshape((size, size))\n",
+ " z1=out1.get(\"labels\").reshape((size, size))\n",
  " plt.jet()\n",
  " c=plt.pcolor(x1_, x2_, z1)\n",
  " plt.contour(x1_ , x2_, z1, linewidths=1, colors='black')\n",
@@ -933,7 +933,7 @@
  "metadata": {},
  "outputs": [],
  "source": [
- "svm=sg.GMNPSVM(1, gaussian_kernel, labels)\n",
+ "svm=sg.create_machine(\"GMNPSVM\", C=1, kernel=gaussian_kernel, labels=labels)\n",
  "_=svm.train(feats_train)\n",
  "\n",
  "size=100\n",
@@ -947,10 +947,10 @@
  " for i in range(len(kernels)):\n",
  " plt.subplot(1,len(kernels),i+1)\n",
  " plt.title(kernels[i].get_name())\n",
- " svm.set_kernel(kernels[i])\n",
+ " svm.put(\"kernel\", kernels[i])\n",
  " svm.train(feats_train)\n",
  " grid_out=svm.apply(grid)\n",
- " z=grid_out.get_labels().reshape((size, size))\n",
+ " z=grid_out.get(\"labels\").reshape((size, size))\n",
  " plt.pcolor(x, y, z)\n",
  " plt.contour(x, y, z, linewidths=1, colors='black')\n",
  " plt.colorbar(c)\n",
@@ -1001,7 +1001,7 @@
  "name": "python",
  "nbconvert_exporter": "python",
  "pygments_lexer": "ipython3",
- "version": "3.7.3"
+ "version": "3.7.1"
  }
  },
  "nbformat": 4,

doc/ipython-notebooks/multiclass/multiclass_reduction.ipynb

@@ -203,10 +203,13 @@
  " bin_machine = sg.create_machine(\"LibLinear\", liblinear_solver_type=\"L2R_L2LOSS_SVC\",\n",
  " use_bias=True, C1=C, C2=C)\n",
  "\n",
- " mc_machine = sg.LinearMulticlassMachine(strategy, feats_train, bin_machine, lab_train)\n",
+ " mc_machine = sg.create_machine(\"LinearMulticlassMachine\",\n",
+ " multiclass_strategy=strategy, \n",
+ " machine=bin_machine, \n",
+ " labels=lab_train)\n",
  "\n",
  " t_begin = time.process_time()\n",
- " mc_machine.train()\n",
+ " mc_machine.train(feats_train)\n",
  " t_train = time.process_time() - t_begin\n",
  "\n",
  " t_begin = time.process_time()\n",
@@ -236,11 +239,11 @@
  "source": [
  "print(\"\\nOne-vs-Rest\")\n",
  "print(\"=\"*60)\n",
- "evaluate(sg.MulticlassOneVsRestStrategy(), 5.0)\n",
+ "evaluate(sg.create_multiclass_strategy(\"MulticlassOneVsRestStrategy\"), 5.0)\n",
  "\n",
  "print(\"\\nOne-vs-One\")\n",
  "print(\"=\"*60)\n",
- "evaluate(sg.MulticlassOneVsOneStrategy(), 2.0)"
+ "evaluate(sg.create_multiclass_strategy(\"MulticlassOneVsOneStrategy\"), 2.0)"
  ]
  },
  {
@@ -466,7 +469,11 @@
  " \n",
  " classifier = sg.create_machine(\"LibSVM\", epsilon=epsilon)\n",
  "\n",
- " mc_machine = sg.KernelMulticlassMachine(strategy, kernel, classifier, lab_train)\n",
+ " mc_machine = sg.create_machine(\"KernelMulticlassMachine\",\n",
+ " multiclass_strategy=strategy, \n",
+ " kernel=kernel, \n",
+ " machine=classifier,\n",
+ " labels=lab_train)\n",
  "\n",
  " t_begin = time.process_time()\n",
  " mc_machine.train()\n",
@@ -485,7 +492,7 @@
  "\n",
  "print(\"\\nOne-vs-Rest\")\n",
  "print(\"=\"*60)\n",
- "evaluate_multiclass_kernel(sg.MulticlassOneVsRestStrategy())"
+ "evaluate_multiclass_kernel(sg.create_multiclass_strategy(\"MulticlassOneVsRestStrategy\"))"
  ]
  },
  {
@@ -599,7 +606,11 @@
  " \n",
  "classifier=sg.create_machine(\"LibSVM\", epsilon=epsilon)\n",
  "\n",
- "mc_machine=sg.KernelMulticlassMachine(sg.MulticlassOneVsRestStrategy(), kernel, classifier, labels)\n",
+ "mc_machine=sg.create_machine(\"KernelMulticlassMachine\",\n",
+ " multiclass_strategy=sg.create_multiclass_strategy(\"MulticlassOneVsRestStrategy\"),\n",
+ " kernel=kernel, \n",
+ " machine=classifier, \n",
+ " labels=labels)\n",
  "\n",
  "mc_machine.train()\n",
  "\n",
@@ -612,8 +623,8 @@
  "out=mc_machine.apply_multiclass(grid) #main output\n",
  "z=out.get(\"labels\").reshape((size, size))\n",
  "\n",
- "sub_out0=mc_machine.get_submachine_outputs(0) #first submachine\n",
- "sub_out1=mc_machine.get_submachine_outputs(1) #second submachine\n",
+ "sub_out0=sg.as_machine(mc_machine.get(\"machines\", 0)).apply_binary() #first submachine\n",
+ "sub_out1=sg.as_machine(mc_machine.get(\"machines\", 1)).apply_binary() #second submachine\n",
  "\n",
  "z0=sub_out0.get_labels().reshape((size, size))\n",
  "z1=sub_out1.get_labels().reshape((size, size))\n",
@@ -655,14 +666,17 @@
  "bin_machine = sg.create_machine(\"LibLinear\", liblinear_solver_type=\"L2R_L2LOSS_SVC\",\n",
  " use_bias=True, C1=C, C2=C)\n",
  "\n",
- "mc_machine1 = sg.LinearMulticlassMachine(sg.MulticlassOneVsOneStrategy(), feats_tr, bin_machine, labels)\n",
- "mc_machine1.train()\n",
+ "mc_machine1 = sg.create_machine(\"LinearMulticlassMachine\",\n",
+ " multiclass_strategy=sg.create_multiclass_strategy(\"MulticlassOneVsOneStrategy\"),\n",
+ " machine=bin_machine, \n",
+ " labels=labels)\n",
+ "mc_machine1.train(feats_tr)\n",
  "\n",
  "out1=mc_machine1.apply_multiclass(grid) #main output\n",
  "z1=out1.get_labels().reshape((size, size))\n",
  "\n",
- "sub_out10=mc_machine1.get_submachine_outputs(0) #first submachine\n",
- "sub_out11=mc_machine1.get_submachine_outputs(1) #second submachine\n",
+ "sub_out10=sg.as_machine(mc_machine.get(\"machines\", 0)).apply_binary() #first submachine\n",
+ "sub_out11=sg.as_machine(mc_machine.get(\"machines\", 1)).apply_binary() #second submachine\n",
  "\n",
  "z10=sub_out10.get_labels().reshape((size, size))\n",
  "z11=sub_out11.get_labels().reshape((size, size))\n",
@@ -714,7 +728,7 @@
  "name": "python",
  "nbconvert_exporter": "python",
  "pygments_lexer": "ipython3",
- "version": "3.7.3"
+ "version": "3.7.1"
  }
  },
  "nbformat": 4,

examples/meta/src/multiclass/k_nearest_neighbours.sg.in

@@ -6,8 +6,8 @@ CSVFile f_labels_test("@SHOGUN_DATA@/classifier_4class_2d_linear_labels_test.dat
 #![create_features]
 Features features_train = create_features(f_feats_train)
 Features features_test = create_features(f_feats_test)
-MulticlassLabels labels_train(f_labels_train)
-MulticlassLabels labels_test(f_labels_test)
+Labels labels_train = create_labels(f_labels_train)
+Labels labels_test = create_labels(f_labels_test)
 #![create_features]
 
 #![choose_distance]
@@ -16,7 +16,7 @@ Distance d = create_distance("EuclideanDistance", lhs=features_train, rhs=featur
 
 #![create_instance]
 int k = 3
-KNN knn(k, d, labels_train)
+Machine knn = create_machine("KNN", k=k, distance=d, labels=labels_train)
 #![create_instance]
 
 #![train_and_apply]

examples/meta/src/multiclass/large_margin_nearest_neighbours.sg.in

@@ -6,8 +6,8 @@ CSVFile f_labels_test("@SHOGUN_DATA@/classifier_4class_2d_linear_labels_test.dat
 #![create_features]
 Features features_train = create_features(f_feats_train)
 Features features_test = create_features(f_feats_test)
-MulticlassLabels labels_train(f_labels_train)
-MulticlassLabels labels_test(f_labels_test)
+Labels labels_train = create_labels(f_labels_train)
+Labels labels_test = create_labels(f_labels_test)
 #![create_features]
 
 #![create_instance]
@@ -21,7 +21,7 @@ Distance lmnn_distance = lmnn.get_distance()
 #![train_metric]
 
 #![train_and_apply]
-KNN knn(k, lmnn_distance,labels_train)
+Machine knn = create_machine("KNN", k=k, distance=lmnn_distance, labels=labels_train)
 knn.train()
 MulticlassLabels labels_predict = knn.apply_multiclass(features_test) 
 #![train_and_apply]

examples/undocumented/python/classifier_multiclass_ecoc.py

@@ -12,8 +12,6 @@
 
 def classifier_multiclass_ecoc (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,label_test_multiclass=label_testdat,lawidth=2.1,C=1,epsilon=1e-5):
 
- from shogun import ECOCStrategy, LinearMulticlassMachine
- from shogun import MulticlassLabels
  import shogun as sg
 
  def nonabstract_class(name):
@@ -30,11 +28,11 @@ def nonabstract_class(name):
 
  fea_train = sg.create_features(fm_train_real)
  fea_test = sg.create_features(fm_test_real)
- gnd_train = MulticlassLabels(label_train_multiclass)
+ gnd_train = sg.create_labels(label_train_multiclass)
  if label_test_multiclass is None:
  gnd_test = None
  else:
- gnd_test = MulticlassLabels(label_test_multiclass)
+ gnd_test = sg.create_labels(label_test_multiclass)
 
  base_classifier = sg.create_machine("LibLinear",
  liblinear_solver_type="L2R_L2LOSS_SVC",
@@ -54,17 +52,18 @@ def run_ecoc(ier, idr):
  encoder.put('labels', gnd_train)
  encoder.put('features', fea_train)
 
- strategy = ECOCStrategy(encoder, decoder)
- classifier = LinearMulticlassMachine(strategy, fea_train, base_classifier, gnd_train)
- classifier.train()
+ strategy = sg.ECOCStrategy(encoder, decoder)
+ classifier = sg.create_machine("LinearMulticlassMachine", multiclass_strategy=strategy, 
+ machine=base_classifier, labels=gnd_train)
+ classifier.train(fea_train)
  label_pred = classifier.apply(fea_test)
  if gnd_test is not None:
  evaluator = sg.create_evaluation("MulticlassAccuracy")
  acc = evaluator.evaluate(label_pred, gnd_test)
  else:
  acc = None
 
- return (classifier.get_num_machines(), acc)
+ return (len(classifier.get("machines")), acc)
 
 
  for ier in range(len(encoders)):

examples/undocumented/python/classifier_multiclassocas.py

@@ -4,12 +4,12 @@
 
 def classifier_multiclassocas (num_vec=10,num_class=3,distance=15,width=2.1,C=1,epsilon=1e-5,seed=1):
  from shogun import MulticlassLabels
+ import shogun as sg
  try:
- from shogun import MulticlassOCAS
+ sg.create_machine("MulticlassOCAS")
  except ImportError:
  print("MulticlassOCAS not available")
  return
- import shogun as sg
 
  # reproducible results
  random.seed(seed)
@@ -26,12 +26,12 @@ def classifier_multiclassocas (num_vec=10,num_class=3,distance=15,width=2.1,C=1,
  feats_train=sg.create_features(fm_train)
  feats_test=sg.create_features(fm_test)
 
- labels=MulticlassLabels(label_train)
+ labels=sg.create_labels(label_train)
 
- classifier = MulticlassOCAS(C,feats_train,labels)
- classifier.train()
+ classifier = sg.create_machine("MulticlassOCAS", labels=labels, C=C)
+ classifier.train(feats_train)
 
- out = classifier.apply(feats_test).get_labels()
+ out = classifier.apply(feats_test).get("labels")
  #print label_test
  #print out
  return out,classifier

examples/undocumented/python/kernel_histogram_word_string.py

@@ -9,9 +9,9 @@
 
 def kernel_histogram_word_string (fm_train_dna=traindat,fm_test_dna=testdat,label_train_dna=label_traindat,order=3,ppseudo_count=1,npseudo_count=1):
 
- from shogun import StringCharFeatures, StringWordFeatures, DNA, BinaryLabels
- from shogun import HistogramWordStringKernel, AvgDiagKernelNormalizer
- from shogun import PluginEstimate#, MSG_DEBUG
+ from shogun import StringCharFeatures, StringWordFeatures, DNA
+ from shogun import AvgDiagKernelNormalizer
+ import shogun as sg
 
  charfeat=StringCharFeatures(DNA)
  #charfeat.io.set_loglevel(MSG_DEBUG)
@@ -24,17 +24,15 @@ def kernel_histogram_word_string (fm_train_dna=traindat,fm_test_dna=testdat,labe
  feats_test=StringWordFeatures(charfeat.get_alphabet())
  feats_test.obtain_from_char(charfeat, order-1, order, 0, False)
 
- pie=PluginEstimate(ppseudo_count,npseudo_count)
- labels=BinaryLabels(label_train_dna)
- pie.set_labels(labels)
- pie.set_features(feats_train)
- pie.train()
+ labels=sg.create_labels(label_train_dna)
+ pie=sg.create_machine("PluginEstimate", pos_pseudo=ppseudo_count, neg_pseudo=npseudo_count, labels=labels)
+ pie.train(feats_train)
 
- kernel=HistogramWordStringKernel(feats_train, feats_train, pie)
+ kernel=sg.create_kernel("HistogramWordStringKernel", estimate=pie)
+ kernel.init(feats_train, feats_train)
  km_train=kernel.get_kernel_matrix()
  kernel.init(feats_train, feats_test)
- pie.set_features(feats_test)
- pie.apply().get_labels()
+ pie.apply(feats_test).get("labels")
  km_test=kernel.get_kernel_matrix()
  return km_train,km_test,kernel
 

examples/undocumented/python/kernel_salzberg_word_string.py

@@ -10,7 +10,7 @@ def kernel_salzberg_word_string (fm_train_dna=traindat,fm_test_dna=testdat,label
 order=3,gap=0,reverse=False):
  from shogun import StringCharFeatures, StringWordFeatures, DNA, BinaryLabels
  from shogun import SalzbergWordStringKernel
- from shogun import PluginEstimate
+ import shogun as sg
 
  charfeat=StringCharFeatures(fm_train_dna, DNA)
  feats_train=StringWordFeatures(charfeat.get_alphabet())
@@ -20,18 +20,15 @@ def kernel_salzberg_word_string (fm_train_dna=traindat,fm_test_dna=testdat,label
  feats_test=StringWordFeatures(charfeat.get_alphabet())
  feats_test.obtain_from_char(charfeat, order-1, order, gap, reverse)
 
- pie=PluginEstimate()
- labels=BinaryLabels(label_train_dna)
- pie.set_labels(labels)
- pie.set_features(feats_train)
- pie.train()
+ labels=sg.create_labels(label_train_dna)
+ pie=sg.create_machine("PluginEstimate", labels=labels)
+ pie.train(feats_train)
 
- kernel=SalzbergWordStringKernel(feats_train, feats_train, pie, labels)
+ kernel=sg.SalzbergWordStringKernel(feats_train, feats_train, pie, labels)
  km_train=kernel.get_kernel_matrix()
 
  kernel.init(feats_train, feats_test)
- pie.set_features(feats_test)
- pie.apply().get_labels()
+ pie.apply(feats_test).get("labels")
  km_test=kernel.get_kernel_matrix()
  return km_train,km_test,kernel
 

examples/undocumented/python/metric_lmnn.py

@@ -8,25 +8,25 @@
 
 def metric_lmnn(train_fname=traindat,test_fname=testdat,label_train_fname=label_traindat,k=3):
  try:
- from shogun import MulticlassLabels,LMNN,KNN
+ from shogun import LMNN
  except ImportError:
  return
  import shogun as sg
 
  # wrap features and labels into Shogun objects
  feats_train=sg.create_features(sg.read_csv(train_fname))
  feats_test=sg.create_features(sg.read_csv(test_fname))
- labels=MulticlassLabels(sg.read_csv(label_train_fname))
+ labels=sg.create_labels(sg.read_csv(label_train_fname))
 
  # LMNN
- lmnn=LMNN(feats_train,labels,k)
+ lmnn=sg.LMNN(feats_train,labels,k)
  lmnn.train()
  lmnn_distance=lmnn.get_distance()
 
  # perform classification with KNN
- knn=KNN(k,lmnn_distance,labels)
+ knn=sg.create_machine("KNN", k=k,distance=lmnn_distance,labels=labels)
  knn.train()
- output=knn.apply(feats_test).get_labels()
+ output=knn.apply(feats_test).get("labels")
 
  return lmnn,output