Herzlich Willkommen

Live processing contents

Wednesday, January 23, 2013

Mining Twitter with Couch DB

CLUSTERING  : How You Make Tweet ? etc

save as setting.py
 code :


access_token='xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
access_secret='xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
consumer_key='xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
consumer_secret='xxxxxxxxxxxxxxxxxxxxxxx'
database = 'twitterutils'



named db = 'twitterutils' in couchdb
----------------------------------------------------------------------------------------------------------------------------
save as tweet_sources.py

code :

import re
from collections import defaultdict
from argparse import ArgumentParser

from matplotlib import pyplot
from couchdb import Server

import settings

def get_arguments():
    parser = ArgumentParser(description="Show a graph with the tweet source popularity")

    parser.add_argument("-start", dest="start",
                        nargs="?", help="Start date in YYYY-MM-DD HH:MM format")

    parser.add_argument("-end", dest="end",
                        nargs="?", help="End date in YYYY-MM-DD HH:MM format")

    parser.add_argument("-top", default=10, type=int,
                        help="Number of the most significant sources to show")

    parser.add_argument("-pie", action="store_true",
                        help="Show a pie chart instead")

    return parser.parse_args()

def main():
    args = get_arguments()
   
    server = Server()
    db = server = server[settings.database]

    date_pattern = r"(\d{4})-(\d{1,2})-(\d{1,2}) (\d{1,2}):(\d{2})"

    if args.start:
        date_match = re.match(date_pattern, args.start)
        if not date_match:
            print("Invalid start date format")
            exit(-1)
        start_key = [int(date_match.group(1)),
                     int(date_match.group(2)),
                     int(date_match.group(3)),
                     int(date_match.group(4)),
                     int(date_match.group(5))]
    else:
        start_key = []

Mining Follower Twitter in Python

FOLLOWER TWITTER in PYTHON


LIMITED ONLY 100-150 TWEETS @ HOURS
CODE :

# -------.PY---
import sys, csv, StringIO
import tweepy

def get_followers(api, screen_name):

    followers_count = api.get_user(screen_name = screen_name).followers_count

    cursor = tweepy.Cursor(api.followers, screen_name = screen_name)
    followers = cursor.items()

    followers_list = []
    count = 1
    for follower in followers:
        _row = (
            follower.screen_name,
            unicode(follower.name),
            unicode(follower.location),
            str(follower.created_at),
            str(follower.followers_count),
            str(follower.friends_count),
            str(follower.statuses_count),
            str(follower.favourites_count),
            str(follower.lang),
            str(follower.verified),
            unicode(follower.description),
        )

        row = [ _str.encode('utf8') for _str in _row ]
        followers_list.append(row)

        sys.stderr.write(str(count) + '/' + str(followers_count)+"\n")
        count += 1
       
        return followers_list


       
def main():
    stringio = StringIO.StringIO()
    writer = csv.writer(stringio)

    csv_header = (
        'screen_name',
        'name',
        'location',
        'created_at',
        'followers_count',
        'friends_count',
        'statuses_count',
        'favourites_count',
        'lang',
        'verified',
        'description',
        )
    writer.writerow(csv_header)
   


    screen_name = 'XXXXXXXXXX - FILL SCREENNAME TWITTER'
    api = tweepy.API()
    writer.writerows(get_followers(api, screen_name))

   
    sys.stdout.write(stringio.getvalue())

if __name__ == "__main__":
    main()


Mining Tweet Media dengan R

CLUSTER TWEET MEDIA in R


CODE :

#mengambil paket twitteR
require(twitteR)
#mengambil jumlah tweet pada HashTag
aaa2011 <- br="" n="150)" searchtwitter="" urabaya=""># konvert ke frame data
df <- aaa2011="" as.data.frame="" br="" do.call="" lapply="" rbind=""># mendapatkan nama kolum
names(df)
# melihat isi 3 kolum pertama
head(df,3)


# melihat berapa banyak akun twitter yang unik see 
length(unique(df$screenName))


