Simple Method Sending Email using JavaMail API

package javamail;

import javax.mail.*;
import javax.mail.internet.*;
import java.util.*;

public class JavaMail {   
  //From address
String d_email = "fromUsername@gmail.com",
            d_password = "password", //your email password
            d_host = "smtp.gmail.com",
            d_port = "465",
            m_to = "toUsername@gmail.com", // Target email address
            m_subject = "Testing",
            m_text = "Hey, this is a test email.";
   
    public JavaMailDemo() {
        Properties props = new Properties();
        props.put("mail.smtp.user", d_email);
        props.put("mail.smtp.host", d_host);
        props.put("mail.smtp.port", d_port);
        props.put("mail.smtp.starttls.enable", "true");
        props.put("mail.smtp.auth", "true");
        //props.put("mail.smtp.debug", "true");
        props.put("mail.smtp.socketFactory.port", d_port);
        props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
        props.put("mail.smtp.socketFactory.fallback", "false");
        try {
            Authenticator auth = new SMTPAuthenticator();
            Session session = Session.getInstance(props, auth);    
            MimeMessage msg = new MimeMessage(session);
            msg.setText(m_text);
            msg.setSubject(m_subject);
            msg.setFrom(new InternetAddress(d_email));
            msg.addRecipient(Message.RecipientType.TO, new InternetAddress(m_to));
            Transport.send(msg);
        } catch (Exception mex) {
            mex.printStackTrace();
        }
    }
  
    public static void main(String[] args) {
        JavaMail blah = new JavaMail();
    }
 
    private class SMTPAuthenticator extends javax.mail.Authenticator {
        public PasswordAuthentication getPasswordAuthentication() {
            return new PasswordAuthentication(d_email, d_password);
        }
    }
}

Read More

Multiple ROC Curve for multiple number of classifiers

In my previous post I have explained about how to generate a single ROC Curve for single classifier, but in the practical cases you will need to generate Multiple ROC Curve for multiple numbers of classifiers. This is very important to evaluate the performance of the classifiers. The following steps will gives you the complete idea of how to draw Multiple ROC Curve for multiple numbers of classifiers.

Open the Weka tool and select the knowledge flow tab.

Figure 1

Figure 2

• When it is loaded, the first thing is to select ArffLoader from the DataSources menu, which is used to input the data. Drag ArffLoader into the knowledge flow layout as shown in figure 3.
• From the evaluation tab select the ClassAssigner and put it into the knowledge flow layout.
• From the evaluation tab select the ClassValuePicker and put it into the knowledge flow layout.
• From the evaluation tab select the CrossValidationFoldMaker (we have using 10 fold cross validation) and put it into the knowledge flow layout.
• Next step is to choose the classifiers from classifiers tab, in this tutorial I am using Random Forest (RF) and Naïve Bayes as classifiers. Select RF from trees tab and Naïve Bayes from bayes tab.
• We are going perform the performance of the classifiers, for that from the evaluation tab select the ClassifierPerformanceEvaluator(we need two performance evaluator one for each classifier) ) and put it into the knowledge flow layout.
• Finally we have to plot the ROC Curve, for that from the visualization tab select ModelPerformanceChart  and put it into the knowledge flow layout.

Figure 3

Now all the components need to draw the ROC are on the layout, next thing is to do the connections.

• To connect ArffLoader with the ClassAssigner , right click on the ArffLoader  and select the data set and connect it to the ClassAssigner 

Figure 4

• Right click on the ClassAssigner and select the dataset, connect it to ClassValuePicker.
• Right click on the ClassValuePicker and select the dataset, connect it to. CrossValidationFoldMaker.
• Next we have to assign the training and test set data to the classifier algorithms
• Right click on the CrossValidationFoldMaker and select the training data, connect it to RF classifier. Right click on the CrossValidationFoldMaker and select the testing data, connect it to RF classifier.Similarly do the same for Naïve Bayes classifier also.
• Right click on the RF Classifier and select the batchClassifier, connect it to ClassifierPerformanceEvaluator. Do the same for the Naïve Bayes classifier also.
• Right click on the ClassifierPerformanceEvaluator and select the thresholdData, connect it to ModelPerformanceChart. Now the total arrangement looks like figure 4.

