see5-installer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1380fb827ffd5d330084fa570f9f68ac2a609f091fb74beea6ec452322e0a5b7
+  data.tar.gz: 4aac7f019a64516204120e9dcbdfe45e80683db2569f01e1f709d2c467bbbe7f
+SHA512:
+  metadata.gz: b1bfa5f9f0d52ce63134a64ced9e9900351e8f8e6017ac147ba4b1bdda4f382cf22743cc0eddbe85fa8681e8f262573a750584276a9d3472ec9e68b9f36a0344
+  data.tar.gz: ec7eca895ab7bf122b5947c89647cf481ed1af005ef14b43b4c50f706eb3cf626403970b929863a4c0a0d5b3f1bd62125423072cfa204942696ef6c6ae3b8764

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,11 @@
+---
+Style/ClassAndModuleChildren:
+  Exclude:
+    - "test/**"
+
+Style/Documentation:
+  Exclude:
+    - "test/**"
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.1.0] - 2021-03-24
+
+- Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in see5-installer.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"

data/README.md

@@ -0,0 +1,29 @@
+# See5::Installer
+
+This gem installs the executables `c5.0` and `gritbot`, which can be used by other gems. It provides no other functionality. The executable files are left inside the gem directory, so they do not make any unnecessary assumptions about the directory structure of the system.
+
+This repo contains snapshots of the source trees of C5.0 and GritBot, downloaded from <https://www.rulequest.com/download.html>. These packages are both licensed under GPL Version 3. The gem itself is licensed under the MIT License.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "see5-installer"
+```
+
+And then execute:
+
+```
+bundle install
+```
+
+Or install it yourself as:
+
+```
+gem install see5-installer
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at <https://github.com/elebow/see5-installer>.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/ext/c5.0/Makefile

@@ -0,0 +1,86 @@
+#*************************************************************************#
+#*									 *#
+#*		Makefile for the C5.0 system				 *#
+#*		----------------------------				 *#
+#*									 *#
+#*************************************************************************#
+
+
+CC	= gcc -ffloat-store
+CFLAGS = -g -Wall -DVerbOpt -O0
+LFLAGS = $(S)
+SHELL  = /bin/csh
+
+
+#	Definitions of file sets
+#	New file ordering suggested by gprof
+
+src =\
+	global.c\
+	c50.c\
+	construct.c\
+	formtree.c\
+	info.c\
+	discr.c\
+	contin.c\
+	subset.c\
+	prune.c\
+	p-thresh.c\
+	trees.c\
+	siftrules.c\
+	ruletree.c\
+	rules.c\
+	getdata.c\
+	implicitatt.c\
+	mcost.c\
+	confmat.c\
+	sort.c\
+	update.c\
+	attwinnow.c\
+	classify.c\
+	formrules.c\
+	getnames.c\
+	modelfiles.c\
+	utility.c\
+	xval.c
+
+obj =\
+	 c50.o global.o\
+	 construct.o formtree.o info.o discr.o contin.o subset.o prune.o\
+	 p-thresh.o trees.o\
+	 formrules.o siftrules.o ruletree.o rules.o\
+	 xval.o\
+	 getnames.o getdata.o implicitatt.o\
+	 mcost.o classify.o confmat.o sort.o\
+	 update.o utility.o\
+	 modelfiles.o\
+	 attwinnow.o\
+
+all:
+	make c5.0
+	$(CC) $(LFLAGS) -o report report.c -lm
+
+
+# debug version (including verbosity option)
+
+c5.0dbg:\
+	$(obj) defns.i extern.i text.i Makefile
+	$(CC) -g -o c5.0dbg $(obj) -lm
+
+
+# production version
+
+c5.0:\
+	$(src) defns.i text.i Makefile
+	cat defns.i $(src)\
+		| egrep -v 'defns.i|extern.i' >c50gt.c
+	$(CC) $(LFLAGS) -O3 -o c5.0 c50gt.c -lm
+	strip c5.0
+	rm c50gt.c
+
+
+$(obj):		Makefile defns.i extern.i text.i
+
+
+.c.o:
+	$(CC) $(CFLAGS) -c $<

data/ext/c5.0/attwinnow.c

