Aktana, Inc., the leader in intelligent customer engagement for the global life sciences industry, today announced the acquisition of Tact.ai's field engagement and conversational AI technology. The addition extends Aktana's leadership in field ...

Aktana Acquires Tact.ai's Field Engagement and Conversational AI Technology

The integration helps organizations significantly accelerate their Mean Time to Resolution (MTTR) by delivering turnkey remediations with automatic code generation. By leveraging Amazon Bedrock, Orca effectively operates as a security co-pilot,

Orca Security Announces Generative AI Integration With Amazon Bedrock

The company continues to invest in technology and innovation, exploring emerging trends such as automation and artificial intelligence to further enhance its services. By staying at the forefront of industry advancements, ArcBest aims to continue ...

How ArcBest Corporation is Redefining the Logistics Industry

Genie Life Sciences, a provider of cloud-connected laboratory orchestration solutions, announced today a new integration with the Opentrons OT-2 and F

Genie Life Sciences Announces a New Software Integration with the Opentrons OT-2 and Flex Lab Robots

What does that mean for the nearly $188 billion gaming industry and for the players? L.A. Times Sarah Parvini joined Lisa McRee with more on a record shattering deal for a Santa Monica-based company.

LA Times Today: Microsoft acquires Activision Blizzard in $69-billion gaming deal

Arcellx, Inc. (NASDAQ: ACLX), a biotechnology company reimagining cell therapy through the development of innovative immunotherapies for patients with cancer and other

Arcellx to Participate in Two Upcoming Investor Conferences

anchored by expert technicians and cutting-edge patented technology, today announces its latest innovation, the Remote, Mobile, and Calibration CoPilot platforms. "We believe it will revolutionize the way ADAS service and calibration businesses manage ...

Opus IVS Unleashes Business and Technician Productivity with Launch of Mobile and Calibration CoPilot

NASA's first moon spacecraft for astronauts in 50 years is coming together.The Orion spacecraft for Artemis 2, set to fly around the moon in 2024 with a crew of four, saw its crew and service modules joined at NASA on Oct.

Artemis 2 Orion spacecraft comes together ahead of 2024 moon mission (photos)

The Orion spacecraft for Artemis 2, set to fly around the moon in 2024 with a crew of four, saw its crew and service modules joined at NASA on Oct. 19. Next will come a rigorous series of tests to ready it for the big lunar journey, agency officials said in a statement.

Arcadian Infracom, a St. Louis-based fiber infrastructure firm, has expanded its executive team with a new hire. Arcadian has hired Brock Killen as its first full-time chief financial officer. Killen joins Arcadian after having most recently been president and chief operating officer at Creve Coeur-based Knowink, which provides election technology.

Fiber startup Arcadian Infracom expands C-suite with CFO hire

Artelogic

artelogic

