How jotis86/alzheimer-project works
Main Components
• Data Layer:
• Data acquisition and cleaning (directories like Data, Data_exploration, and Statistics).
• Storage of raw and cleaned data (e.g., CSVs, Parquet files, and MRI image datasets).
• Analytics and Model Building:
• Machine Learning components (located in Machine_learning, with training notebooks and pickled models).
• Deep Learning components (found in Deep_learning, including model files like alzheimer_model.h5 and relevant notebooks).
• Application and User Interface:
• Interactive application with Streamlit (code in App folder and Deep_learning/app.py).
• Visualization components (Data_visualization folder and Power_BI dashboards).
• External Integrations:
• Chat Bot integration with Cohere (as described in the README).
• Alexa Skill (detailed in the README, though the implementation details might reside outside the visible file structure).
• Supporting Documentation and Reports:
• PDFs and reports inside the App folder and documentation in Project_Management and README files.
Relationships and Data Flow
• Data flows from the raw data sources into preprocessing pipelines (Data and Data_exploration).
• Preprocessed data feeds into the ML and DL model training pipelines.
• Trained models (serialized using Joblib/pickle or in .h5 format) are then consumed by the interactive application layer.
• Outbound integrations send results to Power BI for advanced dashboards and also interact with chat bot and Alexa skill modules for voice and text-driven assistance.
• There is also cross-referencing among the analysis (machine learning & deep learning) and visualization components for improved feedback and iterative development.
Architectural Patterns and Design Principles
• Separation of Concerns: Distinct folders for data processing, ML/DL development, and frontend application.
• Modularity: By keeping deep learning models separate from machine learning models, as well as using individual components for EDA, visualizations, and interactive web apps, the architecture supports modular development and testing.
• Integration: The use of various interfaces (Streamlit for web, Power BI for dashboards, Alexa for voice interactions) shows that the system is built to integrate multiple user interaction channels.
• Data Pipeline: The clear flow from raw data and exploratory analysis into model training and then into front-end applications reflects a typical end-to-end data pipeline architecture.
Relevant Technologies/Frameworks
• Python as the main programming language.
• Pandas, NumPy for analytics.
• Scikit-learn (ML model training) and TensorFlow (DL image processing).
• Streamlit for building the interactive application.
• Power BI for external dashboards.
• Chat Bot integration using Cohere.
• Various libraries like OpenCV, Pillow for image processing.
• Joblib (or pickle) for model serialization.
Instructing the Principal Software Engineer
• Block for “Data Acquisition & Preprocessing” (covering Data, Data_exploration, Statistics).
• Separate blocks for “Machine Learning Pipeline” (Machine_learning, related notebooks & model files) and “Deep Learning Pipeline” (Deep_learning, MRI Dataset, and DL model files).
• A block for “Interactive Application” covering the Streamlit app in App and Deep_learning/app.py.
• Blocks for “Visualizations & Dashboards” (Data_visualization folder and Power_BI dashboards).
• Blocks representing “Chat Bot Integration” and “Alexa Skill” (to show external integration layers even if the implementation is external).
• The flow from data sources to preprocessing modules, then into both ML and DL pipelines.
• Links from the interactive application to external visualization services (Power BI) and communication interfaces (Chat Bot, Alexa).
• Data storage/processing (e.g., rounded rectangles),
• Computational/modeling components (e.g., squares),
• User interfaces and integrations (e.g., parallelograms).
• Annotations or legends to clarify which parts of the file tree correspond to each block.