原

gSpan 频繁子图挖掘算法的实现

2012年12月06日 07:52:44 阅读数：17830
gSpan 是一种高效的频繁子图挖掘算法，参考 http://www.cs.ucsb.edu/~xyan/software/gSpan.htm 。
/*
 *  gSpan algorithm implemented by coolypf
 *  http://blog.csdn.net/coolypf
 */

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>
#include <vector>
#include <map>
#include <set>

using namespace std;

const int LABEL_MAX = 100;
int min_support;
int nr_graph;

struct Graph
{
    vector<int> node_label;
    vector<int> *edge_next, *edge_label;
    vector<int> gs;

    void removeEdge(int x, int a, int y)
    {
        for (size_t i = 0; i < node_label.size(); ++i)
        {
            int t;
            if (node_label[i] == x)
                t = y;
            else if (node_label[i] == y)
                t = x;
            else
                continue;
            for (size_t j = 0; j < edge_next[i].size(); ++j)
            {
                if (edge_label[i][j] == a && node_label[edge_next[i][j]] == t)
                {
                    /* remove edge */
                    edge_label[i][j] = edge_label[i].back();
                    edge_label[i].pop_back();
                    edge_next[i][j] = edge_next[i].back();
                    edge_next[i].pop_back();
                    j--;
                }
            }
        }
    }

    bool hasEdge(int x, int a, int y)
    {
        for (size_t i = 0; i < node_label.size(); ++i)
        {
            int t;
            if (node_label[i] == x)
                t = y;
            else if (node_label[i] == y)
                t = x;
            else
                continue;
            for (size_t j = 0; j < edge_next[i].size(); ++j)
                if (edge_label[i][j] == a && node_label[edge_next[i][j]] == t)
                    return true;
        }
        return false;
    }
} *GS;

struct GraphData
{
    vector<int> nodel;
    vector<bool> nodev;

    vector<int> edgex;
    vector<int> edgey;
    vector<int> edgel;
    vector<bool> edgev;
};

class EdgeFrequency
{
    int *array;
    int u, v;

public:
    void init(int max_node_label, int max_edge_label)
    {
        u = max_node_label + 1;
        v = u * (max_edge_label + 1);
        array = new int[u * v];
    }

    int& operator()(int x, int a, int y) { return array[x * v + a * u + y]; }

    int operator()(int x, int a, int y) const { return array[x * v + a * u + y]; }
} EF;

struct Edge
{
    int ix, iy;
    int x, a, y;

    Edge(int _ix, int _iy, int _x, int _a, int _y) : ix(_ix), iy(_iy), x(_x), a(_a), y(_y) {}

    bool operator<(const Edge &e) const
    {
        if (ix > iy)
        {
            if (e.ix < e.iy)
                return true;
            if (iy < e.iy || (iy == e.iy && a < e.a))
                return true;
        }
        else if (e.ix < e.iy)
        {
            if (ix > e.ix)
                return true;
            if (ix == e.ix)
            {
                if (x < e.x)
                    return true;
                if (x == e.x && (a < e.a || (a == e.a && y < e.y)))
                    return true;
            }
        }
        return false;
    }
};

struct GraphCode
{
    vector<const Edge *> seq;
    vector<int> gs;
};

vector<Graph *> S;  // graph mining result

void subgraph_mining(GraphCode &gc, int next);