Figure 5

• Next we are going to input the data, for that right clicks on the ArffLoader and select configure. Browse for the arrf file in your system, click ok button.
• Right click on the ClassValuePicker and selects for which class we going to draw the ROC Curve.
• Right click on the CrossValidationFoldMaker and selects how many folds we are using (default will be 10 fold cross validation) for selecting the training and testing data. Ten fold cross validation means from the input 90% data are used as training data and remaining 10% used as the testing data.
• Next we have to run the model for that right clicks on the ArffLoader and selects start loading

Figure 6

To see the ROC Curve Right click the ModelPerformanceChart, and select show chart. The result will be look like in the figure 7.

Figure 7

Figure 8

Read More

How to plot ROC Curves in weka?

Receiver Operating Characteristic (ROC) represents the different trade-off between false positives and false negatives. It is created by plotting the fraction of true positives out of the total actual positives (True Positive Rate) vs. the fraction of false positives out of the total actual negatives (False Positive Rate), at various threshold settings. 

 

Do the steps given here for classification, after that right click on the result list

 

Select Visualize threshold curve

 

X axis will be False Positive Rate and Y axis will be True Positive Rate

To save the image click  Alt + Shift + Left Mouse Button

Read More

Classification using Weka - Weka Tutorial 1

This tutorial gives in depth idea of how the classification in data mining is done using the weka tool.

1. Click the explorer tab in the weka (Figure 1)
   

   

   Figure 1

2. under the Preprocess tab click open file (Figure  2)
   

   

   Figure 2

3. Open an .arff file to do classification (Figure 3)

4. 

   Figure 3

   Click the classify tab, choose the classifier

   

   Figure 4

5. Click the start button

   

   Figure 5

6. The result will like the following.

   

   Figure 6

Read More

Java Code to Copy eMail from One Folder to Another in Gmail

The following java code copies the eMails from one folder to another folder in gmail.

Steps

1. First create a new label in gmail by clicking the manage label link
2. Create new label(Name of the source folder)
3. Give the name of new label in source folder(eg:PHISH) place in the code
4. Run the code  
   

Libraries Required :- JavaMail Download  

Source Code
import java.util.Properties;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Store;

/**
 *
 * @Sarju
 */
public class MoveMailToFolder {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.setProperty("mail.store.protocol", "imaps");
        try {
            Session session = Session.getInstance(props, null);
            Store store = session.getStore();
            //eMail Authentication
            store.connect("imap.gmail.com", "username@gmail.com", "password");
            Folder inbox = store.getFolder("INBOX");//Source folder
            inbox.open(Folder.READ_WRITE);
            System.out.println("Opened source...");
            Folder spam = store.getFolder("PHISH"); // Destination folder
            spam.open(Folder.READ_WRITE);
            //Get the latest message
            Message[] msgs = inbox.getMessages(inbox.getMessageCount()-inbox.getUnreadMessageCount(),inbox.getMessageCount());
            inbox.copyMessages(msgs, spam);
            System.out.println("Copied messages...");
            inbox.close(false);
            store.close();
            } catch (Exception mex) {
        }
    }
}

Read More

The Cigarette Smokers Problem

Multithreading - Multiprocessor operating systems
The Cigarette Smokers Problem
Consider a simulation with three smoker threads and one agent thread. Each
smoker continuously makes a cigarette and smokes it. But to make a cigarette, a
smoker needs three ingredients: tobacco, paper, and matches. One of the smoker
threads has only paper, another has only tobacco, and the third has only matches.
The agent thread has an infinite supply of all three materials. The three smoker
threads are initially blocked. The agent places two randomly chosen (different)
ingredients on the table and unblocks the one smoker who has the remaining
ingredient. The agent then blocks. The unblocked smoker removes the two
ingredients from the table, makes a cigarette, and smokes it for a random amount of
time, unblocking the agent on completion of smoking the cigarette. The agent then
puts out another random two of the three ingredients, and the cycle repeats.
Write a multi-class multithreaded Java program that uses a monitor to
synchronize the agent thread and the three smoker threads. Do not mechanically
translate semaphore code into monitor code! The agent thread executes in an
agent object created from an agent class. Each smoker thread executes in a smoker
object. All smoker objects are created from one smoker class whose constructor is
used to specify the ingredient possessed by the smoker object. A driver class with a
main method constructs the objects and starts the threads. Use a single monitor
object instantiated from a class Control for synchronization. Each of the four
threads invokes a synchronized monitor method for its synchronization. No
semaphores are allowed. No synchronized blocks are allowed, only synchronized
methods. No busy waiting is allowed. No calls to nap inside a synchronized method
are allowed (do not nap while holding the monitor object's lock, that is, while inside
a synchronized method or while inside a method called by a synchronized method).
Source Code:
/*
Cigarette Smoker's Problem Solution using java
Author : Sarju
Date: 10-03-2013
*/
import java.util.ArrayList;
import java.util.Random;
class CigaretteSmokersProblem {

