e ai galera, eu tenho que fazer um classificador de texto usando o naive bayes, para começar a me acostumar com a assunto, resolvi criar um simples classificador para o problema (Play Tenis?) do livro do tom mitchell, vou deixar ele aqui caso alguém tenha alguma sugestão tanto de melhoria para esse ou sobre naive bayes em geral fique a vontade para compartilhar.
ele tem 4 classes a classe BaseTreinamento tem as características do problema aqui vai ela:
public class BaseTreinamento {
//caracteristicas do problema PLAY TENIS ?
private int numDay;
private String outlook;
private String temperature;
private String humidity;
private String wind;
private String playTenis;
//construtor
public BaseTreinamento(int numDay, String outlook, String tempereture, String huminity, String wind, String playTenis){
this.numDay = numDay;
this.outlook = outlook;
this.temperature = tempereture;
this.humidity = huminity;
this.wind = wind;
this.playTenis = playTenis;
}
//gets and sets
public String getOutlook() {
return outlook;
}
public void setOutlook(String outlook) {
this.outlook = outlook;
}
public String getTemperature() {
return temperature;
}
public void setTemperature(String tempereture) {
this.temperature = tempereture;
}
public String getHumidity() {
return humidity;
}
public void setHumidity(String humidity) {
this.humidity = humidity;
}
public String getWind() {
return wind;
}
public void setWind(String wind) {
this.wind = wind;
}
public String getPlayTenis() {
return playTenis;
}
public void setPlayTenis(String playTenis) {
this.playTenis = playTenis;
}
public int getNumDay() {
return numDay;
}
public void setNumDay(int numDay) {
this.numDay = numDay;
}
//metodo para calcular o numero de classes passada nele
public double calculaQuantidadeClasse(BaseTreinamento[] vetorTreinamento, String playTenisClasse){
double calculaQuantidadeClasse = 0.0;
for(int i=0; i<vetorTreinamento.length; i++){
if(playTenisClasse.equals(vetorTreinamento[i].getPlayTenis())){
calculaQuantidadeClasse = calculaQuantidadeClasse + 1;
}
}
return calculaQuantidadeClasse;
}
}
depois temos a classe NaiveBayes que onde ficam os métodos que calculam as probabilidades que a técnica usa
public class NaiveBayes {
//calcular a probabilidade a priori das classes
public double probabilidadePrioriClasse(BaseTreinamento[] vetorTreinamento, String playTenisClasse){
//double numTotal = vetorTreinamento[0].getTamanhoBase(vetorTreinamento);
int contador = 0;
double probabilidadePrioriClasse = 0.0;
for(int i=0; i<vetorTreinamento.length; i++){
if(playTenisClasse.equals(vetorTreinamento[i].getPlayTenis())){
contador = contador + 1;
}
probabilidadePrioriClasse = contador/(double)vetorTreinamento.length;
}
return probabilidadePrioriClasse;
}
//calcular a probabilidade dos valores das caracteristicas de Outlook
public double probabilidadeCaracteristicaOutlook(BaseTreinamento[] vetorTreinamento, String caracteristica){
int contador = 0;
double probabilidadeCaracteristicaOutlook = 0.0;
for(int i=0; i<vetorTreinamento.length; i++){
if(caracteristica.equals(vetorTreinamento[i].getOutlook())){
contador = contador + 1;
}
probabilidadeCaracteristicaOutlook = contador/(double)vetorTreinamento.length;
}
return probabilidadeCaracteristicaOutlook;
}
//calcular a probabilidade dos valores das caracteristicas de Temperature
public double probabilidadeCaracteristicaTemperature(BaseTreinamento[] vetorTreinamento, String caracteristica){
int contador = 0;
double probabilidadeCaracteristicaTemperature = 0.0;
for(int i=0; i<vetorTreinamento.length; i++){
if(caracteristica.equals(vetorTreinamento[i].getTemperature())){
contador = contador + 1;
}
probabilidadeCaracteristicaTemperature = contador/(double)vetorTreinamento.length;
}
return probabilidadeCaracteristicaTemperature;
}
//calcular a probabilidade dos valores das caracteristicas de Humidity
public double probabilidadeCaracteristicaHumidity(BaseTreinamento[] vetorTreinamento, String caracteristica){
int contador = 0;
double probabilidadeCaracteristicaHumidity = 0.0;
for(int i=0; i<vetorTreinamento.length; i++){
if(caracteristica.equals(vetorTreinamento[i].getHumidity())){
contador = contador + 1;
}
probabilidadeCaracteristicaHumidity = contador/(double)vetorTreinamento.length;
}
return probabilidadeCaracteristicaHumidity;
}
//calcular a probabilidade dos valores das caracteristicas de Wind
public double probabilidadeCaracteristicaWind(BaseTreinamento[] vetorTreinamento, String caracteristica){
int contador = 0;
double probabilidadeCaracteristicaWind = 0.0;
for(int i=0; i<vetorTreinamento.length; i++){
if(caracteristica.equals(vetorTreinamento[i].getWind())){
contador = contador + 1;
}
probabilidadeCaracteristicaWind = contador/(double)vetorTreinamento.length;
}
return probabilidadeCaracteristicaWind;
}
//calcular a probabilidade condicional entre os valores das caracteristicas de Outlook e as classes
public double probabilidadeCondicionalClasseCaracteristicaOutlook(BaseTreinamento[] vetorTreinamento, String caracteristica, String playTenisClasse){
int contador = 0;
double probabilidadeCondicionalClasseCaracteristicaOutlook = 0.0;
for(int i=0; i<vetorTreinamento.length; i++){
if(playTenisClasse.equals(vetorTreinamento[i].getPlayTenis()) && caracteristica.equals(vetorTreinamento[i].getOutlook())){
contador = contador + 1;
}
probabilidadeCondicionalClasseCaracteristicaOutlook = contador/vetorTreinamento[0].calculaQuantidadeClasse(vetorTreinamento, playTenisClasse);
}
return probabilidadeCondicionalClasseCaracteristicaOutlook;
}
//calcular a probabilidade condicional entre os valores das caracteristicas de Temperature e as classes
public double probabilidadeCondicionalClasseCaracteristicaTemperature(BaseTreinamento[] vetorTreinamento, String caracteristica, String playTenisClasse){
int contador = 0;
double probabilidadeCondicionalClasseCaracteristicaTemperature = 0.0;
for(int i=0; i<vetorTreinamento.length; i++){
if(playTenisClasse.equals(vetorTreinamento[i].getPlayTenis()) && caracteristica.equals(vetorTreinamento[i].getTemperature())){
contador = contador + 1;
}
probabilidadeCondicionalClasseCaracteristicaTemperature = contador/vetorTreinamento[0].calculaQuantidadeClasse(vetorTreinamento, playTenisClasse);
}
return probabilidadeCondicionalClasseCaracteristicaTemperature;
}
//calcular a probabilidade condicional entre os valores das caracteristicas de Humidity e as classes
public double probabilidadeCondicionalClasseCaracteristicaHumidity(BaseTreinamento[] vetorTreinamento, String caracteristica, String playTenisClasse){
int contador = 0;
double probabilidadeCondicionalClasseCaracteristicaHumidity = 0.0;
for(int i=0; i<vetorTreinamento.length; i++){
if(playTenisClasse.equals(vetorTreinamento[i].getPlayTenis()) && caracteristica.equals(vetorTreinamento[i].getHumidity())){
contador = contador + 1;
}
probabilidadeCondicionalClasseCaracteristicaHumidity = contador/vetorTreinamento[0].calculaQuantidadeClasse(vetorTreinamento, playTenisClasse);
}
return probabilidadeCondicionalClasseCaracteristicaHumidity;
}
//calcular a probabilidade condicional entre os valores das caracteristicas de Wind e as classes
public double probabilidadeCondicionalClasseCaracteristicaWind(BaseTreinamento[] vetorTreinamento, String caracteristica, String playTenisClasse){
int contador = 0;
double probabilidadeCondicionalClasseCaracteristicaWind = 0.0;
for(int i=0; i<vetorTreinamento.length; i++){
if(playTenisClasse.equals(vetorTreinamento[i].getPlayTenis()) && caracteristica.equals(vetorTreinamento[i].getWind())){
contador = contador + 1;
}
probabilidadeCondicionalClasseCaracteristicaWind = contador/vetorTreinamento[0].calculaQuantidadeClasse(vetorTreinamento, playTenisClasse);
}
return probabilidadeCondicionalClasseCaracteristicaWind;
}
//calcular a probabilidade a posteriori entre os valores das caracteristicas de Outlook e as classes
public double probabilidadePosterioriClasseCaracteristicaOutlook( BaseTreinamento[] vetorTreinamento, String caracteristica, String playTenisClasse){
double resultadoProbabilidadeCondicionalClasseCaracteristicaOutlook = this.probabilidadeCondicionalClasseCaracteristicaOutlook(vetorTreinamento, caracteristica, playTenisClasse);
double resultadoProbabilidadeCaracteristicaOutlook = this.probabilidadeCaracteristicaOutlook(vetorTreinamento, caracteristica);
double resultadoProbabilidadePrioriClasse = this.probabilidadePrioriClasse(vetorTreinamento, playTenisClasse);
double resultadoFinal = 0.0;
resultadoFinal = (resultadoProbabilidadeCondicionalClasseCaracteristicaOutlook* resultadoProbabilidadePrioriClasse)/resultadoProbabilidadeCaracteristicaOutlook;
return resultadoFinal;
}
//calcular a probabilidade a posteriori entre os valores das caracteristicas de Temperature e as classes
public double probabilidadePosterioriClasseCaracteristicaTemperature( BaseTreinamento[] vetorTreinamento, String caracteristica, String playTenisClasse){
double resultadoProbabilidadeCondicionalClasseCaracteristicaTemperature = this.probabilidadeCondicionalClasseCaracteristicaTemperature(vetorTreinamento, caracteristica, playTenisClasse);
double resultadoProbabilidadeCaracteristicaTemperature = this.probabilidadeCaracteristicaTemperature(vetorTreinamento, caracteristica);
double resultadoProbabilidadePrioriClasse = this.probabilidadePrioriClasse(vetorTreinamento, playTenisClasse);
double resultadoFinal = 0.0;
resultadoFinal = (resultadoProbabilidadeCondicionalClasseCaracteristicaTemperature* resultadoProbabilidadePrioriClasse)/resultadoProbabilidadeCaracteristicaTemperature;
return resultadoFinal;
}
//calcular a probabilidade a posteriori entre os valores das caracteristicas de Humidity e as classes
public double probabilidadePosterioriClasseCaracteristicaHumidity( BaseTreinamento[] vetorTreinamento, String caracteristica, String playTenisClasse){
double resultadoProbabilidadeCondicionalClasseCaracteristicaHumidity = this.probabilidadeCondicionalClasseCaracteristicaHumidity(vetorTreinamento, caracteristica, playTenisClasse);
double resultadoProbabilidadeCaracteristicaHumidity = this.probabilidadeCaracteristicaHumidity(vetorTreinamento, caracteristica);
double resultadoProbabilidadePrioriClasse = this.probabilidadePrioriClasse(vetorTreinamento, playTenisClasse);
double resultadoFinal = 0.0;
resultadoFinal = (resultadoProbabilidadeCondicionalClasseCaracteristicaHumidity* resultadoProbabilidadePrioriClasse)/resultadoProbabilidadeCaracteristicaHumidity;
return resultadoFinal;
}
//calcular a probabilidade a posteriori entre os valores das caracteristicas de Wind e as classes
public double probabilidadePosterioriClasseCaracteristicaWind( BaseTreinamento[] vetorTreinamento, String caracteristica, String playTenisClasse){
double resultadoProbabilidadeCondicionalClasseCaracteristicaWind = this.probabilidadeCondicionalClasseCaracteristicaWind(vetorTreinamento, caracteristica, playTenisClasse);
double resultadoProbabilidadeCaracteristicaWind = this.probabilidadeCaracteristicaWind(vetorTreinamento, caracteristica);
double resultadoProbabilidadePrioriClasse = this.probabilidadePrioriClasse(vetorTreinamento, playTenisClasse);
double resultadoFinal = 0.0;
resultadoFinal = (resultadoProbabilidadeCondicionalClasseCaracteristicaWind* resultadoProbabilidadePrioriClasse)/resultadoProbabilidadeCaracteristicaWind;
return resultadoFinal;
}
//Classificador
public double classificadorNaiveBayesYes(String caracteristicaOutlook, String caracteristicaTemperature,String caracteristicaHumidity,String caracteristicaWind, ResultadosTreinamento resultado){
double temp1 = 0.0;
double temp2 = 0.0;
double temp3 = 0.0;
double temp4 = 0.0;
if(caracteristicaOutlook.equals("sunny")){
temp1 = resultado.getResultadoPosterioriSunnyYes();
}else if(caracteristicaOutlook.endsWith("overcast")){
temp1 = resultado.getResultadoPosterioriOvercastYes();
}else{
temp1 = resultado.getResultadoPosterioriRainYes();
}
if(caracteristicaTemperature.equals("hot")){
temp2 = resultado.getResultadoPosterioriHotYes();
}else if(caracteristicaTemperature.equals("mild")){
temp2 = resultado.getResultadoPosterioriMildYes();
}else{
temp2 = resultado.getResultadoPosterioriCoolYes();
}
if(caracteristicaHumidity.equals("normal")){
temp3 = resultado.getResultadoPosterioriNormalYes();
}else{
temp3 = resultado.getResultadoPosterioriHighYes();
}
if(caracteristicaWind.equals("strong")){
temp4 = resultado.getResultadoPosterioriStrongYes();
}else{
temp4 = resultado.getResultadoPosterioriWeakYes();
}
return temp1*temp2*temp3*temp4;
}
//Classificador
public double classificadorNaiveBayesNo(String caracteristicaOutlook, String caracteristicaTemperature,String caracteristicaHumidity,String caracteristicaWind, ResultadosTreinamento resultado){
double temp1 = 0.0;
double temp2 = 0.0;
double temp3 = 0.0;
double temp4 = 0.0;
if(caracteristicaOutlook.equals("sunny")){
temp1 = resultado.getResultadoPosterioriSunnyNo();
}else if(caracteristicaOutlook.endsWith("overcast")){
temp1 = resultado.getResultadoPosterioriOvercastNo();
}else{
temp1 = resultado.getResultadoPosterioriRainNo();
}
if(caracteristicaTemperature.equals("hot")){
temp2 = resultado.getResultadoPosterioriHotNo();
}else if(caracteristicaTemperature.equals("mild")){
temp2 = resultado.getResultadoPosterioriMildNo();
}else{
temp2 = resultado.getResultadoPosterioriCoolNo();
}
if(caracteristicaHumidity.equals("normal")){
temp3 = resultado.getResultadoPosterioriNormalNo();
}else{
temp3 = resultado.getResultadoPosterioriHighNo();
}
if(caracteristicaWind.equals("strong")){
temp4 = resultado.getResultadoPosterioriStrongNo();
}else{
temp4 = resultado.getResultadoPosterioriWeakNo();
}
return temp1*temp2*temp3*temp4;
}
}
na classe ResultadosTreinamento ficam salvos os pesos apos o classificador treinar na base de dados, esses pesos são usados na hora de decidir de qual classe será o novo conjunto de características
public class ResultadosTreinamento {
private double resultadoPosterioriSunnyYes = 0.0;
private double resultadoPosterioriSunnyNo = 0.0;
private double resultadoPosterioriOvercastYes = 0.0;
private double resultadoPosterioriOvercastNo = 0.0;
private double resultadoPosterioriRainYes = 0.0;
private double resultadoPosterioriRainNo = 0.0;
private double resultadoPosterioriHotYes = 0.0;
private double resultadoPosterioriHotNo = 0.0;
private double resultadoPosterioriMildYes = 0.0;
private double resultadoPosterioriMildNo = 0.0;
private double resultadoPosterioriCoolYes = 0.0;
private double resultadoPosterioriCoolNo = 0.0;
private double resultadoPosterioriHighYes = 0.0;
private double resultadoPosterioriHighNo = 0.0;
private double resultadoPosterioriNormalYes = 0.0;
private double resultadoPosterioriNormalNo = 0.0;
private double resultadoPosterioriWeakYes = 0.0;
private double resultadoPosterioriWeakNo = 0.0;
private double resultadoPosterioriStrongYes = 0.0;
private double resultadoPosterioriStrongNo = 0.0;
public ResultadosTreinamento() {
}
public double getResultadoPosterioriSunnyYes() {
return resultadoPosterioriSunnyYes;
}
public void setResultadoPosterioriSunnyYes(double resultadoPosterioriSunnyYes) {
this.resultadoPosterioriSunnyYes = resultadoPosterioriSunnyYes;
}
public double getResultadoPosterioriSunnyNo() {
return resultadoPosterioriSunnyNo;
}
public void setResultadoPosterioriSunnyNo(double resultadoPosterioriSunnyNo) {
this.resultadoPosterioriSunnyNo = resultadoPosterioriSunnyNo;
}
public double getResultadoPosterioriOvercastYes() {
return resultadoPosterioriOvercastYes;
}
public void setResultadoPosterioriOvercastYes(
double resultadoPosterioriOvercastYes) {
this.resultadoPosterioriOvercastYes = resultadoPosterioriOvercastYes;
}
public double getResultadoPosterioriOvercastNo() {
return resultadoPosterioriOvercastNo;
}
public void setResultadoPosterioriOvercastNo(
double resultadoPosterioriOvercastNo) {
this.resultadoPosterioriOvercastNo = resultadoPosterioriOvercastNo;
}
public double getResultadoPosterioriRainYes() {
return resultadoPosterioriRainYes;
}
public void setResultadoPosterioriRainYes(double resultadoPosterioriRainYes) {
this.resultadoPosterioriRainYes = resultadoPosterioriRainYes;
}
public double getResultadoPosterioriRainNo() {
return resultadoPosterioriRainNo;
}
public void setResultadoPosterioriRainNo(double resultadoPosterioriRainNo) {
this.resultadoPosterioriRainNo = resultadoPosterioriRainNo;
}
public double getResultadoPosterioriHotYes() {
return resultadoPosterioriHotYes;
}
public void setResultadoPosterioriHotYes(double resultadoPosterioriHotYes) {
this.resultadoPosterioriHotYes = resultadoPosterioriHotYes;
}
public double getResultadoPosterioriHotNo() {
return resultadoPosterioriHotNo;
}
public void setResultadoPosterioriHotNo(double resultadoPosterioriHotNo) {
this.resultadoPosterioriHotNo = resultadoPosterioriHotNo;
}
public double getResultadoPosterioriMildYes() {
return resultadoPosterioriMildYes;
}
public void setResultadoPosterioriMildYes(double resultadoPosterioriMildYes) {
this.resultadoPosterioriMildYes = resultadoPosterioriMildYes;
}
public double getResultadoPosterioriMildNo() {
return resultadoPosterioriMildNo;
}
public void setResultadoPosterioriMildNo(double resultadoPosterioriMildNo) {
this.resultadoPosterioriMildNo = resultadoPosterioriMildNo;
}
public double getResultadoPosterioriCoolYes() {
return resultadoPosterioriCoolYes;
}
public void setResultadoPosterioriCoolYes(double resultadoPosterioriCoolYes) {
this.resultadoPosterioriCoolYes = resultadoPosterioriCoolYes;
}
public double getResultadoPosterioriCoolNo() {
return resultadoPosterioriCoolNo;
}
public void setResultadoPosterioriCoolNo(double resultadoPosterioriCoolNo) {
this.resultadoPosterioriCoolNo = resultadoPosterioriCoolNo;
}
public double getResultadoPosterioriHighYes() {
return resultadoPosterioriHighYes;
}
public void setResultadoPosterioriHighYes(double resultadoPosterioriHighYes) {
this.resultadoPosterioriHighYes = resultadoPosterioriHighYes;
}
public double getResultadoPosterioriHighNo() {
return resultadoPosterioriHighNo;
}
public void setResultadoPosterioriHighNo(double resultadoPosterioriHighNo) {
this.resultadoPosterioriHighNo = resultadoPosterioriHighNo;
}
public double getResultadoPosterioriNormalYes() {
return resultadoPosterioriNormalYes;
}
public void setResultadoPosterioriNormalYes(double resultadoPosterioriNormalYes) {
this.resultadoPosterioriNormalYes = resultadoPosterioriNormalYes;
}
public double getResultadoPosterioriNormalNo() {
return resultadoPosterioriNormalNo;
}
public void setResultadoPosterioriNormalNo(double resultadoPosterioriNormalNo) {
this.resultadoPosterioriNormalNo = resultadoPosterioriNormalNo;
}
public double getResultadoPosterioriWeakYes() {
return resultadoPosterioriWeakYes;
}
public void setResultadoPosterioriWeakYes(double resultadoPosterioriWeakYes) {
this.resultadoPosterioriWeakYes = resultadoPosterioriWeakYes;
}
public double getResultadoPosterioriWeakNo() {
return resultadoPosterioriWeakNo;
}
public void setResultadoPosterioriWeakNo(double resultadoPosterioriWeakNo) {
this.resultadoPosterioriWeakNo = resultadoPosterioriWeakNo;
}
public double getResultadoPosterioriStrongYes() {
return resultadoPosterioriStrongYes;
}
public void setResultadoPosterioriStrongYes(double resultadoPosterioriStrongYes) {
this.resultadoPosterioriStrongYes = resultadoPosterioriStrongYes;
}
public double getResultadoPosterioriStrongNo() {
return resultadoPosterioriStrongNo;
}
public void setResultadoPosterioriStrongNo(double resultadoPosterioriStrongNo) {
this.resultadoPosterioriStrongNo = resultadoPosterioriStrongNo;
}
}
e por fim, a classe Principal onde é feito a chamada da base de treinamento, o treinamento em sí, e o teste de classificação do novo conjunto de características
public class Principal {
public static void main(String[] args) {
NaiveBayes naive = new NaiveBayes();
double decisaoYes = 0.0;
double decisaoNo = 0.0;
//vetor do tipo baseTreinamento onde ficará a base de treinamento
BaseTreinamento[] baseTreinamento = new BaseTreinamento[14];
ResultadosTreinamento resultado = new ResultadosTreinamento();
//instanciar base de treinamento
baseTreinamento[0] = new BaseTreinamento(1, "sunny", "hot", "high", "weak", "no");
baseTreinamento[1] = new BaseTreinamento(2, "sunny", "hot", "high", "strong", "no");
baseTreinamento[2] = new BaseTreinamento(3, "overcast", "hot", "high", "weak", "yes");
baseTreinamento[3] = new BaseTreinamento(4, "rain", "mild", "high", "weak", "yes");
baseTreinamento[4] = new BaseTreinamento(5, "rain", "cool", "normal", "weak", "yes");
baseTreinamento[5] = new BaseTreinamento(6, "rain", "cool", "normal", "strong", "no");
baseTreinamento[6] = new BaseTreinamento(7, "overcast", "cool", "normal", "strong", "yes");
baseTreinamento[7] = new BaseTreinamento(8, "sunny", "mild", "high", "weak", "no");
baseTreinamento[8] = new BaseTreinamento(9, "sunny", "cool", "normal", "weak", "yes");
baseTreinamento[9] = new BaseTreinamento(10, "rain", "mild", "normal", "weak", "yes");
baseTreinamento[10] = new BaseTreinamento(11, "sunny", "mild", "normal", "strong", "yes");
baseTreinamento[11] = new BaseTreinamento(12, "overcast", "mild", "high", "strong", "yes");
baseTreinamento[12] = new BaseTreinamento(13, "overcast", "hot", "normal", "weak", "yes");
baseTreinamento[13] = new BaseTreinamento(14, "rain", "mild", "high", "strong", "no");
//Treinamento e Salvar pesos
resultado.setResultadoPosterioriSunnyYes(naive.probabilidadePosterioriClasseCaracteristicaOutlook(baseTreinamento, "sunny", "yes"));
resultado.setResultadoPosterioriSunnyNo(naive.probabilidadePosterioriClasseCaracteristicaOutlook(baseTreinamento, "sunny", "no"));
resultado.setResultadoPosterioriOvercastYes(naive.probabilidadePosterioriClasseCaracteristicaOutlook(baseTreinamento, "overcast", "yes"));
resultado.setResultadoPosterioriOvercastNo(naive.probabilidadePosterioriClasseCaracteristicaOutlook(baseTreinamento, "overcast", "no"));
resultado.setResultadoPosterioriRainYes(naive.probabilidadePosterioriClasseCaracteristicaOutlook(baseTreinamento, "rain", "yes"));
resultado.setResultadoPosterioriRainNo(naive.probabilidadePosterioriClasseCaracteristicaOutlook(baseTreinamento, "rain", "no"));
resultado.setResultadoPosterioriHotYes(naive.probabilidadePosterioriClasseCaracteristicaTemperature(baseTreinamento, "hot", "yes"));
resultado.setResultadoPosterioriHotNo(naive.probabilidadePosterioriClasseCaracteristicaTemperature(baseTreinamento, "hot", "no"));
resultado.setResultadoPosterioriMildYes(naive.probabilidadePosterioriClasseCaracteristicaTemperature(baseTreinamento, "mild", "yes"));
resultado.setResultadoPosterioriMildNo(naive.probabilidadePosterioriClasseCaracteristicaTemperature(baseTreinamento, "mild", "no"));
resultado.setResultadoPosterioriCoolYes(naive.probabilidadePosterioriClasseCaracteristicaTemperature(baseTreinamento, "cool", "yes"));
resultado.setResultadoPosterioriCoolNo(naive.probabilidadePosterioriClasseCaracteristicaTemperature(baseTreinamento, "cool", "no"));
resultado.setResultadoPosterioriNormalYes(naive.probabilidadePosterioriClasseCaracteristicaHumidity(baseTreinamento, "normal", "yes"));
resultado.setResultadoPosterioriNormalNo(naive.probabilidadePosterioriClasseCaracteristicaHumidity(baseTreinamento, "normal", "no"));
resultado.setResultadoPosterioriHighYes(naive.probabilidadePosterioriClasseCaracteristicaHumidity(baseTreinamento, "high", "yes"));
resultado.setResultadoPosterioriHighNo(naive.probabilidadePosterioriClasseCaracteristicaHumidity(baseTreinamento, "high", "no"));
resultado.setResultadoPosterioriStrongYes(naive.probabilidadePosterioriClasseCaracteristicaWind(baseTreinamento, "strong", "yes"));
resultado.setResultadoPosterioriStrongNo(naive.probabilidadePosterioriClasseCaracteristicaWind(baseTreinamento, "strong", "no"));
resultado.setResultadoPosterioriWeakYes(naive.probabilidadePosterioriClasseCaracteristicaWind(baseTreinamento, "weak", "yes"));
resultado.setResultadoPosterioriWeakNo(naive.probabilidadePosterioriClasseCaracteristicaWind(baseTreinamento, "weak", "no"));
decisaoYes = naive.classificadorNaiveBayesYes("sunny", "cool", "high", "strong", resultado);
decisaoNo = naive.classificadorNaiveBayesNo("sunny", "cool", "high", "strong", resultado);
if(decisaoYes > decisaoNo){
System.out.println("Pertence a classe YES");
}else{
System.out.println("Pertence a classe NO");
}
}
}
é isso, fiquem a vontade para dar sugestões, abraço