int main(int argc, char **argv)
{
    clock_t clk = clock();

    /* parse command line options */
    assert(argc == 5);
    int num = atoi(argv[3]), denom = atoi(argv[4]);
    assert(num && denom && num <= denom);

    /* read graph data */
    FILE *fp = fopen(argv[1], "r");
    assert(fp);
    bool occ_node_label[LABEL_MAX + 1], occ_edge_label[LABEL_MAX + 1];
    int freq_node_label[LABEL_MAX + 1], freq_edge_label[LABEL_MAX + 1];
    memset(freq_node_label, 0, sizeof(freq_node_label));
    memset(freq_edge_label, 0, sizeof(freq_edge_label));
    GraphData *gd = NULL;
    vector<GraphData *> v_gd;
    while (1)
    {
        static char dummy[10];
        if (fscanf(fp, "%s", dummy) <= 0)
        {
            if (gd)
            {
                v_gd.push_back(gd);
                for (int i = 0; i <= LABEL_MAX; ++i)
                {
                    if (occ_node_label[i])
                        freq_node_label[i]++;
                    if (occ_edge_label[i])
                        freq_edge_label[i]++;
                }
            }
            break;
        }
        if (*dummy == 't')
        {
            int id;
            fscanf(fp, "%s%d", dummy, &id);
            if (gd)
            {
                v_gd.push_back(gd);
                for (int i = 0; i <= LABEL_MAX; ++i)
                {
                    if (occ_node_label[i])
                        freq_node_label[i]++;
                    if (occ_edge_label[i])
                        freq_edge_label[i]++;
                }
            }
            if (id < 0) break;
            assert(id == (int)v_gd.size());
            gd = new GraphData;
            memset(occ_node_label, 0, sizeof(occ_node_label));
            memset(occ_edge_label, 0, sizeof(occ_edge_label));
        }
        else if (*dummy == 'v')
        {
            int id, label;
            fscanf(fp, "%d%d", &id, &label);
            assert(id == (int)gd->nodel.size() && label <= LABEL_MAX);
            gd->nodel.push_back(label);
            gd->nodev.push_back(true);
            occ_node_label[label] = true;
        }
        else if (*dummy == 'e')
        {
            int x, y, label;
            fscanf(fp, "%d%d%d", &x, &y, &label);
            assert(x < (int)gd->nodel.size() && y < (int)gd->nodel.size() && label <= LABEL_MAX);
            gd->edgex.push_back(x);
            gd->edgey.push_back(y);
            gd->edgel.push_back(label);
            gd->edgev.push_back(true);
            occ_edge_label[label] = true;
        }
        else
            assert(0);
    }
    fclose(fp);

    min_support = v_gd.size() * num / denom;
    if (min_support < 1)
        min_support = 1;
    printf("%d graphs with minSup = %d\n", (int)v_gd.size(), min_support);

    /* sort labels of vertices and edges in GS by their frequency */
    int rank_node_label[LABEL_MAX + 1], rank_edge_label[LABEL_MAX + 1];
    for (int i = 0; i <= LABEL_MAX; ++i)
    {
        rank_node_label[i] = i;
        rank_edge_label[i] = i;
    }
    for (int i = LABEL_MAX; i > 0; --i)
    {
        for (int j = 0; j < i; ++j)
        {
            int tmp;
            if (freq_node_label[rank_node_label[j]] < freq_node_label[rank_node_label[j + 1]])
            {
                tmp = rank_node_label[j];
                rank_node_label[j] = rank_node_label[j + 1];
                rank_node_label[j + 1] = tmp;
            }
            if (freq_edge_label[rank_edge_label[j]] < freq_edge_label[rank_edge_label[j + 1]])
            {
                tmp = rank_edge_label[j];
                rank_edge_label[j] = rank_edge_label[j + 1];
                rank_edge_label[j + 1] = tmp;
            }
        }
    }

    /* remove infrequent vertices and edges */
    /* ralabel the remaining vertices and edges in descending frequency */

    int max_node_label = 0, max_edge_label = 0;
    for (int i = 0; i <= LABEL_MAX; ++i)
    {
        if (freq_node_label[rank_node_label[i]] >= min_support)
            max_node_label = i;
        if (freq_edge_label[rank_edge_label[i]] >= min_support)
            max_edge_label = i;
    }
    printf("remaining max vertex, edge label: %d, %d\n", max_node_label, max_edge_label);

    int rank_to_node_label[LABEL_MAX + 1], rank_to_edge_label[LABEL_MAX + 1];
    memcpy(rank_to_node_label, rank_node_label, sizeof(rank_to_node_label));
    for (int i = 0; i <= LABEL_MAX; ++i)
        rank_node_label[rank_to_node_label[i]] = i;
    memcpy(rank_to_edge_label, rank_edge_label, sizeof(rank_to_edge_label));
    for (int i = 0; i <= LABEL_MAX; ++i)
        rank_edge_label[rank_to_edge_label[i]] = i;

    for (size_t i = 0; i < v_gd.size(); ++i)
    {
        GraphData &gd = *v_gd[i];
        for (size_t j = 0; j < gd.nodel.size(); ++j)
        {
            if (freq_node_label[gd.nodel[j]] < min_support)
                gd.nodev[j] = false;
            else
                gd.nodel[j] = rank_node_label[gd.nodel[j]];
        }
        for (size_t j = 0; j < gd.edgel.size(); ++j)
        {
            if (!gd.nodev[gd.edgex[j]] || !gd.nodev[gd.edgey[j]])
            {
                gd.edgev[j] = false;
                continue;
            }
            if (freq_edge_label[gd.edgel[j]] < min_support)
                gd.edgev[j] = false;
            else
                gd.edgel[j] = rank_edge_label[gd.edgel[j]];
        }

        /* re-map vertex index */
        map<int, int> m;
        int cur = 0;
        for (size_t j = 0; j < gd.nodel.size(); ++j)
        {
            if (!gd.nodev[j]) continue;
            m[j] = cur++;
        }
        for (size_t j = 0; j < gd.edgel.size(); ++j)
        {
            if (!gd.edgev[j]) continue;
            gd.edgex[j] = m[gd.edgex[j]];
            gd.edgey[j] = m[gd.edgey[j]];
        }
    }

    /* build graph set */
    nr_graph = (int)v_gd.size();
    GS = new Graph[nr_graph];
    for (int i = 0; i < nr_graph; ++i)
    {
        Graph &g = GS[i];
        GraphData &gd = *v_gd[i];
        for (size_t j = 0; j < gd.nodel.size(); ++j)
            if (gd.nodev[j])
                g.node_label.push_back(gd.nodel[j]);
        g.edge_next = new vector<int>[g.node_label.size()];
        g.edge_label = new vector<int>[g.node_label.size()];
        for (size_t j = 0; j < gd.edgel.size(); ++j)
        {
            if (!gd.edgev[j]) continue;
            g.edge_label[gd.edgex[j]].push_back(gd.edgel[j]);
            g.edge_label[gd.edgey[j]].push_back(gd.edgel[j]);
            g.edge_next[gd.edgex[j]].push_back(gd.edgey[j]);
            g.edge_next[gd.edgey[j]].push_back(gd.edgex[j]);
        }
    }

    /* find all subgraphs with only one vertex for reference */
    for (int i = 0; i <= max_node_label; ++i)
    {
        Graph *g = new Graph;
        g->node_label.push_back(i);
        for (int j = 0; j < nr_graph; ++j)
        {
            const Graph &G = GS[j];
            for (size_t k = 0; k < G.node_label.size(); ++k)
            {
                if (G.node_label[k] == i)
                {
                    g->gs.push_back(j);
                    break;
                }
            }
        }
        S.push_back(g);
    }

    /* enumerate all frequent 1-edge graphs in GS */

    EF.init(max_node_label, max_edge_label);
    for (int x = 0; x <= max_node_label; ++x)
    {
        for (int a = 0; a <= max_edge_label; ++a)
        {
            for (int y = x; y <= max_node_label; ++y)
            {
                int count = 0;
                for (int i = 0; i < nr_graph; ++i)
                    if (GS[i].hasEdge(x, a, y))
                        count++;
                EF(x, a, y) = count;
                EF(y, a, x) = count;
            }
        }
    }

    for (int x = 0; x <= max_node_label; ++x)
    {
        for (int a = 0; a <= max_edge_label; ++a)
        {
            for (int y = x; y <= max_node_label; ++y)
            {
                if (EF(x, a, y) < min_support)
                    continue;
                GraphCode gc;
                for (int i = 0; i < nr_graph; ++i)
                    if (GS[i].hasEdge(x, a, y))
                        gc.gs.push_back(i);
                Edge e(0, 1, x, a, y);
                gc.seq.push_back(&e);
                subgraph_mining(gc, 2);

                /* GS <- GS - e */
                for (int i = 0; i < nr_graph; ++i)
                    GS[i].removeEdge(x, a, y);
            }
        }
    }

    /* output mining result */

    printf("Found %d frequent subgraphs\n", (int)S.size());

    fp = fopen(argv[2], "w");
    assert(fp);
    for (int i = 0; i < (int)S.size(); ++i)
    {
        const Graph &g = *S[i];
        fprintf(fp, "t # %d * %d\nx", i, (int)g.gs.size());
        for (size_t j = 0; j < g.gs.size(); ++j)
            fprintf(fp, " %d", g.gs[j]);
        fprintf(fp, "\n");
        for (size_t j = 0; j < g.node_label.size(); ++j)
            fprintf(fp, "v %d %d\n", (int)j, rank_to_node_label[g.node_label[j]]);
        if (g.node_label.size() < 2)
        {
            fprintf(fp, "\n");
            continue;
        }
        for (int j = 0; j < (int)g.node_label.size(); ++j)
        {
            for (size_t k = 0; k < g.edge_label[j].size(); ++k)
                if (j < g.edge_next[j][k])
                    fprintf(fp, "e %d %d %d\n", j, g.edge_next[j][k], rank_to_edge_label[g.edge_label[j][k]]);
        }
        fprintf(fp, "\n");
    }
    fclose(fp);

    printf("Total time: (%d / %d) seconds\n", (int)(clock() - clk), (int)CLOCKS_PER_SEC);

    return 0;
}