    public static void main(String[] args) {
        table smokingtable = new table();

        agent controlAgent = new agent(smokingtable);

        controlAgent.start();

        for (int i = 0; i < 3; i++)
        {
            // each smoker-thread gets the controlAgent, so the thread can wake up the agent and we don't have to do notifyAll();
            smoker smokerThread = new smoker(smokingtable, i, "Smoker " + Integer.toString(i+1), controlAgent);
            smokerThread.start();
        }
    }
}

class smoker extends Thread {

    private table smokingtable = new table();
    private String ingredient;
    private int ingredientNumber;
    private agent controlAgent;

    public smoker(table pSmokingtable, int pIngredientNumber, String pName, agent pAgent)
    {
        // only save the number of the ingredient, we'll get the ingredient's name while the thread is running
        ingredientNumber = pIngredientNumber;
        this.smokingtable = pSmokingtable;
        setName(pName);
        controlAgent = pAgent;
    }

    @Override
    public void run()
    {
        while(true)
        {
            ingredient = smokingtable.getSmokerIngredient(ingredientNumber);

            if (!smokingtable.hasIngredient(ingredient) && !smokingtable.isEmpty())
            {
                System.out.println(getName() + " has " + ingredient + ".");
                try {
                    doSmoke();
                    System.out.println(getName() + " tells the agent to start the next round.");
                    // the thread tells the agent to continue
                    controlAgent.wake();
                } catch (Exception e) {}
            }
        }
    }

    public synchronized void doSmoke() throws Exception
    {
        System.out.println(getName() + " rolls the cigarette.");
        Thread.sleep(2500);
        System.out.println(getName() + " smokes.");
        Thread.sleep(2500);
        System.out.println(getName() + " has finished.");
    }

  }

class agent extends Thread {

    private table smokingtable;

    public agent(table pSmokingtable)
    {
        smokingtable = pSmokingtable;
    }

    @Override
    public void run()
    {
        while(true)
        {
            try {
                Thread.sleep(5000);
            } catch (Exception e) {}
            smokingtable.setAgentIngredients();
            // this triggers the smoker-threads to look at the table
            System.out.println("\n");
            System.out.println("The agents puts " + smokingtable.getAgentIngredients() + " on the table.");
            // pause the agent while one smoker thread is running
            pause();
        }
    }

    public synchronized void wake()
    {
        try
        {
            notify();
        } catch(Exception e){}
    }


    public synchronized void pause()
    {
        try
        {
            this.wait();
        } catch (Exception e) {}
    }

   
}

/*Class for creating table*/
class table {
    //Variables for storing ingredients(tabacco,paper,matches)
    private ArrayList allIngredients  = new ArrayList();
    private ArrayList agentIngredients = new ArrayList();

    public table()
    {
        allIngredients .add("tabacco");
        allIngredients .add("paper");
        allIngredients .add("matches");
    }
    /*Function for setting two ingredients randomly*/
    public void setAgentIngredients()
    {
        Random random = new Random();

        agentIngredients.clear();

        ArrayList copyAllElements = (ArrayList) allIngredients .clone();

        int ingredient1 = random.nextInt(copyAllElements.size());
        agentIngredients.add(copyAllElements.get(ingredient1));

        copyAllElements.remove(ingredient1);
        int ingredient2 = random.nextInt(copyAllElements.size());
        agentIngredients.add(copyAllElements.get(ingredient2));
    }
    /*Function for checking weather the table is empty*/
    public boolean isEmpty()
    {
        return (agentIngredients.size() == 0);
    }
    /*Function for getting two ingredients that
    are set previously by the function setAgentIngredients()*/
    public synchronized String getAgentIngredients()
    {
        notifyAll();
        return agentIngredients.toString();
    }
    /*Function for getting the ingredient
    with the corresponding smoker*/
    public synchronized String getSmokerIngredient(int pIngredient)
    {
        try {
            this.wait();
        } catch (Exception e) {}
        return allIngredients .get(pIngredient);
    }
    /*Function for Checking the smoker has the same ingredient
    as in the table if so smoking is is not possible*/
    public boolean hasIngredient(String ingredientName)
    {
        return (agentIngredients.contains(ingredientName));
    }