# membuat sebuah kolom nilai random atas username dan menggambar plot 
# melihat berapa banyak nilai random yang kita butuhkan 
n <- br="" df="" length="" screenname="" unique=""># menggenerate sebuah vektor dengan nilai radom untuk me-replace nama tersebut. kita akan mendapatkan  2 digits nilai 
randuser <- 10="" 50="" br="" n="" round="" runif=""># Melakukan matching antara nomor random dengan sebuah username
screenName <- br="" df="" screenname="" unique="">screenName <- as.character="" br="" sapply="" screenname="">randuser <- br="" cbind="" randuser="" screenname=""># sekarang melakukan random dengan nilai data twitter yang ada dan melakukan matching  dengan nilai  pada username 
rand.df  <- br="" by="screenName" df="" merge="" nbsp="" randuser="">

# menentukan frekuensi tweets per akun 
counts <- br="" rand.df="" randuser="" table=""># membuat sebuah frame data urut untuk manipulasi data dan plotting  
countsSort <- count="sort(counts," data.frame="" decreasing="TRUE)," row.names="NULL)<br" user="unlist(dimnames(counts)),"># membuat sebuah subset terhadap siapa yang melakukan tweet paling sedikit 5 kali tweet
countsSortSubset <- count="" countssort="" subset=""> 0)
# melakukan ektrak dan menghitung berapa banyak tweet dari setiap akun yang me-retweet 
# melakukan pembersihan data twitter dengan meremove karakter noise (aneh) 
rand.df$text <- br="" function="" iconv="" rand.df="" row="" sapply="" text="" to="UTF-8"># meremove simbol @ dari username 
trim <- br="" function="" sub="" x="">
require(stringr)
rand.df$to <- br="" function="" name="" rand.df="" sapply="" text="" trim=""># ektraksi data retweet
rand.df$rt <- br="" function="" rand.df="" sapply="" text="" tweet="">  trim(str_match(tweet,"^RT (@[[:alnum:]_]*)")[2]))
# mereplace nama dengan nilai anonim 
randuser <- br="" data.frame="" randuser="">rand.df$rt.rand <- as.character="" br="" match="" rand.df="" randuser="" rt="">                                                         as.character(randuser$screenName))]
# membuat sebuah table yang menganonimasi ID dan nilai RT pada setiap akun
countRT <- br="" rand.df="" rt.rand="" table="">countRTSort <- br="" countrt="" sort=""># melakukan subset tweet RT 
countRTSortSubset <- countrt="" countrtsort="" subset="">2)
# membuat sebuah data frame untuk ploting 
countRTSortSubset.df <-data .frame="" rt_count="as.numeric(unlist(countRTSortSubset)))<br" user="as.factor(unlist(dimnames(countRTSortSubset))),"># mengkombinasikan tweet dan retweet pada data frame 
countUser <- br="" by.x="randuser" by.y="user" countssortsubset="" merge="" randuser="">TweetRetweet <- all.x="TRUE)<br" by.x="randuser" by.y="user" countrtsortsubset.df="" countuser="" merge=""># membuat plot cleveland dari tweet count dan count akun tweet 
# data poin solid = jumlah tweet, R = jumlah retweets
require(ggplot2)
require(grid)
ggplot() + 
  geom_point(data = TweetRetweet, mapping =  aes(reorder(randuser, count), count), size = 3) +
  geom_point(data = TweetRetweet, mapping =  aes(randuser, RT_count), size = 4, shape = "R") +
  xlab("Author") +
  ylab("Number of messages") +
  coord_flip() +
  theme_bw() +
  theme(axis.title.x = element_text(vjust = -0.5, size = 14)) +
  theme(axis.title.y = element_text(size = 14, angle=90)) +
  theme(plot.margin = unit(c(1,1,2,2), "lines"))