This paper is under CC 4.0 license. available on arxiv Authors: (1) Shreyash Mishra has an equal contribution from IIIT Sri City, India; (2) S Suryavardan has an equal contribution from IIIT Sri City, India; (3) Megha Chakraborty, University of South Carolina, USA; (4) Parth Patwa, UCLA, USA; (5) Anku Rani, University of South Carolina, USA; (6) Aman Chadha, work does not relate to a position at Amazon from Stanford University, USA, or Amazon AI, USA; (7) Aishwarya Reganti, CMU, USA; (8) Amitava Das, University of South Carolina, USA; (9) Amit Sheth, University of South Carolina, USA; (10) Manoj Chinnakotla, Microsoft, USA; (11) Asif Ekbal, IIT Patna, India; (12) Srijan Kumar, Georgia Tech, USA. Table of Links Abstract & Introduction Related Work Task Details Participating systems Results Conclusion and Future Work and References Abstract Analyzing memes on the internet has emerged as a crucial endeavor due to the impact this multi modal form of content wields in shaping online discourse. Memes have become a powerful tool for expressing emotions and sentiments, possibly even spreading hate and misinformation, through humor and sarcasm. In this paper, we present the overview of the Memotion 3 shared task, as part of the DeFactify 2 workshop at AAAI-23. The task released an annotated dataset of Hindi-English code-mixed memes based on their Sentiment (Task A), Emotion (Task B), and Emotion intensity (Task C). Each of these is defined as an individual task and the participants are ranked separately for each task. Over 50 teams registered for the shared task and 5 made final submissions to the test set of the Memotion 3 dataset. CLIP, BERT modifications, ViT etc. were the most popular models among the participants along with approaches such as Student-Teacher model, Fusion, and Ensembling. The best final F1 score for Task A is 34.41, Task B is 79.77 and Task C is 59.82. Memes, codemixed, multimodal, Hindi-English Keywords 1. Introduction The term meme is derived from the Ancient Greek word mimema, meaning imitated thing, which comes from the verb mimeisthai, meaning to mimic. The term was coined by Richard Dawkins, a British evolutionary biologist, in his book The Selfish Gene [1]. Dawkins used the concept of a meme to explain the spread of cultural phenomena and ideas, drawing parallels between memes and genes. Dawkins provided examples of memes such as melodies, catchphrases, fashion, and arch-building technology in his book. Interestingly, the word meme is a self-describing term, also known as autological, meaning that it is a meme itself. The reach of online content is vast and has the capacity to reach a massive viewership. Memes propagate through multiple mediums including social media, messaging, apps, and emails. An article on memes quotes "When you plant a fertile meme in my mind, you literally, parasitize my brain" [2]. This quote indicates the impact of memes on a viewer’s mind. It spreads to others who find it motivating, offensive, amusing, or relatable in some ways [3]. Memes are used to convey an opinion. When a person comes across a meme that they find relatable, they often share it with others who they think would find relatable. Different people interpret memes differently which means what can be offensive for one person might not be for other. This difference in interpretation is a result of cultural, gender, and demographic differences. The memes can also be used to spread offensive and hateful content [4]. Identifying and halting the dissemination of hateful memes is an arduous undertaking for both human beings and AI models, as it requires comprehending the intricate subtleties and socio-political contexts that form their interpretation. The deficiencies of current hate speech moderation techniques highlight the pressing need to enhance the effectiveness of automated hate speech detection. Given their subtlety and multi-modal nature, memes pose a more challenging issue to address compared to only text. In this paper, we present the findings of the Memotion 3 shared task, where participants were provided with an annotated dataset of 10k memes [5], and were tasked with detecting the sentiment, emotion and emotion intensity of the meme. Unlike the previous iteration of memotion [6, 7] which provided English memes, current iteration studies codemixed HindiEnglish (Hinglish) memes. The paper is organized as follows: we describe the related work and the task in section 2 and 3 respectively; Section 4 contains the details of the dataset we collected for Memotion analysis: Memotion 3.0; followed by a brief description of baseline models and their results in 5. We conclude and mention some possible future works in section 6.

Overview of Memotion 3: Sentiment & Emotion
Analysis of Codemixed Hinglish - Abstract & Introduction

It’s been about 6 years since I started working with Django, and through all these years I’ve made some personal customizations in Django’s structure, and coding style. I decided to wrap up all these to-dos and not-to-dos as an instructor so I could use them in the future and also might be helpful to others. Table of the content Modular Settings Third Party apps that could save you a lot of time: Always Have a TODO file Always Have a core web-app Using Django’s web-app to stay Cohesive Django’s custom management commands Store your service messages in a separated file Bypassing the meanings Managing a web-apps files Stick To Generic Views and Mixins Use Serializers! Fixtures Modular Settings: https://github.com/mrShahsafi/Edu/tree/master/djnagoForFun/djnagoForFun/settings When you are developing your Django project, and after each new web-app you’ll notice you have a lot in your settings.py and finding and managing your configs is harder than yesterday. As you might notice, when you are calling the very famous manage.py Django’s entry-point command, it will try to create and set to it. DJANGO_SETTINGS_MODULE PROJECT_NAME.settings What I do, I convert the settings.py to a python module with the . .py init Every project as least has 2 separated running environments: Development Environment Production Environment And some of your setting’s configs are similar in different environments. Until now we can include three files in our settings module 1- base.py 2- development.py 3- production.py As I said the base.py is for configs that are similar in different environments base.py: from pathlib import Path
import os  # Do not delete this

# Your everywhere service name

SITE_NAME = ""
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent.parent


# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = os.getenv(
    "DJANGO_KEY",
    default=“”,
)


# Application definition
DEFAULT_APPS = [
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
]

THIRD_PARTY_APPS = []

CREATED_APPS = []


INSTALLED_APPS = DEFAULT_APPS + CREATED_APPS + THIRD_PARTY_APPS 

MIDDLEWARE = []

ROOT_URLCONF = 
TEMPLATES = 
WSGI_APPLICATION = 
AUTH_PASSWORD_VALIDATORS = 
# Internationalization
…
# Static files (CSS, JavaScript, Images)
…
if not os.path.exists("logs"):
    os.makedirs(os.path.join(BASE_DIR, "logs")) Pretty cool right? Let’s go to other files. In the development.py you must include only development configs. development.py from .base import *

# import socket  # only if you haven't already imported this

DEBUG = True

ALLOWED_HOSTS = [
    "localhost",
    "127.0.0.1",
]

try:
    from .local import *
except Exception:
    pass

DATABASES = {
     "default": {
         "ENGINE": "django.db.backends.sqlite3",
         "NAME": BASE_DIR / "db.sqlite3",
     }
 }


INSTALLED_APPS += [
    "debug_toolbar",
    #    'django_extensions'
]

MIDDLEWARE += [
    "debug_toolbar.middleware.DebugToolbarMiddleware",
]

"""
    These commented config  will use \
        when you are running the project on Docker. 
"""
# hostname, _, ips = socket.gethostbyname_ex(socket.gethostname())
# INTERNAL_IPS = [ip[:-1] + "1" for ip in ips] + ["127.0.0.1", "10.0.2.2"]

INTERNAL_IPS = ["127.0.0.1", "10.0.2.2"] You might notice the file that I include here , we’ll get into it later. local.py Now let’s take a look at our production configs. production.py from .base import *

DEBUG = False

ALLOWED_HOSTS = [#YOUR_PRODUCTION_HOSTS_ADDRESSESS]

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql_psycopg2",
        "NAME": os.getenv("DB_NAME", default="db"),
        "USER": os.getenv("DB_USER", default="root"),
        "PASSWORD": os.getenv("DB_PASS", default="root-password"),
        "HOST": "postgres",
        "PORT": "5432",
    }
} When we have our three files, we must somehow manage them at the entry point of the settings module and I mean the .py: your module initializer file: init .py: init from os import getenv

env = getenv("DJANGO_ENV", default="development")

if env == "production":
    print("You Are in the Production Mode.")
    from .porduction import *
elif env == "development":
    print("Warning! You Are in the Development Mode.\nDo Not use in any server.")
    from .development import * Well, now it is time to explain that mysterious local.py file! Everything that only belongs to your local machine configs is going to lie there. For example, your email SMTP configs, your local database and etc. and remember, the local.py will always be in the .gitignore. Of course, Django usually contains more third-party modules like DRF, Celery, Allauth, cache services, CORS headers, channels, Sentry. It is simple now, you’ll make a separate file for each of these modules and call it at the end of your base.py file. Here I only explain the DRF and you will get the pattern. base.py # At the end of your base.py

try:
 from .drf_settings import *
except Exception:
 pass drf_settings.py: from datetime import timedelta
from .base import SITE_NAME