/* traverse a graph and find its minimal DFS code */
class Traveler
{
    const vector<const Edge *> &s;
    const Graph &g;
    bool is_min;
    vector<int> g2s;
    vector<vector<bool> > f;

    void DFS(vector<int> &v, int c, int next)
    {
        if (c >= (int)s.size())
            return;
        vector<int> bak;
        while (!v.empty())
        {
            bool flag = false;
            int x = v.back();
            for (size_t i = 0; i < g.edge_next[x].size(); ++i)
            {
                int y = g.edge_next[x][i];
                if (f[x][y]) continue;
                flag = true;
                if (g2s[y] < 0)
                {
                    Edge e(g2s[x], next, g.node_label[x], g.edge_label[x][i], g.node_label[y]);
                    if (*s[c] < e) continue;
                    if (e < *s[c])
                    {
                        is_min = false;
                        return;
                    }
                    g2s[y] = next;
                    v.push_back(y);
                    f[x][y] = true;
                    f[y][x] = true;
                    DFS(v, c + 1, next + 1);
                    if (!is_min) return;
                    f[x][y] = false;
                    f[y][x] = false;
                    v.pop_back();
                    g2s[y] = -1;
                }
                else
                {
                    Edge e(g2s[x], g2s[y], g.node_label[x], g.edge_label[x][i], g.node_label[y]);
                    if (*s[c] < e) continue;
                    if (e < *s[c])
                    {
                        is_min = false;
                        return;
                    }
                    f[x][y] = true;
                    f[y][x] = true;
                    DFS(v, c + 1, next);
                    if (!is_min) return;
                    f[x][y] = false;
                    f[y][x] = false;
                }
            }
            if (flag) break;
            bak.push_back(v.back());
            v.pop_back();
        }
        while (!bak.empty())
        {
            v.push_back(bak.back());
            bak.pop_back();
        }
    }

public:
    Traveler(const vector<const Edge *> &_s, const Graph &_g) : s(_s), g(_g), is_min(true) {}

    bool isMin() const { return is_min; }

    void travel()
    {
        g2s.resize(0);
        g2s.resize(g.node_label.size(), -1);
        f.resize(g.node_label.size());
        for (size_t i = 0; i < g.node_label.size(); ++i)
        {
            f[i].resize(0);
            f[i].resize(g.node_label.size(), false);
        }

        for (size_t i = 0; i < g.node_label.size(); ++i)
        {
            int x = g.node_label[i];
            if (x > s[0]->x) continue;
            assert(x == s[0]->x);
            vector<int> v(1, i);
            g2s[i] = 0;
            DFS(v, 0, 1);
            g2s[i] = -1;
        }
    }
};

/* traverse a subgraph and find its children in graph */
class SubTraveler
{
    const vector<const Edge *> &s;
    const Graph &g;
    set<Edge> &c;
    int next;
    vector<int> rm;  // rightmost
    vector<int> s2g;
    vector<int> g2s;
    vector<vector<bool> > f;

    void DFS(int p)
    {
        int x, y;

        if (p >= (int)s.size())
        {
            /* grow from rightmost path, pruning stage (3) */
            int at = 0;
            while (at >= 0)
            {
                x = s2g[at];
                for (size_t i = 0; i < g.edge_label[x].size(); ++i)
                {
                    y = g.edge_next[x][i];
                    if (f[x][y])
                        continue;
                    int ix = g2s[x], iy = g2s[y];
                    assert(ix == at);
                    Edge ne(0, 1, g.node_label[x], g.edge_label[x][i], g.node_label[y]);
                    /* pruning */
                    if (EF(ne.x, ne.a, ne.y) < min_support)
                        continue;
                    /* pruning stage (1) */
                    if (ne < *s[0])
                        continue;
                    /* pruning stage (2) */
                    if (iy >= 0)
                    {
                        if (ix <= iy)
                            continue;
                        bool flag = false;
                        for (size_t j = 0; j < g.edge_label[y].size(); ++j)
                        {
                            int z = g.edge_next[y][j], w = g.edge_label[y][j];
                            if (!f[y][z])
                                continue;
                            if (w > ne.a || (w == ne.a && g.node_label[z] > ne.x))
                            {
                                flag = true;
                                break;
                            }
                        }
                        if (flag)
                            continue;
                    }
                    else
                        iy = next;
                    ne.ix = ix;
                    ne.iy = iy;
                    c.insert(ne);

                }
                at = rm[at];
            }
            return;
        }

        const Edge &e = *s[p];
        x = s2g[e.ix];
        assert(g.node_label[x] == e.x);

        for (size_t i = 0; i < g.edge_label[x].size(); ++i)
        {
            if (g.edge_label[x][i] != e.a)
                continue;
            y = g.edge_next[x][i];
            if (f[x][y])
                continue;
            if (g.node_label[y] != e.y)
                continue;
            if (s2g[e.iy] < 0 && g2s[y] < 0)
            {
                s2g[e.iy] = y;
                g2s[y] = e.iy;
                f[x][y] = true;
                f[y][x] = true;
                DFS(p + 1);
                f[x][y] = false;
                f[y][x] = false;
                g2s[y] = -1;
                s2g[e.iy] = -1;
            }
            else
            {
                if (y != s2g[e.iy])
                    continue;
                if (e.iy != g2s[y])
                    continue;
                f[x][y] = true;
                f[y][x] = true;
                DFS(p + 1);
                f[x][y] = false;
                f[y][x] = false;
            }
        }
    }

public:
    SubTraveler(const vector<const Edge *> &_s, const Graph &_g, set<Edge> &_c)
        : s(_s), g(_g), c(_c) {}

