Importieren Sie Lisp -Daten in RapidMiner (CSV,…)

Question

Ich habe Daten in Lisp -Form und muss sie in RapidMiner verarbeiten. Ich bin neu in Lisp und RapidMiner. RapidMiner akzeptiert das Lisp nicht (ich denke, es liegt daran, dass es die Programmiersprache ist), daher muss ich wahrscheinlich irgendwie irgendwie in CSV oder so etwas konvertieren. Keines Beispiel für Code:

(def-instance Adelphi
   (state newyork)
   (control private)
   (no-of-students thous:5-10)
   ...)
(def-instance Arizona-State
   (state arizona)
   (control state)
   (no-of-students thous:20+)
   ...)
(def-instance Boston-College
   (state massachusetts)
   (location suburban)
   (control private:roman-catholic)
   (no-of-students thous:5-10)
   ...)

Ich wäre wirklich dankbar für jeden Rat.

Answer 1

Sie können die Tatsache nutzen, dass LISPs Parser dem Lisp -Benutzer zur Verfügung steht. Ein Problem mit diesen Daten ist, dass einige Werte Colons enthalten, mit dem Packungsnamenabscheider in Common Lisp verwendet wird. Ich habe einige gemeinsame LISP -Code erstellt, um Ihre Frage zu lösen, aber ich musste das erwähnte Problem durch die Definition geeigneter Pakete umgehen.

Hier ist der Code, der natürlich erweitert werden muss (folgt den gleichen Mustern, die bereits darin verwendet werden) für alles, was Sie in dem Beispiel in Ihrer Frage ausgelassen haben:

(defpackage #:thous
  (:export #:5-10 #:20+))
(defpackage #:private
  (:export #:roman-catholic))

(defstruct (college (:conc-name nil))
  (name "")
  (state "")
  (location "")
  (control "")
  (no-of-students ""))

(defun data->college (name data)
  (let ((college (make-college :name (write-to-string name :case :capitalize))))
    (loop for (key value) in data
       for string = (remove #\| (write-to-string value :case :downcase))
       do (case key
            (state (setf (state college) string))
            (location (setf (location college) string))
            (control (setf (control college) string))
            (no-of-students (setf (no-of-students college) string))))
    college))

(defun read-data (stream)
  (loop for (def-instance name . data) = (read stream nil nil)
     while def-instance
     collect (data->college name data)))

(defun print-college-as-csv (college stream)
  (format stream
          "~a~{,~a~}~%"
          (name college)
          (list (state college)
                (location college)
                (control college)
                (no-of-students college))))

(defun data->csv (in out)
  (let ((header (make-college :name "College"
                              :state "state"
                              :location "location"
                              :control "control"
                              :no-of-students "no-of-students")))
    (print-college-as-csv header out)
    (dolist (college (read-data in))
      (print-college-as-csv college out))))

(defun data-file-to-csv (input-file output-file)
  (with-open-file (in input-file)
   (with-open-file (out output-file
                        :direction :output
                        :if-does-not-exist :create
                        :if-exists :supersede)
     (data->csv in out))))

Die Hauptfunktion ist Data-File-to-CSV, die aufgerufen werden kann (data-file-to-csv "path-to-input-file" "path-to-output-file") in einer gemeinsamen Lisp -Replikation nach dem Laden dieses Code.

Bearbeiten: Einige zusätzliche Gedanken

Es wäre tatsächlich einfacher, anstatt Paketdefinitionen für alle Werte mit Kolons hinzuzufügen, um eine regelmäßige Ausdrucksuche durchzuführen und über die Daten zu ersetzen, um alle Werte um Zitate (") hinzuzufügen. Dadurch werden sie sofort als Zeichenfolgen analysieren. In diesem Fall die Linie for string = (remove #\| (write-to-string value :case :downcase)) könnte entfernt werden und string ersetzt werden durch value in allen Zeilen der case Aussage.

Aufgrund der hohen Regelmäßigkeit der Daten sollte es nicht einmal notwendig sein, die Lisp -Definitionen überhaupt korrekt zu analysieren. Stattdessen können Sie die Daten einfach mit regulären Ausdrücken extrahieren. Eine Sprache, die besonders für die Regex-basierte Transformation von Textdateien geeignet ist, sollte für diesen Job wie awk oder perl in Ordnung sein.