Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 18 vistas

    Reporte Practica 1 IA 2 Carrillo López Oscar Abraham

    Cargado por

    Oscar Abraham Carrillo
    Este reporte describe una práctica sobre perceptrones realizada por Oscar Abraham Carrillo López para la asignatura de Inteligencia Artificial 2. En la práctica se implementó un perceptrón para clasificar puntos en un plano mediante pesos y un sesgo. El código incluye una interfaz gráfica que permite agregar puntos y establecer los parámetros del perceptrón para dividir los puntos por debajo y encima de la línea de decisión. El perceptrón es un modelo fundamental en inteligencia artificial que ha sentado las bases para algoritmos de apre

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd

    Reporte Practica 1 IA 2 Carrillo López Oscar Abraham

    Cargado por

    Oscar Abraham Carrillo
    18 vistas11 páginas
    Este reporte describe una práctica sobre perceptrones realizada por Oscar Abraham Carrillo López para la asignatura de Inteligencia Artificial 2. En la práctica se implementó un perceptrón para clasificar puntos en un plano mediante pesos y un sesgo. El código incluye una interfaz gráfica que permite agregar puntos y establecer los parámetros del perceptrón para dividir los puntos por debajo y encima de la línea de decisión. El perceptrón es un modelo fundamental en inteligencia artificial que ha sentado las bases para algoritmos de apre

    Título original

    reporte_practica_1_IA_2_carrillo_lópez_oscar_abraham.docx

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Este reporte describe una práctica sobre perceptrones realizada por Oscar Abraham Carrillo López para la asignatura de Inteligencia Artificial 2. En la práctica se implementó un perceptrón para clasificar puntos en un plano mediante pesos y un sesgo. El código incluye una interfaz gráfica que permite agregar puntos y establecer los parámetros del perceptrón para dividir los puntos por debajo y encima de la línea de decisión. El perceptrón es un modelo fundamental en inteligencia artificial que ha sentado las bases para algoritmos de apre

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    18 vistas11 páginas

    Reporte Practica 1 IA 2 Carrillo López Oscar Abraham

    Cargado por

    Oscar Abraham Carrillo
    Este reporte describe una práctica sobre perceptrones realizada por Oscar Abraham Carrillo López para la asignatura de Inteligencia Artificial 2. En la práctica se implementó un perceptrón para clasificar puntos en un plano mediante pesos y un sesgo. El código incluye una interfaz gráfica que permite agregar puntos y establecer los parámetros del perceptrón para dividir los puntos por debajo y encima de la línea de decisión. El perceptrón es un modelo fundamental en inteligencia artificial que ha sentado las bases para algoritmos de apre

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    de 11

    UNIVERSIDAD DE GUADALAJARA

    CENTRO UNIVERSITARIO DE CIENCIAS EXACTAS E INGENIERÍAS

    Reporte

    Nombre: Oscar Abraham Carrillo López Matrícula: 219294188

    Nombre del curso: Nombre del profesor: JULIO


    ESTEBAN VALDES LOPEZ
    Inteligencia artificial 2

    Módulo: D02 Actividad: Practica 1

    Fecha: 02/14/2023

    Bibliografía:
    Estamos creando las bases de un perceptrón con esta practica
    pero para dar contexto veamos un poco de que és y su historia. El
    perceptrón fue propuesto por primera vez por Frank Rosenblatt
    en 1958 como un modelo de neurona artificial que puede
    aprender a clasificar patrones en función de la entrada de datos.
    El perceptrón es un algoritmo de aprendizaje supervisado que ha
    sido utilizado en una variedad de aplicaciones, desde el
    reconocimiento de caracteres manuscritos hasta la detección de
    spam en el correo electrónico. El modelo del perceptrón es
    relativamente simple, pero ha sentado las bases para algoritmos
    de aprendizaje más complejos y sofisticados en la actualidad. En
    esta era de grandes cantidades de datos, el perceptrón sigue
    siendo una herramienta valiosa para el análisis de datos y la toma
    de decisiones automatizadas en la inteligencia artificial.

    En esta practica vamos a demostrar a travéz de los pesos y el bias


    como es que un perceptron clasifica los datos en esta caso
    contamos con dos entradas (x, y) y dos pesos w1, w2 y un bias

    Menu:
    Agregamos puntos:

    Agregamos datos de W1, W2 y B


    y ejecutamos con “start”

    Los puntos divididos abajo de la recta se pintan de verde y los


    demas siguen en rojo logrando ver como se clasifican los datos

    Codigo:
    GUI.java (La interfaz grafica y main function):

    import javax.swing.*;
    import java.awt.*;
    import java.awt.geom.*;
    import java.awt.event.*;
    import java.util.ArrayList;

    public class GUI {


    JFrame frame;
    JButton startButton;
    JButton clearButton;
    JTextField w1Field;
    JTextField w2Field;
    JTextField bField;
    JLabel w1;
    JLabel w2;
    JLabel b;
    Graph g = new Graph();
    Neuron neuron;

    GUI(){
    frame = new JFrame("Perceptron");

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setSize(750,500);
    frame.setLocationRelativeTo(null);

    clearButton = new JButton("clear");


    clearButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
    //Here goes the action (method) you want to execute when
    clicked
    System.out.println("clear button ");
    g.points = new ArrayList<>();
    g.repaint();
    }
    });
    clearButton.setBounds(500,400,100,30);

    // Creating start button


    startButton = new JButton("start");
    startButton.setBounds(600,400,100,30);
    startButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
    //Here goes the action (method) you want to execute when
    clicked

    System.out.println("start button ");


    neuron = new Neuron(Integer.valueOf(w1Field.getText()),
    Integer.valueOf(w2Field.getText()), Integer.valueOf(bField.getText()));
    System.out.println(w1Field.getText() + " " + w2Field.getText()
    + " " + bField.getText());
    g.validatePoints(neuron);
    // g.setNeuron(neuron);
    // g.setCompute(true);
    // g.setCompute(false);
    g.repaint();
    }
    });

    //Input boxes
    w1 = new JLabel("W1");
    w1.setBounds(500, 350, 50, 20);
    w1Field = new JTextField(10);
    w1Field.setBounds(520,350,150,20);
    w2 = new JLabel("W2");
    w2.setBounds(500, 300, 50, 20);
    w2Field = new JTextField(10);
    w2Field.setBounds(520,300,150,20);
    b = new JLabel("B");
    b.setBounds(500, 250, 50, 20);
    bField = new JTextField(10);
    bField.setBounds(520,250,150,20);
    g.setBounds(50,50,400,400);

    // Adding elements to the GUI


    frame.add(w1Field);
    frame.add(w1);
    frame.add(w2Field);
    frame.add(w2);
    frame.add(bField);
    frame.add(b);
    frame.add(startButton); // Adds Button to content pane of frame
    frame.add(clearButton); // Adds Button to content pane of frame
    frame.add(g);
    frame.setLayout(null);
    // frame.pack();
    frame.setVisible(true);
    }

    public static void main(String args[]){


    GUI gui = new GUI();
    }
    }

    Graph.java (El plano x, y)

    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    import java.util.ArrayList;
    import java.util.List;

    public class Graph extends JPanel{

    static boolean arr [] = {false};

    int chartPoints []={0,0,0,0};

    class ChartPoint extends Point{


    int pointX;
    int pointY;

    boolean above = false;

    ChartPoint(int x, int y){


    this.x=x;
    this.y=y;
    pointX = (200-x)*-1;
    pointY = (200-y);
    }

    }
    public List<ChartPoint> points = new ArrayList<>();

    Graph(){
    setBackground(new Color(167,203,249));
    addMouseListener(new MouseAdapter() {
    @Override
    public void mousePressed(MouseEvent e){
    points.add(new ChartPoint(e.getX(), e.getY()));

    repaint();
    }
    });

    void setCompute(boolean compute){


    arr[0] = compute;
    }

    boolean [] getCompute(){
    return arr;
    }

    void setNeuron (Neuron n){


    chartPoints[0]= n.point1[0];
    chartPoints[1]= n.point1[1];
    chartPoints[2]= n.point2[0];
    chartPoints[3]= n.point2[1];
    }

    void validatePoints(Neuron n){


    for (ChartPoint p : points){
    int aux_y = n.computeFunction(p.pointX);
    if(aux_y > p.pointY){
    System.out.println(aux_y+ " p.pointY" + p.pointY + " p.pointX
    " + p.pointX);
    p.above= true;
    }
    }
    setNeuron(n);
    }

    @Override
    public void paintComponent (Graphics g){
    super.paintComponent(g);
    Graphics g2 = (Graphics2D) g;
    boolean drawLine = false;
    g2.setColor(Color.RED);
    for (ChartPoint p : points){
    if (p.above) {
    drawLine = true;
    g2.setColor(new Color( 51, 0, 243 ));
    }
    g2.fillOval(p.x, p.y, 5, 5);
    g2.setColor(Color.RED);
    }
    g2.setColor(Color.BLACK);
    Dimension d = this.getSize();
    int height = (int) d.getHeight()/2;
    int width = (int) d.getWidth()/2;
    g.drawLine(width, 0, width, height+height);
    g.drawLine(0, height, width+width, height);
    for (int i = 0; i < height*2 ; i+=20) {
    g.drawLine(width-10, i, width+10, i);
    g.drawString(String.valueOf(200-i), width-15, i);
    }
    for (int i = 0; i < width*2 ; i+=40) {
    g.drawLine(i, height-10, i, height+10);
    g.drawString(String.valueOf((200-i)*-1), i, height-15);
    }

    if (drawLine) {
    System.out.println("En el while");
    g.drawLine(chartPoints[0], chartPoints[1], chartPoints[2],
    chartPoints[3]);
    }

    }
    Neuron.java (Logica y el que calcula la linea con los datos)

    public class Neuron {


    int w1;
    int w2;
    int b;
    int m;
    int c;
    int point1 [] = {0,0};
    int point2 [] = {0,0};

    Neuron(int w1, int w2, int b){


    System.out.println(w1+ " " + w2+ " " + b);
    m =(-1*w1)/w2;
    c=(-1*b)/w2;
    System.out.println( m+" " +c);
    computePoints();
    }

    int transform_y(int y){


    if (y > 200) {
    return 200;
    } else if (y < -200) {
    return -200;
    } else {
    return y;
    }
    }

    void computePoints(){
    int n = 0;
    while (computeFunction(n) < 200 && computeFunction(n) > -200) {
    n--;
    }
    System.out.println(computeFunction(n));
    point1[0]=n+200;
    point1[1]=Math.abs(computeFunction(n)-200);
    n = 0;
    while (computeFunction(n) < 200 && computeFunction(n) > -200) {
    n++;
    }
    point2[0]=n+200;
    System.out.println(computeFunction(n));
    point2[1]=Math.abs(computeFunction(n)-200);
    System.out.println(point1[0] + " " + point1[1] + " " + point2[0] + "
    " + point2[1]);
    }

    int computeFunction(int x){


    return (this.m*x)+this.c;
    }

    En conclusión, el perceptrón es un modelo fundamental en el


    campo de la inteligencia artificial que ha sentado las bases para
    una variedad de algoritmos de aprendizaje supervisado y no
    supervisado. Aunque es relativamente simple, el perceptrón ha
    demostrado su utilidad en aplicaciones prácticas, como la
    clasificación de imágenes y el análisis de sentimientos. Su
    capacidad para aprender y adaptarse a los datos de entrada lo
    convierte en una herramienta valiosa para el análisis de datos en
    grandes conjuntos de información.

    También podría gustarte