@@ -0,0 +1,394 @@
+/*************************************************************************/
+/*									 */
+/*  Copyright 2010 Rulequest Research Pty Ltd.				 */
+/*									 */
+/*  This file is part of C5.0 GPL Edition, a single-threaded version	 */
+/*  of C5.0 release 2.07.						 */
+/*									 */
+/*  C5.0 GPL Edition is free software: you can redistribute it and/or	 */
+/*  modify it under the terms of the GNU General Public License as	 */
+/*  published by the Free Software Foundation, either version 3 of the	 */
+/*  License, or (at your option) any later version.			 */
+/*									 */
+/*  C5.0 GPL Edition is distributed in the hope that it will be useful,	 */
+/*  but WITHOUT ANY WARRANTY; without even the implied warranty of	 */
+/*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU	 */
+/*  General Public License for more details.				 */
+/*									 */
+/*  You should have received a copy of the GNU General Public License	 */
+/*  (gpl.txt) along with C5.0 GPL Edition.  If not, see 		 */
+/*									 */
+/*      <http://www.gnu.org/licenses/>.					 */
+/*									 */
+/*************************************************************************/
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Routines for winnowing attributes				 */
+/*	---------------------------------				 */
+/*									 */
+/*************************************************************************/
+
+
+#include "defns.i"
+#include "extern.i"
+
+float		*AttImp=Nil;		/* att importance */
+Boolean		*Split=Nil,		/* atts used in unpruned tree */
+		*Used=Nil;		/* atts used in pruned tree */
+
+
+/*************************************************************************/
+/*									 */
+/*	Winnow attributes by constructing a tree from half the data.	 */
+/*	Remove those that are never used as splits and those that	 */
+/*	increase error on the remaining data, and check that the new	 */
+/*	error cost does not increase					 */
+/*									 */
+/*************************************************************************/
+
+
+void WinnowAtts()
+/*   ----------  */
+{
+    Attribute	Att, Removed=0, Best;
+    CaseNo	i, Bp, Ep;
+    float	Base;
+    Boolean	First=true, *Upper;
+    ClassNo	c;
+    extern Attribute	*DList;
+    extern int		NDList;
+
+    /*  Save original case order  */
+
+    SaveCase = Alloc(MaxCase+1, DataRec);
+    ForEach(i, 0, MaxCase)
+    {
+	SaveCase[i] = Case[i];
+    }
+
+    /*  Split data into two halves with equal class frequencies  */
+
+    Upper = AllocZero(MaxClass+1, Boolean);
+
+    Bp = 0;
+    Ep = MaxCase;
+    ForEach(i, 0, MaxCase)
+    {
+	c = Class(SaveCase[i]);
+
+	if ( Upper[c] )
+	{
+	    Case[Ep--] = SaveCase[i];
+	}
+	else
+	{
+	    Case[Bp++] = SaveCase[i];
+	}
+
+	Upper[c] = ! Upper[c];
+    }
+
+    Free(Upper);
+
+    /*  Use first 50% of the cases for building a winnowing tree
+	and remaining 50% for measuring attribute importance  */
+
+    AttImp = AllocZero(MaxAtt+1, float);
+    Split  = AllocZero(MaxAtt+1, Boolean);
+    Used   = AllocZero(MaxAtt+1, Boolean);
+
+    Base = TrialTreeCost(true);
+
+    /*  Remove attributes when doing so would reduce error cost  */
+
+    ForEach(Att, 1, MaxAtt)
+    {
+	if ( AttImp[Att] < 0 )
+	{
+	    SpecialStatus[Att] ^= SKIP;
+	    Removed++;
+	}
+    }
+
+    /*  If any removed, rebuild tree and reinstate if error increases  */
+
+    if ( Removed && TrialTreeCost(false) > Base )
+    {
+	ForEach(Att, 1, MaxAtt)
+	{
+	    if ( AttImp[Att] < 0 )
+	    {
+		AttImp[Att] = 1;
+		SpecialStatus[Att] ^= SKIP;
+		Verbosity(1, fprintf(Of, "  re-including %s\n", AttName[Att]))
+	    }
+	}
+
+	Removed=0;
+    }
+
+    /*  Discard unused attributes  */
+
+    ForEach(Att, 1, MaxAtt)
+    {
+	if ( Att != ClassAtt && ! Skip(Att) && ! Split[Att] )
+	{
+	    SpecialStatus[Att] ^= SKIP;
+	    Removed++;
+	}
+    }
+
+    /*  Print summary of winnowing  */
+
+    if ( ! Removed )
+    {
+	fprintf(Of, T_NoWinnow);
+    }
+    else
+    {
+	fprintf(Of, T_AttributesWinnowed, Removed, Plural(Removed));
+
+	/*  Print remaining attributes ordered by importance  */
+
+	while ( true )
+	{
+	    Best = 0;
+	    ForEach(Att, 1, MaxAtt)
+	    {
+		if ( AttImp[Att] >= 1 &&
+		     ( ! Best || AttImp[Att] > AttImp[Best] ) )
+		{
+		    Best = Att;
+		}
+	    }
+	    if ( ! Best ) break;
+
+	    if ( First )
+	    {
+		fprintf(Of, T_EstImportance);
+		First = false;
+	    }
+	    if ( AttImp[Best] >= 1.005 )
+	    {
+		fprintf(Of, "%7d%%  %s\n",
+			    (int) ((AttImp[Best] - 1) * 100 + 0.5),
+			    AttName[Best]);
+	    }
+	    else
+	    {
+		fprintf(Of, "     <1%%  %s\n", AttName[Best]);
+	    }
+	    AttImp[Best] = 0;
+	}
+    }
+
+    if ( Removed )
+    {
+	Winnowed = true;
+
+	/*  Reset DList  */
+
+	NDList = 0;
+	ForEach(Att, 1, MaxAtt)
+	{
+	    if ( DFreq[Att] && ! Skip(Att) )
+	    {
+		DList[NDList++] = Att;
+	    }
+	}
+    }
+
+    /*  Restore case order and clean up  */
+
+    ForEach(i, 0, MaxCase)
+    {
+	Case[i] = SaveCase[i];
+    }
+
+    FreeUnlessNil(SaveCase);				SaveCase = Nil;
+    FreeUnlessNil(AttImp);				AttImp = Nil;
+    FreeUnlessNil(Split);				Split = Nil;
+    FreeUnlessNil(Used);				Used = Nil;
+
+    Now = 0;
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Build trial tree and check error cost on remaining data.	 */
+/*	If first time, note split attributes and check effect of	 */
+/*	removing every attribute					 */
+/*									 */
+/*************************************************************************/
+
+
+float TrialTreeCost(Boolean FirstTime)
+/*    -------------  */
+{
+    Attribute	Att;
+    float	Base, Cost, SaveMINITEMS;
+    CaseNo	SaveMaxCase, Cut;
+    int		SaveVERBOSITY;
+
+    Verbosity(1,
+	fprintf(Of, ( FirstTime ? "\nWinnow cycle:\n" : "\nCheck:\n" )))
+
+    /*  Build and prune trial tree  */
+
+    SaveMaxCase   = MaxCase;
+    SaveVERBOSITY = VERBOSITY;
+    SaveMINITEMS  = MINITEMS;
+    MINITEMS      = Max(MINITEMS / 2, 2.0);
+
+    Cut = (MaxCase+1) / 2 - 1;
+
+    InitialiseWeights();
+    LEAFRATIO = 0;
+    VERBOSITY = 0;
+    MaxCase   = Cut;
+
+    memset(Tested, 0, MaxAtt+1);		/* reset tested attributes */
+
+    SetMinGainThresh();
+    FormTree(0, Cut, 0, &WTree);
+
+    if ( FirstTime )
+    {
+	/*  Find attributes used in unpruned tree  */
+
+	ScanTree(WTree, Split);
+    }
+
+    Prune(WTree);
+
+    VERBOSITY = SaveVERBOSITY;
+    MaxCase   = SaveMaxCase;
+    MINITEMS  = SaveMINITEMS;
+
+    Verbosity(2,
+	PrintTree(WTree, "Winnowing tree:");
+	fprintf(Of, "\n  training error cost %g\n", ErrCost(WTree, 0, Cut)))
+
+    Base = ErrCost(WTree, Cut+1, MaxCase);
+
+    Verbosity(1,
+	fprintf(Of, "  initial error cost %g\n", Base))
+
+    if ( FirstTime )
+    {
+	/*  Check each attribute used in pruned tree  */
+
+	ScanTree(WTree, Used);
+
+	ForEach(Att, 1, MaxAtt)
+	{
+
+	    if ( ! Used[Att] )
+	    {
+		Verbosity(1,
+		    if ( Att != ClassAtt && ! Skip(Att) )
+		    {
+			fprintf(Of, "  %s not used\n", AttName[Att]);
+		    })
+
+		if ( Split[Att] )
+		{
+		    AttImp[Att] = 1;
+		}
+
+		continue;
+	    }
+
+	    /*  Determine error cost if this attribute omitted  */
+
+	    SpecialStatus[Att] ^= SKIP;
+
+	    Cost = ErrCost(WTree, Cut+1, MaxCase);
+
+	    AttImp[Att] = ( Cost < Base ? -1 : Cost / Base );
+	    Verbosity(1,
+		fprintf(Of, "  error cost without %s = %g%s\n",
+			    AttName[Att], Cost,
+			    ( Cost < Base ? " - excluded" : "" )))
+
+	    SpecialStatus[Att] ^= SKIP;
+	}
+    }
+
+    if ( WTree )
+    {
+	FreeTree(WTree);				WTree = Nil;
+    }
+
+    return Base;
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Determine the error rate or cost of T on cases Fp through Lp	 */
+/*									 */
+/*************************************************************************/
+
+
+float ErrCost(Tree T, CaseNo Fp, CaseNo Lp)
+/*    -------  */
+{
+    CaseNo	i;
+    float	ErrCost=0;
+    ClassNo	Pred;
+
+    if ( MCost )
+    {
+	ForEach(i, Fp, Lp)
+	{
+	    if ( (Pred = TreeClassify(Case[i], T)) != Class(Case[i]) )
+	    {
+		ErrCost += MCost[Pred][Class(Case[i])];
+	    }
+	}
+    }
+    else
+    {
+	ForEach(i, Fp, Lp)
+	{
+	    if ( TreeClassify(Case[i], T) != Class(Case[i]) )
+	    {
+		ErrCost += 1.0;
+	    }
+	}
+    }
+
+    return ErrCost;
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Find attributes used in tree T					 */
+/*									 */
+/*************************************************************************/
+
+
+void ScanTree(Tree T, Boolean *Used)
+/*   --------  */
+{
+    DiscrValue	v;
+
+    if ( T->NodeType )
+    {
+	Used[T->Tested] = true;
+
+	ForEach(v, 1, T->Forks)
+	{
+	    ScanTree(T->Branch[v], Used);
+	}
+    }
+}