487 lines
12 KiB
Java
487 lines
12 KiB
Java
import libsvm.*;
|
|
import java.awt.*;
|
|
import java.util.*;
|
|
import java.awt.event.*;
|
|
import java.io.*;
|
|
|
|
public class svm_toy {
|
|
public static void main(String[] args) {
|
|
svm_toy_frame frame = new svm_toy_frame("svm_toy", 500, 500+50);
|
|
}
|
|
}
|
|
class svm_toy_frame extends Frame {
|
|
|
|
static final String DEFAULT_PARAM="-t 2 -c 100";
|
|
int XLEN;
|
|
int YLEN;
|
|
|
|
// off-screen buffer
|
|
|
|
Image buffer;
|
|
Graphics buffer_gc;
|
|
|
|
// pre-allocated colors
|
|
|
|
final static Color colors[] =
|
|
{
|
|
new Color(0,0,0),
|
|
new Color(0,120,120),
|
|
new Color(120,120,0),
|
|
new Color(120,0,120),
|
|
new Color(0,200,200),
|
|
new Color(200,200,0),
|
|
new Color(200,0,200)
|
|
};
|
|
|
|
class point {
|
|
point(double x, double y, byte value)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
this.value = value;
|
|
}
|
|
double x, y;
|
|
byte value;
|
|
}
|
|
|
|
Vector<point> point_list = new Vector<point>();
|
|
byte current_value = 1;
|
|
|
|
svm_toy_frame(String title, int width, int height)
|
|
{
|
|
super(title);
|
|
this.addWindowListener(new WindowAdapter() {
|
|
public void windowClosing(WindowEvent e) {
|
|
System.exit(0);
|
|
}
|
|
});
|
|
this.init();
|
|
this.setSize(width, height);
|
|
XLEN = width;
|
|
YLEN = height-50;
|
|
this.clear_all();
|
|
this.setVisible(true);
|
|
}
|
|
|
|
void init()
|
|
{
|
|
final Button button_change = new Button("Change");
|
|
Button button_run = new Button("Run");
|
|
Button button_clear = new Button("Clear");
|
|
Button button_save = new Button("Save");
|
|
Button button_load = new Button("Load");
|
|
final TextField input_line = new TextField(DEFAULT_PARAM);
|
|
|
|
BorderLayout layout = new BorderLayout();
|
|
this.setLayout(layout);
|
|
|
|
Panel p = new Panel();
|
|
GridBagLayout gridbag = new GridBagLayout();
|
|
p.setLayout(gridbag);
|
|
|
|
GridBagConstraints c = new GridBagConstraints();
|
|
c.fill = GridBagConstraints.HORIZONTAL;
|
|
c.weightx = 1;
|
|
c.gridwidth = 1;
|
|
gridbag.setConstraints(button_change,c);
|
|
gridbag.setConstraints(button_run,c);
|
|
gridbag.setConstraints(button_clear,c);
|
|
gridbag.setConstraints(button_save,c);
|
|
gridbag.setConstraints(button_load,c);
|
|
c.weightx = 5;
|
|
c.gridwidth = 5;
|
|
gridbag.setConstraints(input_line,c);
|
|
|
|
button_change.setBackground(colors[current_value]);
|
|
|
|
p.add(button_change);
|
|
p.add(button_run);
|
|
p.add(button_clear);
|
|
p.add(button_save);
|
|
p.add(button_load);
|
|
p.add(input_line);
|
|
this.add(p,BorderLayout.SOUTH);
|
|
|
|
button_change.addActionListener(new ActionListener()
|
|
{ public void actionPerformed (ActionEvent e)
|
|
{ button_change_clicked(); button_change.setBackground(colors[current_value]); }});
|
|
|
|
button_run.addActionListener(new ActionListener()
|
|
{ public void actionPerformed (ActionEvent e)
|
|
{ button_run_clicked(input_line.getText()); }});
|
|
|
|
button_clear.addActionListener(new ActionListener()
|
|
{ public void actionPerformed (ActionEvent e)
|
|
{ button_clear_clicked(); }});
|
|
|
|
button_save.addActionListener(new ActionListener()
|
|
{ public void actionPerformed (ActionEvent e)
|
|
{ button_save_clicked(input_line.getText()); }});
|
|
|
|
button_load.addActionListener(new ActionListener()
|
|
{ public void actionPerformed (ActionEvent e)
|
|
{ button_load_clicked(); }});
|
|
|
|
input_line.addActionListener(new ActionListener()
|
|
{ public void actionPerformed (ActionEvent e)
|
|
{ button_run_clicked(input_line.getText()); }});
|
|
|
|
this.enableEvents(AWTEvent.MOUSE_EVENT_MASK);
|
|
}
|
|
|
|
void draw_point(point p)
|
|
{
|
|
Color c = colors[p.value+3];
|
|
|
|
Graphics window_gc = getGraphics();
|
|
buffer_gc.setColor(c);
|
|
buffer_gc.fillRect((int)(p.x*XLEN),(int)(p.y*YLEN),4,4);
|
|
window_gc.setColor(c);
|
|
window_gc.fillRect((int)(p.x*XLEN),(int)(p.y*YLEN),4,4);
|
|
}
|
|
|
|
void clear_all()
|
|
{
|
|
point_list.removeAllElements();
|
|
if(buffer != null)
|
|
{
|
|
buffer_gc.setColor(colors[0]);
|
|
buffer_gc.fillRect(0,0,XLEN,YLEN);
|
|
}
|
|
repaint();
|
|
}
|
|
|
|
void draw_all_points()
|
|
{
|
|
int n = point_list.size();
|
|
for(int i=0;i<n;i++)
|
|
draw_point(point_list.elementAt(i));
|
|
}
|
|
|
|
void button_change_clicked()
|
|
{
|
|
++current_value;
|
|
if(current_value > 3) current_value = 1;
|
|
}
|
|
|
|
private static double atof(String s)
|
|
{
|
|
return Double.valueOf(s).doubleValue();
|
|
}
|
|
|
|
private static int atoi(String s)
|
|
{
|
|
return Integer.parseInt(s);
|
|
}
|
|
|
|
void button_run_clicked(String args)
|
|
{
|
|
// guard
|
|
if(point_list.isEmpty()) return;
|
|
|
|
svm_parameter param = new svm_parameter();
|
|
|
|
// default values
|
|
param.svm_type = svm_parameter.C_SVC;
|
|
param.kernel_type = svm_parameter.RBF;
|
|
param.degree = 3;
|
|
param.gamma = 0;
|
|
param.coef0 = 0;
|
|
param.nu = 0.5;
|
|
param.cache_size = 40;
|
|
param.C = 1;
|
|
param.eps = 1e-3;
|
|
param.p = 0.1;
|
|
param.shrinking = 1;
|
|
param.probability = 0;
|
|
param.nr_weight = 0;
|
|
param.weight_label = new int[0];
|
|
param.weight = new double[0];
|
|
|
|
// parse options
|
|
StringTokenizer st = new StringTokenizer(args);
|
|
String[] argv = new String[st.countTokens()];
|
|
for(int i=0;i<argv.length;i++)
|
|
argv[i] = st.nextToken();
|
|
|
|
for(int i=0;i<argv.length;i++)
|
|
{
|
|
if(argv[i].charAt(0) != '-') break;
|
|
if(++i>=argv.length)
|
|
{
|
|
System.err.print("unknown option\n");
|
|
break;
|
|
}
|
|
switch(argv[i-1].charAt(1))
|
|
{
|
|
case 's':
|
|
param.svm_type = atoi(argv[i]);
|
|
break;
|
|
case 't':
|
|
param.kernel_type = atoi(argv[i]);
|
|
break;
|
|
case 'd':
|
|
param.degree = atoi(argv[i]);
|
|
break;
|
|
case 'g':
|
|
param.gamma = atof(argv[i]);
|
|
break;
|
|
case 'r':
|
|
param.coef0 = atof(argv[i]);
|
|
break;
|
|
case 'n':
|
|
param.nu = atof(argv[i]);
|
|
break;
|
|
case 'm':
|
|
param.cache_size = atof(argv[i]);
|
|
break;
|
|
case 'c':
|
|
param.C = atof(argv[i]);
|
|
break;
|
|
case 'e':
|
|
param.eps = atof(argv[i]);
|
|
break;
|
|
case 'p':
|
|
param.p = atof(argv[i]);
|
|
break;
|
|
case 'h':
|
|
param.shrinking = atoi(argv[i]);
|
|
break;
|
|
case 'b':
|
|
param.probability = atoi(argv[i]);
|
|
break;
|
|
case 'w':
|
|
++param.nr_weight;
|
|
{
|
|
int[] old = param.weight_label;
|
|
param.weight_label = new int[param.nr_weight];
|
|
System.arraycopy(old,0,param.weight_label,0,param.nr_weight-1);
|
|
}
|
|
|
|
{
|
|
double[] old = param.weight;
|
|
param.weight = new double[param.nr_weight];
|
|
System.arraycopy(old,0,param.weight,0,param.nr_weight-1);
|
|
}
|
|
|
|
param.weight_label[param.nr_weight-1] = atoi(argv[i-1].substring(2));
|
|
param.weight[param.nr_weight-1] = atof(argv[i]);
|
|
break;
|
|
default:
|
|
System.err.print("unknown option\n");
|
|
}
|
|
}
|
|
|
|
// build problem
|
|
svm_problem prob = new svm_problem();
|
|
prob.l = point_list.size();
|
|
prob.y = new double[prob.l];
|
|
|
|
if(param.kernel_type == svm_parameter.PRECOMPUTED)
|
|
{
|
|
}
|
|
else if(param.svm_type == svm_parameter.EPSILON_SVR ||
|
|
param.svm_type == svm_parameter.NU_SVR)
|
|
{
|
|
if(param.gamma == 0) param.gamma = 1;
|
|
prob.x = new svm_node[prob.l][1];
|
|
for(int i=0;i<prob.l;i++)
|
|
{
|
|
point p = point_list.elementAt(i);
|
|
prob.x[i][0] = new svm_node();
|
|
prob.x[i][0].index = 1;
|
|
prob.x[i][0].value = p.x;
|
|
prob.y[i] = p.y;
|
|
}
|
|
|
|
// build model & classify
|
|
svm_model model = svm.svm_train(prob, param);
|
|
svm_node[] x = new svm_node[1];
|
|
x[0] = new svm_node();
|
|
x[0].index = 1;
|
|
int[] j = new int[XLEN];
|
|
|
|
Graphics window_gc = getGraphics();
|
|
for (int i = 0; i < XLEN; i++)
|
|
{
|
|
x[0].value = (double) i / XLEN;
|
|
j[i] = (int)(YLEN*svm.svm_predict(model, x));
|
|
}
|
|
|
|
buffer_gc.setColor(colors[0]);
|
|
buffer_gc.drawLine(0,0,0,YLEN-1);
|
|
window_gc.setColor(colors[0]);
|
|
window_gc.drawLine(0,0,0,YLEN-1);
|
|
|
|
int p = (int)(param.p * YLEN);
|
|
for(int i=1;i<XLEN;i++)
|
|
{
|
|
buffer_gc.setColor(colors[0]);
|
|
buffer_gc.drawLine(i,0,i,YLEN-1);
|
|
window_gc.setColor(colors[0]);
|
|
window_gc.drawLine(i,0,i,YLEN-1);
|
|
|
|
buffer_gc.setColor(colors[5]);
|
|
window_gc.setColor(colors[5]);
|
|
buffer_gc.drawLine(i-1,j[i-1],i,j[i]);
|
|
window_gc.drawLine(i-1,j[i-1],i,j[i]);
|
|
|
|
if(param.svm_type == svm_parameter.EPSILON_SVR)
|
|
{
|
|
buffer_gc.setColor(colors[2]);
|
|
window_gc.setColor(colors[2]);
|
|
buffer_gc.drawLine(i-1,j[i-1]+p,i,j[i]+p);
|
|
window_gc.drawLine(i-1,j[i-1]+p,i,j[i]+p);
|
|
|
|
buffer_gc.setColor(colors[2]);
|
|
window_gc.setColor(colors[2]);
|
|
buffer_gc.drawLine(i-1,j[i-1]-p,i,j[i]-p);
|
|
window_gc.drawLine(i-1,j[i-1]-p,i,j[i]-p);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(param.gamma == 0) param.gamma = 0.5;
|
|
prob.x = new svm_node [prob.l][2];
|
|
for(int i=0;i<prob.l;i++)
|
|
{
|
|
point p = point_list.elementAt(i);
|
|
prob.x[i][0] = new svm_node();
|
|
prob.x[i][0].index = 1;
|
|
prob.x[i][0].value = p.x;
|
|
prob.x[i][1] = new svm_node();
|
|
prob.x[i][1].index = 2;
|
|
prob.x[i][1].value = p.y;
|
|
prob.y[i] = p.value;
|
|
}
|
|
|
|
// build model & classify
|
|
svm_model model = svm.svm_train(prob, param);
|
|
svm_node[] x = new svm_node[2];
|
|
x[0] = new svm_node();
|
|
x[1] = new svm_node();
|
|
x[0].index = 1;
|
|
x[1].index = 2;
|
|
|
|
Graphics window_gc = getGraphics();
|
|
for (int i = 0; i < XLEN; i++)
|
|
for (int j = 0; j < YLEN ; j++) {
|
|
x[0].value = (double) i / XLEN;
|
|
x[1].value = (double) j / YLEN;
|
|
double d = svm.svm_predict(model, x);
|
|
if (param.svm_type == svm_parameter.ONE_CLASS && d<0) d=2;
|
|
buffer_gc.setColor(colors[(int)d]);
|
|
window_gc.setColor(colors[(int)d]);
|
|
buffer_gc.drawLine(i,j,i,j);
|
|
window_gc.drawLine(i,j,i,j);
|
|
}
|
|
}
|
|
|
|
draw_all_points();
|
|
}
|
|
|
|
void button_clear_clicked()
|
|
{
|
|
clear_all();
|
|
}
|
|
|
|
void button_save_clicked(String args)
|
|
{
|
|
FileDialog dialog = new FileDialog(new Frame(),"Save",FileDialog.SAVE);
|
|
dialog.setVisible(true);
|
|
String filename = dialog.getDirectory() + dialog.getFile();
|
|
if (filename == null) return;
|
|
try {
|
|
DataOutputStream fp = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(filename)));
|
|
|
|
int svm_type = svm_parameter.C_SVC;
|
|
int svm_type_idx = args.indexOf("-s ");
|
|
if(svm_type_idx != -1)
|
|
{
|
|
StringTokenizer svm_str_st = new StringTokenizer(args.substring(svm_type_idx+2).trim());
|
|
svm_type = atoi(svm_str_st.nextToken());
|
|
}
|
|
|
|
int n = point_list.size();
|
|
if(svm_type == svm_parameter.EPSILON_SVR || svm_type == svm_parameter.NU_SVR)
|
|
{
|
|
for(int i=0;i<n;i++)
|
|
{
|
|
point p = point_list.elementAt(i);
|
|
fp.writeBytes(p.y+" 1:"+p.x+"\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(int i=0;i<n;i++)
|
|
{
|
|
point p = point_list.elementAt(i);
|
|
fp.writeBytes(p.value+" 1:"+p.x+" 2:"+p.y+"\n");
|
|
}
|
|
}
|
|
fp.close();
|
|
} catch (IOException e) { System.err.print(e); }
|
|
}
|
|
|
|
void button_load_clicked()
|
|
{
|
|
FileDialog dialog = new FileDialog(new Frame(),"Load",FileDialog.LOAD);
|
|
dialog.setVisible(true);
|
|
String filename = dialog.getDirectory() + dialog.getFile();
|
|
if (filename == null) return;
|
|
clear_all();
|
|
try {
|
|
BufferedReader fp = new BufferedReader(new FileReader(filename));
|
|
String line;
|
|
while((line = fp.readLine()) != null)
|
|
{
|
|
StringTokenizer st = new StringTokenizer(line," \t\n\r\f:");
|
|
if(st.countTokens() == 5)
|
|
{
|
|
byte value = (byte)atoi(st.nextToken());
|
|
st.nextToken();
|
|
double x = atof(st.nextToken());
|
|
st.nextToken();
|
|
double y = atof(st.nextToken());
|
|
point_list.addElement(new point(x,y,value));
|
|
}
|
|
else if(st.countTokens() == 3)
|
|
{
|
|
double y = atof(st.nextToken());
|
|
st.nextToken();
|
|
double x = atof(st.nextToken());
|
|
point_list.addElement(new point(x,y,current_value));
|
|
}else
|
|
break;
|
|
}
|
|
fp.close();
|
|
} catch (IOException e) { System.err.print(e); }
|
|
draw_all_points();
|
|
}
|
|
|
|
protected void processMouseEvent(MouseEvent e)
|
|
{
|
|
if(e.getID() == MouseEvent.MOUSE_PRESSED)
|
|
{
|
|
if(e.getX() >= XLEN || e.getY() >= YLEN) return;
|
|
point p = new point((double)e.getX()/XLEN,
|
|
(double)e.getY()/YLEN,
|
|
current_value);
|
|
point_list.addElement(p);
|
|
draw_point(p);
|
|
}
|
|
}
|
|
|
|
public void paint(Graphics g)
|
|
{
|
|
// create buffer first time
|
|
if(buffer == null) {
|
|
buffer = this.createImage(XLEN,YLEN);
|
|
buffer_gc = buffer.getGraphics();
|
|
buffer_gc.setColor(colors[0]);
|
|
buffer_gc.fillRect(0,0,XLEN,YLEN);
|
|
}
|
|
g.drawImage(buffer,0,0,this);
|
|
}
|
|
} |