Distribution de Poisson et tracé de distribution cumulative de Poisson via sqlite en Python et Java

Dernière fois Dessinez un graphique de la distribution de Poisson et de la distribution cumulative de Poisson en Python et Java, respectivement. J'ai tracé les données créées en Java avec Matplotlib, mais celle qui reliait les données avec CSV Je l'ai réécrit avec SQlite.

L'API Sqlite utilise la norme 3.6 pour Python et [celle-ci] pour Java (https://bitbucket.org/xerial/sqlite-jdbc).

Le code ci-dessous crée les tableaux Poisson et Poisson CDF dans math_data.db et insère la masse stochastique et cumulative pour chaque λ.

Code Java

`poisson.java`




    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        Calc c = new Calc();
        //Modification de la méthode pour stocker la valeur λ dans la liste
        int[] lamList = {1, 4, 8, 10};
        try {
            double p = 0;
            Class.forName("org.sqlite.JDBC");
            connection = DriverManager.getConnection("jdbc:sqlite:math_data.db");
            statement = connection.createStatement();
            connection.setAutoCommit(false);

            //Créer une table
            statement.executeUpdate("DROP TABLE IF EXISTS Poisson");
            statement.executeUpdate("CREATE TABLE IF NOT EXISTS Poisson( lam integer, count integer , p real )");
            //Entrez la valeur
            PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO Poisson values (?, ?, ?);");
//λ Probabilité qu'un événement survenant à une certaine période se produise i fois dans une certaine période p

            for (int i = 0; i < lamList.length; i++) {

                for (int j = 0; j <= 12; j++) {
                    p = c.poisson(lamList[i], j);

                    preparedStatement.setInt(1, lamList[i]);
                    preparedStatement.setInt(2, j);
                    preparedStatement.setDouble(3, p);
                    preparedStatement.addBatch();
                }

            }
            System.out.println(preparedStatement.executeBatch().length + "Enregistrez le lot.");
            connection.commit();


//Distribution cumulative
            statement.executeUpdate("DROP TABLE IF EXISTS PoissonCDF");
            statement.executeUpdate("CREATE TABLE IF NOT EXISTS PoissonCDF( lam integer, count integer , p real )");
            //Entrez la valeur
            preparedStatement = connection.prepareStatement("INSERT INTO PoissonCDF values (?, ?, ?);");
            //λ Probabilité cumulative qu'un événement survenant au cours d'une certaine période se produise i fois ou moins au cours d'une certaine période p

            for (int i = 0; i < lamList.length; i++) {
                double pTotal = 0;
                for (int j = 0; j <= 12; j++) {
                    p = c.poisson(lamList[i], j);
                    pTotal += p;
                    preparedStatement.setInt(1, lamList[i]);
                    preparedStatement.setInt(2, j);
                    preparedStatement.setDouble(3, pTotal);
                    preparedStatement.addBatch();
                }

            }
//Écriture par lots
            System.out.println(preparedStatement.executeBatch().length + "Enregistrez le lot.");
            connection.commit();


        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}


class Calc {

    int factorial(int n) {
        if (n == 0) {
            return 1;
        }
        return n * factorial(n - 1);
    }

    //Densité de masse de probabilité qui ne se produit que k fois lorsque l'événement qui se produit dans une certaine période est un lam moyen
    double poisson(double lam, int k) {
        double total = 0;

        total = Math.pow(lam, k) * Math.pow(Math.E, -lam) / factorial(k);

        return total;
    }

    //Densité de masse de probabilité (y compris 0) qui se produit k fois ou moins lorsque l'événement qui se produit dans une certaine période est un lam moyen
    double poisson_cdf(double lam, int k) {
        double p = 0;
        double total = 0;
        for (int i = 0; i <= k; i++) {
            p = poisson(lam, i);
            total += p;
        }
        return total;
    }
}
//Résultat d'exécution
//Enregistrez 52 lots.
//Enregistrez 52 lots.

L'exécution est terminée. Assurez-vous qu'il est correctement inséré.


ResultSet resultSet;
            resultSet = statement.executeQuery("select * from Poisson");
            while (resultSet.next()) {
                System.out.print(resultSet.getString("lam"));
                System.out.print(",");
                System.out.print(resultSet.getString("count"));
                System.out.print(",");
                System.out.println(resultSet.getString("p"));
            }
            resultSet = statement.executeQuery("select * from PoissonCDF");
            while (resultSet.next()) {
                System.out.print(resultSet.getString("lam"));
                System.out.print(",");
                System.out.print(resultSet.getString("count"));
                System.out.print(",");
                System.out.println(resultSet.getString("p"));
            }

            /*
Résultat d'exécution

            1,0,0.367879441171442
            1,1,0.367879441171442
            1,2,0.183939720585721
            1,3,0.0613132401952404
            1,4,0.0153283100488101
             */

C'est fermement dedans. Ensuite, je veux le charger en Python et le tracer dans Matplotlib.

Code Python

`plotting.py`


import sqlite3
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

sns.set(style="darkgrid")

conn = sqlite3.connect("math_data.db")
c = conn.cursor()
c.execute('SELECT * FROM Poisson')

#liste
lam_db_list = np.array(c.fetchall())
#Puisque le nombre au début de la ligne est λ, je vais le résumer pour le moment et tracer pour chaque λ
lam_db_f = sorted(list(set(map(lambda x: x[0], lam_db_list))))

fig, axe = plt.subplots(1, 2, constrained_layout=True, figsize=(12, 5))

#Faites une liste pour chaque type de nombre λ au début de la ligne et tracez-en en fonction.
for i in range(len(lam_db_f)):
    y_axis = []
    for j in lam_db_list:
        if j[0:1] == lam_db_f[i]:
            y_axis.append(j[2:])

    y_axis = np.array(y_axis).reshape(-1)
    x_axis = range(len(y_axis))
    axe[0].plot(x_axis, y_axis, marker='o', label='$\lambda=%.2f$' % lam_db_f[i])

c.execute('SELECT * FROM PoissonCDF')
lam_db_list = np.array(c.fetchall())
lam_db_f = sorted(list(set(map(lambda x: x[0], lam_db_list))))

for i in range(len(lam_db_f)):
    y_axis = [j[2:] for j in lam_db_list if j[0:1] == lam_db_f[i]]
    y_axis = np.array(y_axis).reshape(-1)
    x_axis = range(len(y_axis))
    axe[1].plot(x_axis, y_axis, marker='o', label='$\lambda=%.2f$' % lam_db_f[i])

conn.close()
axe[0].set_xlabel('k')
axe[0].set_ylabel('probability')
axe[0].set_title('Poisson')
axe[0].legend()
axe[0].grid(True)
axe[0].set_xticks(range(len(x_axis)))
axe[1].set_xlabel('k')
axe[1].set_ylabel('probability')
axe[1].set_title('PoissonCDF')
axe[1].legend()
axe[1].grid(True)
axe[1].set_xticks(range(len(x_axis)))

plt.savefig("poisson_n_cdf.png ")
plt.show()

J'ai pu le tracer proprement. Vous pouvez également tracer diverses distributions de Poisson en modifiant le tableau λ passé du côté Java.

Des difficultés

J'ai créé la création de base de données en matrice inversée et essayé de calculer tous les tableaux en arrondissant à partir du premier numéro de ligne, mais le code est devenu compliqué. Afin de faciliter son utilisation par la suite, nous devons penser à la sortie au stade de la création de la base de données. Surtout si les données concernent un petit nombre de points immobiles, cela deviendra fou, donc je veux éviter d'avoir à jouer avec la structure trop tard.