城市大脑：人工智能在城市管理中的应用

    import os
    from sklearn import datasets, svm, metrics
    from skimage import io, transform
    
    def load_images(folder):
    images = []
    labels = []
    
    for subdir in sorted(os.listdir(folder)):
        if not os.path.isdir(os.path.join(folder, subdir)):
            continue
    
        label = int(subdir) - 1 # class names are numeric
        path = os.path.join(folder, subdir)
        
        for filename in sorted(os.listdir(path)):
            filepath = os.path.join(path, filename)
            
            image = io.imread(filepath)
            resized_image = transform.resize(image, (64, 64))
    
            images.append(resized_image)
            labels.append(label)
    
    return images, labels
    
    if __name__ == '__main__':
    train_folder = 'train'
    test_folder = 'test'
    
    print('Loading training data...')
    X_train, y_train = load_images(train_folder)
    print('Done.')
    
    print('Training classifier...')
    clf = svm.SVC()
    clf.fit(X_train, y_train)
    print('Done.')
    
    print('Loading testing data...')
    X_test, y_test = load_images(test_folder)
    print('Done.')
    
    print('Testing accuracy of classifier:')
    predicted = clf.predict(X_test)
    print(metrics.accuracy_score(y_test, predicted))

    public class MovieRecommender {
    public static void main(String[] args) throws IOException {
        String inputFile = "user_actions.txt";
        List<UserAction> actions = parseActions(inputFile);
        
        // Split the dataset into training and testing sets
        double ratio = 0.8;
        long seed = 0;
        Collections.shuffle(actions, new Random(seed));
        int splitIndex = (int) Math.ceil(ratio * actions.size());
        List<UserAction> trainingSet = actions.subList(0, splitIndex);
        List<UserAction> testingSet = actions.subList(splitIndex, actions.size());
        
        // Extract features from the training set
        Set<Integer> movieIds = extractMovieIds(trainingSet);
        Map<Integer, Integer> frequencyMap = computeFrequency(movieIds, trainingSet);
        List<Double[]> featureVectors = buildFeatureVector(frequencyMap, trainingSet);
        
        // Train a model on the training set
        LogisticRegressionModel lrModel = trainLRModel(featureVectors, trainingSet);
        
        // Evaluate the performance of the model on the testing set
        evaluateModel(lrModel, featureVectors, testingSet);
    }
    
    private static List<UserAction> parseActions(String filePath) throws IOException {
        List<UserAction> actions = new ArrayList<>();
        BufferedReader br = new BufferedReader(new FileReader(filePath));
        while (br.ready()) {
            String line = br.readLine();
            UserAction action = parseLine(line);
            actions.add(action);
        }
        br.close();
        return actions;
    }
    
    private static UserAction parseLine(String line) {
        String[] tokens = line.trim().split("\    ");
        int userId = Integer.parseInt(tokens[0]);
        int websiteId = Integer.parseInt(tokens[1]);
        int movieId = Integer.parseInt(tokens[2]);
        boolean isClick = Boolean.parseBoolean(tokens[3]);
        LocalDateTime timestamp = LocalDateTime.parse(tokens[4], DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        return new UserAction(userId, websiteId, movieId, isClick, timestamp);
    }
    
    private static Set<Integer> extractMovieIds(List<UserAction> actions) {
        Set<Integer> ids = new HashSet<>();
        for (UserAction action : actions) {
            ids.add(action.getMovieId());
        }
        return ids;
    }
    
    private static Map<Integer, Integer> computeFrequency(Set<Integer> movieIds, List<UserAction> actions) {
        Map<Integer, Integer> freqMap = new HashMap<>();
        for (int id : movieIds) {
            freqMap.put(id, 0);
        }
        for (UserAction action : actions) {
            int id = action.getMovieId();
            if (freqMap.containsKey(id)) {
                freqMap.put(id, freqMap.get(id) + 1);
            }
        }
        return freqMap;
    }
    
    private static List<Double[]> buildFeatureVector(Map<Integer, Integer> frequencyMap, List<UserAction> actions) {
        List<Double[]> vectors = new ArrayList<>();
        for (UserAction action : actions) {
            Double[] vector = new Double[2];
            int clickCount = frequencyMap.get(action.getMovieId());
            vector[0] = clickCount / 100.0; // scale clicks to be between 0 and 1
            vector[1] = action.getTimestamp().toInstant(ZoneOffset.UTC).toEpochMilli() / 1000000000.0; // convert timestamps to seconds since epoch
            vectors.add(vector);
        }
        return vectors;
    }
    
    private static LogisticRegressionModel trainLRModel(List<Double[]> featureVectors, List<UserAction> actions) {
        LogisticRegressionModel lrModel = new LogisticRegressionWithSGD();
        lrModel.setNumIterations(100);
        RowMatrix matrix = new RowMatrix(DenseMatrix.fromRows(featureVectors));
        Matrix weights = lrModel.optimize(matrix, DenseVector.fromArray(extractLabels(actions)));
        lrModel.setWeights(weights);
        return lrModel;
    }
    
    private static double[] extractLabels(List<UserAction> actions) {
        double[] labels = new double[actions.size()];
        for (int i = 0; i < actions.size(); i++) {
            labels[i] = actions.get(i).isClick()? 1.0 : 0.0;
        }
        return labels;
    }
    
    private static void evaluateModel(LogisticRegressionModel model, List<Double[]> featureVectors, List<UserAction> actions) {
        Matrix testFeatures = new RowMatrix(DenseMatrix.fromRows(featureVectors)).columnSubset(Arrays.asList(1)); // only use the second feature, which is the timestamp
        double truePositives = 0.0;
        double falsePositives = 0.0;
        double trueNegatives = 0.0;
        double falseNegatives = 0.0;
        for (int i = 0; i < actions.size(); i++) {
            double score = model.predict(testFeatures.viewRow(i))[0];
            double expectedLabel = actions.get(i).isClick()? 1.0 : 0.0;
            if (expectedLabel > 0 && score > 0) {
                truePositives++;
            } else if (expectedLabel <= 0 && score <= 0) {
                trueNegatives++;
            } else if (expectedLabel <= 0 && score > 0) {
                falsePositives++;
            } else if (expectedLabel > 0 && score <= 0) {
                falseNegatives++;
            }
        }
        double precision = truePositives / (truePositives + falsePositives);
        double recall = truePositives / (truePositives + falseNegatives);
        double fScore = 2 * precision * recall / (precision + recall);
        System.out.println("Precision: " + precision);
        System.out.println("Recall: " + recall);
        System.out.println("F1 Score: " + fScore);
    }
    }
    
    class UserAction {
    private int userId;
    private int websiteId;
    private int movieId;
    private boolean isClick;
    private LocalDateTime timestamp;
    
    public UserAction(int userId, int websiteId, int movieId, boolean isClick, LocalDateTime timestamp) {
        this.userId = userId;
        this.websiteId = websiteId;
        this.movieId = movieId;
        this.isClick = isClick;
        this.timestamp = timestamp;
    }
    
    public int getUserId() {
        return userId;
    }
    
    public int getWebsiteId() {
        return websiteId;
    }
    
    public int getMovieId() {
        return movieId;
    }
    
    public boolean isClick() {
        return isClick;
    }
    
    public LocalDateTime getTimestamp() {
        return timestamp;
    }
    }
    
    interface LogisticRegressionModel extends Function<Matrix, double[]> {
    void setWeights(Matrix weights);
    default void optimize(Matrix x, Vector y) {}
    }
    
    class LogisticRegressionWithSGD implements LogisticRegressionModel {
    private final double stepSize;
    private Matrix weights;
    private int numIterations;
    
    public LogisticRegressionWithSGD() {
        this(0.1, 100);
    }
    
    public LogisticRegressionWithSGD(double stepSize, int numIterations) {
        this.stepSize = stepSize;
        this.numIterations = numIterations;
    }
    
    @Override
    public void setWeights(Matrix weights) {
        this.weights = weights;
    }
    
    @Override
    public double[] apply(Matrix x) {
        double threshold = 0.5;
        for (int iter = 0; iter < numIterations; iter++) {
            double dotProductSum = sum(matMultVec(x, weights), axis=1)[0][0];
            Matrix sigmoidGradient = elementWiseOp(x, y -> sigmoid(-dotProductSum + y) * (1 - sigmoid(-dotProductSum + y)), BinaryOperation.MULTIPLY);
            weights = weights.subtract(sigmoidGradient.multiply(stepSize));
        }
        return matMultVec(x, weights)[0].toArray();
    }
    }
    
    enum BinaryOperation {
    ADDITION("+"), SUBTRACTION("-"), MULTIPLY("*"), DIVIDE("/");
    
    private String symbol;
    
    BinaryOperation(String symbol) {
        this.symbol = symbol;
    }
    
    public String getSymbol() {
        return symbol;
    }
    
    public double perform(double x, double y) {
        switch (this) {
            case ADDITION:
                return x + y;
            case SUBTRACTION:
                return x - y;
            case MULTIPLY:
                return x * y;
            case DIVIDE:
                return x / y;
            default:
                throw new IllegalArgumentException("Unsupported binary operation: " + this);
        }
    }
    }
    
    class UnaryFunction {
    public double apply(double x) {
        throw new UnsupportedOperationException();
    }
    }
    
    interface BiFunction extends Function<Double, UnaryFunction>, Serializable {
    default double perform(double x, double y) {
        return ((UnaryFunction) apply(x)).apply(y);
    }
    }