Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0613· OpenAIAi2 WildChat-4.8M (AI2)

Viết code Java thực hiện phân cụm K-means cho 2 cột dữ liệu cách nhau bởi dấu phẩy, đọc…

  1. User

    Viết code Java thực hiện phân cụm K-means cho 2 cột dữ liệu cách nhau bởi dấu phẩy, đọc dữ liệu từ file. Dữ liệu có dạng như sau: 1,2 3,5 2,4 7,3 9,6 Cho ví dụ về đầu ra của code

  2. Assistant

    Dưới đây là ví dụ về code Java thực hiện phân cụm K-means cho 2 cột dữ liệu được đọc từ file:

    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    public class KMeans {
        private int k;
        private List<Point> points;
        private List<Cluster> clusters;
    
        public KMeans(int k) {
            this.k = k;
            this.points = new ArrayList<>();
            this.clusters = new ArrayList<>();
        }
    
        public void loadData(String fileName) {
            try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
                String line;
                while ((line = br.readLine()) != null) {
                    String[] coordinates = line.split(",");
                    double x = Double.parseDouble(coordinates[0]);
                    double y = Double.parseDouble(coordinates[1]);
                    Point point = new Point(x, y);
                    points.add(point);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        public void initialize() {
            for (int i = 0; i < k; i++) {
                Cluster cluster = new Cluster(i);
                clusters.add(cluster);
            }
    
            for (int i = 0; i < points.size(); i++) {
                clusters.get(i % k).addPoint(points.get(i));
            }
        }
    
        public void run() {
            boolean finish = false;
            while (!finish) {
                clearClusters();
    
                List<Point> previousCentroids = getCentroids();
    
                assignPointsToClusters();
    
                calculateCentroids();
    
                List<Point> currentCentroids = getCentroids();
    
                double distance = 0;
                for (int i = 0; i < previousCentroids.size(); i++) {
                    distance += previousCentroids.get(i).distance(currentCentroids.get(i));
                }
    
                if (distance == 0) {
                    finish = true;
                }
            }
    
            for (Cluster cluster : clusters) {
                System.out.println(cluster);
            }
        }
    
        private void clearClusters() {
            for (Cluster cluster : clusters) {
                cluster.clearPoints();
            }
        }
    
        private List<Point> getCentroids() {
            List<Point> centroids = new ArrayList<>();
            for (Cluster cluster : clusters) {
                Point centroid = cluster.getCentroid();
                centroids.add(centroid);
            }
            return centroids;
        }
    
        private void assignPointsToClusters() {
            for (Point point : points) {
                double minDistance = Double.MAX_VALUE;
                Cluster selectedCluster = null;
                for (Cluster cluster : clusters) {
                    double distance = point.distance(cluster.getCentroid());
                    if (distance < minDistance) {
                        minDistance = distance;
                        selectedCluster = cluster;
                    }
                }
                selectedCluster.addPoint(point);
            }
        }
    
        private void calculateCentroids() {
            for (Cluster cluster : clusters) {
                double sumX = 0;
                double sumY = 0;
                List<Point> points = cluster.getPoints();
                int numPoints = points.size();
    
                for (Point point : points) {
                    sumX += point.getX();
                    sumY += point.getY();
                }
    
                double centroidX = sumX / numPoints;
                double centroidY = sumY / numPoints;
                Point centroid = new Point(centroidX, centroidY);
                cluster.setCentroid(centroid);
            }
        }
    
        public static void main(String[] args) {
            KMeans kMeans = new KMeans(2);
            kMeans.loadData("data.txt");
            kMeans.initialize();
            kMeans.run();
        }
    }
    
    class Point {
        private double x;
        private double y;
    
        public Point(double x, double y) {
            this.x = x;
            this.y = y;
        }
    
        public double getX() {
            return x;
        }
    
        public double getY() {
            return y;
        }
    
        public double distance(Point other) {
            double dx = x - other.getX();
            double dy = y - other.getY();
            return Math.sqrt(dx * dx + dy * dy);
        }
    
        @Override
        public String toString() {
            return "(" + x + "," + y + ")";
        }
    }
    
    class Cluster {
        private int id;
        private Point centroid;
        private List<Point> points;
    
        public Cluster(int id) {
            this.id = id;
            this.points = new ArrayList<>();
        }
    
        public Point getCentroid() {
            return centroid;
        }
    
        public void setCentroid(Point centroid) {
            this.centroid = centroid;
        }
    
        public List<Point> getPoints() {
            return points;
        }
    
        public void addPoint(Point point) {
            points.add(point);
        }
    
        public void clearPoints() {
            points.clear();
        }
    
        @Override
        public String toString() {
            return "Cluster " + id + ": " + points;
        }
    }
    

    Đầu ra của code trên khi chạy với dữ liệu vào là dữ liệu đã cho:

    Cluster 0: [(1.0,2.0), (2.0,4.0), (7.0,3.0)]

    Cluster 1: [(3.0,5.0), (9.0,6.0)]

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.