REST_FRAMEWORK = {
    "DEFAULT_SCHEMA_CLASS": "drf_spectacular.openapi.AutoSchema",
    "DEFAULT_PARSER_CLASSES": (
        "rest_framework.parsers.JSONParser",
        "rest_framework.parsers.MultiPartParser",
        "rest_framework.parsers.FileUploadParser",
    ),
    "DEFAULT_AUTHENTICATION_CLASSES": (
        "rest_framework_simplejwt.authentication.JWTAuthentication",
    ),
    "DEFAULT_PERMISSION_CLASSES": (
        "rest_framework.permissions.IsAuthenticatedOrReadOnly",
    ),
    "DEFAULT_FILTER_BACKENDS": ("django_filters.rest_framework.DjangoFilterBackend",),
    "DEFAULT_PAGINATION_CLASS": "core.pagination.CustomPagination",
    "PAGE_SIZE": 9,
    # "DEFAULT_VERSIONING_CLASS": "rest_framework.versioning.AcceptHeaderVersioning", # when we active versioning the swagger ui brakes!= ""
    "TEST_REQUEST_DEFAULT_FORMAT": "json",
    "EXCEPTION_HANDLER": "core.errors.custom_exception_handler",
} Third Party apps that could save you a lot of time: Sentry : It will manage your project transactions, errors, etc. and report to you weekly Django debug toolbar : For the development, it offers very good tools like the SQL query time, available signals and etc. Django Chacheops : A slick app that supports automatic or manual queryset caching and automatic granular event-driven invalidation. Django Admin Honeypot : Django application that provides utilities for preventing automated form spam. uses the library to generate test data for your Django models. This has been “hard-forked” from in order to support newer versions of Python and Django Django Seed : Django-seed faker django_faker Django Filter : Django-filter is a reusable Django application allowing users to declaratively add dynamic QuerySet filtering from URL parameters. Django Allauth : Integrated set of Django applications addressing authentication, registration, account management as well as 3rd party (social) account authentication. And most of the time, it will satisfy your requirements DRF Spectacular : Sane and flexible OpenAPI 3.0 schema generation for If your are using Django REST framework and writing APIs. Django Cities : Place models and worldwide place data for Django. Always Have a TODO : https://github.com/mrShahsafi/Edu/blob/master/djnagoForFun/TODO.md When you have a lot of tasks that need to be done very fast and right, you can not mention all your to-dos in your task management service. Most of the developers write their to-dos in the codebase and in most of the time, they forget to do them! Make sure you have a todo.md or everything else is suitable for you to store all your tod-os list in it! # The project Todo List items

---
- [ ] un-done Task
- [x] done Task
---
## Models

## APIs
- [ ] django channels middleware for JwtAuth
## Others

## Bugs

## Emails
- [x] Forgot Password link

## Tests
- [ ] model tests for Advertisement

## NOTES Another benefit of the tod-os file is you can review all your tod-os in just one file later and archive them as a project document. Always have a core web-app: https://github.com/mrShahsafi/Edu/tree/master/djnagoForFun/core You will always have some models, validations, normalizers, permissions, etc. that you could use in all your future web apps. I call this the common web-app ‘core’. Feel free to call it anything you want. Using Django’s web-app to stay Cohesive https://github.com/mrShahsafi/socialmedia As much as your web-apps perform an atomic action, you will have more space to maintain them in the future. For example, the authentication/authorization process must not be in the user’s app; they are 2 different steps and by separating their web-apps you will easily copy/paste their module to your new project with a very small amount of changes. Django custom management commands: https://github.com/mrShahsafi/Winance/tree/main/wallet/management/commands Django comes with a very useful topic: By following these instructions, your custom command will be like this . Custom Management cmd python manage.py my_custom_command For example, maybe you want to create command or test your machine dependencies before you perform a special action. In this way, all your commands have one structure both for writing and execution. And believe me, it is very important when your project becomes a little complex. fake_user Store your service messages in a separated file: https://github.com/mrShahsafi/Edu/blob/master/djnagoForFun/core/responses/api_messages.py When you raise an error or return a permission denied , you’ll have a message to show. Stay away from hardcoding them into your logic. All you need just a file that contains all these messages as variables. Bypassing the meanings https://github.com/mrShahsafi/Winance/blob/main/wallet/models/base.py Sometimes some actions do not really need to done. For example, you need to delete big amount of data from your database daily. It will be a expensive transaction for your database. Use abstract model that contains attribute with the default value and try to inherit all your other models from this common model. is_deleted False All you need to do for bulk delete is turn the flag of your instances to and make sure you filter your querysets with: is_deleted True qs = Model.objects.filter(is_deleted=Flase) What I have just done here is an example, but you get the idea. Managing a web-apps files Don’t always write all your code in just one file. If you see your .py is become bigger than what could be red in a one or two scrolls, you need to break it to separate files, especially when it comes to views.py. A view’s task is just to deliver the logics to a specific controller. What I do is add a new layer to my views called logics. Lets say we have a registration view called , you can write the registrations logics in and use it in your view. RegistrationApi auth.logics.registration_api_logic Stick to Generic Views and Mixins: Django developers think the Generic views and mixins are for the beginners as they grow as backend developers in the industry. Well I must say, that is not true at all. This is the power of the Django. Then why you are using Django at all if you need to write everything from the scratch? Also when you are using something like the DRF spectacular for Documenting the views , it is very easy for these type of modules to sync your schema and view when you have been use the generic views . Use Serializers! This concept may be a little strange to you but how many time do you use the request.data instead of using a serializer for it? I’m sure it happens sometimes. Remember that the serializers are the best practice to yourAPI view (from validating to creating ) And again, when you are using something like the DRF spectacular for Documenting, it is very easy for these type of modules to sync your schema. And also remember, when you breaking your tasks apart as atomic process, they will be very easy to maintain in the future. So if you wanna hear from me: Separate your serializers by their identities These three serializers: MyModelListSerializer MyModelDetailSerializer MyModelInputSerializer are better than just having MyModelSerializer. Fixtures: introduced concept to provide initial data for models. Django fixtures Always have the fixtures directory; it helps you to store all your fixed files and data in specific place. Conclusion: Hope you’ll enjoy using Django with these discussed concepts and structures. Also, I’ve prepared a service that could generate better projects and web-apps for you. You can check it out . Django here Thanks.