    void travel(int _next)
    {
        next = _next;
        s2g.resize(0);
        s2g.resize(next, -1);
        g2s.resize(0);
        g2s.resize(g.node_label.size(), -1);
        f.resize(g.node_label.size());
        for (size_t i = 0; i < g.node_label.size(); ++i)
        {
            f[i].resize(0);
            f[i].resize(g.node_label.size(), false);
        }

        /* find rightmost path */
        rm.resize(0);
        rm.resize(next, -1);
        for (size_t i = 0; i < s.size(); ++i)
            if (s[i]->iy > s[i]->ix && s[i]->iy > rm[s[i]->ix])
                rm[s[i]->ix] = s[i]->iy;

        for (size_t i = 0; i < g.node_label.size(); ++i)
        {
            if (g.node_label[i] != s[0]->x)
                continue;
            s2g[s[0]->ix] = (int)i;
            g2s[i] = s[0]->ix;
            DFS(0);
            g2s[i] = -1;
            s2g[s[0]->ix] = -1;
        }
    }
};

void subgraph_mining(GraphCode &gc, int next)
{
    /* construct graph from DFS code */
    Graph *g = new Graph;
    vector<const Edge *> &s = gc.seq;
    g->node_label.resize(next);
    g->edge_label = new vector<int>[next];
    g->edge_next = new vector<int>[next];
    for (size_t i = 0; i < s.size(); ++i)
    {
        int ix = s[i]->ix, iy = s[i]->iy, a = s[i]->a;
        g->node_label[ix] = s[i]->x;
        g->node_label[iy] = s[i]->y;
        g->edge_label[ix].push_back(a);
        g->edge_label[iy].push_back(a);
        g->edge_next[ix].push_back(iy);
        g->edge_next[iy].push_back(ix);
    }

    /* minimum DFS code pruning stage (4) */
    Traveler t(s, *g);
    t.travel();
    if (!t.isMin())
    {
        delete[] g->edge_label;
        delete[] g->edge_next;
        delete g;
        return;
    }

    S.push_back(g);

    /* enumerate potential children with 1-edge growth */
    map<Edge, vector<int> > m;
    for (size_t i = 0; i < gc.gs.size(); ++i)
    {
        set<Edge> c;
        SubTraveler st(s, GS[gc.gs[i]], c);
        st.travel(next);
        for (set<Edge>::const_iterator j = c.begin(); j != c.end(); ++j)
            m[*j].push_back(gc.gs[i]);
    }

    /* mining subgraph children */
    for (map<Edge, vector<int> >::iterator i = m.begin(); i != m.end(); ++i)
    {
        const Edge *e = &i->first;
        vector<int> &spp = i->second;
        if ((int)spp.size() < min_support)
            continue;
        GraphCode child_gc;
        child_gc.gs.swap(spp);
        child_gc.seq = s;
        child_gc.seq.push_back(e);
        if (e->iy == next)
            subgraph_mining(child_gc, next + 1);
        else
            subgraph_mining(child_gc, next);
    }

    g->gs.swap(gc.gs);
}
展开阅读全文
还能输入1000个字符

gSpan频繁子图挖掘算法

12-17 阅读数 4925

参考资料：http://www.cs.ucsb.edu/~xyan/papers/gSpan.pdf http://www.cs.ucsb.edu/~xyan/papers/gSpan-short.... 博文 来自： 小飞侠的博客

图解gSpan

12-25 阅读数 354

频繁子图挖掘的基本概念 参考 https://blog.csdn.net/qq_41653753/article/details/79112436 gSpan 为了遍历图，gSpan算法... 博文 来自： 代伟-dwdm的博客

gSpan算法研究

03-23 阅读数 1122

摘要 随着信息技术的不断发展，人类可以很容易地收集和储存大量的数据，然而，如何在海量的数据中提取对用户有用的信息逐渐地成为巨大挑战。为了应对这种挑战，数据挖掘技术应运而生，成为了最近一段时期数据科学的... 博文 来自： 贪玩的小猫的博客

8大经典数据挖掘算法

06-24 阅读数 2万+

大概花了将近2个月的时间，自己把18大数据挖掘的经典算法进行了学习并且进行了代码实现，涉及到了决策分类，聚类，链接挖掘，关联挖掘，模式挖掘等等方面。也算是对数据挖掘领域的小小入门了吧。下面就做个小小的... 博文 来自： hechenghai

图挖掘基本概念

01-21 阅读数 3860

1、图挖掘 近年来，图挖掘作为，数据挖掘的重要组成部分引起了社会各界的极大关注。图挖掘（Graph Mining）是指利用图模型从海量数据中发现和提起有用知识和信息的过程。通过图挖掘所获取的知识和信... 博文 来自： qq_41653753的博客