# menghitung jumlah follower dari setiap akun twitter  
# ekstrak username dari data set non anonim 
users <- br="" df="" screenname="" unique="">users <- as.character="" br="" sapply="" users=""># membuat sebuah data frame untuk manipulasi lebih lanjut 
users.df <- data.frame="" followers="" stringsasfactors="FALSE)<br" users="users,"># melakukan looping untuk mempopulasikan  users$followers dengan sebuah count follower dari twitter API
for (i in 1:nrow(users.df))
{
  # memunculkan peringatan untuk men-skip user jika akunnya terproteksi 
  # atau jika terdapat beberapa error 
  result <- followerscount="" getuser="" i="" silent="FALSE);<br" try="" users.df="" users="">  if(class(result) == "try-error") next;
  # mendapakan jumlah followeer dari setiap user 
  users.df$followers[i] <- br="" followerscount="" getuser="" i="" users.df="" users=""> 
  print('Sleeping for 60 seconds...')
  Sys.sleep(60);
}
# melakukan merging follower akun dengan jumlah tweet per authors 
followerCounts <- br="" by.x="screenName" by.y="users" merge="" users.df="" weetretweet=""># melakukan konversi menjadi numerik untuk analisis lebih lanjut 
followerCounts$followers <- as.numeric="" br="" followercounts="" followers="">followerCounts$counts <- as.numeric="" br="" counts="" followercounts="" nbsp="">
# membuat sebuah plot
ggplot(data = followerCounts, aes(count, followers)) +
  geom_text(aes(label = randuser, size = RT_count)) +
  scale_size(range=c(3,10)) +
  scale_x_log10(breaks = c(10,20,40,60,80,100)) +
  scale_y_log10(breaks = c(10,100,seq(1000,7000,1000))) +
  xlab("Number of Messages") +
  ylab("Number of Followers") +
  theme_bw()  +
  theme(axis.title.x = element_text(vjust = -0.5, size = 14)) +
  theme(axis.title.y = element_text(size = 14, angle=90)) +
  theme(plot.margin = unit(c(1,1,2,2), "lines"))



# Rasio retweet untuk tweet 
#
# membuat tabel dengan nilai count tweet per orang 
t <- as.data.frame="" br="" nbsp="" rand.df="" randuser="" table=""># membuat tabel dengan count retweet per orang 
rt <- as.data.frame="" br="" nbsp="" rand.df="" rt.rand="" table=""># melakukan kombinasi tweet count dan retweet count per orang 
t.rt <- br="" by="Var1" merge="" rt="" t=""># membuat kolom baru dan menambahkan rasio tweet atau retweet 
t.rt["ratio"] <- br="" req.x="" req.y="" t.rt=""># mengurutkan isi kolom  dan menaruh nama dengan ratio urut 
sort.t.rt <- br="" order="" ratio="" t.rt=""># terkecuali dengan count tweet brjumlah 2 atau lebih sedikit 
sort.t.rt.subset <- req.x="" sort.t.rt="" subset="">2)
#
# menghapus level leftover yang tidak digunakan dari subset 
sort.t.rt.subset.drop <- br="" droplevels="" sort.t.rt.subset=""># melakukan plot  akun secara berurut  terhadap tweets user > 5 tweet
# people > 5 tweets
ggplot(sort.t.rt.subset.drop, aes(reorder(Var1, ratio), ratio)) +
  xlab("Author") +
  ylab("Ratio of messages retweeted by others to original messages")+
  geom_point() +
  coord_flip() +
  theme_bw()  +
  theme(axis.title.x = element_text(vjust = -0.5, size = 14)) +
  theme(axis.title.y = element_text(size = 14, angle=90)) +
  theme(plot.margin = unit(c(1,1,2,2), "lines"))




# ekstraksi pasangan tweeter dan retweet 
rt <- data.frame="" rt="rand.df$rt.rand)<br" user="rand.df$randuser,"># pengambilan hanya pada pasangan unik
rt.u <- br="" na.omit="" rt="" unique=""># mulai melakukan plotting analisys sosial network 
require(igraph)
require (sna)
degree <- br="" sna::degree="">g <- directed="F)<br" graph.data.frame="" rt.u="">g <- as.undirected="" br="" g="">g.adj <- br="" g="" get.adjacency=""># plot grafik network 
gplot(g.adj, usearrows = FALSE,
      vertex.col = "grey",vertex.border = "black",
      displaylabels = FALSE, edge.lwd = 0.01, edge.col 
      = "grey30", vertex.cex = 0.5)