12 Essential Django Programming Tips for Developers

An application can only be as good as the features it is providing for its end-users. Every developer toes the line between indiscriminately adding gems and building new functionality themselves. When time is of the essence, these are the gems I reach for: - An relatively older gem and stable, but this is a gem that includes a view helper and javascript helper to display relative time (i.e. 'updated 2 minutes ago') local_time - Devise is still the go-to gem for authentication in most Rails apps. Its ease of use and existing features make it dead-simple to add authentication. For those looking for a simpler gem with a smaller footprint, gets a runner up in this list for authentication. devise Authlogic - When you start to follow the Service Object pattern, adding Interactor can help guide your context and result of those objects through a common interface. Interactor and - Rolify allows us to assign roles such as User or Admin then CanCanCan will enable us to take those roles and apply authorization policies. However, there is a case for for those who like the Policy Object approach's simplicity. rolify cancancan Pundit - When you need to encrypt data in your database for compliance or even client security, Lockbox makes it very easy to do. Working with plenty of types out of the box, such as most database types, other Rails tools(ActiveStorage), and third-party gems(Shrine). Lockbox - This is when it comes to running asynchronous tasks. Sidekiq is backed by Redis and has been long supported by the ActiveJob Rails abstractions. Sidekiq the gem - A simple yet powerful approach to adding pagination into your Rails applications. In many places, it is as simple a few drop-in changes, but can be used to on anything from ActiveRecord collections to plain Arrays. It also has templates to be used in many of the most known CSS frameworks such as Bootstrap. Kaminari - Take the guesswork out of email design and CSS inlining inside of Rails Mailers. This gem allows you to use Bootstrap-like HTML structures, use a Bootstrap like design, and inline the CSS to work in most email browser/apps. Quite the timesaver! Bootstrap Email - This will help standardize around common issues found when calculating money as well as providing a few template helpers. money-rails - Everyone should know what their application is doing and where it is spending its time. This gem adds a profiler to the development pages and can include some nifty flame graphs when you really want to dig into the data. Rack Mini Profiler , , - I personally like to use RSpec over the default Rails test framework. Though, the community can be quite divisive on testing tools! With every test suite, I include FactoryBot to easily spin up objects for those specs and SimpleCov to dig into my test coverage. rspec-rails factory_bot_rails simplecov - Still my #1 gem for working with email in a Rails app. In your local development, it catches the outgoing mail and opens in a browser, rendering it as it would an email. letter_opener or - When I am looking to handle an extensive HTTP API or system, I will reach for the infinitely configurable Faraday. Still, when there are only a few HTTP interactions needed, HTTParty is super simple to use to make HTTP calls. Faraday HTTParty Note: This list is the type of content you would find in my upcoming book . The book guides you from humble beginnings by deploying an app to production. The book is now in pre-sale (but not for long), and you can grab a free chapter right now! Build A SaaS App in Rails 6

Stories, News & Mentions about ARTELOGIC

Artelogic’s Stories on HackerNoon

Artelogic's News & Mentions