gspan攻略

01-10 阅读数 50

介绍 gSpan算法是图挖掘邻域的一个算法，而作为子图挖掘算法，又是其他图挖掘算法的基础，所以gSpan算法在图挖掘算法中还是非常重要的。gSpan算法在挖掘频繁子图的时候，用了和FP-grown中相... 博文 来自： 代伟-dwdm的博客

c++怎么运用java代码？c++怎么运用java代码？

02-24

- 问答

数据挖掘之关联分析六（子图模式）

08-20 阅读数 1393

子图模式频繁子图挖掘（frequent subgraph mining）：在图的集合中发现一组公共子结构。 图和子图图是一种用来表示实体集之间联系的数据结构。子图，图G′=(V′,E′)G' = (... 博文 来自： Beavers

18种典型算法

11-12 阅读数 897

18 Candidates for the Top 10 Algorithms in Data Mining Classification ============== #1. C4.5 Qu... 博文 来自： 开心一刻的专栏

机器学习与数据挖掘中的十大经典算法

02-17 阅读数 1万+

机器学习与数据挖掘中的十大经典算法 背景： top10算法的前期背景是吴教授在香港做了一个关于数据挖掘top10挑战的一个报告，会后有一名内地的教授提出了一个类似的想法。吴教授觉得非常好，... 博文 来自： crazyhacking的专栏

算法&模型

09-16 阅读数 3万+

在行业设备大数据平台建设中，势必要用到大数据技术，而大数据技术中，机器学习与数据挖掘算法是重要的一环，我们通过这些算法与模型对设备的故障进行监控与预测，对设备技改需求进行预测，对设备采购需求进行预测以... 博文 来自： 我和我追逐的梦~~~

【Python数据挖掘课程】七.PCA降维操作及subplot子图绘制

11-26 阅读数 1万+

这篇文章主要介绍四个知识点，也是我那节课讲课的内容。 1.PCA降维操作； 2.Python中Sklearn的PCA扩展包； 3.Matplotlib的... 博文 来自： 杨秀璋的专栏

机器学习10大经典算法

06-14 阅读数 1564

一、C4.5  C4.5，是机器学习算法中的一个分类决策树算法，  它是决策树(决策树也就是做决策的节点间的组织方式像一棵树，其实是一个倒树)核心算法  ID3的改进算法，所以基本上了解了一半决... 博文 来自： u010398493的专栏

Python进阶(二十三)-Django使用pymysql连接MySQL数据库做增删改查

04-06 阅读数 4万+

Python进阶(二十三)-Django使用pymysql连接MySQL数据库做增删改查  IDE说明：   Python：3.5   Django:1.10   Pymysql:0.7.10 ... 博文 来自： IT全栈 华强工作室

Python网络编程06----django数据库的增删改查

05-10 阅读数 3489