    public synchronized void pause()
    {
        try {
            this.wait();
        } catch (Exception e) {}
    }
}

Read More

Semaphores - Multiprocessor operating systems using Java

/*PROGRAM 1 – Semaphores - Multiprocessor operating systems
Assume there are three processes: Pa, Pb, and Pc. Only Pa can output
the letter A, Pb B, and Pc C.
Utilizing only semaphores (and no other variables) the processes are
synchronized so that the output satisfies the following conditions:
a) A B must be output before any C's can be output.
b) B's and C's must alternate in the output string, that is, after the
first B is output, another B cannot be output until a C is output.
Similarly, once a C is output, another C cannot be output until a B is output.
c) The total number of B's and C's which have been output at any given point in the output
string cannot exceed the number of A's which have been output up to that point.
Examples
AACB -- invalid, violates a)
ABACAC -- invalid, violates b)
AABCABC -- invalid, violates c)
AABCAAABC -- valid
AAAABCBC -- valid
AB -- valid*/

/*AUTHORS: Sarju S, Nidhin AS
Date: 3rd March 2013*/
class ABC {
    int aCount=0;//Variable used to ensure the third rule
    boolean  isPrintBC= false;//Used to ensure the second rule
    //Function used to print A
    synchronized void printA() {
        System.out.print("A");
        aCount++;
        try{
            Thread.sleep(1000);
            notify();
        }
        catch(Exception e){}
    }
    //Function used to print B
    synchronized void printB() {
        if(isPrintBC)//True
        try {
            wait();
        } catch(InterruptedException e) {
        System.out.println("InterruptedException caught");
        }
        //False
        if(aCount>0){
            System.out.print("B");
            try{
            Thread.sleep(1000);
            }
            catch(Exception e){}
            aCount--;
            isPrintBC=true;
            notify();
           
   
        }
        //Rule 3 voilated
        else{
            isPrintBC=true;
            notify();
            }
        }
    //Function used to print C
    synchronized void printC() {
    if(!isPrintBC)//False
        try {
            wait();
        } catch(InterruptedException e) {
        System.out.println("InterruptedException caught");
        }
        //True
        if(aCount>0){
            System.out.print("C");
            try{
            Thread.sleep(1000);
            }
            catch(Exception e){}
           
            aCount--;
            isPrintBC=false;
            notify();
   
        }
        //Rule 3 voilated
        else{
            isPrintBC=false;
            notify();
            }
    }
}
//Process Pa outputs A
class Pa implements Runnable {
    ABC abc;
    Pa(ABC abc) {
        this.abc = abc;
        new Thread(this, "Pa").start();
    }
    public void run() {
        for(int i=0;i<10 br="" i="">        abc.printA();
        }
    }
}
//Process Pb outputs B
class Pb implements Runnable {
    ABC abc;
    Pb(ABC abc) {
        this.abc = abc;
        new Thread(this, "Pb").start();
    }
    public void run() {
        for(int i=0;i<10 br="" i="">            abc.printB();
        }
    }
}
//Process Pc outputs C
class Pc implements Runnable {
    ABC abc;
    Pc(ABC abc) {
        this.abc = abc;
        new Thread(this, "Pc").start();
    }
    public void run() {
        for(int i=0;i<10 br="" i="">        abc.printC();
        }
    }
}
//Main Class
class Multi_Process_OS {
    public static void main(String args[]) {
    ABC abc = new ABC();
        new Pa(abc);
        new Pb(abc);
        new Pc(abc);
    }
}

Read More