# mendapatkan beberapa atribut network 
gden(g.adj) # density
grecip(g.adj) # reciprocity
gtrans(g.adj) # transitivity
centralization(g.adj, degree)
# menghitung univariate conditional dengan test grafik 
# density
print(cug.gden   <- br="" cug.test="" g.adj="" gden="">plot(cug.gden)
range(cug.gden$rep.stat)
# reciprocity
print(cug.recip   <- br="" cug.test="" g.adj="" grecip="">plot(cug.recip)
range(cug.recip$rep.stat)
# transistivity
print(cug.gtrans <- br="" cug.test="" g.adj="" gtrans="">plot(cug.gtrans)
range(cug.gtrans$rep.stat)
# centralisation
print(cug.cent <- centralization="" cug.test="" fun.arg="list(FUN=degree)))<br" g.adj="">
# mencari berapa komunitas yang eksis dalam network menggunakan walktrap 
g.wc <- g="" modularity="TRUE)<br" steps="1000," walktrap.community="">plot(as.dendrogram(g.wc))
max(g.wc$membership)+1


#-------------------------------------------- END -------------------------------------------------#

Twitter Mining dengan R - rattle

* CODE TWITTER tweet mining
   Trend Topic Hierarchycal
  ---------------------------------

##############################################################################
### Membaca tweets dari Twitter menggunakan format ATOM 

# instalasi paket XML dibutuhkan sekali dan digunakan untuk seluruh sesi  (jika program R masih belum terinstall paket XML )
install.packages('XML')

# Meload paket XML yang dibutuhkan untuk menarik data format xml
require(XML)

# Menginisialisasi sebuah variabel penyimpanan untuk tweet Twitter  dengan membuat nama data baru yang akan diisi bentuk vector dengan data bentuk Character
mydata.vectors <- br="" character="">
# membuat paginasi untuk mendapatkan lebih banyak tweets  (contohnya dengan nilai 400) dan memasukan "#Kota xxx" yang akan dilakukan mining
# membuat koneksi langsung dengan Feed Atom twitter

for (page in c(1:400))
{
    # mencari parameter contohnya #Surabaya
    twitter_q <- br="" urabaya="" urlencode="">    # Koneksi dengan URL
    twitter_url = paste('http://search.twitter.com/search.atom?q=',twitter_q,'&rpp=100&page=', page, sep='')
    # memperoleh remote URL dan memecah data
    mydata.xml <- astext="F)<br" twitter_url="" xmlparsedoc="">    # ektraksi judul tabel  twitter url
    mydata.vector <- br="" http:="" mydata.xml="" namespaces="c(" s:entry="" s:title="" s="" tom="" www.w3.org="" xmlvalue="" xpathsapply="">    # mengumpulkan tweets baru dengan tweets sebelumnya  dan memasukkannya ke .vectors dengan nama "mydata.vectors"
    mydata.vectors <- br="" c="" mydata.vector="" mydata.vectors="">}

# Ada berapa Tweets ?
length(mydata.vectors)

 #-----------------------------------------------------------------------------------------#

 ###
### Menggunakan paket Text Mining (tm)
###

# melakukan instalasi paket twitter mining (jika program R di komputer belum terinstall)
install.packages('tm')
# mengambil dan menggunakan library tm (text mining)
require(tm)

# membuat sebuah corpus (kamus kata berupa kumpulan data text digital untuk dilakukan  sebagai bantuan proses analisis data)
# corpus yang didapat dari pembentukan dari data vector disimpan dalam bentuk corpus dengan nama "mydata.corpus)
mydata.corpus <- br="" corpus="" ectorsource="" mydata.vectors="">
# merubah seluruh huruf data menjadi huruf kecil
mydata.corpus <- br="" mydata.corpus="" tm_map="" tolower="">
# menghapus tanda baca dalam tweets sebagai proses pembersihan
mydata.corpus <- br="" mydata.corpus="" removepunctuation="" tm_map="">
# menghapus kata-kata umum dan stopwords, dapat dimasukan kata-kata sebagai proses cleaning (seperti kata hubung, kata yang tidak penting)
my_stopwords <- ada="" aku="" atau="" bisa="" br="" c="" dan="" dapat="" dia="" english="" kalau="" kamu="" mana="" saya="" stopwords="" tak="" tetapi="" yang="">mydata.corpus <- br="" my_stopwords="" mydata.corpus="" removewords="" tm_map="">
# membangun sebuah   term-document matrix yang disimpan dalam format ".dtm"
mydata.dtm <- br="" mydata.corpus="" termdocumentmatrix="">
# memeriksa  document-term matrix
mydata.dtm

# memeriksa kata-kata yang paing populer dengan low frequent yang dapat ditentukan user, semakin kecil. data yang didapat semakin banyak
findFreqTerms(mydata.dtm, lowfreq=10)


#-----------------------------------------------------------------------------------------------#


# menampilkan kata yang berasosiasi terdekat dengan kata trending yang ditampilkan dalam proses mining di atas, sebagai contoh
# kata 'rsbi' sebagai kata trending yang muncul di proses sebelumnya
findAssocs(mydata.dtm, 'rsbi', 0.20)

# menghilangkan kerenggangan (jarak) untuk menghapus kerenggangan untuk simpkifikasi dengan cluster plotremove sparse terms to simplify the cluster plot
# menarik parameter untuk menentukan jumlah kata.
# nilai sparse atau kerenggangan dapat ditentukan. semakin kecil maka kemungkinan banyak data yang terfilter tetapi dilihat dari data tweet yang
# di mining, belum tentu data tweet yang dimining memiliki sparse yang tinggi ataupun rendah
mydata.dtm2 <- mydata.dtm="" removesparseterms="" sparse="0.95)<br">
# mengkonversi dokumen text mengkonversi matrik nilai kerenggangan ke sebuah standard data frame  dan disimpan dalam bentuk .df
sby1.df <- as.data.frame="" br="" inspect="" mydata.dtm2="">
#  periksa dimensi dari data frame
nrow(sby1.df)
ncol(sby1.df)

#-------------------------------------------------------------------------------------------------------#
 # pembentukan dendrogram
sby1.df.scale <- br="" sby1.df="" scale="">d <- br="" dist="" distance="" matrix="" method="euclidean" sby1.df.scale="">fit <- br="" d="" hclust="" method="ward">plot(fit) # muncul dendogram?
 #jumlah cut disesuaikan dengan jumlah data yang termining, jangan sampai melebihi jumlah tweet yang ter-mining.
groups <- 5="" br="" clusters="" cut="" cutree="" fit="" into="" k="7)" tree=""># gambar dendogram border cluster dengan warna merah
rect.hclust(fit, k=7, border="red")

#------------------------------------------------------------------------------------------------------#

 # membuat matrik data dari data frame contohnya "sby1.df" dan dilakukan pemotongan data untuk kolom 1 sampai 11 dan baris 1 sampai  50 (jika data terlalu banyak)
# dilakukan penyimpanan data dalam bentuk matrik
# membuat adjacent matrik dari matrik sebelumnya dan disimpan dalam nama , contohnya "dotsby1"

sbyM <- br="" nbsp="" sby1.df="">dataM <- as.matrix="" br="" sbym="">dataM[dataM>=1] <- 1="" br="">dotsby1 <- br="" datam="" t="">View(dotsby1)

#-------------------------------------------------------------------------------------------------------#

#menggunakan library igraph dan RColorBrewer dari Package CRAN
#install package CRAN jika program R belum terdapat library igraph dan RColorBrewer
library(igraph)
library(RColorBrewer)


# set nilai 0 dalam diagonal matrix 
diag(dotsby1) = 0

# membuat graph
g = graph.adjacency(dotsby1, weighted=TRUE, mode="undirected",
add.rownames=TRUE)
# membuat layout
glay = layout.fruchterman.reingold(g)

# membuat superimpose sebuah struktur cluster dengan k means clustering
kmg = kmeans(dotsby1, centers=6)
gk = kmg$cluster






# memilih desain plot masing masing dot
gbrew = c("red", brewer.pal(8, "Dark2"))
gpal = rgb2hsv(col2rgb(gbrew))
gcols = rep("", length(gk))
for (k in 1:8) {
gcols[gk == k] = hsv(gpal[1,k], gpal[2,k], gpal[3,k], alpha=0.5)
}






# mempersiapkan frame untuk plot
V(g)$size = 10
V(g)$label = V(g)$name
V(g)$degree = degree(g)
#V(g)$label.cex = 1.5 * log10(V(g)$degree)
V(g)$label.color = hsv(0, 0, 0.2, 0.55)
V(g)$frame.color = NA
V(g)$color = gcols
E(g)$color = hsv(0, 0, 0.7, 0.3)

# membuat plot
plot(g, layout=glay)
title("\n TWEET",
col.main="gray40", cex.main=1.5, family="serif")

#####################################################-----------############################## dilanjutkan####

RESULT :