首先定义model如下.class UserInfo(models.Model): username=models.CharField(max_length=50,null=True,prim... 博文 来自： 根号下的麻辣烫

Python实现FP-growth算法寻找关联规则（含原理+代码）

07-01 阅读数 2501

（原创作者：陈玓玏） 一、FP-growth应用场景 FP-growth和Apriori一样，可以用于挖掘频繁项，常用于购物篮的规则提取，也就是挖掘客户购买商品时的关联程度，比如共有一万个客户... 博文 来自： 陈玓玏的博客

经典图割算法中图的构建及实现:Graph-Cut

11-03 阅读数 1450

经典图割算法中图的构建及实现之graph-cut 本文目的： 讲解目前典型的3种图割算法：graph-cut、grab-but、one-cut。本文主要讲解graph-cut的方法在应用时，准则... 博文 来自： jy02660221的博客

gspan频繁子图挖掘算法

08-05
gspan频繁子图挖掘算法，中文版论文，最流行的频繁子图挖掘算法
下载

频繁项集挖掘算法——Relim算法

03-29 阅读数 1685

        前面我们已经介绍了3中频繁项集挖掘算法，今天我们来介绍一种新的不需要候选项集的频繁项集挖掘算法——Relim算法。        FP-growth算法是当前挖掘频繁项集算法中速度最快... 博文 来自： my_learning_road的博客

社区检测与高密子图挖掘（上）

08-02 阅读数 1254

前面我们说过图的第二个优点是拉帮结派，在图里面是很容易形成团伙结构，近年来，研究这个问题的论文也是汗牛充栋。本章，我们就这一问题所衍生出来的两个方向：社区检测（Community Detection）... 博文 来自： geek_wh2016的博客

频繁子图挖掘

11-02
频繁子图挖掘的说明
下载

关联规则挖掘之频繁子图发现

06-21
关联规则挖掘算法可以挖掘出频繁项集。如果项集元素之间有顺序，则可以形成一个图的结构，关联规则挖掘依旧可以挖掘出频繁子图，在数据挖掘领域非常有用。本资源是频繁子图挖掘的一个C++实现。
下载

求数据挖掘raking,或者gspan算法的源代码,谢谢了.非常感谢

05-21

求数据挖掘raking,或者gspan算法的源代码,谢谢了.非常感谢 论坛

频繁子图挖掘算法gSpan的实现

10-30 阅读数 1418

频繁子图挖掘算法gSpan的实现项目地址：https://github.com/betterenvi/gSpangSpan算法简介频繁子图挖掘是数据挖掘中一个非常广泛的应用。频繁子图挖掘是指从大量的图... 博文 来自： loginforall的博客

gspan图模式挖掘算法

12-08
gspan论文，是图模式挖掘算法
下载

频繁项集挖掘Apriori算法及其Python实现

08-27 阅读数 2854

Apriori算法是通过限制候选产生发现频繁项集。Apriori算法使用一种称为逐层搜索的迭代方法，其中k项集用于探索（k+1）项集。首先，通过扫描数据库，累计每个项的计数，并收集满足最小支持度的项，... 博文 来自： Halfopen的专栏

图挖掘技术概览

09-20 阅读数 675

图挖掘技术思维导图 图匹配是比较图之间结构相似性的过程​ 近似图匹配在数据图中搜索出与模式图在数据和节点与边属性上匹配的子图，允许噪声和错误，最大公共子图，最小公共超图来衡量两个图之间的相似程... 博文 来自： 打死也不读博士

第四章 数据流挖掘

05-28 阅读数 333

考虑到数据到来的速度实在是太快了，以致将全部数据存在活动存储器（即传统数据库）并在我们选定的时间内与之交互是不可能的。数据流处理的每个算法都在某种程度上包含流的汇总过程。 考虑如何从流中抽取有用样本... 博文 来自： HAR_fernman的博客

频繁子图挖掘算法gaston

03-30
用于频繁子图的挖掘算法，目前效率基本是高于gindex的两倍
下载

《Graph Learning专栏》 ： 高密子图挖掘

08-30 阅读数 905

本周我们介绍另一图上的“聚类”算法—高密子图挖掘(Dense Subgraph Mining)，这类算法与社群检测不同的是处理的数据对象是异构图(节点的类型不是单一的，同类型节点之间一般没有边)，社群... 博文 来自： geek_wh2016的博客

频繁项集挖掘算法——Apriori算法

03-28 阅读数 2147

前言        关联规则就是在给定训练项集上频繁出现的项集与项集之间的一种紧密的联系。其中“频繁”是由人为设定的一个阈值即支持度 （support）来衡量，“紧密”也是由人为设定的一个关联阈值即置... 博文 来自： my_learning_road的博客

密集子图挖掘算法的相关知识

01-22 阅读数 1063

1、子图密度的定义方法 （1）绝对密度：其度量的是构成一个密集子图的规则和参数值，是一个定量的描述。密度定义考量的只是密集子图内部节点和边的特性，与密集子图外部的拓扑结构无关。绝对的密集子图定义一般... 博文 来自： qq_41653753的博客

R语言包arules进行频繁项集挖掘的最简单例子

06-03 阅读数 612

arules是进行频繁项集挖掘（frequent itemset mining）的有效工具，不过我在使用的时候发现网上很多例子都比较繁琐，这里总结一下其中apriori方法的最简单使用方法，这里首先给... 博文 来自： qysh123的专栏

FP-Growth序列频繁模式挖掘

12-30 阅读数 2631

1算法设计目标 输入不同的命令是用户使用Linux服务器的基本途径，通过长时间采集不同用户在使用服务器过程中所使用的命令序列，挖掘其中频繁出现的命令序列，可以帮助我们了解用户使用该服务器的基本规律。... 博文 来自： 乔的博客

C++实现Apriori算法，频繁模式数据挖掘，最大频繁项集，闭频繁项集

11-01
C++实现Apriori算法，频繁模式数据挖掘，最大频繁项集，闭频繁项集，里面包括测试数据以及apriori.cpp、 apriori.h 、apriori_test.cpp三个文件。具体的相见博客：http://blog.csdn.ne...
下载

闭频繁项集的挖掘——Closet算法

03-17 阅读数 921

 Closet算法有很大一部分涉及到了FP-Growth算法，但是FP-Growth什么的大牛们都写了很多就不多赘述了吧。  话不多说直接上方法。  首先，对事务数据库进行扫描，得到一个根据项的支持度... 博文 来自： u014473918的博客

序列挖掘算法比较

09-13 阅读数 1672

AprioriAll + GSP + FreeSpan + PrefixSpan 1.基本概念 AprioriAll算法属于Apriori类算法，其基本思想为首先遍历序列数据库生成候选序列... 博文 来自： shuke1991的博客

频繁项集挖掘算法——FP-growth算法

03-28 阅读数 3291

        上一篇我们介绍了Apriori算法，但是我们可以分析得出，Apriori算法可能收到两种非平凡开销的影响：它可能需要产生大量候选项集；它可能需要重复的扫描整个数据库，通过模式匹配检查一... 博文 来自： my_learning_road的博客

商品频繁二项集挖掘方法

01-14 阅读数 486

一 频繁二项集 现实中有许多关联规则挖掘算法，比如最著名的Apriori算法，以及FP-树频集算法，本例介绍关于商品的频繁二项集算法。 二 算法设计思路 1 将每一笔订单的商品按照两两分... 博文 来自： 实践求真知

频繁项集挖掘算法——Eclat算法

03-28 阅读数 3110

        前面介绍过的Apriori算法和FP-growth算法都是从TID项集格式（即｛TID：itemset｝）的事务集中挖掘频繁模式，其中TID是事务标识符，而itemset是事务TID中... 博文 来自： my_learning_road的博客

高效频繁模式挖掘算法PrePost和FIN的C++源码

11-21 阅读数 1748

这两个算法均给予我们小组提出了基于模式树节点集的新颖数据结构，它们的效率要优于传统主流挖掘算法，可以在其基础上重写所有与频繁项集挖掘相关的任务，如闭模式、最长模式和TOP-K模式等等。... 博文 来自： SIGMA实验室

频繁项集挖掘算法Apriori FPGrowth

03-26 阅读数 7349

参考：http://blog.sina.com.cn/s/blog_5357c0af0101jq6z.html http://blog.csdn.net/huagong_adu/article/de... 博文 来自： xbmatrix的博客

时间序列频繁模式挖掘：GSP算法、SPADE算法

08-07 阅读数 9941

什么是时间戳概念的频繁模式挖掘？ 所谓时间戳(time-stamp)就是加入了时间序列的概念，即每次发生的时间都有时间先后的顺序，在前面讲解的Apriori算法中并没有加入此概念，虽然Apriori... 博文 来自： chixujohnny

频繁项集挖掘算法——H-mine算法

03-29 阅读数 1302

       前面我们已经介绍了4种频繁项集挖掘算法，有经典的，也有比较新提出的，现在我们再来学习一种比较新的频繁项集挖掘算法——H-mine算法。         前面已经提到FP-growth 将... 博文 来自： my_learning_road的博客

FP-Tree频繁模式树算法

01-28 阅读数 8568

参考资料：http://blog.csdn.net/sealyao/article/details/6460578 更多数据挖掘算法：https://github.com/linyiqun/DataM... 博文 来自： 走在前往架构师的路上

频繁模式挖掘Apriori算法详解

08-03 阅读数 3839

本数据挖掘算法是本人进入研究生学习阶段进行的第一项“比较难”的学习，下文除了源代码有参考Zealseeker博主之外均为原创手打，如有哪里写的不严谨，望请谅解。       首先频繁模式(Freque... 博文 来自： chixujohnny

PrefixSpan序列模式挖掘算法

02-12 阅读数 1万+

更多数据挖掘代码：https://github.com/linyiqun/DataMiningAlgorithm 介绍 与GSP一样，PrefixSpan算法也是序列模式分析算法的一种，不过与前者不同... 博文 来自： 走在前往架构师的路上

4种序列模式挖掘算法的比较分析

08-15 阅读数 7548

http://fpcheng.blog.51cto.com/2549627/829527     算法简介 AprioriAll算法属于Apriori类算法，其基本思想为首先遍历序列数据库生成候选... 博文 来自： u011860731的专栏

什么是闭频繁项集 closed patterns ？

04-11 阅读数 3724

所谓闭项集，就是指一个项集X，它的直接超集的支持度计数都不等于它本身的支持度计数。 如果闭项集同时是频繁的，也就是它的支持度大于等于最小支持度阈值，那它就称为闭频繁项集。 例如，有交易数据库 ... 博文 来自： xiaolang85的专栏

FPgrowth用python3实现挖掘频繁项集

08-13 阅读数 1123

参考的是以下的博客： https://blog.csdn.net/Gamer_gyt/article/details/51113753 输入： simpDat = [['r', 'z... 博文 来自： zllnau66的博客

基于EasyIPCamera实现的数字网络摄像机IPCamera的模拟器IPC RTSP Simulator

03-22 阅读数 7402

还记得去年在北京安博会上，看到一些厂家的展示台上，各种船舶、公路、车辆的高清视频直播，好奇这些数据是怎么接到现场的，现场成百上千家展台，不可能有那么大的带宽供应，细想数据肯定不是实时的，果然，盯着看了... 博文 来自： Babosa的专栏

如何在ArcGIS Online中构建自己的应用程序模板初级篇-显示地图

11-21 阅读数 4万+

开发ArcGIS Online应用程序模板之前，需要了解怎么使用ArcGIS API for JavaScript。     在ArcGIS Online当中如何构架自己的应用程序模板，我们得先要了... 博文 来自： ArcGIS产品与技术专栏

JSP/Servlet环境配置

02-23 阅读数 6720

下载安装JDK并配置环境变量 这里我下载安装的是jdk-7u51-windows-i586，如果你没有请到Oracle官网下载； 【我的电脑】-【高级系统设置】-【环境变量】-系统变量中的Path添加... 博文 来自： hankaibo

python图片处理类之~PIL.Image模块(ios android icon图标自动生成处理)

08-31 阅读数 7万+

1.从pyCharm提示下载PIL包  http://www.pythonware.com/products/pil/   2.解压后，进入到目录下 cd /Users/jianan/Dow... 博文 来自： 专注于cocos+unity+服务器全栈

expat介绍文档翻译

03-22 阅读数 4万+

原文地址：http://www.xml.com/pub/a/1999/09/expat/index.html 因为需要用，所以才翻译了这个文档。但总归赖于英语水平很有限，翻译出来的中文有可能... 博文 来自： ymj7150697的专栏

pandas某一列中每一行拆分成多行的方法

11-29 阅读数 1195

在处理数据过程中，常会遇到将一条数据拆分成多条，比如一个人的地址信息中，可能有多条地址，既有家庭地址也有工作地址，还有电话信息等等类似的情况，实际使用数据的时候又需要分开处理，这个时候就需要将这一条数... 博文 来自： dongcheng 的博客

配置简单功能强大的excel工具类搞定excel导入导出工具类(一)

09-22 阅读数 4万+

对于J2EE项目导入导出Excel是最普通和实用功能,本工具类使用步骤简单,功能强大,只需要对实体类进行简单的注解就能实现导入导出功能,导入导出操作的都是实体对象. 请看一下这个类都有哪些功能:   ... 博文 来自： 李坤 大米时代 第五期

vue移动端flexible.js结合Muse-ui使用的小坑

11-27 阅读数 1万+

因为公司有个项目有webapp的需求，在前期准备的期间考虑过使用ionic，毕竟该项目web端的框架使用的是Angular，项目组的人也都比较熟悉，但是我们毕竟只是做个移动的网页，不想用ionic那么... 博文 来自： zhangl的博客

DirectX修复工具增强版

02-09 阅读数 195万+

最后更新：2018-12-20 DirectX修复工具最新版：DirectX Repair V3.8 增强版  NEW! 版本号：V3.8.0.11638 大小: 107MB/7z格式压缩，18... 博文 来自： VBcom的专栏

C语言函数操作大全----(超详细)

05-12 阅读数 2万+

fopen（打开文件） 相关函数 open，fclose 表头文件 #include 定义函数 FILE * fopen(const char * path,const char * mode)... 博文 来自： 独旅天涯

避免 Hibernate 中用get/load方法获取的实体调用set方法后自动更新

04-15 阅读数 1万+

1、问题症状描述       最近在处理一个新需求问题，代码的大致逻辑是获取一个实体对象，调用该对象的set方法设置其中的某些字段，然后把修改后的实体作为参数供其他地方调用，根据返回值来决定是否更新这... 博文 来自： Mr_Alex

ThreadLocal的设计理念与作用

09-25 阅读数 6万+

Java中的ThreadLocal类允许我们创建只能被同一个线程读写的变量。因此，如果一段代码含有一个ThreadLocal变量的引用，即使两个线程同时执行这段代码，它们也无法访问到对方的Thread... 博文 来自： u011860731的专栏

Git的理解和使用

09-28 阅读数 3497

Git介绍 Git（the stupid content tracker）是一个源自Linux内核项目的源码管理工具。和传统的CVS、SVN不同，git是一个分布式源码管理工具。 Git命令... 博文 来自： No talent but persistence

GIS算法--已知一点经纬度，方位角，距离求另一点

08-24 阅读数 8714

已知一个点A的经纬度坐标，点B相对与A的方位角，B到A的距离，求B的经纬度坐标，用Javascript语言来完成该算法，借用了一下openL CommonFunc.caculate={ ... 博文 来自： 夕颜的专栏

微信小程序调用微信支付接口

07-06 阅读数 6645

前言：应项目要求，需要使用微信小程序做支付，写完后告知手续费太高方案不予通过（宝宝心里苦，但宝宝不说）。此次开发在因站在巨人的肩膀上顺利完成。 微信支付文档传送门：https://pay.wei... 博文 来自： idwarf

centos 查看命令源码

11-19 阅读数 9万+

# yum install yum-utils 设置源: [base-src] name=CentOS-5.4 - Base src - baseurl=http://vault.ce... 博文 来自： linux/unix

将Excel文件导入数据库（POI+Excel+MySQL+jsp页面导入）第一次优化

09-05 阅读数 3万+

本篇文章是根据我的上篇博客，给出的改进版，由于时间有限，仅做了一个简单的优化。相关文章：将excel导入数据库2018年4月1日，新增下载地址链接：点击打开源码下载地址十分抱歉，这个链接地址没有在这篇... 博文 来自： Lynn_Blog

phpmailer使用qq邮箱、163邮箱成功发送邮件实例代码

08-06 阅读数 4923

以前使用qq邮箱、163服务器发送邮件，帐号直接使用密码，现在不行了，得使用授权码，简单记录下 1、首先开通POP3/SMTP服务，qq邮箱——帐号——设置，找到POP3/SMTP点开启，输入短信会有... 博文 来自： 爱代码也爱生活

Android OkHttp（一）初识

10-18 阅读数 890

目前在Android开发中，开源的网络请求框架有Android-async-http  ，Volley，Okhttp等，这几种框架都是市面上主流的，每种都有各自的优点。今天主要来看看Okhttp。之前... 博文 来自： zhangxiaowei

linux上安装Docker(非常简单的安装方法)

06-29 阅读数 22万+

最近比较有空，大四出来实习几个月了，作为实习狗的我，被叫去研究Docker了，汗汗！ Docker的三大核心概念：镜像、容器、仓库 镜像：类似虚拟机的镜像、用俗话说就是安装文件。 容器：类似一个轻量... 博文 来自： 我走小路的博客

搭建图片服务器《二》-linux安装nginx

09-22 阅读数 4万+

nginx是个好东西，Nginx (engine x) 是一个高性能的HTTP和反向代理服务器，也是一个IMAP/POP3/SMTP服务器。Nginx是由伊戈尔·赛索耶夫为俄罗斯访问量第二的Rambl... 博文 来自： maoyuanming0806的博客

强连通分量及缩点tarjan算法解析

11-16 阅读数 59万+

强连通分量： 简言之 就是找环（每条边只走一次，两两可达） 孤立的一个点也是一个连通分量   使用tarjan算法 在嵌套的多个环中优先得到最大环( 最小环就是每个孤立点）   定义： int Ti... 博文 来自： 九野的博客

关于SpringBoot bean无法注入的问题（与文件包位置有关）

12-16 阅读数 18万+

问题场景描述整个项目通过Maven构建，大致结构如下： 核心Spring框架一个module spring-boot-base service和dao一个module server-core 提供系统... 博文 来自： 开发随笔

Java中BIO、NIO和AIO的区别和应用场景

04-21 阅读数 1万+

最近一直在准备面试，为了使自己的Java水平更上一个档次，拜读了李林峰老师的《Netty权威指南》，了解了Java关于IO的发展和最新的技术，真是受益匪浅，现在把我总结的关于BIO、NIO和AIO的区... 博文 来自： 我的编程世界

jquery/js实现一个网页同时调用多个倒计时(最新的)

11-25 阅读数 46万+

jquery/js实现一个网页同时调用多个倒计时(最新的) 最近需要网页添加多个倒计时. 查阅网络,基本上都是千遍一律的不好用. 自己按需写了个.希望对大家有用. 有用请赞一个哦! //js ... 博文 来自： Websites

tomcat将jsp转成java后的文件位置

05-19 阅读数 1675

1.tomcat\work\Catalina\localhost\test\org\apache\jsp 博文 来自： li346985170的专栏

蜂窝小区最短距离的坐标系解法

10-14 阅读数 1万+

如下图所示，蜂窝小区，以1为中心，顺时针编号，编号最大限定为100000。求任意两编号之间的最短距离。两个相邻小区的距离为1 示例：19到30的最短距离为5 实现如下三个接口： /**********... 博文 来自： NYS001的专栏

SNMP协议详解<二>

10-29 阅读数 13万+

上一篇文章讲解了SNMP的基本架构，本篇文章将重点分析SNMP报文，并对不同版本（SNMPv1、v2c、v3）进行区别！ 四、SNMP协议数据单元 在SNMP管理中，管理站（NMS）和代理（Age... 博文 来自： 假装在纽约

oracle数据库导出ORA-39127错误解决方案

12-09 阅读数 6085

错误类型及描述: expdp 导出表在表分析是开始出现报错。 ORA-39127: unexpected error from call to export_string :=SYS.DBMS_A... 博文

决策树算法评价标准熵 DB2视频教程 运营管理视频教程 视频压缩信号 交互设计视频教程
ios获取idfa server的安全控制模型是什么 sql android title搜索 ios 动态修改约束 大数据挖掘算法0基础 nlp视频算法音频算法

没有更多推荐了，返回首页
注册